GitHub - git-tips/tips: Most commonly used git tips and tricks.

git-tips

Collection of git-tips, want to add your tips? Checkout contributing.md

Tools:

git-tip - A handy CLI to make optimum use of these tips. (Here in Docker container)

📖 Read the interactive GitBook documentation here!

P.S: All these commands are tested on git version 2.7.4 (Apple Git-66).

Basic Operations

List of all files till a commit

git ls-tree --name-only -r <commit-ish>

Quickly switch to the previous branch

git checkout -

Alternatives:

git checkout @{-1}

Delete remote branch

git push origin --delete <remote_branchname>

Alternatives:

git push origin :<remote_branchname>

git branch -dr <remote/branch>

Delete remote tag

git push origin :refs/tags/<tag-name>

Undo local changes with the content in index(staging)

git checkout -- <file_name>

Reword the previous commit message

git commit -v --amend

See commit history for just the current branch

git cherry -v master

Amend author.

git commit --amend --author='Author Name <email@address.com>'

Stage parts of a changed file, instead of the entire file

git add -p

Pick commits across branches using cherry-pick

git checkout <branch-name> && git cherry-pick <commit-ish>

Grab a single file from a stash

git checkout <stash@{n}> -- <file_path>

Alternatives:

git checkout stash@{0} -- <file_path>

Create new working tree from a repository (git 2.5)

git worktree add -b <branch-name> <path> <start-point>

Create new working tree from HEAD state

git worktree add --detach <path> HEAD

Show all commits in the current branch yet to be merged to master

git cherry -v master

Alternatives:

git cherry -v master <branch-to-be-merged>

Modify previous commit without modifying the commit message

git add --all && git commit --amend --no-edit

Prunes references to remove branches that have been deleted in the remote.

git fetch -p

Alternatives:

git remote prune origin

Retrieve the commit hash of the initial revision.

 git rev-list --reverse HEAD | head -1

Alternatives:

git rev-list --max-parents=0 HEAD

git log --pretty=oneline | tail -1 | cut -c 1-40

git log --pretty=oneline --reverse | head -1 | cut -c 1-40

Import from a bundle

git clone repo.bundle <repo-dir> -b <branch-name>

Ignore one file on commit (e.g. Changelog).

git update-index --assume-unchanged Changelog; git commit -a; git update-index --no-assume-unchanged Changelog

Fetch pull request by ID to a local branch

git fetch origin pull/<id>/head:<branch-name>

Alternatives:

git pull origin pull/<id>/head:<branch-name>

Restore deleted file.

git checkout <deleting_commit> -- <file_path>

Restore file to a specific commit-hash

git checkout <commit-ish> -- <file_path>

Marks your commit as a fix of a previous commit.

git commit --fixup <SHA-1>

Skip staging area during commit.

git commit --only <file_path>

Interactive staging.

git add -i

Status of ignored files.

git status --ignored

Checkout a new branch without any history

git checkout --orphan <branch_name>

Find guilty with binary search

git bisect start                    # Search start 
git bisect bad                      # Set point to bad commit 
git bisect good v2.6.13-rc2         # Set point to good commit|tag 
git bisect bad                      # Say current state is bad 
git bisect good                     # Say current state is good 
git bisect reset                    # Finish search

Bypass pre-commit and commit-msg githooks

git commit --no-verify

Clone a single branch

git clone -b <branch-name> --single-branch https://github.com/user/repo.git

Create and switch new branch

git checkout -b <branch-name>

Alternatives:

git branch <branch-name> && git checkout <branch-name>

git switch -c <branch-name>

Show all local branches ordered by recent commits

git for-each-ref --sort=-committerdate --format='%(refname:short)' refs/heads/

Clone a shallow copy of a repository

git clone https://github.com/user/repo.git --depth 1

Force push to Remote Repository

git push -f <remote-name> <branch-name>

Group commits by authors and title

git shortlog

Forced push but still ensure you don't overwrite other's work

git push --force-with-lease <remote-name> <branch-name>

Number of commits in a branch

git rev-list --count <branch-name>

Add object notes

git notes add -m 'Note on the previous commit....'

Apply commit from another repository

git --git-dir=<source-dir>/.git format-patch -k -1 --stdout <SHA1> | git am -3 -k

Specific fetch reference

git fetch origin master:refs/remotes/origin/mymaster

Generates a summary of pending changes

git request-pull v1.0 https://git.ko.xz/project master:for-linus

Show git status short

git status --short --branch

Checkout a commit prior to a day ago

git checkout master@{yesterday}

Push the current branch to the same name on the remote repository

git push origin HEAD

Push a new local branch to remote repository and track

git push -u origin <branch_name>

Update a submodule to the latest commit

cd <path-to-submodule>
git pull origin <branch>
cd <root-of-your-main-project>
git add <path-to-submodule>
git commit -m "submodule updated"

Duplicating a repository

git clone --bare https://github.com/exampleuser/old-repository.git

git push --mirror https://github.com/exampleuser/new-repository.git

Branching

List all branches that are already merged into master

git branch --merged master

Remove branches that have already been merged with master

git branch --merged master | grep -v '^\*' | xargs -n 1 git branch -d

Alternatives:

git branch --merged master | grep -v '^\*\|  master' | xargs -n 1 git branch -d # will not delete master if master is not checked out

List all branches and their upstreams, as well as last commit on branch

git branch -vv

Track upstream branch

git branch -u origin/mybranch

Delete local branch

git branch -d <local_branchname>

Get list of all local and remote branches

git branch -a

Get only remote branches

git branch -r

Find out branches containing commit-hash

git branch -a --contains <commit-ish>

Alternatives:

git branch --contains <commit-ish>

Rename a branch

git branch -m <new-branch-name>

Alternatives:

git branch -m [<old-branch-name>] <new-branch-name>

Archive the `master` branch

git archive master --format=zip --output=master.zip

Delete local branches that has been squash and merged in the remote.

git branch -vv | grep ': gone]' | awk '{print $1}' | xargs git branch -D

Export a branch with history to a file.

git bundle create <file> <branch-name>

Get the name of current branch.

git rev-parse --abbrev-ref HEAD

Show the most recent tag on the current branch.

git describe --tags --abbrev=0

List all branch is WIP

git checkout master && git branch --no-merged

Preformatted patch file.

git format-patch -M upstream..topic

Switch to a branch (modern alternative to checkout)

git switch <branch-name>

Alternatives:

git switch -c <new-branch-name>

Log and History

Show helpful guides that come with Git

git help -g

Search change by content

git log -S'<a term in the source>'

Show changes over time for specific file

git log -p <file_name>

List all the conflicted files

git diff --name-only --diff-filter=U

List of all files changed in a commit

git diff-tree --no-commit-id --name-only -r <commit-ish>

Unstaged changes since last commit

git diff

Changes staged for commit

git diff --cached

Alternatives:

git diff --staged

Show both staged and unstaged changes

git diff HEAD

What changed since two weeks?

git log --no-merges --raw --since='2 weeks ago'

Alternatives:

git whatchanged --since='2 weeks ago'

See all commits made since forking from master

git log --no-merges --stat --reverse master..

Show all tracked files

git ls-files -t

Show all untracked files

git ls-files --others

Show all ignored files

git ls-files --others -i --exclude-standard

Visualize the version tree.

git log --pretty=oneline --graph --decorate --all

Alternatives:

gitk --all

git log --graph --pretty=format:'%C(auto) %h | %s | %an | %ar%d'

Visualize the tree including commits that are only referenced from reflogs

git log --graph --decorate --oneline $(git rev-list --walk-reflogs --all)

Show inline word diff.

git diff --word-diff

Show changes using common diff tools.

git difftool [-t <tool>] <commit1> <commit2> <path>

Commits in Branch1 that are not in Branch2

git log Branch1 ^Branch2

List n last commits

git log -<n>

Alternatives:

git log -n <n>

Open all conflicted files in an editor.

git diff --name-only | uniq | xargs $EDITOR

View the GPG signatures in the commit log

git log --show-signature

Extract file from another branch.

git show <branch_name>:<file_name>

List only the root and merge commits.

git log --first-parent

List commits and changes to a specific file (even through renaming)

git log --follow -p -- <file_path>

Search Commit log across all branches for given text

git log --all --grep='<given-text>'

Get first commit in a branch (from master)

git log --oneline master..<branch-name> | tail -1

Alternatives:

git log --reverse master..<branch-name> | head -6

Show the author, time and last revision made to each line of a given file

git blame <file-name>

Show how many lines does an author contribute

git log --author='_Your_Name_Here_' --pretty=tformat: --numstat | gawk '{ add += $1; subs += $2; loc += $1 - $2 } END { printf "added lines: %s removed lines: %s total lines: %s
", add, subs, loc }' -

Alternatives:

git log --author='_Your_Name_Here_' --pretty=tformat: --numstat | awk '{ add += $1; subs += $2; loc += $1 - $2 } END { printf "added lines: %s, removed lines: %s, total lines: %s
", add, subs, loc }' - # on Mac OSX

Show all the git-notes

git log --show-notes='*'

List unpushed git commits

git log --branches --not --remotes

Alternatives:

git log @{u}..

git cherry -v

Add everything, but whitespace changes

git diff --ignore-all-space | git apply --cached

blame on certain range

git blame -L <start>,<end>

Show a Git logical variable.

git var -l | <variable>

Get the repo name.

git rev-parse --show-toplevel

logs between date range

git log --since='FEB 1 2017' --until='FEB 14 2017'

Exclude author from logs

git log --perl-regexp --author='^((?!excluded-author-regex).*)$'

View expanded details of changes in last commit

git show

Visualize each position of HEAD in the last 30 days

git reflog

Merging and Rebasing

Rebases 'feature' to 'master' and merges it in to master

git rebase master feature && git checkout master && git merge -

Stash changes before rebasing

git rebase --autostash

Squash fixup commits normal commits.

git rebase -i --autosquash

Change previous two commits with an interactive rebase.

git rebase --interactive HEAD~2

Find common ancestor of two branches

git merge-base <branch-name> <other-branch-name>

Change a branch base

git rebase --onto <new_base> <old_base>

Miscellaneous

Everyday Git in twenty commands or so

git help everyday

Untrack files without deleting

git rm --cached <file_path>

Alternatives:

git rm --cached -r <directory_path>

Don’t consider changes for tracked file.

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

Check if the change was a part of a release.

git name-rev --name-only <SHA-1>

List ignored files.

git check-ignore *

Count unpacked number of objects and their disk consumption.

git count-objects --human-readable

Prune all unreachable objects from the object database.

git gc --prune=now --aggressive

Instantly browse your working repository in gitweb.

git instaweb [--local] [--httpd=<httpd>] [--port=<port>] [--browser=<browser>]

Find lines matching the pattern (regex or string) in tracked files

git grep --heading --line-number 'foo bar'

Backup untracked files.

git ls-files --others -i --exclude-standard | xargs zip untracked.zip

Send a collection of patches as emails

git send-email [<options>] <file|directory>…

git send-email [<options>] <format-patch options>

Remotes

Changing a remote's URL

git remote set-url origin <URL>

Get list of all remote references

git remote

Alternatives:

git remote show

Adding Remote name

git remote add <remote-nickname> <remote-url>

List all currently configured remotes

git remote -v

List references in a remote repository

git ls-remote git://git.kernel.org/pub/scm/git/git.git

Refresh the list of remote branches

git remote update origin --prune

Setup and Config

Remove sensitive data from history, after a push

git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch <path-to-your-file>' --prune-empty --tag-name-filter cat -- --all && git push origin --force --all

Reset author, after author has been changed in the global config.

git commit --amend --reset-author --no-edit

Get git bash completion

curl -L http://git.io/vfhol > ~/.git-completion.bash && echo '[ -f ~/.git-completion.bash ] && . ~/.git-completion.bash' >> ~/.bashrc

Git Aliases

git config --global alias.<handle> <command> 
git config --global alias.st status

Always rebase instead of merge on pull.

git config --global pull.rebase true

Alternatives:

#git < 1.7.9
git config --global branch.autosetuprebase always

List all the alias and configs.

git config --list

Make git case sensitive.

git config --global core.ignorecase false

Add custom editors.

git config --global core.editor '$EDITOR'

Auto correct typos.

git config --global help.autocorrect 1

Reuse recorded resolution, record and reuse previous conflicts resolutions.

git config --global rerere.enabled 1

Remove entry in the global config.

git config --global --unset <entry-name>

Ignore file mode changes on commits

git config core.fileMode false

Turn off git colored terminal output

git config --global color.ui false

Specific color settings

git config --global <specific command e.g branch, diff> <true, false or always>

Alias: git undo

git config --global alias.undo '!f() { git reset --hard $(git rev-parse --abbrev-ref HEAD)@{${1-1}}; }; f'

Edit [local/global] git config

git config [--global] --edit

List all git aliases

git config -l | grep alias | sed 's/^alias\.//g'

Alternatives:

git config -l | grep alias | cut -d '.' -f 2

Use SSH instead of HTTPs for remotes

git config --global url.'git@github.com:'.insteadOf 'https://github.com/'

Prevent auto replacing LF with CRLF

git config --global core.autocrlf false

Edit config for each level

git config --edit --system

git config --edit --global

git config --edit --local

Stashing

Saving current state of tracked files without committing

git stash

Alternatives:

git stash push

Saving current state of unstaged changes to tracked files

git stash -k

Alternatives:

git stash --keep-index

git stash push --keep-index

Saving current state including untracked files

git stash -u

Alternatives:

git stash push -u

git stash push --include-untracked

Saving current state with message

git stash push -m <message>

Alternatives:

git stash push --message <message>

Saving current state of all files (ignored, untracked, and tracked)

git stash -a

Alternatives:

git stash --all

git stash push --all

Show list of all saved stashes

git stash list

Show the contents of any stash in patch form

git stash show -p <stash@{n}>

Apply any stash without deleting from the stashed list

git stash apply <stash@{n}>

Apply last stashed state and delete it from stashed list

git stash pop

Alternatives:

git stash apply stash@{0} && git stash drop stash@{0}

Delete all stored stashes

git stash clear

Alternatives:

git stash drop <stash@{n}>

Submodules and Subtrees

Update all the submodules

git submodule foreach git pull

Alternatives:

git submodule update --init --recursive

git submodule update --remote

Deploying git tracked subfolder to gh-pages

git subtree push --prefix subfolder_name origin gh-pages

Alternatives:

git subtree push --prefix subfolder_name origin branch_name

Adding a project to repo using subtree

git subtree add --prefix=<directory_name>/<project_name> --squash git@github.com:<username>/<project_name>.git master

Get latest changes in your repo for a linked project using subtree

git subtree pull --prefix=<directory_name>/<project_name> --squash git@github.com:<username>/<project_name>.git master

Tagging

Create local tag

git tag <tag-name>

Delete local tag

git tag -d <tag-name>

Undoing Changes

Sync with remote, overwrite local changes

git fetch origin && git reset --hard origin/master && git clean -f -d

Git reset first commit

git update-ref -d HEAD

Reset: preserve uncommitted local changes

git reset --keep <commit>

Revert: Undo a commit by creating a new commit

git revert <commit-ish>

Reset: Discard commits, advised for private branch

git reset <commit-ish>

Before deleting untracked files/directory, do a dry run to get the list of these files/directories

git clean -n

Forcefully remove untracked files

git clean -f

Forcefully remove untracked directory

git clean -f -d

Undo assume-unchanged.

git update-index --no-assume-unchanged <file_name>

Clean the files from `.gitignore`.

git clean -X -f

Dry run. (any command that supports dry-run flag should do.)

git clean -fd --dry-run

Unstaging Staged file

git reset HEAD <file-name>

Revert: Reverting an entire merge

git revert -m 1 <commit-ish>

Restore file (modern alternative to reset/checkout --)

git restore <file-name>

Alternatives:

git restore --staged <file-name>

Name		Name	Last commit message	Last commit date
Latest commit History 410 Commits
.github/workflows		.github/workflows
.vscode		.vscode
docs		docs
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
LICENSE		LICENSE
README.md		README.md
book.json		book.json
build-readme.js		build-readme.js
contributing.md		contributing.md
package-lock.json		package-lock.json
package.json		package.json
tips.json		tips.json

Folders and files

Latest commit

History

Repository files navigation

git-tips

Tools:

Table of Contents

Basic Operations

List of all files till a commit

Quickly switch to the previous branch

Delete remote branch

Delete remote tag

Undo local changes with the content in index(staging)

Reword the previous commit message

See commit history for just the current branch

Amend author.

Stage parts of a changed file, instead of the entire file

Pick commits across branches using cherry-pick

Grab a single file from a stash

Create new working tree from a repository (git 2.5)

Create new working tree from HEAD state

Show all commits in the current branch yet to be merged to master

Modify previous commit without modifying the commit message

Prunes references to remove branches that have been deleted in the remote.

Retrieve the commit hash of the initial revision.

Import from a bundle

Ignore one file on commit (e.g. Changelog).

Fetch pull request by ID to a local branch

Restore deleted file.

Restore file to a specific commit-hash

Marks your commit as a fix of a previous commit.

Skip staging area during commit.

Interactive staging.

Status of ignored files.

Checkout a new branch without any history

Find guilty with binary search

Bypass pre-commit and commit-msg githooks

Clone a single branch

Create and switch new branch

Show all local branches ordered by recent commits

Clone a shallow copy of a repository

Force push to Remote Repository

Group commits by authors and title

Forced push but still ensure you don't overwrite other's work

Number of commits in a branch

Add object notes

Apply commit from another repository

Specific fetch reference

Generates a summary of pending changes

Show git status short

Checkout a commit prior to a day ago

Push the current branch to the same name on the remote repository

Push a new local branch to remote repository and track

Update a submodule to the latest commit

Duplicating a repository

Branching

List all branches that are already merged into master

Remove branches that have already been merged with master

List all branches and their upstreams, as well as last commit on branch

Track upstream branch

Delete local branch

Get list of all local and remote branches

Get only remote branches

Find out branches containing commit-hash

Rename a branch

Archive the master branch

Delete local branches that has been squash and merged in the remote.

Export a branch with history to a file.

Get the name of current branch.

Show the most recent tag on the current branch.

List all branch is WIP

Preformatted patch file.

Switch to a branch (modern alternative to checkout)

Log and History

Show helpful guides that come with Git

Search change by content

Show changes over time for specific file

List all the conflicted files

List of all files changed in a commit

Unstaged changes since last commit

Archive the `master` branch