Master Git: Visual Guide to the Most Essential Commands

Basic Usage

The four core commands move files among the working directory, staging area (index), and repository: git add <files> – stage files in the index. git commit – create a snapshot from the index and record it. git reset -- <files> – undo the last git add; git reset without arguments clears the entire index. git checkout -- <files> – discard local changes by copying files from the index back to the working directory.

Interactive modes are available via git reset -p, git checkout -p, or git add -p. You can also bypass the index entirely by committing directly from the repository.

Conventions

Images use a five‑character green identifier to represent commit IDs, orange branches to indicate branch pointers, and a HEAD label attached to the current branch. The diagram shows the last five commits, with ed489 as the newest; main points to it, while stable points to its grandparent.

Command Details

Diff

Multiple ways exist to view changes between two commits. Example commands are illustrated in the accompanying diagram.

Commit

When committing, Git creates a new commit from the staged files, sets the current node as the parent, and moves the current branch pointer to the new commit. If the branch points to an ancestor, the new commit still updates the branch, potentially requiring a merge later.

To amend the most recent commit, use git commit --amend, which creates a new commit with the same parent and discards the old one.

Checkout

git checkout

copies files from a historical commit (or the index) to the working directory and can also switch branches. Specifying a file name copies that file from the chosen commit to both the index and working directory; omitting a file name leaves the current branch unchanged.

If a branch name is given, HEAD moves to that branch and the working tree is updated to match the commit pointed to by the new HEAD. If no name is supplied, Git creates a detached HEAD, allowing temporary navigation among historical versions.

Detached HEAD Commits

When HEAD is detached, commits are created normally but are not referenced by any named branch; they exist on an anonymous line and may be garbage‑collected if not anchored.

To preserve such a state, create a new branch with git checkout -b <name>.

Reset

git reset

moves the current branch pointer and optionally updates the index and working directory. Without options, only the branch moves. --hard updates both index and working tree; --soft leaves them unchanged.

When a path is supplied, the effect mirrors checkout for that file, but the index is also updated.

Merge

git merge

combines two branches. If the other branch is an ancestor, the command does nothing; if the current commit is an ancestor of the other, a fast‑forward occurs. Otherwise, a three‑way merge creates a new commit.

Cherry‑Pick

git cherry-pick

copies a specific commit onto the current branch, creating a new commit with identical changes.

Rebase

git rebase

replays commits from one branch onto another, producing a linear history. It is essentially an automated series of cherry‑picks. Options like --onto limit the range, and --interactive enables editing, reordering, or squashing commits.

Technical Notes

File contents are stored as blobs in .git/objects and referenced by SHA‑1 hashes. The index ( .git/index) lists these blobs, while commits store a tree object that mirrors the directory structure. Each commit records the hash of its parent tree.

Commits made on a detached HEAD are recorded in the reflog but may be pruned over time, similar to the effects of git commit --amend or git rebase.