Git Commands Cheatsheet

Key Takeaways

• Master the Three States: Understanding the transition between the Working Directory, the Staging Area (Index), and the Repository (HEAD) is critical for error prevention.
• Branching Efficiency: Git branches are merely lightweight pointers to specific commits, making context switching nearly instantaneous compared to legacy VCS.
• History Integrity: Use git rebase for clean, linear histories in local branches, but never rebase commits that have been pushed to a shared remote.
• Data Recovery: The git reflog is your ultimate safety net, allowing you to recover "lost" commits or undone resets.
• Atomic Commits: Aim for small, single-purpose commits to simplify code reviews and make git revert operations safer.
• Conflict Resolution: Most merge conflicts arise from overlapping changes in the same lines; mastering git diff and git merge --abort is essential for workflow stability.

Introduction

In the modern software development lifecycle (SDLC), version control is not merely a tool—it is the foundational infrastructure upon which collaborative engineering is built. Since its inception by Linus Torvalds in 2005, Git has become the industry standard, currently powering over 90% of professional software development workflows. Unlike older Centralized Version Control Systems (CVCS) like Subversion (SVN), Git is a Distributed Version Control System (DVCS), meaning every developer possesses a full-fledged copy of the project history.

The complexity of Git often stems from its dual nature: it provides "porcelain" commands (user-friendly interfaces for common tasks) and "plumbing" commands (low-level operations that manipulate the underlying object database). For a developer, moving from "knowing the commands" to "understanding the mechanics" is the threshold between a junior contributor and a senior engineer. This guide serves as a high-density technical cheatsheet and deep-dive analysis into the Git ecosystem, designed to optimize your command-line proficiency and architectural understanding of version control.

Deep Analysis

To master Git, one must look past the syntax and understand the underlying data structures. Git operates as a content-addressable filesystem. Every file, directory structure, and commit is stored as an object identified by a 160-bit SHA-1 hash. This ensures data integrity; if even a single bit changes in a file, its hash changes, alerting the system to corruption or unauthorized modification.

1. The Git Object Model

The Git database consists of four primary object types:

• Blobs (Binary Large Objects): These store the actual file content. Notably, blobs do not store filenames or permissions; they only store the data.
• Trees: These represent directories. A tree object maps filenames and permissions to specific blob hashes or other tree hashes, effectively reconstructing the folder hierarchy.
• Commits: A commit object points to a specific root tree and contains metadata: the author, the committer, a timestamp, a log message, and a pointer to the parent commit(s).
• Tags: A persistent pointer to a specific commit, often used for versioning (e.g., v1.0.4).

2. The Core Workflow Lifecycle

The Git workflow is defined by the movement of data through three distinct areas. Understanding this prevents the common mistake of "losing" changes or accidentally committing sensitive data.

# 1. Working Directory: Where you modify files
# 2. Staging Area (Index): Where you prepare the next snapshot
# 3. Git Directory (Repository): Where the permanent snapshots reside

git add <file>       # Moves changes from Working Directory to Staging
git commit -m "msg"  # Moves changes from Staging to Repository

3. Categorized Command Reference

A. Setup and Initialization

These commands establish the environment for a new project or interface with an existing one.

git init                 # Initialize a new local Git repository
git clone <url>          # Download an existing repository from a remote
git config --global user.name "Name"  # Set global identity
git config --global user.email "email@example.com" # Set global identity

B. The Daily Workflow (The "Inner Loop")

These are the high-frequency commands used during active development.

git status               # Inspect the state of the working directory and index
git add <file>           # Stage a specific file
git add .                # Stage all modified and new files
git commit -m "message"  # Record the staged snapshot
git commit --amend       # Modify the most recent commit (add forgotten files or fix message)
git diff                 # Show changes between working directory and index
git diff --staged        # Show changes between index and HEAD

C. Branching and Merging

Branching is Git's "killer feature." Because a branch is just a 40-character file containing a SHA-1 hash, creating a branch is a near-zero-cost operation.

git branch               # List all local branches
git branch <name>        # Create a new branch
git checkout <branch>    # Switch to a specific branch
git checkout -b <name> # Create and switch to a new branch simultaneously
git merge <branch>      # Merge the specified branch into the current branch
git branch -d <name>    # Delete a branch (safe)
git branch -D <name>    # Force delete a branch (unsafe)

D. Remote Synchronization

In a team environment, synchronization with a central server (GitHub, GitLab, Bitbucket) is paramount.

git remote add origin <url> # Link local repo to a remote server
git fetch origin           # Download objects/refs from remote without merging
git pull origin <branch>  # Fetch AND merge remote changes into current branch
git push origin <branch>  # Upload local commits to the remote server
git remote -v              # List all configured remotes

E. Inspection and Debugging

When things go wrong, these commands allow you to perform forensic analysis on the history.

git log --oneline --graph --all # Visual representation of commit history
git log -p <file>            # Show commit history with patch/diff for a file
git show <commit_hash>      # Show details of a specific commit
git blame <file>             # Show who changed what line and when
git reflog                     # Show a log of all movements in HEAD (the ultimate undo)

4. Advanced Recovery and Undoing

The ability to move the HEAD pointer is what makes Git powerful. However, it requires precision.

• git reset --soft <commit>: Moves HEAD to the specified commit, but keeps your changes in the Staging Area. Ideal for "squashing" multiple small commits into one.
• git reset --mixed <commit>: (Default) Moves HEAD and resets the Staging Area, but keeps changes in the Working Directory.
• git reset --hard <commit>: Moves HEAD, resets Staging, and destroys all changes in the Working Directory. Use with extreme caution.
• git revert <commit>: Creates a new commit that does the exact inverse of the specified commit. This is the safe way to undo changes on a shared remote branch.

Comparison / Alternatives

While Git is dominant, understanding how it compares to other version control paradigms provides context for its design decisions.