Git Cheatsheet

Key Takeaways

Master Git by understanding three layers: Core Commands (daily operations), Reset/Revert (undo strategies), and Branching Strategies (team workflows). Most teams thrive on GitHub Flow or Feature Branch patterns. Always pull before pushing on shared branches.

Git Setup & Configuration

git config --global user.name "Your Name"
git config --global user.email "your@email.com"
git config --list                          # View all config
git config user.name "Local Name"          # Per-repo override (no --global)

Repository Initialization

git init                    # Initialize new repo
git clone [url]            # Clone existing repo

Staging & Committing

git add [file]             # Stage specific file
git add .                  # Stage all changes
git commit -m "msg"        # Commit staged changes
git status                 # View current status
git log                    # View commit history

Branching

git branch [name]          # Create new branch
git checkout [branch]      # Switch to branch
git checkout -b [branch]   # Create & switch to branch
git merge [branch]         # Merge branch into current
git branch -d [branch]     # Delete branch

Remote Operations

git remote -v              # List remote repos
git remote add origin [url] # Add remote
git push origin [branch]   # Push to remote
git pull origin [branch]   # Fetch & merge
git fetch origin           # Fetch without merging

Stashing (Temporary Storage)

git stash                  # Stash current changes
git stash list             # View all stashes
git stash pop              # Apply & remove latest stash
git stash apply stash@{n}  # Apply specific stash
git stash -u               # Stash including untracked files

Diff & Inspection

git diff                   # View unstaged changes
git diff --cached          # View staged changes
git diff branch1..branch2  # Compare branches
git log --graph            # Visualize commit history
git log -p [file]          # Show changes for file

Tagging

git tag                    # List tags
git tag -a [name] -m "msg" # Create annotated tag
git push origin --tags     # Push all tags

Merge Conflicts

git merge --abort          # Cancel merge
git checkout --ours [file] # Keep current branch version
git checkout --theirs [file] # Accept incoming version

Cleanup

git clean -n               # Dry run (preview deletions)
git clean -f               # Delete untracked files

Interview Angle

When to use Reset, Revert, or Checkout:

• git reset --soft HEAD~1: Undo last commit, keep changes staged (edit & recommit).
• git reset --hard: Discard all local changes (nuclear option—use on local branches only).
• git reset (no flags): Unstage files without losing them.
• git revert [hash]: Create new commit that undoes a specific commit (safe for shared branches).
• git checkout -- [file]: Discard changes to one file before staging.

Visual Git Workflow

graph LR
    A["Working Directory<br/>(git add)"] -->|git add| B["Staging Area<br/>(git commit)"]
    B -->|git commit| C["Local Repo<br/>(git push)"]
    C -->|git push| D["Remote Repo"]
    D -->|git fetch| E["Fetch without merge"]
    D -->|git pull| F["Fetch + Merge"]
    E -->|git merge| C
    F -->|auto-merge| C
    G["Stash Area"] -->|git stash| A
    A -->|git stash pop| G

Branching Strategies

Each strategy fits different team sizes, release cadences, and deployment needs.

Strategy	Primary Characteristics	Advantages	Use Cases	Drawbacks
Feature Branch	Branch per feature, merge to main	Simple, parallel development	Most small to mid-size teams	Merge conflicts if long-lived
GitHub Flow	Branch → PR → review → merge → deploy	Continuous delivery, simple process	SaaS, frequent releases	Less structured for complex releases
Gitflow	develop + main + feature/release/hotfix	Clear separation of concerns, planned releases	Larger projects, scheduled releases	More complex, more branch overhead
Trunk-Based	Short-lived branches, frequent merges	Optimized for CI/CD, fewer conflicts	High-velocity teams, feature flags	Requires strong testing discipline
Forking	Contributors fork, submit PRs	Decentralized, open-source standard	Open-source, external contributors	Extra PR workflow step

Interview Angle

Gitflow vs. Trunk-Based in CI/CD contexts: Gitflow suits teams releasing on a schedule (mobile apps, major versions). Trunk-Based thrives in continuous deployment (SaaS, microservices). Feature Branch is the safest starting point for most teams—simple enough to learn, flexible enough to scale.

Common Gotchas

• Never force push on shared branches (git push --force origin main)—it rewrites history and breaks teammate branches.
• Always pull before pushing to avoid conflicts and rejected pushes.
• Merge vs. Rebase confusion: Merge creates a commit, rebase replays history. Use merge for shared branches, rebase locally for clean history.
• Stale branches accumulate—delete branches after merging with git branch -d [name].
• Detached HEAD state occurs after checking out a commit; create a branch to save work: git checkout -b recovery-branch.

---

Next Steps: Master one branching strategy for your team. Practice reset/revert scenarios locally before using on shared branches.