Git Basics: A Beginner's Guide to Version Control

# Debian / Ubuntu
sudo apt install git

# Fedora
sudo dnf install git

# macOS (Homebrew)
brew install git

# Windows
# Download from https://git-scm.com/download/win — includes Git Bash

git --version

git config --global user.name "Ada Lovelace"
git config --global user.email "ada@example.com"

# Default branch name for new repos (Git still defaults to "master" unless you set this)
git config --global init.defaultBranch main

# Your preferred editor for commit messages
git config --global core.editor "code --wait"

# Colored output in the terminal
git config --global color.ui auto

# Rebase (not merge) when you run `git pull` on a tracking branch
git config --global pull.rebase true

git config --list                # every effective setting, merged across scopes
git config --list --show-origin  # ...and which file each one came from
git config user.email            # a single key
git config --global --edit       # open ~/.gitconfig directly in your editor

git init                     # initialize in the current directory
git init my-project          # create the directory and initialize it
git init --bare              # a repository with no working directory — used for servers

git clone https://github.com/user/repo.git
git clone https://github.com/user/repo.git my-folder   # clone into a custom directory name

git clone --branch develop https://github.com/user/repo.git   # check out a specific branch
git clone --depth 1 https://github.com/user/repo.git          # shallow clone: only the latest commit

# Comments start with #
node_modules/          # ignore a whole directory
*.log                  # ignore every file matching a glob
!important.log         # ...except this one (negation)
/dist                  # leading slash: only at the repo root, not any nested "dist"
build/**/*.map         # ** matches across directory boundaries

git check-ignore -v path/to/file   # debug WHY a file is (or isn't) ignored, and by which rule
git rm --cached already-tracked.log  # stop tracking a file WITHOUT deleting it locally

git status
git status -s     # short format: one line per file, with change-type letters
git status -b     # short format, plus the current branch and ahead/behind counts
git status --ignored   # also list files excluded by .gitignore

$ git status -sb
## main...origin/main [ahead 1]
 M src/index.js
A  src/utils.js
?? notes.txt

git add index.js              # stage one file
git add src/ tests/           # stage everything under these directories
git add .                     # stage everything in and below the current directory
git add -A                    # stage everything in the whole repo, including deletions, from any cwd
git add -u                    # stage modifications and deletions only — never new/untracked files
git add -p                    # interactively choose which *hunks* of a file to stage
git add --dry-run .           # preview what would be staged, without staging it

git commit -m "Add input validation"
git commit -am "Fix typo"          # -a stages every tracked, modified file first (skips untracked!)
git commit                         # opens $EDITOR for a multi-line message
git commit --amend                 # replace the previous commit with a new one (message and/or content)
git commit --amend --no-edit       # amend the content, keep the existing message
git commit -v                      # show the diff being committed inside the message editor

git diff                       # working directory vs. staging area (unstaged changes)
git diff --staged              # staging area vs. last commit (a.k.a. --cached)
git diff HEAD                  # working directory vs. last commit (staged + unstaged together)
git diff main..feature         # a branch against another branch
git diff -- src/index.js       # limit the diff to one path
git diff --stat                # summary: files changed, insertions/deletions, no line-by-line detail

diff --git a/src/greet.js b/src/greet.js
index 83db48f..bf269c4 100644
--- a/src/greet.js
+++ b/src/greet.js
@@ -1,3 +1,3 @@
 function greet(name) {
-  return "Hello " + name;
+  return `Hello, ${name}!`;
 }

git show HEAD              # the most recent commit
git show abc1234           # a specific commit by (abbreviated) SHA
git show --stat HEAD       # just the changed-files summary

git log                          # full history, newest first
git log --oneline                # one compact line per commit
git log --oneline --graph --all  # ASCII graph of every branch's history — hugely useful
git log -p                       # each commit's full diff inline
git log -n 5                     # limit to the last 5 commits
git log --author="Ada"           # filter by author (substring match)
git log --grep="fix"             # filter by commit message content
git log -- src/index.js          # history that touched one path

git blame src/index.js
git blame -L 10,20 src/index.js   # only lines 10–20
git blame -w src/index.js         # ignore whitespace-only changes

git branch                       # list local branches, * marks the current one
git branch -a                    # local + remote-tracking branches
git branch -v                    # list with each branch's latest commit
git branch feature/login         # create a new branch (doesn't switch to it)
git branch -m old-name new-name  # rename a branch
git branch -d feature/login      # delete a branch (only if fully merged)
git branch -D feature/login      # force-delete, even if unmerged — use with intent

# Modern (recommended)
git switch feature/login          # switch to an existing branch
git switch -c feature/signup      # create AND switch, in one step
git switch -                      # switch back to the previous branch (like cd -)

# Legacy, still everywhere in older docs/scripts
git checkout feature/login
git checkout -b feature/signup

git switch main
git merge feature/login              # merge feature/login into the current branch
git merge --no-ff feature/login      # always create a merge commit, even if a fast-forward is possible
git merge --ff-only feature/login    # fail instead of merging, unless a fast-forward is possible
git merge --abort                    # bail out of a merge with conflicts, back to the pre-merge state

<<<<<<< HEAD
const GREETING = "Hello";
=======
const GREETING = "Hi there";
>>>>>>> feature/login

git status                # lists files still marked "both modified"
git diff                  # shows the conflict markers in context
git checkout --ours -- path/to/file    # take "our" side entirely for one file
git checkout --theirs -- path/to/file  # take "their" side entirely for one file
git merge --abort          # start over instead of resolving

git restore index.js               # discard unstaged changes, back to the last commit's version
git restore --staged index.js      # unstage the file, but keep its edits in the working directory

git reset --soft HEAD~1     # undo the last commit, keep everything staged
git reset HEAD~1            # (--mixed, the default) undo the commit, unstage the changes
git reset --hard HEAD~1     # undo the commit AND discard the changes entirely
git reset HEAD -- file.js   # unstage one specific file, keep its edits

git revert abc1234             # revert one commit, opens editor for the message
git revert --no-edit abc1234   # ...using the default generated message
git revert -n abc1234          # revert into the staging area, but don't commit yet (stack up multiple)

git clean -n     # dry run — show what WOULD be deleted, deletes nothing
git clean -f     # actually delete untracked files
git clean -fd    # ...and untracked directories too

git stash                      # stash tracked changes (staged + unstaged)
git stash push -m "wip: login" # same, with a descriptive message
git stash -u                   # also stash untracked files

git stash list                 # see every stash, most recent first
git stash show -p stash@{1}    # view a specific stash's diff

git stash pop                  # re-apply the most recent stash AND remove it from the list
git stash apply                # re-apply the most recent stash, but KEEP it in the list

git stash drop stash@{0}       # delete one stash without applying it
git stash clear                # delete every stash

git remote -v                       # list remotes with their URLs
git remote add origin <url>         # register a new remote named "origin"
git remote set-url origin <url>     # change a remote's URL
git remote show origin              # detailed info: tracked branches, push/pull URLs

git fetch origin                # update remote-tracking branches (origin/main, etc.)
git fetch --all                 # fetch from every configured remote
git fetch --prune               # also delete local references to branches deleted on the remote

git pull                    # fetch + merge (or rebase, if pull.rebase is configured)
git pull --rebase           # fetch + rebase, just for this one pull
git pull origin main        # explicitly specify remote and branch

git push                              # push the current branch to its configured upstream
git push origin main                  # push explicitly to a remote and branch
git push -u origin feature/login      # push AND set feature/login to track origin/feature/login
git push origin --delete feature/old  # delete a branch on the remote

git tag                          # list all tags
git tag v1.0.0                   # lightweight tag on the current commit
git tag -a v1.0.0 -m "Release 1.0.0"   # annotated tag — has its own message, author, and date
git tag -d v1.0.0                # delete a local tag

git push origin v1.0.0           # push a single tag
git push origin --tags           # push every local tag

git checkout v1.0.0              # check out a tag (detached HEAD)

node_modules/
dist/
.env
*.log

git branch correct-branch     # create a branch AT the current (wrong) commit
git reset --hard HEAD~1       # move the original branch back, dropping the commit from it
git switch correct-branch     # your commit is safe here, on the branch it should've been on

git pull --rebase     # fetch their commits, replay yours on top
git push

git switch -c rescue-branch   # immediately save the current commit under a real branch name