Simplifying Your Git Workflow with Aliases
Introduction to Git Aliases
Git aliases are a powerful feature that allows you to create custom shortcut commands for longer Git command sequences. They can significantly simplify and speed up your Git workflow by reducing repetitive typing and complexity.
How to Configure Git Aliases
Configuring a Git alias is straightforward. You can define aliases in the .gitconfig file located in your home directory, or you can set them directly via the command line using the git config command.
Setting an Alias via .gitconfig
To set an alias in .gitconfig, you need to edit the file and add your alias under the [alias] section. For example:
[alias]
co = checkout
br = branch
ci = commit
Setting an Alias via Command Line
Alternatively, you can set an alias directly from the command line:
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
This will update your .gitconfig file with the new aliases.
Examples of Git Aliases
Let's explore some practical examples of Git aliases from the attached file, showcasing how they can simplify your daily Git usage:
1. Quick Commit: Instead of typing git commit -m "Your message", use:
cm = commit -m
Usage:
git cm "Your initial commit"
2. Interactive Rebase: Replace the lengthy git rebase -i HEAD~3 with:
ri = rebase -i
Usage:
git ri HEAD~3
3. Staging All Changes: Use a simple git aa instead of git add --all:
aa = add --all
4. Viewing Logs: Instead of git log --oneline --graph --all, configure:
lg = log --oneline --graph --all
Usage:
git lg
5. Deleting Branches: Replace git branch -d with:
bd = branch -d
Usage:
git bd feature-branch
Useful Git Aliases
To further streamline your Git experience, I've compiled an extensive list of Git aliases that cover a wide range of functionalities, from basic commit operations to advanced log filtering. This comprehensive list is designed to cater to both novice and seasoned Git users.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # https://git-scm.com/docs/git-config#Documentation/git-config.txt-alias | |
| [alias] | |
| # Add files to the staging area | |
| # @example: git a | |
| a=add | |
| # Add all files to the staging area | |
| # @example: git aa | |
| aa=add --all | |
| # Commit the staged changes | |
| # @example: git c | |
| c=commit | |
| # Commit with a message | |
| # @example: git cm | |
| cm=commit --message | |
| # Commit without running hooks | |
| # @example: git cn | |
| cn=commit --no-verify | |
| # Commit with a message, without running hooks | |
| # @example: git cmn | |
| cmn=commit --message --no-verify | |
| # Amend the last commit | |
| # @example: git ca | |
| ca=commit --amend | |
| # Amend the last commit without running hooks | |
| # @example: git can | |
| can=commit --amend --no-verify | |
| # Amend the last commit, reusing the same message | |
| # @example: git car | |
| car=commit --amend --reuse-message HEAD | |
| # Commit all changes | |
| # @example: git caa | |
| caa=commit --all | |
| # Commit all changes without running hooks | |
| # @example: git caan | |
| caan=commit --all --no-verify | |
| # Commit all changes with a message | |
| # @example: git caam | |
| caam=commit --all --message | |
| # Work-in-progress commit of all changes | |
| # @example: git wip "Temp" | |
| wip=!git commit --all --no-verify --message 'wip: '${1:-Temp} | |
| # Reset HEAD softly to a specific commit | |
| # @example: git rh | |
| # @example: git rh [commit] | |
| rh=!git reset --soft ${1:-HEAD} | |
| # Reset HEAD hard to a specific commit | |
| # @example: git rhr | |
| # @example: git rhr [commit] | |
| rhr=!git reset --hard ${1:-HEAD} | |
| # Restore working directory files | |
| # @example: git discard | |
| discard=!git restore ${1:-.} | |
| # Unstage files from the staging area | |
| # @example: git unstage | |
| unstage=!git restore --staged ${1:-.} | |
| # Undo the last commit | |
| # @example: git undo | |
| # @example: git undo [commit] | |
| undo=!git reset ${1:-HEAD}^ | |
| # root - Delete the HEAD reference | |
| # @example: git undo-from-root | |
| undo-from-root=update-ref -d HEAD | |
| # Show short status of the repository | |
| # @example: git st | |
| st=status --short | |
| # Show the status of the repository | |
| # @example: git sts | |
| sts=status | |
| # Show short status with branch information | |
| # @example: git stv | |
| stv=status --short --branch | |
| # List files with merge conflicts | |
| # @example: git conflicts | |
| conflicts=!git st | grep '^[UMDA]\\{2\\} ' | awk '{ print $2 }' | |
| # List all staged files | |
| # @example: git staged | |
| staged=!git st | grep '^[M|A|D]' | |
| # List all unstaged but tracked files | |
| # @example: git unstaged | |
| unstaged=!git st | grep '^ [M|A|D]' | |
| # List all untracked files | |
| # @example: git untracked | |
| untracked=!git st | grep '^?' | |
| # List all files with changes, including untracked and modified | |
| # @example: git changes | |
| changes=!git st | grep -E '\\?| M|MM|DM| D' | |
| # Display the log with color | |
| # @example: git l | |
| l=log --color=always | |
| # Display the last 100 commits from all branches with color | |
| # @example: git lo | |
| lo=log --color=always --all --max-count=100 | |
| # Display a colored graphical log of all branches | |
| # @example: git lolg | |
| lolg=log --color=always --all --graph | |
| # Show the last commit with file changes statistics | |
| # @example: git last | |
| last=log -1 HEAD --stat | |
| # Display a graphical tree of all commits and branches | |
| # @example: git tree | |
| tree=log --graph --oneline --all | |
| # List commit hashes | |
| # @example: git commits | |
| commits=log --pretty='%h' | |
| # Show the hash of the last commit | |
| # @example: git last-commit | |
| last-commit=log -1 HEAD --pretty='%h' | |
| # List branches with detailed information | |
| # @example: git b | |
| b=branch --verbose --verbose --color=always | |
| # List all branches with detailed information | |
| # @example: git bv | |
| bv=branch --verbose --verbose --color=always --list | |
| # List all branches (local and remote) with detailed information | |
| # @example: git ba | |
| ba=branch --verbose --verbose --color=always --list --all | |
| # Delete a specified branch | |
| # @example: git bd [branch-name] | |
| bd=branch --delete | |
| # Show multiple branches and their divergences | |
| # @example: git bs | |
| bs=show-branch | |
| # List branches that are merged into the current HEAD | |
| # @example: git merged | |
| merged=branch --no-color --merged | |
| # List all local branches except HEAD | |
| # @example: git branches | |
| branches=!git ba | grep -v 'HEAD' | |
| # Get the name of the current branch | |
| # @example: git current-branch | |
| current-branch=rev-parse --abbrev-ref HEAD | |
| # Get the default branch name (e.g., main or master) | |
| # @example: git main-branch | |
| main-branch=config init.defaultBranch | |
| # Delete branches that are merged, excluding main, master, and develop | |
| # @example: git clear-merged | |
| clear-merged=!git merged | grep -v '\\*\\|main\\|master\\|develop' | xargs git branch -D | |
| # List remote branches for a specified remote (default: origin) | |
| # @example: git remote-branches [remote-name] | |
| remote-branches=!git branch -a | grep remotes/${1:-origin}/ | cut -f 3 -d '/' | |
| # Deinitialize and remove a specified submodule | |
| # @example: git remove-submodule [submodule-path] | |
| remove-submodule=!git submodule deinit -f -- ${1} && rm -rf .git/modules/${1} ${1} | |
| # Synchronize and update all submodules recursively | |
| # @example: git update-submodules | |
| update-submodules=!git submodule sync && git submodule update --recursive | |
| # Switch to a specified branch or commit | |
| # @example: git co [branch-name] | |
| co=checkout | |
| # Create and switch to a new branch | |
| # @example: git cob [new-branch-name] | |
| cob=checkout -b | |
| # Guess and switch to a branch based on partial input | |
| # @example: git cog [partial-branch-name] | |
| cog=checkout --guess | |
| # Rebase the current branch with statistics | |
| # @example: git r [base-branch] | |
| r=rebase --stat | |
| # Abort an ongoing rebase | |
| # @example: git ra | |
| ra=rebase --abort | |
| # Continue a rebase after resolving conflicts | |
| # @example: git rc | |
| rc=rebase --continue | |
| # Skip a patch during a rebase | |
| # @example: git rs | |
| rs=rebase --skip | |
| # Start an interactive rebase | |
| # @example: git ri [base-branch] | |
| ri=rebase --interactive | |
| # Start an interactive rebase with automatic stash and apply | |
| # @example: git ris [base-branch] | |
| ris=rebase --interactive --autostash | |
| # Start an interactive rebase with automatic squash | |
| # @example: git risq [base-branch] | |
| risq=rebase --interactive --autosquash | |
| # Perform an interactive rebase with autostash and show stats, defaulting to HEAD | |
| # @example: git autosrebase [commit] | |
| autosrebase=rebase --autostash --interactive --stat ${1:-HEAD} | |
| # Perform an autosrebase starting from the parent of a specified commit | |
| # @example: git rebase-from [commit] | |
| rebase-from="!f() { COMMIT=$(git rev-parse ${1:-HEAD}); git autosrebase $COMMIT^; }; f" | |
| # Begin an autosrebase, setting the latest commit to be edited | |
| # @example: git edit [commit] | |
| edit="!f() { GIT_SEQUENCE_EDITOR='sed -i -e 1s/^pick/edit/' git autosrebase ${1:-HEAD}^; }; f" | |
| # Start an autosrebase, dropping the latest commit | |
| # @example: git drop [commit] | |
| drop="!f() { GIT_SEQUENCE_EDITOR='sed -i -e 1s/^pick/drop/' git autosrebase ${1:-HEAD}^; }; f" | |
| # Begin an autosrebase, rewording the latest commit | |
| # @example: git reword [commit] | |
| reword="!f() { GIT_SEQUENCE_EDITOR='sed -i -e 1s/^pick/reword/' git autosrebase ${1:-HEAD}^; }; f" | |
| # Create a fixup commit for a specified commit | |
| # @example: git fixup [commit] | |
| fixup="!f() { COMMIT=$(git rev-parse ${1:-HEAD}); git commit --no-verify --fixup $COMMIT; }; f" | |
| # Create a fixup commit for a specified commit and autosquash it | |
| # @example: git fix [commit] | |
| fix="!f() { COMMIT=$(git rev-parse ${1:-HEAD}); git commit --no-verify --fixup $COMMIT; GIT_SEQUENCE_EDITOR=: git rebase --autosquash -i $COMMIT^; }; f" | |
| # Create a squash commit for a specified commit | |
| # @example: git squash [commit] | |
| squash="!f() { git commit --squash ${1:-HEAD} --no-verify --no-post-rewrite; }; f" | |
| # Stage all changes and create a fixup commit for a specified commit | |
| # @example: git fix-all [commit] | |
| fix-all=!git add . && git fix ${1:-HEAD} | |
| # Stage all changes and create a squash commit for a specified commit | |
| # @example: git squash-all [commit] | |
| squash-all=!git add . && git squash ${1:-HEAD} | |
| # Cherry-pick a commit | |
| # @example: git cp [commit-hash] | |
| cp=cherry-pick | |
| # Abort an ongoing cherry-pick operation | |
| # @example: git cpa | |
| cpa=cherry-pick --abort | |
| # Continue a cherry-pick after resolving conflicts | |
| # @example: git cpc | |
| cpc=cherry-pick --continue | |
| # Skip a commit during a cherry-pick | |
| # @example: git cps | |
| cps=cherry-pick --skip | |
| # Stash current changes | |
| # @example: git s | |
| s=stash | |
| # Stash all changes, including untracked files and ignored files | |
| # @example: git saa | |
| saa=stash --all | |
| # Stash changes without stashing changes already added to the index | |
| # @example: git stsh | |
| stsh=stash --keep-index | |
| # Pop the top stash entry | |
| # @example: git sp | |
| sp=stash pop | |
| # Save changes in a new stash | |
| # @example: git ss [message] | |
| ss=stash save | |
| # Drop the top stash entry | |
| # @example: git sd | |
| sd=stash drop | |
| # Apply the top stash entry | |
| # @example: git sa | |
| sa=stash apply | |
| # List stashes in a pretty format | |
| # @example: git stashes | |
| stashes=stash list --pretty=format:%gd | |
| # Show the patch and statistics for the top stash entry | |
| # @example: git sst | |
| sst=stash show --patch --stat | |
| # Show the patch for a specified stash entry | |
| # @example: git ssw [stash-index] | |
| ssw=stash show -p stash@{${1:-0}} | |
| # Stash changes including untracked files | |
| # @example: git ssu | |
| ssu=stash save --include-untracked | |
| # Show patches for all stashes | |
| # @example: git patches | |
| patches="!f() { for s in $(git stashes); do git stash show -p $s; done; };f" | |
| # Fetch updates from the remote | |
| # @example: git f | |
| f=fetch | |
| # Fetch updates from all remotes | |
| # @example: git fa | |
| fa=fetch --all | |
| # Pull updates from the remote | |
| # @example: git u | |
| u=pull | |
| # Pull with fast-forward only, showing stats and pruning | |
| # @example: git uf | |
| uf=pull --ff-only --stat --prune | |
| # Pull with rebase | |
| # @example: git ur | |
| ur=pull --rebase | |
| # Pull with rebase from the origin remote for the current branch | |
| # @example: git up | |
| up=pull --rebase origin HEAD | |
| # Pull with rebase from the origin remote for the main branch | |
| # @example: git uu | |
| uu=!git pull --rebase origin $(git main-branch) | |
| # Pull with rebase from the upstream remote for the main branch | |
| # @example: git uup | |
| uup=!git pull --rebase upstream $(git main-branch) | |
| # Push the current branch to the origin remote with verbose output | |
| # @example: git p | |
| p=!git push --verbose origin $(git current-branch) | |
| # Force push (with lease) the current branch to the origin remote with verbose output | |
| # @example: git pf | |
| pf=!git push --verbose origin $(git current-branch) --force-with-lease | |
| # Push all branches to the origin remote with verbose output | |
| # @example: git pa | |
| pa=!git push --verbose origin $(git current-branch) --all | |
| # Push tags of the current branch to the origin remote with verbose output | |
| # @example: git pt | |
| pt=!git push --verbose origin $(git current-branch) --tags | |
| # Push the current branch to the origin remote and set it as upstream with verbose output | |
| # @example: git pc | |
| pc=!git push --verbose --set-upstream origin $(git current-branch) | |
| # Pull and then push the current branch to/from the origin remote with verbose output | |
| # @example: git pp | |
| pp=!git pull origin $(git current-branch) && git push --verbose origin $(git current-branch) | |
| # Show differences between commits, commit and working tree, etc. | |
| # @example: git d | |
| d=diff | |
| # Show differences made since midnight of the current day | |
| # @example: git today | |
| today=diff --stat 'HEAD@{midnight}' | |
| # Show differences made on the previous day | |
| # @example: git yesterday | |
| yesterday=diff --stat 'HEAD@{yesterday}' 'HEAD@{midnight}' | |
| # List remote repositories with detailed information | |
| # @example: git re | |
| re=remote --verbose --verbose | |
| # Prune all stale remote tracking branches | |
| # @example: git rep | |
| rep=remote prune | |
| # Update remote branches and prune any stale branches | |
| # @example: git reu | |
| reu=remote update --prune | |
| # Change a global configuration setting | |
| # @example: git cg [setting] [value] | |
| cg=config --global | |
| # List all global configuration settings | |
| # @example: git configs | |
| configs=config --global --list | |
| # List all configuration settings with their origin | |
| # @example: git cfgs | |
| cfgs=config --list --show-origin | |
| # Interactively search through all configuration settings and their origins | |
| # @example: git cfgz | |
| cfgz=!git cfgs | fzf --ansi | |
| # Get the top-level directory of the Git repository | |
| # @example: git root-dir | |
| root-dir=rev-parse --show-toplevel | |
| # Remove files from the repository that match a given pattern | |
| # @example: git remove-files '[pattern]' | |
| remove-files="!f(){ find . -name $1 -print0 | xargs -0 git rm -f --ignore-unmatch; }; f" | |
| # Get the configured pager used by Git | |
| # @example: git pager | |
| pager=config --get core.pager | |
| # Shorten a URL using git.io | |
| # @example: git shorten [url] | |
| shorten=!sh -c 'curl -i https://git.io -F url=$1' | |
| # Extract the first 7 characters of a commit hash | |
| # @example: git grep-commit | |
| grep-commit=!sh -c 'grep -o "[a-f0-9]{7}" | cut -d" " -f1 | tr -d "\n"' | |
| # Get the last word in a line, often used to get the last part of a branch name | |
| # @example: git tail | |
| tail=!rev | cut -d' ' -f 1 | rev | |
| # Extract the branch name from a string | |
| # @example: git grep-branch | |
| grep-branch=!sh -c 'sed "s/^..//g" | rev | cut -d" " -f 1 | rev' | |
| # Extract the branch name from a string, removing 'remotes/origin/' prefix | |
| # @example: git head-branch | |
| head-branch=!sh -c 'sed "s/^..//g" | cut -d" " -f 1 | tr -d "\n" | sed "s@remotes/origin/@@"' | |
| # Interactive log view using fzf to select a commit | |
| # @example: git fzl | |
| fzl=!git log --color=always | fzf --ansi | git grep-commit | |
| # Interactive diff selection with fzf for multiple files | |
| # @example: git fzdiff [options] | |
| fzdiff=!HASH=$(git diff $@ --name-only | fzf --multi --ansi --header \" git diff [ --preview 'git diff $@ --color=always -- {-1}' <pathspec >…]\") | |
| # Interactive add using fzf to select multiple files with changes | |
| # @example: git fza | |
| fza=!HASH=$(git changes | fzf --ansi -m --header \" git add --force [ ^-x\t- restore [ ^-s\t- restore --staged [ --preview 'git diff $@ --color=always -- {-1}' --bind 'ctrl-x:reload(git restore $(cut -d \" \" -f3 <<<{}) 1>/dev/null && git changes)' --bind 'ctrl-u:reload(git restore --staged $(cut -d \" \" -f3 <<<{}) 1>/dev/null && git changes)' <pathspec >…]\n >git <pathspec >…]\nﮦ >git <pathspec >…]\" | git tail) && git add $(echo ${HASH} | awk '{ print $0 }') && git status | |
| # Interactive unstage using fzf to select unstaged files | |
| # @example: git fzu | |
| fzu=!HASH=$(git unstaged | fzf --ansi -m --header \" git restore [ --preview 'git diff $@ --color=always -- {-1}' <pathspec >…]\" | git tail) && git restore -- $(echo ${HASH} | awk '{ print $0 }') && git st -b | |
| # Interactive unstage staged files using fzf | |
| # @example: git fzus | |
| fzus=!HASH=$(git staged | fzf --ansi -m --header \" git restore --staged [ --preview 'git diff $@ --color=always -- {-1}' <pathspec >…]\" | git tail) && git restore --staged -- $(echo ${HASH} | awk '{ print $0 }') && git st -b | |
| # Interactive checkout branch using fzf | |
| # @example: git fzc | |
| fzc=!HASH=$(git branches | fzf --ansi --header \" git checkout --guess [ <branch >]\" | git head-branch) && [[ -n \"${HASH}\" ]] && git checkout --guess $(echo ${HASH} | awk '{ print $1 }') | |
| # Interactive delete branch using fzf | |
| # @example: git fzbd | |
| fzbd=!HASH=$(git branches | fzf --ansi -m --header \" git branch -d [ <branch >]\" | git head-branch --preview 'git branch -d $@ --color=always -- {-1}' | git tail) && [[ -n \"${HASH}\" ]] && git branch -d $(echo ${HASH} | awk '{ print $1 }') | |
| # Interactive force delete branch using fzf | |
| # @example: git fzbx | |
| fzbx=!HASH=$(git branches | fzf --ansi -m --header \" git branch -D [ <branch >]\" | git head-branch --preview 'git branch -D $@ --color=always -- {-1}' | git tail) && [[ -n \"${HASH}\" ]] && git branch -D $(echo ${HASH} | awk '{ print $1 }') | |
| # Interactive rebase using fzf to select a commit | |
| # @example: git fzr | |
| fzr=!HASH=$(git log --color=always | fzf --ansi --header \" git rebase --autostash --interactive --stat [ <options >]^\n\" | git grep-commit) && [[ -n \"${HASH}\" ]] && git rebase-from $(echo ${HASH} | awk '{ print $1 }') | |
| # Interactive fixup using fzf to select a commit | |
| # @example: git fzf | |
| fzf=!HASH=$(git log --color=always | fzf --ansi --header \" git fixup [ <pathspec >…]\" | git grep-commit) && [[ -n \"${HASH}\" ]] && git fix $(echo ${HASH} | awk '{ print $1 }') && git st -b | |
| # Interactive reword using fzf to select a commit | |
| # @example: git fzw | |
| fzw=!HASH=$(git log --color=always | fzf --ansi --header \" git reword [ <options >]\" | git grep-commit) && [[ -n \"${HASH}\" ]] && git reword $(echo ${HASH} | awk '{ print $1 }') | |
| # Interactive edit using fzf to select a commit | |
| # @example: git fze | |
| fze=!HASH=$(git log --color=always | fzf --ansi --header \" git edit [ <options >]\" | git grep-commit) && [[ -n \"${HASH}\" ]] && git edit $(echo ${HASH} | awk '{ print $1 }') | |
| # Interactive drop commit using fzf | |
| # @example: git fzd | |
| fzd=!HASH=$(git log --color=always | fzf --ansi --header \" git drop [ <options >]\" | git grep-commit) && [[ -n \"${HASH}\" ]] && git drop $(echo ${HASH} | awk '{ print $1 }') | |
| # Interactive soft reset using fzf | |
| # @example: git fzhs | |
| fzhs=!HASH=$(git log --color=always | fzf --ansi --header \" git reset --soft [ <options >]^\" | git grep-commit) && [[ -n \"${HASH}\" ]] && git reset --soft $(echo ${HASH} | awk '{ print $1\"^\" }') && git st -b | |
| # Interactive hard reset using fzf | |
| # @example: git fzhh | |
| fzhh=!HASH=$(git log --color=always | fzf --ansi --header \" git reset --hard [ <options >]^\" | git grep-commit) && [[ -n \"${HASH}\" ]] && git reset --hard $(echo ${HASH} | awk '{ print $1\"^\" }') && git st -b | |
| # Interactive unstage files using fzf | |
| # @example: git fzunstage | |
| fzunstage=!HASH=$(git staged | sed -E 's/(M|A|D) //' | fzf --ansi --header-lines=1 --multi --ansi --header ' git rm --cached <file |
How to Use the Gist
Explore the Gist: Browse through the list of aliases in the Gist. Each alias is accompanied by a brief description, making it easier to understand its purpose and usage.
Incorporate Into Your Workflow: Select the aliases that resonate with your daily Git tasks. You can add these aliases to your
.gitconfigfile or set them up using thegit configcommand, as explained earlier in this post.Customization: Feel free to modify or expand upon these aliases to better fit your personal workflow. Git aliases are highly flexible and can be tailored to meet your specific needs.
Sharing and Collaboration
If you have suggestions or additional aliases that could benefit others, consider contributing to the Gist. Collaboration and knowledge sharing are key to enhancing our collective Git experience.
Final Thoughts
With this extensive list of Git aliases and the foundational knowledge from this post, you're well-equipped to make your Git usage more efficient and enjoyable. Embrace the power of Git aliases and watch your productivity soar!
Remember, the key to effective use of Git aliases lies in identifying the Git commands you use most frequently and simplifying them to suit your workflow.
Top comments (0)