Awesome Tips

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

git checkout -

git checkout @{-1}

git push origin --delete <remote_branchname>

git push origin :<remote_branchname>

git branch -dr <remote/branch>

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

git checkout -- <file_name>

git restore <file_name>

git commit -v --amend

git cherry -v master

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

git add -p

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

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

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

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

git worktree add --detach <path> HEAD

git cherry -v master

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

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

git fetch -p

git remote prune origin

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

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

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

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

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

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

git checkout <deleting_commit> -- <file_path>

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

git commit --fixup <SHA-1>

git commit --only <file_path>

git add -i

git status --ignored

git checkout --orphan <branch_name>

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 

git commit --no-verify

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

git checkout -b <branch-name>

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

git switch -c <branch-name>

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

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

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

git shortlog

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

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

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

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

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

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

git status --short --branch

git checkout master@{yesterday}

git push origin HEAD

git push -u origin <branch_name>

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

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

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

git clone --filter=blob:none --sparse <url> && cd <repo> && git sparse-checkout set <dir1> <dir2>

git branch --column

git tag --column

git worktree list

git worktree remove <path>

git worktree prune

git branch --merged master

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

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

git branch -vv

git branch -u origin/mybranch

git branch -d <local_branchname>

git branch -a

git branch -r

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

git branch --contains <commit-ish>

git branch -m <new-branch-name>

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

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

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

git bundle create <file> <branch-name>

git rev-parse --abbrev-ref HEAD

git describe --tags --abbrev=0

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

git format-patch -M upstream..topic

git switch <branch-name>

git switch -c <new-branch-name>

git help -g

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

git log -p <file_name>

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

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

git diff

git diff --cached

git diff --staged

git diff HEAD

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

git whatchanged --since='2 weeks ago'

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

git ls-files -t

git ls-files --others

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

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

gitk --all

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

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

git diff --word-diff

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

git log Branch1 ^Branch2

git log -<n>

git log -n <n>

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

git log --show-signature

git show <branch_name>:<file_name>

git log --first-parent

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

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

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

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

git blame <file-name>

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 }' -

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

git log --show-notes='*'

git log --branches --not --remotes

git log @{u}..

git cherry -v

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

git blame -L <start>,<end>

git var -l | <variable>

git rev-parse --show-toplevel

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

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

git show

git reflog

git range-diff <base>..<old-tip> <base>..<new-tip>

git range-diff <rev1>...<rev2>

git bisect start <bad> <good> && git bisect run <script>

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

git blame -L :'<funcname>' <file>

git blame -M -C <file>

git blame -C -C -C <file>

git log --oneline --graph --all --decorate

git log --diff-filter=D --summary | grep delete

git log --all --full-history -- <file>

git shortlog -sn --since='1 year ago'

git shortlog -sne --all

git verify-commit <commit>

git log --show-signature

git diff --color-words

git diff --word-diff=color

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

git rebase --autostash

git rebase -i --autosquash

git rebase --interactive HEAD~2

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

git rebase --onto <new_base> <old_base>

git commit --fixup=<commit> && git rebase -i --autosquash <commit>~1

git rebase -i --root

git help everyday

git rm --cached <file_path>

git rm --cached -r <directory_path>

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

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

git check-ignore *

git count-objects --human-readable

git gc --prune=now --aggressive

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

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

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

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

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

git remote set-url origin <URL>

git remote

git remote show

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

git remote -v

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

git remote update origin --prune

git bundle create <file>.bundle --all

git bundle create <file>.bundle <branch-name>

git clone <file>.bundle <directory>

git clone --filter=blob:none <url>

git clone --filter=tree:0 <url>

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

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

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

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

git config --global pull.rebase true

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

git config --list

git config --global core.ignorecase false

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

git config --global help.autocorrect 1

git config --global rerere.enabled 1

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

git config core.fileMode false

git config --global color.ui false

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

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

git config [--global] --edit

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

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

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

git config --global core.autocrlf false

git config --edit --system

git config --edit --global

git config --edit --local

git maintenance start

git maintenance run --task=gc

git config gpg.format ssh && git config user.signingkey ~/.ssh/id_ed25519.pub && git commit -S -m '<message>'

git config rerere.enabled true

git config --global init.defaultBranch main

git stash

git stash push

git stash -k

git stash --keep-index

git stash push --keep-index

git stash -u

git stash push -u

git stash push --include-untracked

git stash push -m <message>

git stash push --message <message>

git stash -a

git stash --all

git stash push --all

git stash list

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

git stash apply <stash@{n}>

git stash pop

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

git stash clear

git stash drop <stash@{n}>

git stash push --keep-index

git stash push -m '<message>' <file1> <file2>

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

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

git submodule foreach git pull

git submodule update --init --recursive

git submodule update --remote

git subtree push --prefix subfolder_name origin gh-pages

git subtree push --prefix subfolder_name origin branch_name

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

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

git tag <tag-name>

git tag -d <tag-name>

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

git update-ref -d HEAD

git reset --keep <commit>

git revert <commit-ish>

git reset <commit-ish>

git clean -n

git clean -f

git clean -f -d

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

git clean -X -f

git clean -fd --dry-run

git reset HEAD <file-name>

git revert -m 1 <commit-ish>

git restore <file-name>

git restore --staged <file-name>