# Git : Basics and Essential Commands ## Introduction Git is the 'undo' button that works even after your laptop has been dropped, drenched, or worst of all updated by Windows. It's a distributed version control system that tracks every change in your code, letting you rewind to any point in time, create parallel versions to experiment, and collaborate without chaos. In this guide, we'll cover Git's core concepts, essential commands, and a practical workflow. --- ## Setting Up Git Before diving into Git commands, you'll need to install and configure it on your system. This includes setting up your identity and connecting to GitHub. Follow this comprehensive setup guide from The Odin Project: [Setting Up Git](https://www.theodinproject.com/lessons/foundations-setting-up-git) Once your setup is complete, you're ready to start using Git. --- ## Git Basics and Core Terminologies Understanding Git's key concepts is essential before jumping into commands. ### Repository (Repo) A **repository** is your project folder that Git tracks. It contains your files plus a hidden `.git` folder where Git stores all version history, configuration, and metadata. Think of it as your project's time capsule. ### Working Directory The **working directory** is simply the folder on your computer where you create, edit, and delete files your normal workspace. No magic here, just your regular files. ### Staging Area (Index) The **staging area** is your shopping cart on Amazon. Your working directory is the entire store. You toss items in, take items out, change quantities then you hit 'Place order' (commit). Nothing is final until you checkout, and you can preview the exact invoice before you pay. This preview step (using `git diff --staged`) is crucial it lets you review exactly what you're about to commit. No surprises, no regrets. ### Commit A **commit** is a snapshot of your staged changes at a specific point in time. Each commit includes: * The changes you made * A descriptive message * Author information and timestamp * A unique identifier (hash) Commits are your project's breadcrumbs. Remember to **"Commit early and often"** small, focused commits beat large, mixed ones every time. ![Git Gud: The Working Tree, Staging Area, and Local Repo | by Lucas Maurer | Medium](https://miro.medium.com/1*diRLm1S5hkVoh5qeArND0Q.png align="left") ### Branch A **branch** is an independent line of development. The default branch is usually called `main`. Branches let you break things in peace experiment wildly on a feature branch while your main code stays stable and deployable. ### HEAD **HEAD** is a pointer showing which commit (or branch) you're currently on—like a "You Are Here" marker in your project's timeline. --- ## Essential Git Commands Let's explore the fundamental commands you'll use daily. Master these, and you've conquered 90% of Git. ### `git init` - Initialize a Repository Creates a new Git repository in your current directory. ```bash git init ``` **What happens**: Git creates a hidden `.git` folder containing all version control data your project's complete history, configuration, and branch information. This folder is Git's brain. You rarely need to touch it; Git commands handle everything. ### `git status` - Check Repository Status Shows the current state of your working directory and staging area. ```bash git status ``` **What it shows**: * Current branch * Modified files * Staged files (ready to commit) * Untracked files **Use this constantly**—it's your Git GPS. Run it before and after other commands to understand what's happening. When in doubt, `git status` your way out. ### `git add` - Stage Changes Adds changes to the staging area, preparing them for commit. ```bash # Stage specific files git add filename.txt # Stage all changes git add . ``` **Pro tip**: Be selective. Don't blindly `git add .` everything. Review changes with `git status` first, then stage files intentionally. Your future self will thank you during code reviews. ### `git commit` - Save Changes Creates a snapshot of staged changes with a descriptive message. ```bash # Commit with inline message git commit -m "Add homepage header and navigation" ``` **Writing good commit messages**: * Use present tense: "Add feature" not "Added feature" * Be concise but descriptive * First line under 50 characters * Explain *what* and *why*, not *how* **Bad**: "updated stuff", "fix", "changes" **Good**: "Fix login button alignment on mobile", "Add user authentication" **Example**: ```bash git add index.html git commit -m "Create basic HTML structure for homepage" ``` ### `git log` - View Commit History Displays your repository's commit history. ```bash # Basic log git log # Compact one-line view (most useful) git log --oneline # Beautiful graph view git log --oneline --graph --all ``` The `--oneline` flag is your friend—it shows commit history without overwhelming you with details. **Example output**: ```bash a3f4b2c Add navigation menu to homepage 8d7e1a9 Initial commit with HTML structure ``` --- ### `git diff` - View Changes Shows differences between various states in your repository. ```bash # Show unstaged changes git diff # Show staged changes (preview before commit) git diff --staged ``` **Always run** `git diff --staged` before committing. It's your safety check preview exactly what you're about to save. Catches embarrassing mistakes before they become permanent history. ### Other Useful Commands `git checkout` - Older syntax for switching branches (still widely used) `git restore` - Discard changes in working directory ```bash git restore filename.txt # Undo uncommitted changes ``` `git rm` - Remove files from Git tracking ```bash git rm filename.txt ``` `git blame` - See who last modified each line (for investigation, not actual blaming!) ```bash git blame filename.txt ``` ## A Basic Git Workflow Here's a practical workflow for using Git in your daily development. ### Starting a New Project ```bash # Create and initialize mkdir my-website cd my-website git init # Create files echo "

Welcome

" > index.html # Check status git status # Stage and commit git add index.html git commit -m "Initial commit: Add HTML structure" ``` --- ### The 4-Step Git Waltz ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1767700378167/5aac8ba3-00f2-4858-a72c-fe04228c6254.jpeg align="center") **Status ▶ Diff ▶ Add ▶ Commit** – DO it every 15 minutes and you'll never lose work again. ```bash # 1. STATUS - Check what changed git status # 2. DIFF - Review your changes git diff # 3. ADD - Stage what you want to save git add filename.txt # (Optional) Preview staged changes git diff --staged # 4. COMMIT - Make it permanent git commit -m "Descriptive message about changes" ``` ### Key Workflow Principles **The mantra**: **Status ▶ Diff ▶ Add ▶ Commit** **Best practices**: * Check `git status` frequently make it your reflex * Preview changes with `git diff --staged` before committing * Write clear, descriptive commit messages * Commit small, logical changes frequently * Use branches for new features or experiments * When in doubt, commit…! you can always undo, but you can't recover uncommitted work --- ## Conclusion You've now learned the fundamentals of Git the essential tool for modern software development. You understand core concepts like repositories, commits, staging, and branches, plus the key commands to manage your projects effectively. Remember two mantras: **"Commit early and often."** Small, frequent commits create a clear project history and make it easier to track down issues or undo mistakes. **"Status ▶ Diff ▶ Add ▶ Commit"** – Your four-step dance to Git mastery. Make it a habit, and version control becomes second nature. ### Helpful Resources **Git Cheat Sheets**: * [Official Git Cheat Sheet](https://git-scm.com/cheat-sheet) - Quick reference from Git's official documentation * [GitHub Git Cheat Sheet](https://education.github.com/git-cheat-sheet-education.pdf) - Comprehensive PDF guide from GitHub Education At Last I also want to add this classic xkcd one ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1767700664659/d2874529-a40d-449b-8244-d5d70a2cb9f6.jpeg align="center")