Git Basics Commands: Essential Commands Every Developer Must Know
🎯 Learning Strategy: This guide covers the 20% of Git commands you'll use 80% of the time. Master these fundamentals before moving to advanced topics.
Repository Management Commands
Repository Basics
A Git repository (or repo) is a collection of files and their complete history. These commands help you create, clone, and manage repositories.
git init
Initializes a new Git repository in the current directory.
📌 Use when: Starting a new project from scratch
What happens: Creates a hidden .git directory containing all repository metadata.
Basic Usage
git init
git init -b main
Initialize with specific branch name (sets default branch to main)
git init --bare
Initialize in bare mode (for central repositories/servers)
git init --quiet
Initialize without verbose output
git clone
Creates a local copy of an existing remote repository.
📌 Use when: Working with existing projects from GitHub, GitLab, etc.
What happens: Downloads entire repository including all history and branches.
Basic Usage
git clone https://github.com/user/repository.git
git clone repo-url project-name
Clone repository into a specific directory name
git clone -b develop repo-url
Clone specific branch only (not the default branch)
git clone --depth 1 repo-url
Shallow clone (only recent history, saves disk space)
git clone --recursive repo-url
Clone repository with all submodules
🎮 Practice Exercise 1:
1. Create a new directory:
2. Navigate into it:
3. Initialize Git:
4. Verify with:
1. Create a new directory:
mkdir practice-git2. Navigate into it:
cd practice-git3. Initialize Git:
git init4. Verify with:
ls -la (should see .git folder)
💡 Pro Tip: Use
git init when starting new projects from scratch.
Use git clone when you want to contribute to or use existing projects.
Most beginners start by cloning repositories to learn from existing code.
git status: Your Git Dashboard
Understanding Repository State
git status is your most frequently used Git command.
It shows the current state of your working directory and staging area.
Basic Usage
git status
Common git status Output Scenarios
Clean Working Directory
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
Untracked Files Present
On branch main
Untracked files:
(use "git add <file>..." to include in what will be committed)
newfile.txt
config.yml
nothing added to commit but untracked files present
Modified Files Not Staged
On branch main
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: README.md
modified: src/index.js
no changes added to commit
Files Ready to Commit
On branch main
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
new file: script.js
modified: index.html
deleted: oldfile.txt
git status -s
Short status format (compact output with status codes)
git status -sb
Short status with branch information
git status --ignored
Show ignored files in output
git status -uno
Ignore untracked files in output (cleaner view)
✅ Best Practice: Run
git status before and after every Git command.
It helps you understand what's happening and prevents mistakes.
Make it a habit - it's the Git equivalent of looking both ways before crossing.
Core Workflow Commands: Add & Commit
The Git Workflow Cycle
Files move through three states: Working Directory → Staging Area → Repository.
git add moves files from working directory to staging area.
git commit moves files from staging area to repository.
git add: Staging Changes
Moves changes from working directory to staging area.
Basic Usage
git add filename.txt
git add .
Stage all changes in current directory and subdirectories
git add -u
Stage all tracked files (modified/deleted only)
git add -A
Stage all files (new + modified + deleted)
git add *.js
Stage all JavaScript files using wildcard
git add -p
Interactive staging (review each change)
git add --no-ignore-removal
Stage removed files as well
git commit: Saving Snapshots
Creates permanent snapshot of staged changes.
Basic Usage
git commit -m "Add login functionality"
git commit -am "Quick update"
Stage all tracked files and commit (skip git add)
git commit --amend
Modify the most recent commit (change message or add files)
git commit --no-verify
Skip pre-commit and commit-msg hooks
git commit --allow-empty
Create empty commit (useful for CI/CD triggers)
git commit -v
Show diff in commit message editor
git commit --dry-run
Show what would be committed without actually committing
⚠️ Important Note about git commit -am:
git commit -am only stages and commits tracked files.
It will NOT stage new (untracked) files. Use git add . first for new files.
Also, the -am flag only works when you already have tracked files with changes.
Commit Message Guidelines
📝 Effective Commit Message Format:
1. Subject line (50 chars max): Imperative mood
2. Blank line: Separates subject from body
3. Body (72 chars per line): Explain WHY, not what
4. Footer: Reference issues, breaking changes
1. Subject line (50 chars max): Imperative mood
2. Blank line: Separates subject from body
3. Body (72 chars per line): Explain WHY, not what
4. Footer: Reference issues, breaking changes
# Example of good commit message structure
Add user profile picture upload
- Implement file validation for jpg, png formats
- Add progress bar for upload feedback
- Create responsive image cropper component
- Handle file size limit (max 5MB)
Fixes #123
Related to #456
🎮 Practice Exercise 2:
1. Create a file:
2. Check status:
3. Stage file:
4. Check status again:
5. Commit:
6. View history:
1. Create a file:
echo "# My Project" > README.md2. Check status:
git status3. Stage file:
git add README.md4. Check status again:
git status5. Commit:
git commit -m "Add project README"6. View history:
git log --oneline
Viewing History & Differences
Inspecting Changes
git log shows commit history, while git diff and git show
help you examine specific changes in detail.
git log: Viewing History
Displays commit history with various formatting options.
Basic Usage
git log
git log --oneline
One line per commit (compact view)
git log --graph --all --oneline
Graph visualization with all branches
git log -10
Show last 10 commits only
git log -p
Show patch (diff) for each commit
git log --stat
Show statistics (files changed, insertions/deletions)
git log --since="2024-01-01"
Show commits since specific date
git log --grep="bug"
Search commits containing "bug" in message
git log --author="John"
Show commits by specific author
git diff: Comparing Changes
Shows differences between files, commits, or branches.
Basic Usage
git diff
git diff --staged
Compare staged changes with last commit
git diff HEAD~3
Compare with 3 commits ago
git diff main..feature
Compare two branches
git diff --name-only
Show only file names, not content
git diff --word-diff
Word-level differences (easier to read)
git diff --cached
Alias for --staged (older Git versions)
git diff HEAD
Compare working directory with last commit
git diff abc123 def456 -- README.md
Compare specific file between two commits
git show: Examining Commits
Displays detailed information about specific commits.
Basic Usage
git show abc123def
git show HEAD
Show latest commit details
git show --stat
Show statistics only (files changed count)
git show --name-only
Show only file names in commit
git show abc123:README.md
Show specific file version from commit
git show --pretty=fuller
Show detailed commit information
git show HEAD~2:src/
Show directory contents from 2 commits ago
🔍 Debugging Tip: Use
git diff to see what you're about to commit.
Use git log -p to find when a bug was introduced.
Use git show to examine specific suspicious commits.
.gitignore & .gitkeep Files
Controlling What Git Tracks
.gitignore tells Git which files to ignore (not track).
.gitkeep is a convention to track empty directories.
Creating .gitignore
Create and manage files to exclude from version control.
Basic Usage
touch .gitignore
echo "*.log" >> .gitignore
Add pattern to ignore all log files
git check-ignore -v filename
Check why a file is being ignored
git ls-files --others --ignored
List all ignored files
git rm --cached filename
Remove file from Git but keep locally
.gitkeep Usage
Tracking empty directories in Git (convention, not command).
Creating Empty Directories
mkdir -p logs images uploads
touch logs/.gitkeep images/.gitkeep uploads/.gitkeep
git add logs/.gitkeep
Stage .gitkeep file to track directory
echo "*" > dir/.gitignore
Alternative: create .gitignore to keep directory
echo "!.gitignore" >> dir/.gitignore
Add exception to keep .gitignore file itself
find . -name ".gitkeep" -type f
Find all .gitkeep files in project
Common .gitignore Patterns
# ==========================================
# COMMON .gitignore PATTERNS
# ==========================================
# Operating system files
.DS_Store
Thumbs.db
desktop.ini
*.swp
*.swo
*~
# IDE and editor files
.vscode/
.idea/
*.swp
*.swo
*.sublime-*
# Dependency directories
node_modules/
vendor/
__pycache__/
*.pyc
*.pyo
.pytest_cache/
# Build outputs
dist/
build/
*.exe
*.dll
*.so
*.dylib
# Environment variables
.env
.env.local
.env.development.local
.env.test.local
.env.production.local
.secrets
# Logs and databases
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
*.sqlite
*.db
# Temporary files
*.tmp
*.temp
temp/
tmp/
# Coverage reports
coverage/
*.lcov
htmlcov/
# Package manager files
package-lock.json
yarn.lock
pnpm-lock.yaml
⚠️ Important: .gitignore only affects untracked files.
If you've already committed a file, adding it to .gitignore won't remove it from Git.
Use
git rm --cached filename to stop tracking previously committed files.
.gitignore Pattern Syntax
| Pattern | Meaning | Example |
|---|---|---|
| *.log | All files ending with .log | app.log, error.log |
| temp/ | Entire directory and its contents | temp/file.txt, temp/sub/file.txt |
| !important.log | Exception (don't ignore this file) | important.log (kept, others ignored) |
| /debug.log | Only at root level, not subdirectories | debug.log (root), not src/debug.log |
| debug/*.log | All .log files in debug directory | debug/app.log, debug/error.log |
| debug/**/*.log | All .log files in debug and subdirectories | debug/file.log, debug/sub/file.log |
🎮 Practice Exercise 3:
1. Create .gitignore:
2. Add patterns:
3. Create empty directory:
4. Add .gitkeep:
5. Stage and commit:
1. Create .gitignore:
touch .gitignore2. Add patterns:
echo "*.log\nnode_modules/\n.env" > .gitignore3. Create empty directory:
mkdir data4. Add .gitkeep:
touch data/.gitkeep5. Stage and commit:
git add . && git commit -m "Add .gitignore and directories"
Git Basics Cheat Sheet
Quick Reference Guide
Copy and keep this cheat sheet handy while you're learning Git.
Repository Setup
git init
Initialize new repository
git clone [url]
Clone existing repository
git remote add origin [url]
Add remote repository
Status & Info
git status
Check repository status
git status -s
Short status format
git log --oneline
Compact commit history
Basic Workflow
git add [file]
Stage specific file
git add .
Stage all changes
git commit -m "[msg]"
Commit staged changes
git commit -am "[msg]"
Stage tracked files and commit
Viewing Changes
git diff
Show unstaged changes
git diff --staged
Show staged changes
git show
Show latest commit
git log -p
History with changes
Common Workflow Patterns
Daily Development Workflow
git status # Check current state
git add . # Stage all changes
git commit -m "Description" # Commit changes
git push # Push to remote
Careful Review Workflow
git status # Check what changed
git diff # Review unstaged changes
git add -p # Interactively stage changes
git diff --staged # Review staged changes
git commit # Commit with editor
Debugging & Investigation
git log --oneline -20 # Recent commits
git show [commit-hash] # Examine specific commit
git diff [hash1] [hash2] # Compare two commits
git blame filename # Who changed what line
🚀 Next Steps: Once you've mastered these basic commands, learn:
1. Branching (
2. Remote operations (
3. Undoing changes (
4. Stashing (
git branch, git checkout, git merge)2. Remote operations (
git push, git pull, git fetch)3. Undoing changes (
git reset, git revert, git restore)4. Stashing (
git stash) for temporary saves
💪 Keep Practicing: The key to Git mastery is regular practice.
Use these commands daily. Make mistakes in a practice repository.
Try breaking things and fixing them. Every expert was once a beginner!
