Quick reference

Git reference

Setup, daily commands, history recovery and team workflows.

Git records snapshots and relationships. Commit small, meaningful changes, inspect the diff before committing and use branches to isolate work that is not ready for main. When something goes wrong, prefer restore or revert over rewriting history you have already shared.

Read the full explanationGit & GitHub

Work through the guided lesson, then test yourself with a challenge.

Branches and integration

git branch

git branch --list

Lists local branches. Add -a for remote refs and -d to delete a merged branch.

git checkout

git checkout <branch>

The older multi-purpose command for branches and files. Use switch and restore in new workflows.

git cherry-pick

git cherry-pick <commit>

Applies a single commit from another branch onto the current one.

git merge

git merge --no-ff <branch>

Integrates another branch. A no-fast-forward merge keeps a visible merge commit.

git merge --abort

git merge --abort

Cancels an in-progress merge and returns to the pre-merge state.

git switch

git switch -c <branch>

Creates and switches branches. Prefer it over checkout for branch operations.

git worktree

git worktree add <path> <branch>

Checks out another branch in a separate directory, so you can work without stashing.

Merge conflict markers

Conflicts mark your side, the incoming side and the common base. Edit the file, remove markers, then stage it.

Branches and merges

git branch --merged

git branch --merged

Lists branches already merged into the current branch.

git branch -d

git branch -d <branch>

Deletes a branch that has been merged.

git branch -D (force delete)

git branch -D <branch>

Force-deletes a branch, even with unmerged commits.

git branch -m

git branch -m <new-name>

Renames the current branch or another branch.

git checkout -b

git checkout -b <branch>

The older create-and-switch command. Prefer git switch -c.

git cherry

git cherry -v main

Lists commits on a branch that are not yet upstream, with +/- markers.

git merge --ff-only

git merge --ff-only <branch>

Fails unless the merge can be a fast-forward, which keeps history linear.

git merge --no-commit

git merge --no-commit <branch>

Performs a merge but stops before committing so you can review.

git merge --squash

git merge --squash <branch>

Stages the combined changes without recording a merge commit.

git mergetool

git mergetool

Opens the configured visual merge tool for conflicted files.

git range-diff

git range-diff <old-range> <new-range>

Compares two versions of a patch series after a rebase.

git rerere

Reuses recorded conflict resolutions for the same hunks.

git switch - (previous)

Switches back to the previous branch.

Everyday workflow

git add

git add <path>

Stages a specific change for the next commit. Use git add -p to stage part of a file.

git blame

git blame <file>

Shows which commit last changed each line. Use it to understand context, not to assign blame.

git commit

git commit -m "Explain why"

Records staged changes. The message should explain why the change exists, not repeat the diff.

git commit --amend

git commit --amend

Replaces the last commit, for example to fix the message. Do not amend commits that others have pulled.

git diff

Shows unstaged changes. Use --staged for what will be committed and --stat for a summary.

git fetch

Downloads remote refs without changing your working tree. Inspect before merging.

git log

git log --oneline --graph --decorate

Shows history. The compact graph makes branches and merges readable.

git mv

git mv <from> <to>

Renames a file and records the move for Git.

git pull

git pull --rebase

Fetches and integrates remote work. Rebase keeps local commits linear.

git push

git push -u origin <branch>

Publishes local commits. The first push sets the upstream branch.

git rm

git rm <path>

Removes a file from the working tree and the index.

git show

git show <ref>

Shows a commit, tag or object with its diff.

git status

Shows the working tree and staging state. Start here before guessing what changed.

History and recovery

git clean

git clean -fd

Removes untracked files and directories. Preview with -n first.

git reflog

A local log of where HEAD has been. It is the fastest way to recover commits after a reset.

git reset --hard

git reset --hard <ref>

Moves the branch and discards working-tree changes. This can destroy uncommitted work.

git reset --mixed

git reset HEAD~1

Moves the branch back and unstages changes, leaving the working tree intact.

git reset --soft

git reset --soft HEAD~1

Moves the branch back while keeping changes staged, ideal for re-splitting a commit.

git restore

git restore <path>

Discards working-tree changes for a path, or restores a staged file with --staged. Be certain before running it.

git revert

git revert <commit>

Creates a new commit that undoes an earlier one. It is safe on shared history.

git stash

git stash push -m "wip"

Shelves uncommitted work temporarily. Do not use it as long-term storage.

git stash apply vs pop

git stash apply / git stash pop

apply keeps the stash entry; pop applies and removes it.

Hooks

commit-msg hook

.git/hooks/commit-msg

Validates the commit message, for example against Conventional Commits.

post-merge hook

.git/hooks/post-merge

Runs after a merge or pull, often to install dependencies.

pre-commit hook

.git/hooks/pre-commit

Runs before a commit is created. Perfect for linting and formatting checks.

pre-push hook

.git/hooks/pre-push

Runs before pushing. Use it for tests, not for long deployments.

Inspection

git blame -L

git blame -L <start>,<end> <file>

Limits blame to a line range.

git cat-file

git cat-file -p <object>

Prints the contents of any Git object: commit, tree, blob or tag.

git count-objects

git count-objects -v

Reports loose object counts and repository size.

git diff --check

git diff --check

Reports whitespace errors such as trailing spaces and conflict markers.

git diff --stat

git diff --stat

A summary of changed files and line counts.

git diff --word-diff

git diff --word-diff

Highlights changed words instead of whole lines, which is easier for prose.

git for-each-ref

git for-each-ref

Iterates refs with formatting, great for scripting branch reports.

git fsck

Checks repository integrity and reports dangling or corrupt objects.

git hash-object

git hash-object <file>

Computes the object id Git would use for a file.

git log --author

git log --author=<name>

Filters history by author.

git log --follow

git log --follow <path>

Follows a file across renames.

git log --since

git log --since="2 weeks ago"

Filters commits by date.

git log --stat

git log --stat

Shows changed files and line counts per commit.

git log -p

Shows history with the full patch of each commit.

git log -S

git log -S<string>

Finds commits that added or removed a string, also known as pickaxe.

git ls-tree

git ls-tree <tree>

Lists the contents of a tree object.

git rev-list

git rev-list --count <range>

Lists or counts commits reachable from a revision.

git shortlog -sn

git shortlog -sn

A commit count per author, useful for release notes.

git show --stat

git show --stat <ref>

Shows a commit with a file summary instead of the full patch.

git verify-pack

git verify-pack -v <pack>

Inspects the contents and sizes of a packfile.

Inspection and internals

git archive

git archive --format=zip

Exports a snapshot of the tree without the .git directory.

git bisect

git bisect start

Finds the commit that introduced a bug with a binary search.

git grep

git grep <pattern>

Searches tracked files without leaving Git.

git ls-files

Lists tracked files. Combine it with grep for quick audits.

git rev-parse

git rev-parse HEAD

Resolves a ref to a commit hash. Useful in scripts.

git shortlog

git shortlog -sn

Summarises commits per author.

git show-ref

Lists every ref and its hash.

Maintenance

git count-objects -v

git count-objects -v

Shows object counts, pack size and garbage.

git filter-repo

git filter-repo --path <path>

Rewrites history to remove files or paths. A separate tool from the Git project.

git fsck --lost-found

git fsck --lost-found

Writes dangling commits and blobs to .git/lost-found for recovery.

git gc

Compresses loose objects and prunes unreachable ones.

git lfs

git lfs track "*.psd"

Stores large files outside normal Git objects. Requires Git LFS.

git maintenance

git maintenance start

Schedules background repository maintenance.

git prune

Deletes unreachable objects. Usually run through git gc.

git reflog expire

git reflog expire --expire=30.days

Trims old reflog entries. Be careful: this removes a recovery path.

git repack

git repack -ad

Packs all objects into a single packfile and removes redundant packs.

Patches and plumbing

git am

git am <patch>

Applies patches from email, preserving authorship and messages.

git apply

git apply <patch>

Applies a patch file to the working tree without creating a commit.

git apply --check

git apply --check <patch>

Tests whether a patch applies cleanly.

git bundle

git bundle create <file> --all

Packs refs and objects into one file for offline transfer.

git bundle verify

git bundle verify <file>

Checks that a bundle is valid and can be applied.

git commit-tree

git commit-tree <tree> -p <parent>

Creates a commit object from a tree without moving a branch. Plumbing.

git format-patch

git format-patch <range>

Exports commits as email-ready patch files.

git read-tree

git read-tree <tree>

Loads a tree object into the index. Plumbing used by higher-level commands.

git replace

git replace <object> <replacement>

Temporarily substitutes one object for another without rewriting history.

git symbolic-ref

git symbolic-ref HEAD

Reads or writes symbolic refs such as the current branch pointer.

git update-index

git update-index --assume-unchanged <path>

Changes the index directly, including performance hints for large files.

git write-tree

git write-tree

Writes the current index as a tree object and prints its id.

Rewriting and tagging

git describe

git describe --tags

Describes the current commit relative to the nearest tag.

git rebase

git rebase origin/main

Replays commits on a new base. Do not rewrite shared history without coordination.

git rebase --abort

git rebase --abort

Stops an in-progress rebase and restores the original branch state.

git tag

git tag -a v1.0 -m "Release 1.0"

Marks a release point with an annotated, human-readable tag.

Interactive rebase

git rebase -i HEAD~3

Reword, squash, reorder or drop commits before sharing them.

Setup and configuration

.gitignore

Lists paths Git should not track. Commit it so the whole team shares the rules.

git clone

git clone <url>

Copies a remote repository, including its history, and configures origin.

git config

git config --global user.name "…"

Reads or writes configuration. Use --local for repository-specific values.

git help

git help <command>

Opens the manual for a command. git <command> -h shows a short summary.

git init

Creates a repository in the current directory.

git remote

git remote -v

Lists or edits remotes. origin is the conventional name for the main remote.

Setup and remotes

git clone --branch

git clone --branch <name> <url>

Clones a specific branch and checks it out.

git clone --depth

git clone --depth 1 <url>

A shallow clone with limited history. Faster for CI, but blame and log are incomplete.

git config alias

git config --global alias.st status

Creates a shortcut for a command or a longer option combination.

git config core.autocrlf

git config --global core.autocrlf input

Controls line-ending conversion across Windows and Unix.

git config pull.rebase

git config --global pull.rebase true

Makes git pull rebase local commits instead of creating merge commits.

git init --bare

git init --bare repo.git

Creates a repository without a working tree, used as a server-side remote.

git remote add

git remote add <name> <url>

Adds a named remote, such as upstream for the original repository.

git remote remove

git remote remove <name>

Removes a remote and its tracking branches.

git remote set-url

git remote set-url origin <url>

Changes the URL of an existing remote.

git remote show

git remote show origin

Shows fetch and push URLs, tracked branches and remote HEAD.

git sparse-checkout

git sparse-checkout set <paths>

Checks out only selected paths in a large monorepo.

git submodule add

git submodule add <url> <path>

Adds another repository as a submodule at a path.

git submodule status

git submodule status

Lists submodules with their pinned commits.

git submodule update

git submodule update --init --recursive

Fetches and checks out submodule commits after cloning.

Snapshot and staging

git add --all

git add --all

Stages every tracked and untracked change, including deletions.

git add --patch

git add --patch

Stages selected hunks so one commit contains one focused change.

git checkout -- (discard)

git checkout -- <path>

The older way to discard working-tree changes. Prefer git restore.

git clean -n

Previews which untracked files would be removed.

git commit --all

git commit --all -m "message"

Stages tracked changes and commits them in one step. New files still need git add.

git commit --allow-empty

git commit --allow-empty -m "message"

Creates a commit with no changes, useful to trigger CI.

git commit --fixup

git commit --fixup <commit>

Creates a fixup commit to squash into an earlier commit during interactive rebase.

git notes

git notes add -m "why"

Attaches extra information to a commit without changing its hash.

git restore --staged

git restore --staged <path>

Unstages a file while keeping the working-tree change.

git stash branch

git stash branch <branch>

Creates a branch from the commit a stash was made on and applies it there.

git stash drop

git stash drop stash@{0}

Deletes one stash entry without applying it.

git stash list

git stash list

Lists saved stashes with their index and message.

git stash show

git stash show -p

Shows the diff stored in a stash.

Keep going

Turn the reference into recall.

Read the full lesson, then solve the challenge without looking. That is where the knowledge sticks.

Open Git & GitHub Practise this topic Practice challenges