Master Git aliases, shell functions, and productivity shortcuts to streamline your development workflow and boost efficiency

Git Aliases & Shortcuts: Boost Your Productivity

Git aliases are custom shortcuts that can dramatically improve your workflow efficiency. This comprehensive guide covers built-in Git aliases, shell functions, advanced configurations, and productivity-focused shortcuts for developers.

Understanding Git Aliases

Basic Alias Syntax

Git aliases are shortcuts for longer Git commands, configured in your Git configuration.

# Basic alias syntax
git config --global alias.<alias-name> '<git-command>'

# Examples
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status

# Usage
git co main        # Equivalent to: git checkout main
git br -a         # Equivalent to: git branch -a
git ci -m "msg"   # Equivalent to: git commit -m "msg"
git st            # Equivalent to: git status

Viewing Configured Aliases

# View all aliases
git config --get-regexp alias

# View specific alias
git config alias.st

# List all Git configuration
git config --list | grep alias

# Pretty-print aliases
git config --get-regexp alias | sed 's/alias\.//' | sed 's/ / = /'

Essential Git Aliases

Configure fundamental shortcuts for daily Git operations.

# Core navigation aliases
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.st status
git config --global alias.ci commit
git config --global alias.cp cherry-pick
git config --global alias.df diff
git config --global alias.dc 'diff --cached'
git config --global alias.dt difftool
git config --global alias.mt mergetool

# Branch management
git config --global alias.sw switch
git config --global alias.nb 'checkout -b'          # New branch
git config --global alias.db 'branch -d'            # Delete branch
git config --global alias.fb 'branch -D'            # Force delete branch

# Remote operations
git config --global alias.pu push
git config --global alias.pl pull
git config --global alias.ft fetch
git config --global alias.cl clone

Status and Information Aliases

Get quick insights into repository state.

# Enhanced status aliases
git config --global alias.s 'status -s'             # Short status
git config --global alias.sb 'status -sb'           # Short status with branch
git config --global alias.ss 'status'               # Full status

# Information aliases
git config --global alias.last 'log -1 HEAD --stat' # Last commit details
git config --global alias.rv 'remote -v'            # List remotes
git config --global alias.gl 'config --list'        # Git configuration
git config --global alias.branches 'branch -a'      # All branches
git config --global alias.tags 'tag -l'            # List tags

# File information
git config --global alias.ls 'ls-files'            # List tracked files
git config --global alias.ign 'ls-files -o -i --exclude-standard' # Ignored files

Commit and History Aliases

Streamline commit operations and history viewing.

# Commit aliases
git config --global alias.c 'commit'
git config --global alias.ca 'commit -a'           # Commit all modified
git config --global alias.cam 'commit -am'         # Commit all with message
git config --global alias.cm 'commit -m'           # Commit with message
git config --global alias.amen 'commit --amend'    # Amend last commit
git config --global alias.amend 'commit --amend --no-edit' # Amend without editing

# History aliases
git config --global alias.hist 'log --pretty=format:"%h %ad | %s%d [%an]" --graph --date=short'
git config --global alias.l 'log --oneline'        # One-line log
git config --global alias.ll 'log --oneline -10'   # Last 10 commits
git config --global alias.lg 'log --oneline --graph --decorate --all'
git config --global alias.lga 'log --graph --pretty=format:"%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset" --abbrev-commit --all'

Advanced Git Aliases

Complex Log and History Aliases

Create sophisticated log views for better project understanding.

# Advanced log formatting
git config --global alias.tree 'log --graph --pretty=format:"%C(red)%h%C(reset) - %C(yellow)%d%C(reset) %s %C(green)(%cr) %C(bold blue)<%an>%C(reset)" --abbrev-commit'

git config --global alias.timeline 'log --graph --branches --pretty=format:"%C(yellow)%h%C(red)%d%C(reset) - %C(white)%s %C(green)(%cr) %C(bold blue)<%an>%C(reset)" --abbrev-commit'

git config --global alias.changes 'log --pretty=format:"%h %ad | %s%d [%an]" --graph --date=short'

git config --global alias.short 'log --pretty=format:"%h %s [%an]"'

git config --global alias.changelog 'log --pretty=format:"- %s"'

# Date-based logs  
git config --global alias.today 'log --since=midnight --author="$(git config user.name)" --oneline'
git config --global alias.yesterday 'log --since="yesterday.midnight" --until=midnight --author="$(git config user.name)" --oneline'
git config --global alias.week 'log --since="1 week ago" --oneline'

Branch Management Aliases

Advanced branch operations and cleanup.

# Branch analysis
git config --global alias.brs 'for-each-ref --sort=-committerdate refs/heads/ --format="%(color:red)%(refname:short)%(color:reset) - %(color:yellow)%(committerdate:relative)%(color:reset) - %(authorname)"'

git config --global alias.recent 'for-each-ref --count=10 --sort=-committerdate refs/heads/ --format="%(refname:short)"'

git config --global alias.merged 'branch --merged'
git config --global alias.unmerged 'branch --no-merged'

# Branch cleanup
git config --global alias.cleanup '!git branch --merged | grep -v "\*\|main\|master\|develop" | xargs -n 1 git branch -d'

git config --global alias.bclean '!f() { git branch --merged ${1-main} | grep -v " ${1-main}$" | xargs git branch -d; }; f'

git config --global alias.bdone '!f() { git checkout ${1-main} && git up && git bclean ${1-main}; }; f'

# Remote branch management
git config --global alias.prune-all '!git remote | xargs -n 1 git remote prune'
git config --global alias.aliases '!git config -l | grep alias | cut -c7-'

Stash and Temporary Work Aliases

Manage work-in-progress efficiently.

# Stash operations
git config --global alias.sl 'stash list'
git config --global alias.sa 'stash apply'
git config --global alias.ss 'stash save'
git config --global alias.sp 'stash pop'
git config --global alias.sd 'stash drop'
git config --global alias.sc 'stash clear'
git config --global alias.sw 'stash show'

# Work-in-progress shortcuts
git config --global alias.wip '!git add -A && git commit -m "WIP"'
git config --global alias.unwip '!git log -n 1 | grep -q -c "WIP" && git reset HEAD~1'
git config --global alias.wips 'log --grep="WIP" --oneline'

# Quick save and restore
git config --global alias.save '!git add -A && git commit -m "SAVEPOINT"'
git config --global alias.undo 'reset HEAD~1 --mixed'
git config --global alias.amend 'commit -a --amend'
git config --global alias.wipe '!git add -A && git commit -qm "WIPE SAVEPOINT" && git reset HEAD~1 --hard'

Shell Functions and Advanced Shortcuts

Bash/Zsh Functions

Create powerful shell functions that extend Git functionality.

# Add to ~/.bashrc or ~/.zshrc

# Git status with enhanced output
gst() {
    git status -sb
    echo ""
    git --no-pager diff --stat
}

# Quick commit with message
gcm() {
    git commit -m "$*"
}

# Git add, commit, and push in one command
gacp() {
    git add .
    git commit -m "$*"
    git push
}

# Create and checkout new branch
gnb() {
    git checkout -b "$1"
    git push -u origin "$1"
}

# Git log with search
gls() {
    git log --grep="$1" --oneline
}

# Show files changed in last commit
glast() {
    git diff-tree --no-commit-id --name-only -r HEAD
}

# Git blame with line numbers
gblame() {
    git blame -w -M -C -C -C "$1" | nl
}

# Interactive rebase helper
grebase() {
    local commits=${1:-10}
    git rebase -i HEAD~$commits
}

Advanced Shell Functions

# Complex workflow functions

# Sync with upstream
gsync() {
    local branch=${1:-main}
    git fetch upstream
    git checkout $branch
    git merge upstream/$branch
    git push origin $branch
}

# Create PR branch and push
gpr() {
    local branch="pr-$(date +%Y%m%d-%H%M%S)"
    if [ $# -gt 0 ]; then
        branch="$1"
    fi
    git checkout -b "$branch"
    git push -u origin "$branch"
    echo "Created and pushed branch: $branch"
}

# Git worktree helper
gwt() {
    local branch=$1
    local path="../$branch"
    git worktree add "$path" "$branch"
    cd "$path"
}

# Clean up local environment
gcleanup() {
    echo "Cleaning up Git environment..."
    git checkout main 2>/dev/null || git checkout master
    git fetch --prune
    git branch --merged | grep -v "\*\|main\|master" | xargs -n 1 git branch -d
    git gc
    echo "Cleanup complete!"
}

# Show repository statistics
gstats() {
    echo "Repository Statistics:"
    echo "===================="
    echo "Total commits: $(git rev-list --all --count)"
    echo "Total contributors: $(git log --format='%an' | sort -u | wc -l)"
    echo "Repository size: $(du -sh .git | cut -f1)"
    echo "Branches: $(git branch -a | wc -l)"
    echo "Tags: $(git tag | wc -l)"
    echo ""
    echo "Top contributors:"
    git log --format='%an' | sort | uniq -c | sort -nr | head -5
}

PowerShell Functions (Windows)

# Add to PowerShell profile: $PROFILE

function Get-GitStatus { git status -sb }
Set-Alias -Name gst -Value Get-GitStatus

function Set-GitCommit { 
    param([string]$Message)
    git commit -m $Message 
}
Set-Alias -Name gcm -Value Set-GitCommit

function Add-CommitPush {
    param([string]$Message)
    git add .
    git commit -m $Message
    git push
}
Set-Alias -Name gacp -Value Add-CommitPush

function New-GitBranch {
    param([string]$BranchName)
    git checkout -b $BranchName
    git push -u origin $BranchName
}
Set-Alias -Name gnb -Value New-GitBranch

function Show-GitTree {
    git log --graph --pretty=format:'%C(red)%h%C(reset) - %C(yellow)%d%C(reset) %s %C(green)(%cr) %C(bold blue)<%an>%C(reset)' --abbrev-commit --all
}
Set-Alias -Name gtree -Value Show-GitTree

function Sync-GitUpstream {
    param([string]$Branch = "main")
    git fetch upstream
    git checkout $Branch
    git merge "upstream/$Branch"
    git push origin $Branch
}
Set-Alias -Name gsync -Value Sync-GitUpstream

Productivity Workflow Aliases

Daily Development Workflow

Create aliases that match common development patterns.

# Morning routine
git config --global alias.morning '!git checkout main && git pull origin main && git remote prune origin'

# End of day routine  
git config --global alias.evening '!git add . && git commit -m "End of day commit" && git push'

# Feature development workflow
git config --global alias.feature '!f() { git checkout main && git pull && git checkout -b feature/$1; }; f'
git config --global alias.hotfix '!f() { git checkout main && git pull && git checkout -b hotfix/$1; }; f'

# Code review workflow
git config --global alias.review '!f() { git fetch origin pull/$1/head:pr-$1 && git checkout pr-$1; }; f'
git config --global alias.reviewdone '!f() { git checkout main && git branch -D pr-$1; }; f'

# Release workflow
git config --global alias.release '!f() { git checkout main && git pull && git tag -a v$1 -m "Release v$1" && git push origin v$1; }; f'

# Deployment aliases
git config --global alias.deploy '!git checkout main && git pull && echo "Ready for deployment"'
git config --global alias.rollback '!f() { git revert --no-edit $1 && git push; }; f'

Team Collaboration Aliases

Aliases focused on team workflows and communication.

# Team coordination
git config --global alias.standup 'log --since=yesterday --author="$(git config user.name)" --pretty=format:"- %s"'

git config --global alias.teamwork 'log --since="1 week ago" --pretty=format:"%an: %s" --no-merges'

git config --global alias.blame-stats 'blame --line-porcelain | sed -n "s/^author //p" | sort | uniq -c | sort -nr'

# Contribution tracking
git config --global alias.who 'shortlog -sn --no-merges'
git config --global alias.contrib 'shortlog --summary --numbered --email'

# Conflict resolution
git config --global alias.conflicts 'diff --name-only --diff-filter=U'
git config --global alias.resolve '!f() { git add $1 && git commit --no-edit; }; f'

# Code archeology  
git config --global alias.find '!f() { git log --pretty="format:%C(yellow)%h %C(blue)%ad %C(red)%d %C(reset)%s%C(green) [%cn]" --decorate --date=short -S"$1"; }; f'

git config --global alias.search '!f() { git rev-list --all | xargs git grep -l "$1"; }; f'

Specialized Aliases

Git Hooks Integration

Aliases that work with Git hooks and automation.

# Hook management
git config --global alias.hooks '!find .git/hooks -type f -executable'
git config --global alias.hook-list '!ls -la .git/hooks/'

# Pre-commit workflow
git config --global alias.check '!f() { git diff --cached --name-only | xargs lint-staged; }; f'
git config --global alias.safe-commit '!git diff --cached --quiet && echo "Nothing to commit" || (git check && git commit)'

# Testing integration
git config --global alias.test-commit '!f() { npm test && git commit -m "$1"; }; f'
git config --global alias.lint-commit '!f() { npm run lint && git commit -m "$1"; }; f'

Security and Audit Aliases

Aliases for security auditing and compliance.

# Security auditing
git config --global alias.audit-authors 'log --pretty=format:"%an <%ae>" | sort | uniq'
git config --global alias.audit-commits 'log --pretty=format:"%h %an %ad %s" --date=iso'
git config --global alias.secrets '!git log -p | grep -i "password\|key\|token\|secret"'

# File tracking
git config --global alias.track-file '!f() { git log --follow --patch -- "$1"; }; f'
git config --global alias.large-files 'ls-files | xargs ls -l | sort -nrk5 | head -10'

# Repository hygiene
git config --global alias.fsck-full 'fsck --full --strict'
git config --global alias.optimize '!git gc --aggressive && git repack -ad && git prune'

Performance and Maintenance Aliases

Keep repositories healthy and optimized.

# Repository maintenance
git config --global alias.cleanup-all '!git remote prune origin && git gc && git clean -df && git stash clear'

git config --global alias.size '!git count-objects -vH'
git config --global alias.repo-size 'count-objects -v'

# Performance diagnostics
git config --global alias.top-files 'ls-tree -r -t -l --full-name HEAD | sort -n -k 4'
git config --global alias.disk-usage '!git ls-files | xargs -I{} ls -l {} | awk "{sum += \$5} END {print sum/1024/1024 \" MB\"}"'

# Backup and restore
git config --global alias.backup '!git bundle create ../backup-$(date +%Y%m%d).bundle --all'
git config --global alias.snapshot '!git stash push -m "snapshot-$(date +%Y%m%d-%H%M%S)" --include-untracked'

Configuration Management

Global Alias Configuration

Set up a complete alias configuration efficiently.

#!/bin/bash
# setup-git-aliases.sh - Complete alias setup script

echo "Setting up comprehensive Git aliases..."

# Basic aliases
git config --global alias.co checkout
git config --global alias.br branch  
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'
git config --global alias.visual '!gitk'

# Log aliases
git config --global alias.hist 'log --pretty=format:"%h %ad | %s%d [%an]" --graph --date=short'
git config --global alias.lg 'log --oneline --graph --decorate --all'
git config --global alias.ll 'log --oneline -10'

# Advanced aliases
git config --global alias.aliases '!git config -l | grep alias | cut -c7-'
git config --global alias.branches 'branch -a'
git config --global alias.tags 'tag -l'
git config --global alias.remotes 'remote -v'

# Workflow aliases
git config --global alias.up '!git remote update -p; git merge --ff-only @{u}'
git config --global alias.wip '!git add -A && git commit -m "WIP"'
git config --global alias.unwip '!git log -n 1 | grep -q -c "WIP" && git reset HEAD~1'

echo "Git aliases setup complete!"
echo "Run 'git aliases' to see all configured aliases."

Per-Repository Aliases

Configure project-specific aliases.

# Project-specific aliases (run in repository root)
# These are stored in .git/config (not global)

# Project build aliases
git config alias.build '!npm run build'
git config alias.test '!npm test'
git config alias.lint '!npm run lint'

# Deployment aliases  
git config alias.deploy-staging '!git push staging main'
git config alias.deploy-prod '!git push production main'

# Project-specific workflows
git config alias.feature-done '!f() { git checkout develop && git pull && git merge --no-ff $1 && git push && git branch -d $1; }; f'

# Database migration helpers (for projects with DB)
git config alias.migrate '!git pull && npm run migrate'
git config alias.seed '!npm run seed'

Conditional Configuration

Set up different aliases based on context.

# ~/.gitconfig with conditional includes
[includeIf "gitdir:~/work/"]
    path = ~/.gitconfig-work
[includeIf "gitdir:~/personal/"]  
    path = ~/.gitconfig-personal

# ~/.gitconfig-work (work-specific aliases)
[alias]
    standup = log --since=yesterday --author="Work Name" --pretty=format:"- %s"
    deploy = "!f() { git push origin main && notify-slack 'Deployed to production'; }; f"
    
# ~/.gitconfig-personal (personal project aliases)  
[alias]
    blog = "!f() { git add . && git commit -m 'Blog post: $1' && git push; }; f"
    backup = push --mirror backup

Advanced Alias Techniques

Parameterized Aliases

Create aliases that accept parameters for flexibility.

# Function-style aliases with parameters
git config --global alias.clone-cd '!f() { git clone "$1" && cd "$(basename "$1" .git)"; }; f'

git config --global alias.search-commits '!f() { git log --grep="$1" --oneline; }; f'

git config --global alias.compare '!f() { git log --oneline $1..$2; }; f'

git config --global alias.file-history '!f() { git log --follow --patch -- "$1"; }; f'

git config --global alias.branch-age '!f() { git for-each-ref --sort=committerdate refs/heads/ --format="%(committerdate:short) %(refname:short)" | grep "$1"; }; f'

# Complex parameterized workflows
git config --global alias.start-feature '!f() { git checkout ${2:-main} && git pull origin ${2:-main} && git checkout -b "feature/$1"; }; f'

git config --global alias.finish-feature '!f() { git checkout ${2:-main} && git pull origin ${2:-main} && git merge --no-ff "feature/$1" && git push origin ${2:-main} && git branch -d "feature/$1"; }; f'

Conditional Logic in Aliases

Add intelligence to aliases with conditional execution.

# Smart commit that checks for changes first
git config --global alias.smart-commit '!f() { if git diff --quiet && git diff --cached --quiet; then echo "No changes to commit"; else git commit -m "$1"; fi; }; f'

# Safe force push that checks for upstream changes
git config --global alias.safe-force '!f() { git fetch && if git log HEAD..@{u} --oneline | grep -q .; then echo "Remote has new commits, aborting"; else git push --force-with-lease; fi; }; f'

# Branch cleanup that preserves important branches
git config --global alias.safe-cleanup '!git for-each-ref refs/heads/ "--format=%(refname:short)" | while read branch; do if [[ ! "$branch" =~ ^(main|master|develop|staging)$ ]]; then git branch -d "$branch" 2>/dev/null || true; fi; done'

# Intelligent sync that handles different remote scenarios
git config --global alias.smart-sync '!f() { if git remote | grep -q upstream; then git fetch upstream && git rebase upstream/${1:-main}; else git pull origin ${1:-main}; fi; }; f'

Multi-Command Aliases

Chain multiple Git operations for complex workflows.

# Complete feature workflow
git config --global alias.ship '!f() { git checkout main && git pull origin main && git checkout - && git rebase main && git checkout main && git merge --no-ff - && git push origin main && git branch -d -; }; f'

# Release preparation workflow
git config --global alias.prepare-release '!f() { git checkout develop && git pull origin develop && git checkout main && git pull origin main && git merge --no-ff develop && git tag -a "v$1" -m "Release v$1" && git push origin main --follow-tags; }; f'

# Hotfix workflow
git config --global alias.hotfix-start '!f() { git checkout main && git pull origin main && git checkout -b "hotfix/$1"; }; f'

git config --global alias.hotfix-finish '!f() { git checkout main && git merge --no-ff "hotfix/$1" && git tag -a "v$2" -m "Hotfix v$2" && git checkout develop && git merge --no-ff "hotfix/$1" && git branch -d "hotfix/$1" && git push --all && git push --tags; }; f'

Platform-Specific Considerations

Windows-Specific Aliases

Aliases optimized for Windows development environments.

# Windows path handling
git config --global alias.explore '!start .'
git config --global alias.winmerge '!winmergeu.exe'

# Windows-specific diff tools
git config --global alias.windiff '!f() { git difftool --tool=winmerge "$@"; }; f'

# PowerShell integration
git config --global alias.ps '!powershell.exe'
git config --global alias.cmd '!cmd.exe /c'

# Visual Studio integration
git config --global alias.vs '!f() { start devenv "$(git rev-parse --show-toplevel)"; }; f'

macOS-Specific Aliases

Aliases leveraging macOS tools and conventions.

# macOS integration
git config --global alias.open '!open .'
git config --global alias.xcode '!open -a Xcode .'
git config --global alias.code '!code .'

# macOS diff tools
git config --global alias.ksdiff '!ksdiff'
git config --global alias.opendiff '!opendiff'

# Notification integration
git config --global alias.notify '!f() { git "$@" && osascript -e "display notification \"Git command completed\" with title \"Git\""; }; f'

Linux-Specific Aliases

Aliases optimized for Linux development workflows.

# Linux file manager integration
git config --global alias.files '!nautilus .'    # GNOME
git config --global alias.browse '!dolphin .'    # KDE
git config --global alias.pcmanfm '!pcmanfm .'   # LXDE

# Linux diff tools
git config --global alias.meld '!meld'
git config --global alias.kdiff '!kdiff3'

# System integration
git config --global alias.notify '!f() { git "$@" && notify-send "Git" "Command completed"; }; f'

Troubleshooting and Debugging

Diagnostic Aliases

Aliases to help troubleshoot Git issues.

# Repository diagnostics
git config --global alias.doctor '!f() { echo "=== Git Repository Health Check ===" && echo "Git version: $(git --version)" && echo "Repository: $(git rev-parse --show-toplevel)" && echo "Current branch: $(git branch --show-current)" && echo "Remote URLs:" && git remote -v && echo "Repository size: $(du -sh .git)" && echo "Object count:" && git count-objects -v; }; f'

# Configuration debugging
git config --global alias.config-debug '!f() { echo "=== Git Configuration Debug ===" && echo "Global config:" && git config --global --list && echo -e "\nLocal config:" && git config --local --list && echo -e "\nEffective config:" && git config --list; }; f'

# Performance diagnostics
git config --global alias.perf '!f() { echo "=== Performance Diagnostics ===" && time git status && echo -e "\nLarge files:" && git ls-files | xargs ls -l | sort -k5 -nr | head -5; }; f'

# Connectivity testing
git config --global alias.test-remote '!f() { echo "Testing remote connectivity..." && git ls-remote origin > /dev/null && echo "✓ Remote accessible" || echo "✗ Remote connection failed"; }; f'

Troubleshooting Aliases

Quick fixes for common Git problems.

# Common fixes
git config --global alias.fix-author '!f() { git commit --amend --author="$(git config user.name) <$(git config user.email)>" --no-edit; }; f'

git config --global alias.fix-upstream '!f() { git branch --set-upstream-to=origin/$(git symbolic-ref --short HEAD) $(git symbolic-ref --short HEAD); }; f'

git config --global alias.fix-line-endings '!git add . && git commit -m "Fix line endings" && git push'

# Emergency recovery
git config --global alias.abort-merge '!git merge --abort 2>/dev/null || git rebase --abort 2>/dev/null || echo "No merge/rebase in progress"'

git config --global alias.restore-file '!f() { git checkout HEAD -- "$1" && echo "Restored $1 from HEAD"; }; f'

git config --global alias.find-lost '!git fsck --lost-found'

Best Practices and Guidelines

Alias Organization

Structure your aliases for maintainability and discovery.

# Naming conventions:
# Short aliases (2-3 chars) for frequent commands: st, co, br, ci
# Descriptive names for complex operations: cleanup, morning, evening
# Prefixes for categories: 
#   - log-* for logging aliases
#   - branch-* for branch operations  
#   - remote-* for remote operations
#   - fix-* for troubleshooting

# Example organized alias set
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit

git config --global alias.log-tree 'log --graph --oneline --all'
git config --global alias.log-stat 'log --stat'
git config --global alias.log-patch 'log -p'

git config --global alias.branch-clean 'branch -d'
git config --global alias.branch-list 'branch -a'
git config --global alias.branch-recent 'for-each-ref --sort=-committerdate refs/heads/'

git config --global alias.remote-sync '!git fetch --all && git remote prune origin'
git config --global alias.remote-info 'remote show origin'

Security Considerations

Safe alias practices for team environments.

# Avoid aliases that:
# - Execute arbitrary shell commands without validation
# - Expose sensitive information
# - Modify history destructively without safeguards
# - Bypass normal Git safety checks

# Safe alias examples:
git config --global alias.safe-push '!git push --dry-run && read -p "Proceed with push? (y/N) " -n 1 -r && echo && [[ $REPLY =~ ^[Yy]$ ]] && git push'

git config --global alias.safe-reset '!f() { echo "This will reset to $1. Current HEAD is $(git rev-parse HEAD)"; read -p "Continue? (y/N) " -n 1 -r; echo; [[ $REPLY =~ ^[Yy]$ ]] && git reset --hard "$1"; }; f'

# Audit trail aliases
git config --global alias.who-changed '!f() { git log --follow --format="%an <%ae>" -- "$1" | sort | uniq; }; f'
git config --global alias.audit-log 'log --pretty=format:"%h %an %ad %s" --date=iso'

Performance Considerations

Optimize aliases for speed and efficiency.

# Performance tips:
# - Use --no-pager for aliases that should complete quickly
# - Limit output with --max-count or head
# - Cache expensive operations when possible
# - Use native Git commands over shell commands when possible

# Optimized aliases
git config --global alias.quick-log 'log --oneline --max-count=10'
git config --global alias.fast-status 'status --porcelain'
git config --global alias.recent-files 'diff --name-only HEAD~1'

# Avoid expensive operations in frequently-used aliases
# BAD: git config --global alias.st 'status && git log --graph --all'
# GOOD: git config --global alias.st 'status'

Next Steps

⚡ Congratulations! You've mastered Git aliases and shortcuts for maximum productivity.

Continue optimizing your workflow:

Explore Team Collaboration - Apply aliases in team workflows
Master Troubleshooting - Use aliases for problem-solving
Learn Advanced Git Internals - Create aliases for low-level operations

Advanced Alias Topics

Create dynamic aliases that adapt to repository context
Build aliases that integrate with external tools and APIs
Develop team-wide alias standards and distributions
Create aliases for advanced Git workflows (worktrees, subtrees)
Build monitoring and metrics aliases for repository health
Contribute useful aliases to open-source projects

# Export aliases for sharing
git config --get-regexp alias > my-git-aliases.txt

# Import aliases from file  
while read line; do
    if [[ $line == alias.* ]]; then
        key=${line%% *}
        value=${line#* }
        git config --global "$key" "$value"
    fi
done < my-git-aliases.txt

# Create alias installer script
#!/bin/bash
# install-team-aliases.sh
echo "Installing team Git aliases..."
source ./team-aliases.sh
echo "Team aliases installed successfully!"

Git Aliases & Shortcuts

On this page