The Complete Git Command Reference: Mastering Version Control from Basics to Advanced

# Debian/Ubuntu sudo apt-get update sudo apt-get install git # Fedora/RHEL sudo dnf install git # Arch Linux sudo pacman -S git 

# Using Homebrew brew install git # Or download from git-scm.com # Xcode Command Line Tools also includes Git xcode-select --install 

git --version 

git config --global user.name "Your Full Name" git config --global user.email "your.email@example.com" 

# Set different identity for a specific repository cd /path/to/work-project git config user.name "Your Name" git config user.email "work.email@company.com" # Use conditional includes for automatic identity switching # In ~/.gitconfig: [includeIf "gitdir:~/work/"] path = ~/.gitconfig-work [includeIf "gitdir:~/personal/"] path = ~/.gitconfig-personal 

git config --global init.defaultBranch main 

# Use your preferred editor git config --global core.editor "vim" git config --global core.editor "nano" git config --global core.editor "code --wait" # VS Code git config --global core.editor "subl -n -w" # Sublime Text git config --global core.editor "emacs" 

# Show all configuration and their sources git config --list --show-origin # Show specific configuration value git config user.name # List all global configuration git config --global --list # List all local (repository) configuration git config --local --list 

# Remove specific setting git config --global --unset user.name # Remove entire section git config --global --remove-section user 

# Windows: Convert LF to CRLF on checkout, CRLF to LF on commit git config --global core.autocrlf true # macOS/Linux: Convert CRLF to LF on commit, no conversion on checkout git config --global core.autocrlf input # Disable line ending conversion entirely git config --global core.autocrlf false 

# Warn about whitespace errors (trailing whitespace, etc.) git config --global core.whitespace trailing-space,space-before-tab # Make Git diff highlight whitespace errors git config --global color.diff.whitespace "red reverse" 

# Enable colored output git config --global color.ui auto # Customize specific colors git config --global color.branch.current "yellow reverse" git config --global color.branch.local yellow git config --global color.branch.remote green git config --global color.status.added green git config --global color.status.changed yellow git config --global color.status.untracked red 

# Configure external diff tool git config --global diff.tool meld git config --global difftool.meld.path "/usr/bin/meld" git config --global difftool.prompt false # Configure external merge tool git config --global merge.tool kdiff3 git config --global mergetool.kdiff3.path "/usr/bin/kdiff3" git config --global mergetool.prompt false git config --global mergetool.keepBackup false 

# 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 # Advanced aliases git config --global alias.unstage 'reset HEAD --' git config --global alias.last 'log -1 HEAD' git config --global alias.visual 'log --oneline --graph --decorate --all' git config --global alias.amend 'commit --amend --no-edit' # Aliases with arguments git config --global alias.show-branches '!git for-each-ref --sort=-committerdate --format="%(committerdate:short) %(refname:short)" refs/heads/' 

# Cache credentials in memory for 15 minutes (900 seconds) git config --global credential.helper cache git config --global credential.helper 'cache --timeout=3600' # Store credentials permanently (less secure) git config --global credential.helper store # Use OS-specific credential managers # macOS Keychain git config --global credential.helper osxkeychain # Windows Credential Manager git config --global credential.helper manager-core # Linux Secret Service git config --global credential.helper libsecret 

# Only push current branch to its upstream git config --global push.default simple # Push all matching branches git config --global push.default matching # Push current branch to branch of same name git config --global push.default current # Refuse to push if upstream differs git config --global push.default nothing 

# Use rebase instead of merge when pulling git config --global pull.rebase true # Only allow fast-forward merges when pulling git config --global pull.ff only 

# Enable parallel index preload for faster operations git config --global core.preloadindex true # Enable filesystem monitor for large repositories git config --global core.fsmonitor true # Increase HTTP buffer size for large repositories git config --global http.postBuffer 524288000 

[user] name = Your Name email = your.email@example.com [core] editor = vim autocrlf = input [alias] st = status co = checkout [color] ui = auto [push] default = simple 

[user] name = Jane Developer email = jane@example.com signingkey = ABC123DEF456 [core] editor = code --wait autocrlf = input whitespace = trailing-space,space-before-tab pager = delta [init] defaultBranch = main [pull] rebase = true [push] default = simple autoSetupRemote = true [fetch] prune = true [rebase] autoStash = true [merge] conflictstyle = diff3 tool = vscode [diff] colorMoved = zebra tool = vscode [alias] st = status -sb co = checkout br = branch ci = commit unstage = reset HEAD -- last = log -1 HEAD lg = log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit amend = commit --amend --no-edit undo = reset --soft HEAD^ stash-all = stash save --include-untracked [color] ui = auto [credential] helper = osxkeychain 

# Initialize in current directory git init # Initialize in a new directory git init my-project # Initialize with specific initial branch name git init --initial-branch=main my-project # Or shorter: git init -b main my-project 

.git/ ├── HEAD # Points to current branch ├── config # Repository configuration ├── description # Repository description (for GitWeb) ├── hooks/ # Hook scripts ├── info/ # Additional repository information │ └── exclude # Local .gitignore equivalent ├── objects/ # Object database │ ├── info/ │ └── pack/ └── refs/ # References (branches, tags) ├── heads/ # Local branches └── tags/ # Tags 

# Create bare repository git init --bare project.git # Convention: bare repositories end with .git 

# Start a new web project mkdir awesome-website cd awesome-website git init -b main # Create initial structure mkdir src css js touch README.md src/index.html css/style.css js/app.js # Make first commit git add . git commit -m "Initial project structure" 

# Clone a repository git clone https://github.com/user/repository.git # Clone into specific directory git clone https://github.com/user/repository.git my-local-name # Clone specific branch git clone -b develop https://github.com/user/repository.git # Shallow clone (limited history) git clone --depth 1 https://github.com/user/repository.git 

git clone https://github.com/user/repo.git 

git clone git@github.com:user/repo.git 

git clone git://github.com/user/repo.git 

git clone /path/to/repository git clone file:///path/to/repository 

# Clone only latest commit git clone --depth 1 https://github.com/user/large-repo.git # Clone with last 50 commits git clone --depth 50 https://github.com/user/repo.git # Shallow clone single branch git clone --depth 1 --single-branch --branch main https://github.com/user/repo.git 

# Fetch more history git fetch --depth=100 # Convert to full clone git fetch --unshallow 

# Clone with blob filtering (no file contents initially) git clone --filter=blob:none https://github.com/user/repo.git # Clone with tree filtering (fetch trees on-demand) git clone --filter=tree:0 https://github.com/user/repo.git 

# Mirror clone (includes all refs and history) git clone --mirror https://github.com/user/repo.git # Useful for backups or creating exact replicas 

# Clone repository and initialize submodules git clone --recursive https://github.com/user/repo.git # Or equivalently: git clone --recurse-submodules https://github.com/user/repo.git 

# Set configuration during clone git clone -c http.proxy=http://proxy.example.com:8080 https://github.com/user/repo.git # Set branch name git clone -c init.defaultBranch=main https://github.com/user/repo.git 

# Clone then checkout specific commit git clone https://github.com/user/repo.git cd repo git checkout abc123def456 

# Clone the project git clone https://github.com/original/project.git cd project # Add your fork as remote git remote add myfork git@github.com:yourname/project.git # Create feature branch git checkout -b feature/awesome-addition # Work, commit, push to your fork git push -u myfork feature/awesome-addition 

# Shallow clone for quick start git clone --depth 1 --single-branch --branch master https://github.com/torvalds/linux.git # Later, if you need more history cd linux git fetch --unshallow 

# Create exact mirror for backup git clone --mirror https://github.com/company/critical-project.git backup.git # Update backup regularly cd backup.git git remote update 

Working Directory → (git add) → Staging Area → (git commit) → Repository ← (git checkout) ← ← (git reset) ← 

┌─────────────────────┐ │ Working Directory │ ← Your files as you edit them │ - file1.txt │ │ - file2.txt │ └─────────────────────┘ │ │ git add ▼ ┌─────────────────────┐ │ Staging Area │ ← Files staged for commit │ - file1.txt │ └─────────────────────┘ │ │ git commit ▼ ┌─────────────────────┐ │ Repository (HEAD) │ ← Committed history │ - commit abc123 │ │ - commit def456 │ └─────────────────────┘ 

# Full status git status # Short format git status -s git status --short # Show branch and tracking info git status -sb git status --short --branch 

$ git status On branch main Your branch is up to date with 'origin/main'. Changes to be committed: (use "git restore --staged <file>..." to unstage) modified: file1.txt new file: file2.txt Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) modified: file3.txt Untracked files: (use "git add <file>..." to include in what will be committed) file4.txt 

$ git status -s M file1.txt # Modified and staged M file3.txt # Modified but not staged A file2.txt # Added (new file staged) ?? file4.txt # Untracked MM file5.txt # Modified, staged, then modified again 

# Show ignored files git status --ignored # Show untracked files in detail git status -u git status --untracked-files=all # Machine-readable format (for scripts) git status --porcelain # Show status with file stats git status -v git status --verbose 

# Stage specific file git add filename.txt # Stage multiple files git add file1.txt file2.txt file3.txt # Stage all changes in current directory and subdirectories git add . # Stage all changes in repository git add -A git add --all # Stage all modified and deleted files (not new files) git add -u git add --update 

# Enter interactive mode git add -i git add --interactive 

*** Commands *** 1: status 2: update 3: revert 4: add untracked 5: patch 6: diff 7: quit 8: help 

# Stage parts of files interactively git add -p filename.txt git add --patch filename.txt # Patch mode for all files git add -p 

$ git add -p example.py diff --git a/example.py b/example.py index 1234567..abcdefg 100644 --- a/example.py +++ b/example.py @@ -10,6 +10,7 @@ def process_data(data): result = [] for item in data: processed = transform(item) + validated = validate(processed) result.append(processed) return result Stage this hunk [y,n,q,a,d,s,e,?]? y 

# Stage all Python files git add *.py # Stage all files in directory git add src/ # Stage all .txt files recursively git add '*.txt' 

# Add file even if in .gitignore git add -f ignored-file.txt git add --force ignored-file.txt 

# Register untracked file without staging content git add -N newfile.txt git add --intent-to-add newfile.txt 

# Show what would be added git add --dry-run . git add -n . 

# Show added files git add -v file.txt git add --verbose file.txt 

# Stage only bug fix git add src/buggy_module.py git commit -m "Fix: Resolve null pointer exception" # Stage refactoring git add src/refactored_module.py git commit -m "Refactor: Improve code readability" 

git add -p complex_file.py # Stage first logical change: y # Skip unrelated change: n git commit -m "Add validation function" # Now stage the second change git add -p complex_file.py # Stage second logical change: y git commit -m "Add logging" 

# Stage all changes git add -A # Unstage one file git restore --staged unwanted.txt 

# You're in src/ but meant to stage root files pwd # /home/user/project/src git add . # Only stages src/ contents! # Solution: Navigate to repository root or use -A cd .. git add -A 

git add file.txt # Edit file.txt more git commit -m "Update file" # Doesn't include latest edits! # Solution: Always check status before committing git status git add file.txt # Stage latest changes git commit -m "Update file" 

# Accidentally added secrets file git add config/secrets.yml # Solution: Unstage immediately git restore --staged config/secrets.yml # Add to .gitignore echo "config/secrets.yml" >> .gitignore 

# Commit with inline message git commit -m "Add user authentication feature" # Open editor for commit message git commit # Commit with detailed message git commit -m "Add user authentication" -m "- Implement JWT tokens" -m "- Add login endpoint" -m "- Add tests" 

Short summary (50 characters or less) More detailed explanatory text, if necessary. Wrap it to about 72 characters. The blank line separating the summary from the body is critical; tools like git log --oneline will only show the summary. Explain the problem that this commit is solving. Focus on why you are making this change as opposed to how (the code explains that). Are there side effects or other unintuitive consequences of this change? Here's the place to explain them. - Bullet points are okay - Use a hyphen or asterisk for bullets If you use an issue tracker, put references to them at the bottom: Resolves: #123 See also: #456, #789 

git commit -m "feat: add user authentication with JWT" git commit -m "fix: resolve null pointer in payment processing" git commit -m "docs: update API documentation" git commit -m "refactor: simplify database query logic" git commit -m "test: add unit tests for auth module" git commit -m "chore: update dependencies" 

# Stage and commit modified tracked files in one step git commit -a -m "Update all tracked files" git commit -am "Update all tracked files" 

# Modify the last commit git commit --amend # Amend without changing message git commit --amend --no-edit # Amend and change message git commit --amend -m "Corrected commit message" 

# Made a commit git commit -m "Add feature X" # Oops, forgot to include a file git add forgotten-file.txt git commit --amend --no-edit # Or fix typo in commit message git commit --amend -m "Add feature X (corrected)" 

# Create commit without changes (useful for triggering CI/CD) git commit --allow-empty -m "Trigger CI pipeline" 

# Set custom commit date git commit --date="2024-01-15 10:30:00" -m "Backdated commit" # Use author date instead of commit date GIT_AUTHOR_DATE="2024-01-15 10:30:00" git commit -m "Message" 

# Commit with different author git commit --author="Jane Doe <jane@example.com>" -m "Fix bug" 

# Sign commit with GPG key git commit -S -m "Signed commit" git commit --gpg-sign -m "Signed commit" # Configure automatic signing git config --global commit.gpgsign true 

# Show diff in commit message editor git commit -v git commit --verbose 

# Use commit message template git config --global commit.template ~/.gitmessage.txt 

# [Type] Short description (max 50 chars) # Detailed description (wrap at 72 chars) # Explain WHY this change is being made # Related issues # Resolves: # # See also: # 

# Stage specific changes, then commit git add -p file.txt git commit -m "Add first feature" git add -p file.txt git commit -m "Add second feature" 

# Commit specific files, bypassing staging area git commit file1.txt file2.txt -m "Update specific files" 

# Reuse message from previous commit git commit -C HEAD -m "Same message as before" # Edit the reused message git commit -c HEAD 

# Bad: Everything in one commit git add . git commit -m "Various updates" # Good: Separate logical commits git add src/auth.js git commit -m "feat: add JWT authentication" git add src/validation.js git commit -m "feat: add input validation" git add tests/auth.test.js git commit -m "test: add authentication tests" git add README.md git commit -m "docs: update authentication section" 

# Too infrequent (bad) # Work all day, commit once with "Day's work" # Too frequent (bad) # Commit after every line change # Just right (good) # Commit after each logical, working change git commit -m "feat: add login form" git commit -m "feat: add form validation" git commit -m "feat: connect form to API" git commit -m "test: add login form tests" 

# Quick checkpoint git commit -m "WIP: working on feature X" # More checkpoints git commit -m "WIP: partial implementation" # Before pushing, squash WIP commits git rebase -i HEAD~3 # Mark WIP commits with 'squash' or 'fixup' 

# Check what's staged git diff --staged git diff --cached # Check status git status # Run tests npm test # or your test command # Then commit git commit -m "feat: add feature X" 

git commit -m "feat: add password reset functionality Implement password reset workflow: - Add /forgot-password endpoint - Send email with reset token - Add token validation - Allow password update with valid token Closes #234" 

git commit -m "fix: resolve race condition in payment processing The payment confirmation was sometimes sent before database commit, causing confusion when users refreshed and saw 'pending' status. Now we ensure database commit completes before sending confirmation. Fixes #567" 

git commit -m "refactor: extract user validation into separate module No functional changes. Improves code organization and makes validation logic reusable across auth and profile modules." 

git commit -m "docs: add API authentication guide Add comprehensive guide covering: - JWT token generation - Token refresh flow - Error handling - Code examples in multiple languages" 

# Show unstaged changes (working directory vs staging area) git diff # Show staged changes (staging area vs last commit) git diff --staged git diff --cached # Show all changes (working directory vs last commit) git diff HEAD 

$ git diff example.txt diff --git a/example.txt b/example.txt index 1234567..abcdefg 100644 --- a/example.txt +++ b/example.txt @@ -1,5 +1,6 @@ Line 1 Line 2 -Line 3 +Line 3 modified +Line 4 added Line 5 

# Compare two commits git diff commit1 commit2 # Compare with specific commit git diff abc123 # Compare with HEAD git diff HEAD git diff HEAD~1 # One commit before HEAD git diff HEAD~5 # Five commits before HEAD # Compare with branch git diff main git diff origin/main 

# Show differences between branches git diff main..feature-branch # Show what's in feature-branch but not in main git diff main...feature-branch # Compare current branch with main git diff main 

# Diff specific file git diff filename.txt # Diff specific file between commits git diff commit1 commit2 filename.txt # Diff specific file on different branch git diff main:file.txt feature:file.txt 

# Show summary statistics git diff --stat # Show statistics and brief diff git diff --shortstat # Show file name and statistics git diff --numstat # Show summary of changes git diff --summary 

$ git diff --stat file1.txt | 10 +++++----- file2.txt | 5 +++++ file3.txt | 15 --------------- 3 files changed, 15 insertions(+), 20 deletions(-) 

# Show word-by-word differences (better for prose) git diff --word-diff # Color word diff git diff --word-diff=color # Show only changed words git diff --word-diff=plain 

# Ignore whitespace changes git diff -w git diff --ignore-all-space # Ignore whitespace at line end git diff --ignore-space-at-eol # Ignore whitespace amount changes git diff -b git diff --ignore-space-change 

# Show 10 lines of context instead of default 3 git diff -U10 git diff --unified=10 # Show entire file git diff --unified=999999 # Show only changes, no context git diff -U0 

# Force color output (useful for piping) git diff --color # Highlight moved code git diff --color-moved # Show whitespace errors git diff --check 

# Use external diff tool git difftool # Use specific tool git difftool --tool=meld # Compare directory git difftool --dir-diff 

# Show function name in hunk headers git diff -p git diff --show-function # For Python/Java/C, shows which function changed 

# Detect renames (default) git diff -M git diff --find-renames # Detect renames with threshold (50% similarity) git diff -M50% # Detect copies as well git diff -C git diff --find-copies 

# Show binary files changed git diff --binary # Don't show binary file differences git diff --no-binary 

# Use different diff algorithm git diff --minimal # Spend extra time to find smaller diff git diff --patience # Patience algorithm (better for complex changes) git diff --histogram # Histogram algorithm (fast and good) # Configure default algorithm git config --global diff.algorithm histogram 

# Show only added files git diff --diff-filter=A # Show only deleted files git diff --diff-filter=D # Show only modified files git diff --diff-filter=M # Show renamed files git diff --diff-filter=R # Combine filters (added or modified) git diff --diff-filter=AM 

# Review what you're about to commit git diff --staged # If using multiple stages, review each step git diff # Unstaged changes git diff --staged # Staged changes git diff HEAD # All changes since last commit 

# Review all changes in feature branch git diff main...feature-branch # Review specific file changes git diff main...feature-branch -- src/ # Get statistics for pull request git diff main...feature-branch --stat 

# Compare current broken state with last known good commit git diff known-good-commit current-broken-commit # Focus on specific problematic file git diff known-good-commit current-broken-commit -- src/buggy-file.js 

# See what changed in latest pull git fetch git diff HEAD origin/main # Review changes before merging git diff main origin/feature-branch 

# Find whitespace errors before committing git diff --check # See exactly what whitespace changed git diff --ws-error-highlight=all 

# Create patch file git diff > changes.patch # Create patch for specific commits git diff commit1 commit2 > feature.patch # Apply patch git apply changes.patch # Apply patch and stage changes git apply --index changes.patch 

# Default unified format git diff # Context format (old-style) git diff --context # Raw format (for scripts) git diff --raw # Name only git diff --name-only # Name and status git diff --name-status 

# For large repositories, limit diff git diff --patience # More accurate but slower git diff --minimal # Spend extra time finding minimal diff git diff -U0 # No context (faster) # Skip binary files git diff --no-binary 

# Discard changes in working directory (restore from staging area or HEAD) git restore filename.txt # Discard all changes git restore . # Unstage file (restore staging area from HEAD) git restore --staged filename.txt # Unstage all files git restore --staged . 

# Restore from HEAD (last commit) git restore --source=HEAD filename.txt # Restore from specific commit git restore --source=abc123 filename.txt # Restore from different branch git restore --source=main filename.txt # Restore from previous commit git restore --source=HEAD~1 filename.txt 

# Restore file in both working directory and staging area git restore --staged --worktree filename.txt # Short version git restore -SW filename.txt 

# Interactively choose changes to discard git restore -p filename.txt git restore --patch filename.txt 

# Restore entire directory git restore src/ # Restore by pattern git restore '*.txt' # Restore from specific source and path git restore --source=main -- src/ 

# Show what would be restored (dry run) git restore --dry-run filename.txt # Merge restored content (when conflicts) git restore --merge filename.txt # Keep unmerged entries (during conflict resolution) git restore --ours filename.txt git restore --theirs filename.txt 

# Overlay mode (default): only restore specified files git restore --overlay filename.txt # No-overlay: remove files in target that aren't in source git restore --no-overlay --source=main src/ 

# Oops, made unwanted changes to file git status # modified: important-file.txt # Discard changes git restore important-file.txt # Verify git status # nothing to commit, working tree clean 

# Added wrong file git add secrets.txt git status # Changes to be committed: secrets.txt # Unstage it git restore --staged secrets.txt git status # Untracked files: secrets.txt # Add to .gitignore echo "secrets.txt" >> .gitignore 

# File has multiple changes, keep some, discard others git restore -p complex-file.js # Interactively choose: # y - discard this hunk # n - keep this hunk # q - quit # s - split into smaller hunks 

# Need version of file from main branch git restore --source=main -- config/settings.json # This brings main's version to working directory without switching branches 

# Staged changes AND working directory changes git restore -SW buggy-file.py # File now matches HEAD exactly 

# OLD WAY (still works but discouraged) git checkout -- filename.txt # Discard changes git reset HEAD filename.txt # Unstage # NEW WAY (clearer) git restore filename.txt # Discard changes git restore --staged filename.txt # Unstage 

# DANGEROUS: Discards ALL local changes git restore . # SAFER: Check what you're about to discard git diff # See unstaged changes git status # See overall state git stash # Consider stashing instead # Then decide git restore filename.txt # Discard specific file 

# Remove file from working directory and stage deletion git rm filename.txt # Remove multiple files git rm file1.txt file2.txt file3.txt # Remove all .log files git rm *.log # Remove directory recursively git rm -r directory/ 

# Stop tracking file but keep in working directory git rm --cached filename.txt # Remove from Git, keep locally (common for .env files) git rm --cached .env echo ".env" >> .gitignore git commit -m "Stop tracking .env file" 

# Force remove (even if file has uncommitted changes) git rm -f filename.txt git rm --force filename.txt 

# See what would be removed git rm --dry-run -r directory/ git rm -n *.txt 

# Remove all .txt files in directory git rm directory/*.txt # Remove all .log files recursively git rm -r '*.log' 

$ git rm modified-file.txt error: the following file has changes staged in the index: modified-file.txt # Options: # 1. Commit changes first git commit -am "Save changes before removing" git rm modified-file.txt # 2. Force remove (loses changes) git rm -f modified-file.txt # 3. Unstage and remove git restore --staged modified-file.txt git rm modified-file.txt 

# OH NO! Committed API keys git rm --cached config/secrets.yml echo "config/secrets.yml" >> .gitignore git commit -m "Remove secrets file from tracking" # Note: This doesn't remove from history! # File still exists in previous commits # For complete removal, need git filter-branch or BFG Repo-Cleaner 

# Remove entire deprecated module git rm -r src/old-module/ git commit -m "Remove deprecated authentication module" 

# Stop tracking node_modules but keep locally git rm -r --cached node_modules/ echo "node_modules/" >> .gitignore git commit -m "Stop tracking node_modules" 

# Remove all temporary files git rm '*.tmp' '*.cache' '*.swp' git commit -m "Remove temporary files" 

rm filename.txt # Delete file git add filename.txt # Stage deletion git commit -m "Remove file" 

git rm filename.txt # Delete AND stage in one step git commit -m "Remove file" 

rm filename.txt git commit -am "Remove file" # Works but less explicit 

# Undo git rm before commit git restore --staged filename.txt # Unstage git restore filename.txt # Restore file # Or in one step (old command) git checkout HEAD filename.txt 

# Restore file from previous commit git restore --source=HEAD~1 filename.txt # Or checkout from history git checkout HEAD~1 -- filename.txt 

# Rename file git mv oldname.txt newname.txt # Move file to directory git mv file.txt directory/ # Move and rename git mv old-name.txt new-directory/new-name.txt # Move directory git mv old-directory/ new-directory/ 

mv oldname.txt newname.txt git rm oldname.txt git add newname.txt 

# These are equivalent: git mv file.txt renamed.txt # Same as: mv file.txt renamed.txt git add renamed.txt git rm file.txt 

# Status shows rename $ git mv readme.txt README.md $ git status Changes to be committed: renamed: readme.txt -> README.md # In log git log --follow README.md # Shows history through renames 

# Overwrite existing file (dangerous!) git mv -f source.txt destination.txt git mv --force source.txt destination.txt 

# See what would happen git mv -n oldname.txt newname.txt git mv --dry-run oldname.txt newname.txt 

# This might not work on case-insensitive systems: git mv file.txt File.txt # Solution: use intermediate name git mv file.txt temp.txt git mv temp.txt File.txt git commit -m "Fix file name casing" 

# Move related files into subdirectory mkdir utils git mv helper1.py utils/ git mv helper2.py utils/ git mv validator.py utils/ git commit -m "Organize utility functions into utils/ directory" 

# Rename to follow naming convention git mv myComponent.js MyComponent.js # React component git mv database_helper.py db_helper.py # Python convention git commit -m "Rename files to follow project conventions" 

# Rename multiple files (using shell script) for file in *.html; do git mv "$file" "${file%.html}.htm" done git commit -m "Change file extension from .html to .htm" 

# Rename file git mv old-implementation.js new-implementation.js git commit -m "Rename old-implementation to new-implementation" # View history following renames git log --follow new-implementation.js # Shows full history including when it was "old-implementation.js" 

# Configure similarity threshold (default 50%) git config diff.renameLimit 1000 git config diff.renames copies # Also detect copies # View renames in log with similarity percentage git log --stat -M # Show renames git log --stat -C # Show renames and copies 

# Detect renames even if only 30% similar git log --find-renames=30% # Show exact rename percentage git log --stat -M --summary 

# After manual move mv oldname.txt newname.txt # Git shows as delete + add $ git status deleted: oldname.txt untracked: newname.txt # Fix it git rm oldname.txt git add newname.txt # Commit with both staged git commit -m "Rename oldname to newname" # Git will detect rename if content is similar enough 

main → commit C feature → commit E A ← B ← C (main) ↖ D ← E (feature) 

# List local branches git branch # List all branches (including remote) git branch -a git branch --all # List remote branches only git branch -r git branch --remotes # Create new branch (doesn't switch to it) git branch feature-x # Create branch from specific commit git branch feature-x abc123 # Create branch from another branch git branch feature-x develop 

# Show last commit on each branch git branch -v git branch --verbose # Show tracking information git branch -vv # Show merged branches git branch --merged # Show unmerged branches git branch --no-merged 

$ git branch -vv * main abc123 [origin/main] Latest commit message develop def456 [origin/develop: ahead 2] Work in progress feature ghi789 Feature implementation 

# Delete branch (safe: prevents deleting unmerged branches) git branch -d feature-x git branch --delete feature-x # Force delete (even if unmerged) git branch -D feature-x git branch --delete --force feature-x # Delete remote branch git push origin --delete feature-x git push origin :feature-x # Old syntax 

# Rename current branch git branch -m new-name git branch --move new-name # Rename different branch git branch -m old-name new-name # Force rename (overwrite existing) git branch -M old-name new-name 

# Rename local branch git branch -m old-name new-name # Delete old remote branch git push origin --delete old-name # Push new branch and set upstream git push origin -u new-name 

# Create and switch (two commands) git branch feature-x git checkout feature-x # Better: create and switch in one command git checkout -b feature-x # Modern way (Git 2.23+) git switch -c feature-x 

# Copy branch to new name git branch -c existing-branch new-branch git branch --copy existing-branch new-branch # Force copy (overwrite if exists) git branch -C existing-branch new-branch 

# Set upstream for existing branch git branch -u origin/feature-x git branch --set-upstream-to=origin/feature-x # Remove upstream tracking git branch --unset-upstream 

# Create branch from tag git branch hotfix v1.2.3 # Create branch from remote branch git branch local-feature origin/remote-feature # Create branch from specific commit git branch bugfix abc123def 

# List branches matching pattern git branch --list 'feature/*' git branch --list '*fix*' # Case-insensitive matching git branch -i --list 'FEATURE/*' 

# Sort by commit date git branch --sort=-committerdate # Sort by author date git branch --sort=-authordate # Sort alphabetically (default) git branch --sort=refname 

# Always use colors git branch --color=always # Never use colors git branch --color=never # Auto (default) git branch --color=auto 

# Create feature branch from main git checkout main git pull git checkout -b feature/user-authentication # Work on feature git add . git commit -m "Implement login endpoint" # Push to remote git push -u origin feature/user-authentication # After review and merge, delete git checkout main git branch -d feature/user-authentication git push origin --delete feature/user-authentication 

# Create release branch from develop git checkout develop git checkout -b release/v2.0 # Finalize release (bug fixes only) git commit -m "Bump version to 2.0" # Merge to main git checkout main git merge release/v2.0 git tag v2.0 # Merge back to develop git checkout develop git merge release/v2.0 # Delete release branch git branch -d release/v2.0 

# Critical bug in production! git checkout main git checkout -b hotfix/critical-security-fix # Fix and test git commit -m "Fix SQL injection vulnerability" # Merge to main git checkout main git merge hotfix/critical-security-fix git tag v1.2.1 # Merge to develop git checkout develop git merge hotfix/critical-security-fix # Delete hotfix branch git branch -d hotfix/critical-security-fix 

# Switch to existing branch git checkout existing-branch # Create and switch to new branch git checkout -b new-branch # Create branch from specific commit and switch git checkout -b hotfix abc123 # Switch to previous branch git checkout - # Switch to remote branch (creates tracking branch) git checkout remote-branch 

# If you have uncommitted changes $ git checkout other-branch error: Your local changes would be overwritten by checkout # Options: # 1. Commit changes git commit -am "WIP" # 2. Stash changes git stash git checkout other-branch git stash pop # 3. Force checkout (DANGEROUS - loses changes) git checkout -f other-branch 

# Checkout specific commit git checkout abc123 # You're now in detached HEAD state $ git status HEAD detached at abc123 # Any commits made here are orphaned unless you create a branch git checkout -b save-my-work 

# Restore file from HEAD git checkout -- filename.txt # Restore file from specific commit git checkout abc123 -- filename.txt # Restore file from different branch git checkout main -- config.yml # Restore entire directory git checkout main -- src/ 

# Attempt three-way merge when switching branches git checkout -m branch-name # If conflicts, resolves what it can and marks conflicts 

# Create branch with no history (useful for gh-pages) git checkout --orphan gh-pages git rm -rf . # Add new content git add . git commit -m "Initial GitHub Pages commit" 

# Create tracking branch git checkout -t origin/feature-x git checkout --track origin/feature-x # Create with different name git checkout -b local-name origin/remote-name 

# Checkout and discard all local changes git checkout -f branch-name git checkout --force branch-name 

# Switch to existing branch git switch branch-name # Create and switch to new branch git switch -c new-branch git switch --create new-branch # Switch to previous branch git switch - # Force switch (discard local changes) git switch -f branch-name git switch --force branch-name # Discard local changes with confirmation git switch --discard-changes branch-name 

# Create branch from specific commit and switch git switch -c bugfix abc123 # Create from remote branch git switch -c local-feature origin/remote-feature 

# If "feature" doesn't exist locally but "origin/feature" does git switch feature # Automatically creates local tracking branch 

# Switch to specific commit (detached HEAD) git switch --detach abc123 # Create branch from detached HEAD git switch -c save-detached-work 

# OLD WAY (still works) git checkout branch-name git checkout -b new-branch # NEW WAY (clearer) git switch branch-name git switch -c new-branch 

# Feature branches feature/user-authentication feature/payment-integration feat/shopping-cart # Bug fix branches bugfix/login-error fix/memory-leak hotfix/security-vulnerability # Release branches release/v1.2.0 release/2024-q1 # Experimental branches experiment/new-architecture poc/graphql-migration 

# 1. Create from up-to-date main git checkout main git pull git checkout -b feature/new-feature # 2. Regular commits git commit -m "Progress on feature" # 3. Keep updated with main git checkout main git pull git checkout feature/new-feature git merge main # or rebase # 4. Push to remote git push -u origin feature/new-feature # 5. Create pull request (on GitHub/GitLab/etc.) # 6. After merge, clean up git checkout main git pull git branch -d feature/new-feature git push origin --delete feature/new-feature 

# List merged branches git branch --merged main # Delete all merged branches (except main) git branch --merged main | grep -v "\* main" | xargs -n 1 git branch -d # Delete remote-tracking branches that no longer exist git fetch --prune git fetch -p # Remove stale remote-tracking references git remote prune origin 

# Merge branch into current branch git merge feature-branch # Merge with commit message git merge feature-branch -m "Merge feature X implementation" # Merge without committing (stage changes) git merge --no-commit feature-branch # Abort merge git merge --abort 

 C---D (feature) / A---B---E---F (main) After merge: C---D / \ A---B---E---F---G (main, merge commit G) 

# Before: A---B---C (main) \ D---E (feature) # After fast-forward merge: A---B---C---D---E (main, feature) 

# Fast-forward merge happens automatically git checkout main git merge feature # Fast-forward # Force merge commit even for fast-forward git merge --no-ff feature 

# Before: C---D (feature) / A---B---E (main) # After three-way merge: C---D / \ A---B---E---F (main, merge commit) 

git merge --squash feature-branch git commit -m "Implement feature X (squashed)" 

# Explicit recursive strategy git merge -s recursive feature-branch git merge --strategy=recursive feature-branch # With strategy options git merge -s recursive -X ours feature-branch # Prefer our changes git merge -s recursive -X theirs feature-branch # Prefer their changes 

# Use our version entirely, discard theirs git merge -s ours obsolete-feature 

# Merge multiple branches at once git merge feature1 feature2 feature3 

# Merge as subdirectory git merge -s subtree sub-project-branch 

# Ignore whitespace changes git merge -Xignore-space-change feature # Ignore all whitespace git merge -Xignore-all-space feature # Be more patient (better conflict resolution) git merge -Xpatience feature # Use diff3 conflict style (shows common ancestor) git merge -Xdiff3 feature # Rename threshold (for rename detection) git merge -Xrename-threshold=50% feature 

# Verify merge would succeed before doing it git merge --no-commit --no-ff feature git diff --staged # Review changes git merge --abort # Back out if not happy # Or just check if branches can merge git merge-base main feature # Shows common ancestor 

# Only allow fast-forward merges git merge --ff-only feature # Fails if fast-forward not possible # Always create merge commit (no fast-forward) git merge --no-ff feature # Allow fast-forward (default) git merge --ff feature 

# Use theirs version for specific file git checkout --theirs conflicted-file.txt git add conflicted-file.txt # Use ours version git checkout --ours conflicted-file.txt git add conflicted-file.txt 

def calculate_total(items): <<<<<<< HEAD (Current Change) total = sum(item.price for item in items) return total * 1.1 # Add 10% tax ======= total = sum(item.cost for item in items) return total * 1.15 # Add 15% tax >>>>>>> feature-branch (Incoming Change) 

$ git merge feature-branch Auto-merging src/calculator.py CONFLICT (content): Merge conflict in src/calculator.py Automatic merge failed; fix conflicts and then commit the result. # Check status $ git status Unmerged paths: (use "git add <file>..." to mark resolution) both modified: src/calculator.py 

# Use your editor vim src/calculator.py code src/calculator.py nano src/calculator.py 

# Option 1: Keep ours def calculate_total(items): total = sum(item.price for item in items) return total * 1.1 # Option 2: Keep theirs def calculate_total(items): total = sum(item.cost for item in items) return total * 1.15 # Option 3: Combine (often best) def calculate_total(items): # Use 'price' attribute (from HEAD)  total = sum(item.price for item in items) # Use 15% tax rate (from feature-branch)  return total * 1.15 

# Stage resolved file git add src/calculator.py # Check status git status # All conflicts fixed: run "git commit" 

# Commit merge git commit # Opens editor with merge commit message # Or provide message directly git commit -m "Merge feature-branch, resolve calculation conflicts" 

# Launch configured merge tool git mergetool # Use specific tool git mergetool --tool=meld git mergetool --tool=kdiff3 git mergetool --tool=vimdiff 

# Set default merge tool git config --global merge.tool meld # Don't save backup files (.orig) git config --global mergetool.keepBackup false # Don't prompt before launching git config --global mergetool.prompt false 

# Accept all "ours" changes git checkout --ours . # Accept all "theirs" changes git checkout --theirs . # For specific files git checkout --ours path/to/file git checkout --theirs path/to/file 

# Configure diff3 style git config --global merge.conflictstyle diff3 # Conflict now shows: <<<<<<< HEAD current version ||||||| merged common ancestor original version ======= incoming version >>>>>>> branch 

# Configure default merge strategy git config --global pull.rebase false # merge (default) git config --global pull.rebase true # rebase # Always use ours for specific file types git config --global merge.ours.driver true # Then in .gitattributes: # *.config merge=ours 

# Made a mistake? Abort and restart git merge --abort # Or reset to before merge git reset --hard HEAD 

# If merge was stopped (e.g., by pre-commit hook) git merge --continue 

# During rebase, skip commit causing conflicts git rebase --skip # Or cherry-pick git cherry-pick --skip 

# List conflicted files git diff --name-only --diff-filter=U # Show conflicts for specific file git diff file.txt # Show changes from both sides git diff HEAD...MERGE_HEAD 

# Merge causes conflict $ git merge feature CONFLICT (content): Merge conflict in app.js # Edit app.js, resolve conflicts, remove markers # Stage resolved file git add app.js # Complete merge git commit 

# Multiple conflicts $ git merge feature CONFLICT in file1.js CONFLICT in file2.js CONFLICT in file3.js # Resolve each file vim file1.js # resolve git add file1.js vim file2.js # resolve git add file2.js vim file3.js # resolve git add file3.js # Commit when all resolved git commit 

# Launch merge tool for all conflicts git mergetool # Resolve in GUI # Tool stages files automatically # Clean up backup files rm *.orig # Commit git commit 

# Feature branch is definitely correct git checkout --theirs . git add . git commit -m "Merge feature, accepting all their changes" # Or main is definitely correct git checkout --ours . git add . git commit -m "Merge feature, keeping our changes" 

# Use diff3 to see ancestor git config merge.conflictstyle diff3 git merge feature # In file: <<<<<<< HEAD new implementation ||||||| merged common ancestor old implementation ======= alternative new implementation >>>>>>> feature # Now you understand: # - Old had X # - We changed X to Y # - They changed X to Z # - Need to combine Y and Z approaches 

# Regularly merge main into feature branch git checkout feature git merge main 

# Rebase current branch onto main git rebase main # Rebase feature branch onto main (while on feature) git checkout feature git rebase main # Rebase specific branch onto another git rebase main feature-branch # Interactive rebase git rebase -i HEAD~5 git rebase --interactive HEAD~5 

Before rebase: C---D (feature) / A---B---E---F (main) After git checkout feature; git rebase main: C'---D' (feature) / A---B---E---F (main) 

# Safe: Rebasing local, unpushed commits git checkout feature git rebase main 

# DANGEROUS: Rebasing shared branch git checkout main # Public branch! git rebase some-branch # DON'T DO THIS 

# Rebase last 5 commits interactively git rebase -i HEAD~5 # Rebase all commits since main git rebase -i main # Rebase from specific commit git rebase -i abc123 

pick abc123 Add user authentication pick def456 Fix typo in authentication pick ghi789 Add password validation pick jkl012 Update documentation pick mno345 Fix bug in validation # Rebase abc123..mno345 onto previous commit # # Commands: # p, pick <commit> = use commit # r, reword <commit> = use commit, but edit message # e, edit <commit> = use commit, but stop for amending # s, squash <commit> = use commit, meld into previous commit # f, fixup <commit> = like squash, discard commit message # x, exec <command> = run command # b, break = stop here (continue with 'git rebase --continue') # d, drop <commit> = remove commit # l, label <label> = label current HEAD # t, reset <label> = reset HEAD to label # m, merge [-C <commit> | -c <commit>] <label> [# <oneline>] 

pick abc123 Add feature 

reword def456 Fix typo # Will prompt for new message 

edit ghi789 Add validation # Git stops here, you can: # - Amend commit: git commit --amend # - Split commit: git reset HEAD^, then make multiple commits # - Continue: git rebase --continue 

pick abc123 Add feature squash def456 Add tests for feature # Git combines both, lets you edit combined message 

pick abc123 Add feature fixup def456 Fix typo # Git combines, keeps only first message 

drop ghi789 Experimental code 

pick abc123 Add feature exec npm test pick def456 Add another feature exec npm test # Runs tests after each commit 

# You have: abc123 WIP: start feature def456 WIP: continue ghi789 WIP: almost done jkl012 Feature complete mno345 Fix typo pqr678 Actually fix typo # Clean it up: git rebase -i HEAD~6 # Change to: pick abc123 WIP: start feature fixup def456 WIP: continue fixup ghi789 WIP: almost done reword jkl012 Feature complete fixup mno345 Fix typo fixup pqr678 Actually fix typo # Result: Two clean commits 

# You have: abc123 Add feature A def456 Add feature B ghi789 Fix bug in feature A jkl012 Add tests for feature B # Reorder logically: git rebase -i HEAD~4 # Change to: pick abc123 Add feature A pick ghi789 Fix bug in feature A pick def456 Add feature B pick jkl012 Add tests for feature B 

# One commit does too much git rebase -i HEAD~3 # Mark commit with 'edit': edit abc123 Add many features pick def456 Other commit # When Git stops: git reset HEAD^ # Now make separate commits: git add feature1.js git commit -m "Add feature 1" git add feature2.js git commit -m "Add feature 2" # Continue rebase: git rebase --continue 

# Oops, committed secrets git rebase -i HEAD~10 # Find commit with secrets: drop ghi789 Add configuration (contains secrets!) # Or edit to remove just the sensitive file: edit ghi789 Add configuration git rm --cached secrets.yml git commit --amend git rebase --continue 

$ git rebase main ... CONFLICT (content): Merge conflict in file.txt error: could not apply abc123... Commit message hint: Resolve all conflicts manually, mark them as resolved with hint: "git add/rm <conflicted_files>", then run "git rebase --continue". 

# 1. Fix conflicts in files vim file.txt # Resolve conflicts # 2. Stage resolved files git add file.txt # 3. Continue rebase git rebase --continue # If you want to skip this commit: git rebase --skip # If you want to abort entirely: git rebase --abort 

# Keep feature branch up-to-date with main git checkout feature git rebase main # If conflicts, resolve and continue git add resolved-file.txt git rebase --continue # Force push (since history changed) git push --force-with-lease origin feature 

# Squash all feature commits into one git checkout feature git rebase -i main # Mark all except first as 'squash' or 'fixup' pick abc123 First commit squash def456 Second commit squash ghi789 Third commit # Edit combined message, then: git push --force-with-lease 

# Fix commit messages, combine WIP commits git rebase -i HEAD~10 # Reword unclear messages # Fixup WIP commits # Reorder for logical flow # Force push git push --force-with-lease 

# Preserve merge commits during rebase git rebase --preserve-merges main git rebase -p main # Note: --preserve-merges is deprecated, use --rebase-merges git rebase --rebase-merges main 

# Rebase onto different branch than fork point git rebase --onto new-base old-base branch # Example: Move feature from main to develop # Before: # main: A---B---C # feature: D---E # develop: A---B---F---G # # After git rebase --onto develop main feature: # main: A---B---C # develop: A---B---F---G # feature: D'---E' 

# Create fixup commits git commit --fixup=abc123 git commit --squash=def456 # Rebase with autosquash git rebase -i --autosquash main # Configure as default git config --global rebase.autosquash true 

# Automatically stash and reapply during rebase git rebase --autostash main # Configure as default git config --global rebase.autostash true 

# After rebase, force push required (history changed) git push --force-with-lease # This fails if someone else pushed to branch # Safer than --force which overwrites unconditionally 

git checkout feature git rebase main 

git rebase -i HEAD~5 

# Instead of merging main into feature repeatedly git rebase main # Creates linear history 

# Fix last commit git commit --amend # Fix earlier commits git rebase -i HEAD~3 

# NEVER do this: git checkout main git rebase feature # Rewrites public history! 

# DANGEROUS: git rebase main # If others branched from your commits git push --force 

# Sometimes merge commits are informative git merge feature # Shows when feature was integrated 

# Safe: Rebase commits not yet pushed git rebase main # Check if commits are pushed: git log origin/feature..feature # Shows unpushed commits 

# Safer force push git push --force-with-lease origin feature # This fails if remote has commits you don't have locally # Prevents accidentally overwriting others' work 

# After rebase, verify everything works git rebase main npm test # or your test command git push --force-with-lease 

# Don't rebase too many commits at once git rebase -i HEAD~5 # Manageable # Instead of: git rebase -i HEAD~50 # Too many, error-prone 

# Bad: "Fix stuff" # Good: "Fix null pointer exception in payment processing" 

# During rebase, if things are messy git rebase --abort # Returns to state before rebase started 

# View reflog git reflog # Output: abc123 HEAD@{0}: rebase: Add feature def456 HEAD@{1}: rebase: Fix bug ghi789 HEAD@{2}: rebase: Start jkl012 HEAD@{3}: commit: Original state (before rebase) # Reset to before rebase git reset --hard HEAD@{3} # or git reset --hard jkl012 

# Find lost commit in reflog git reflog | grep "lost commit message" # Cherry-pick it back git cherry-pick abc123 

# If you force pushed and broke things for others: # Option 1: Revert the force push (if possible) git reset --hard origin/feature@{1} # Previous state git push --force-with-lease # Option 2: Create revert commits git revert abc123..def456 git push 

# List remotes git remote # List with URLs git remote -v git remote --verbose # Add remote git remote add origin https://github.com/user/repo.git # Add remote with different name git remote add upstream https://github.com/original/repo.git # Remove remote git remote remove origin git remote rm origin # Rename remote git remote rename old-name new-name # Change remote URL git remote set-url origin https://github.com/user/new-repo.git 

# Show detailed information about remote git remote show origin # Output includes: # - Fetch/push URLs # - Remote branches # - Local branches configured for push/pull # - Stale branches 

$ git remote show origin * remote origin Fetch URL: https://github.com/user/repo.git Push URL: https://github.com/user/repo.git HEAD branch: main Remote branches: main tracked develop tracked feature/new-feature tracked refs/remotes/origin/old-branch stale (use 'git remote prune' to remove) Local branch configured for 'git pull': main merges with remote main Local ref configured for 'git push': main pushes to main (up to date) 

# Add original repository as 'upstream' git remote add upstream https://github.com/original/repo.git # Add your fork as 'origin' git remote add origin https://github.com/yourusername/repo.git # List remotes $ git remote -v origin https://github.com/yourusername/repo.git (fetch) origin https://github.com/yourusername/repo.git (push) upstream https://github.com/original/repo.git (fetch) upstream https://github.com/original/repo.git (push) # Fetch from upstream git fetch upstream # Merge upstream changes git merge upstream/main 

# Remove stale remote-tracking branches git remote prune origin # Show what would be pruned git remote prune origin --dry-run # Prune during fetch git fetch --prune git fetch -p 

# Switch from HTTPS to SSH git remote set-url origin git@github.com:user/repo.git # Add push URL different from fetch URL git remote set-url --add --push origin git@github.com:user/repo.git # View remote URLs git remote get-url origin git remote get-url --all origin 

# Fetch from default remote (origin) git fetch # Fetch from specific remote git fetch upstream # Fetch specific branch git fetch origin main # Fetch all remotes git fetch --all # Fetch and prune stale branches git fetch --prune git fetch -p 

Remote repository: origin/main: A---B---C---D---E Local repository before fetch: origin/main: A---B---C main: A---B---C After git fetch: origin/main: A---B---C---D---E (updated) main: A---B---C (unchanged) 

# Fetch specific branch git fetch origin feature-branch # Fetch specific tag git fetch origin tag v1.0.0 # Fetch all tags git fetch --tags # Fetch and create local branch git fetch origin feature-branch:feature-branch 

# Shallow fetch (last N commits only) git fetch --depth=10 # Deepen existing shallow clone git fetch --deepen=50 # Convert shallow to complete git fetch --unshallow # Shallow fetch single branch git fetch --depth=1 origin main 

# Remove remote-tracking branches that no longer exist on remote git fetch --prune # Aggressive pruning (also remove tags) git fetch --prune --prune-tags # Configure automatic pruning git config --global fetch.prune true 

# See what would be fetched without actually fetching git fetch --dry-run git fetch -n 

# Fetch and show what was fetched git fetch --verbose git fetch -v # Show what changed after fetch git fetch git log HEAD..origin/main # Commits on remote not on local git diff HEAD origin/main # Changes between local and remote 

# Start of day routine git fetch --all --prune # See what's new git log HEAD..origin/main --oneline # Update your branch git merge origin/main # or git rebase origin/main 

# Fetch updates git fetch origin # Review what's new without merging git log origin/main --not main --oneline git diff main origin/main # If satisfied, merge git merge origin/main 

# Fetch from all configured remotes git fetch --all # See status across remotes git branch -vv # Merge from upstream git merge upstream/main 

# Pull from tracking branch git pull # Pull from specific remote and branch git pull origin main # Pull with rebase instead of merge git pull --rebase git pull -r # Pull from specific remote git pull upstream 

# git pull is equivalent to: git fetch origin git merge origin/main # git pull --rebase is equivalent to: git fetch origin git rebase origin/main 

git pull # Creates merge commit if branches diverged 

git pull --rebase # Rebases your commits on top of remote commits # Creates linear history 

git pull --ff-only # Only succeeds if fast-forward possible # Fails if branches diverged (safety measure) 

# Use merge (default) git config --global pull.rebase false # Use rebase git config --global pull.rebase true # Use fast-forward only git config --global pull.ff only 

# Pull specific branch into current branch git pull origin feature-branch # Pull and create/update local branch git pull origin feature-branch:feature-branch 

# Pull without commit (stage changes) git pull --no-commit # Pull with verbose output git pull --verbose git pull -v # Pull all remotes git pull --all # Pull and prune git pull --prune 

$ git pull Auto-merging file.txt CONFLICT (content): Merge conflict in file.txt Automatic merge failed; fix conflicts and then commit the result. # Resolve conflicts vim file.txt # Stage resolved files git add file.txt # Complete merge git commit # Or abort pull git merge --abort 

# Explicit workflow (recommended) git fetch origin git log HEAD..origin/main # Review changes git merge origin/main # Merge when ready # Quick workflow (convenient but less control) git pull 

# Push to tracking branch git push # Push to specific remote and branch git push origin main # Push and set upstream tracking git push -u origin feature-branch git push --set-upstream origin feature-branch # Push all branches git push --all # Push tags git push --tags git push --follow-tags # Push tags reachable from pushed commits 

Local repository: main: A---B---C---D---E Remote repository before push: origin/main: A---B---C After git push origin main: origin/main: A---B---C---D---E (updated) 

# First push of new branch, set tracking git push -u origin feature-branch # Future pushes just need: git push # Configure automatic upstream setup git config --global push.autoSetupRemote true 

# Force push (DANGEROUS - overwrites remote) git push --force # Safer force push (fails if remote has changes you don't have) git push --force-with-lease # Force push specific branch git push --force-with-lease origin feature-branch 

# Delete remote branch git push origin --delete feature-branch # Old syntax (still works) git push origin :feature-branch 

# Push local branch to different remote branch git push origin local-branch:remote-branch # Push tag git push origin v1.0.0 # Push all tags git push origin --tags # Delete remote tag git push origin --delete tag v1.0.0 

# Dry run (see what would be pushed) git push --dry-run git push -n # Verbose output git push --verbose git push -v # Verify before push (run pre-push hook) git push --verify # Skip pre-push hook git push --no-verify 

# Configure default push behavior # Simple: Push current branch to its upstream (default) git config --global push.default simple # Current: Push current branch to branch of same name git config --global push.default current # Upstream: Push current branch to its upstream branch git config --global push.default upstream # Matching: Push all matching branches git config --global push.default matching # Nothing: Don't push anything unless explicitly specified git config --global push.default nothing 

$ git push To https://github.com/user/repo.git ! [rejected] main -> main (fetch first) error: failed to push some refs to 'https://github.com/user/repo.git' hint: Updates were rejected because the remote contains work that you do hint: not have locally. This is usually caused by another repository pushing hint: to the same ref. You may want to first integrate the remote changes hint: (e.g., 'git pull ...') before pushing again. # Solution 1: Pull first (merge) git pull git push # Solution 2: Pull with rebase git pull --rebase git push # Solution 3: Force push (DANGEROUS - only for personal branches) git push --force-with-lease 

# Create and switch to new branch git checkout -b feature/new-feature # Make commits git commit -am "Implement feature" # Push and set upstream git push -u origin feature/new-feature # Future pushes git push # Just works 

# Rebase feature on latest main git fetch origin git rebase origin/main # Force push (history changed) git push --force-with-lease 

# Push all branches git push --all origin # Push specific branches git push origin main develop feature-x 

# Delete merged feature branch git branch -d feature-old git push origin --delete feature-old # Or in one command git push origin --delete feature-old 

# Push specific commit message to trigger deployment git commit -m "Deploy to production [deploy]" git push # Or use tags for releases git tag -a v1.2.0 -m "Release version 1.2.0" git push origin v1.2.0 

# Show all branches with tracking info git branch -vv # Output: * main abc123 [origin/main] Latest commit feature def456 [origin/feature: ahead 2, behind 1] Work in progress local ghi789 No tracking information # Ahead 2: You have 2 commits not pushed # Behind 1: Remote has 1 commit you don't have 

# Set upstream for current branch git branch -u origin/main git branch --set-upstream-to=origin/main # Set upstream when pushing git push -u origin feature-branch # Create branch tracking remote branch git checkout -b local-branch origin/remote-branch # Or with git switch git switch -c local-branch origin/remote-branch # Automatic tracking (Git 2.37+) git config --global push.autoSetupRemote true 

# Remove upstream tracking git branch --unset-upstream # Branch no longer tracks remote 

# Fetch updates git fetch origin # See differences git log HEAD..origin/main # What's on remote you don't have git log origin/main..HEAD # What you have that's not on remote # Pull updates git pull # Push updates git push 

# Clone repository git clone https://github.com/team/project.git cd project # Make changes git add . git commit -m "Add feature" # Pull latest changes git pull # Push changes git push 

# Create feature branch git checkout -b feature/awesome-feature # Make commits git commit -am "Implement feature" # Push feature branch git push -u origin feature/awesome-feature # Create pull request on GitHub/GitLab # After review and approval, merge # Delete branch git branch -d feature/awesome-feature git push origin --delete feature/awesome-feature 

# Main branches: # - main: Production-ready code # - develop: Integration branch # Create feature branch from develop git checkout develop git checkout -b feature/new-feature # Develop feature git commit -am "Add feature" # Merge back to develop git checkout develop git merge feature/new-feature git branch -d feature/new-feature # Create release branch git checkout -b release/1.0 develop # Final testing and bug fixes # Merge to main and develop git checkout main git merge release/1.0 git tag v1.0 git checkout develop git merge release/1.0 git branch -d release/1.0 # Hotfix for production git checkout -b hotfix/critical-bug main # Fix bug git checkout main git merge hotfix/critical-bug git tag v1.0.1 git checkout develop git merge hotfix/critical-bug git branch -d hotfix/critical-bug 

# Fork repository on GitHub/GitLab # Clone your fork git clone https://github.com/yourname/project.git cd project # Add upstream remote git remote add upstream https://github.com/original/project.git # Create feature branch git checkout -b feature/contribution # Make changes and commit git commit -am "Add contribution" # Keep updated with upstream git fetch upstream git rebase upstream/main # Push to your fork git push -u origin feature/contribution # Create pull request from your fork to upstream # After merge, sync your fork git checkout main git fetch upstream git merge upstream/main git push origin main 

# Show commit history git log # One commit per line git log --oneline # Show last N commits git log -n 5 git log -5 # Show commits with diffs git log -p git log --patch # Show commit stats git log --stat # Show graph of branches git log --graph --oneline --all 

$ git log commit abc123def456... (HEAD -> main, origin/main) Author: John Doe <john@example.com> Date: Mon Dec 2 10:30:00 2024 -0800 Add user authentication feature Implemented JWT-based authentication with login and logout endpoints. Added middleware for protected routes. commit 789ghi012jkl... Author: Jane Smith <jane@example.com> Date: Sun Dec 1 15:20:00 2024 -0800 Fix bug in payment processing 

# Oneline format git log --oneline # Output: abc123 Commit message # Short format git log --pretty=short # Full format (includes committer) git log --pretty=full # Fuller format (includes dates) git log --pretty=fuller # Custom format git log --pretty=format:"%h - %an, %ar : %s" # Output: abc123 - John Doe, 2 days ago : Commit message 

git log --pretty=format:"%C(yellow)%h%Creset %C(blue)%ad%Creset %C(green)%an%Creset %s" --date=short # Or create alias: git config --global alias.lg "log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --date=relative" # Use: git lg 

# Show branch structure git log --graph # Compact graph git log --graph --oneline # All branches git log --graph --all --oneline # Decorated (show branch/tag names) git log --graph --decorate --oneline 

* abc123 (HEAD -> main) Latest commit * def456 Previous commit | * ghi789 (feature) Feature commit | * jkl012 Another feature commit |/ * mno345 Common ancestor 

# Commits by specific author git log --author="John Doe" # Multiple authors (regex) git log --author="John\|Jane" # Case-insensitive git log --author="john" -i 

# Commits after date git log --since="2024-01-01" git log --after="2 weeks ago" # Commits before date git log --until="2024-12-31" git log --before="1 month ago" # Date range git log --since="2024-01-01" --until="2024-12-31" # Relative dates git log --since="2 weeks ago" git log --since="yesterday" git log --until="3 days ago" 

# Commits with message containing text git log --grep="bug fix" # Case-insensitive git log --grep="BUG" -i # Multiple patterns (OR) git log --grep="fix" --grep="bug" # Multiple patterns (AND) git log --grep="fix" --grep="bug" --all-match # Invert match (exclude) git log --grep="WIP" --invert-grep