Git Command Cheatsheet: From Beginner to Expert

Git is a powerful distributed version control system that enables developers to track changes in source code effectively. It supports branching and merging, allowing multiple developers to work on features simultaneously without disrupting the main codebase. This promotes collaboration and makes it easy to revert to previous versions when necessary. Overall, Git enhances productivity and helps teams coordinate their work effectively.

Git Command Cheatsheet: From Beginners to Expert

git init
- Example: git init my_repo
- Description: Initializes a new Git repository in the specified directory.

git clone <repository_url>
- Example: git clone https://github.com/user/repo.git
- Description: Creates a local copy of a remote repository.

git status
- Example: git status
- Description: Displays the state of the working directory and staging area, including changes that are staged, unstaged, or untracked.

git add <file>
- Example: git add file.txt
- Description: Stages changes in the specified file for the next commit.

git add .
- Example: git add .
- Description: Stages all changes (new, modified, and deleted files) in the current directory.
- When to use: Use this command when you want to stage all changes in your project at once.

git commit -m <message>
- Example: git commit -m "Fix issue with user login"
- Description: Records the staged changes in the repository with a descriptive message.

git log
- Example: git log
- Description: Displays a history of commits in the current branch.

git checkout <branch>
- Example: git checkout feature-branch
- Description: Switches to the specified branch.

git branch
- Example: git branch
- Description: Lists all local branches in the repository, highlighting the current branch.

git branch <branch_name>
- Example: git branch new-feature
- Description: Creates a new branch with the specified name.

git merge <branch>
- Example: git merge feature-branch
- Description: Merges changes from the specified branch into the current branch.
- When to use: Use this command after finishing work on a feature branch to integrate changes back into the main branch.

git pull
- Example: git pull origin main
- Description: Fetches changes from the remote repository and merges them into the current branch.

git push <remote> <branch>
- Example: git push origin main
- Description: Pushes local changes in the specified branch to the remote repository.

git remote add <remote_name> <repository_url>
- Example: git remote add origin https://github.com/user/repo.git
- Description: Adds a new remote repository under a specified name.
- When to use: Use this command when you want to associate a local repository with a remote one.

git remote -v
- Example: git remote -v
- Description: Displays a list of remote repositories and their URLs.

git stash
- Example: git stash
- Description: Temporarily saves changes that are not ready to be committed, allowing you to revert to a clean working directory.

git stash pop
- Example: git stash pop
- Description: Restores the most recent stashed changes and removes them from the stash list.

git rebase <branch>
- Example: git rebase main
- Description: Reapplies commits on top of another base tip, effectively changing the base of your branch.
- When to use: Use this command to integrate changes from one branch into another while keeping a cleaner history.

git reset <file>
- Example: git reset file.txt
- Description: Unstages the specified file, keeping the changes in the working directory.
- When to use: Use this command if you accidentally added a file to the staging area and want to unstage it.

git reset --hard
- Example: git reset --hard HEAD
- Description: Resets the index and working directory to match the last commit, discarding all changes.
- When to use: Use this command when you want to completely discard all local changes and return to the last commit.

git cherry-pick <commit>
- Example: git cherry-pick abc1234
- Description: Applies the changes introduced by a specific commit onto the current branch.
- When to use: Use this command to apply specific commits from another branch without merging the entire branch.

git tag <tag_name>
- Example: git tag v1.0
- Description: Creates a new tag at the current commit.
- When to use: Use this command to mark specific points in your project’s history, like releases or significant changes.

git fetch
- Example: git fetch origin
- Description: Downloads objects and refs from a remote repository without merging changes.
- When to use: Use this command to check for changes on the remote repository without altering your working directory.

git diff
- Example: git diff
- Description: Shows changes between the working directory and the index (staging area).

git config --global user.name <name>
- Example: git config --global user.name "Your Name"
- Description: Sets the name that will be used for commits.
- When to use: Use this command once to configure your identity in Git for all repositories.

git config --global user.email <email>
- Example: git config --global user.email "you@example.com"
- Description: Sets the email that will be used for commits.
- When to use: Use this command once to configure your email in Git for all repositories.

git rebase -i <commit>
- Example: git rebase -i HEAD~3
- Description: Opens an interactive rebase session for the last three commits, allowing for editing, squashing, or reordering.
- When to use: Use this command when you want to clean up your commit history before pushing to a remote repository.

git merge --no-ff <branch>
- Example: git merge --no-ff feature-branch
- Description: Merges the specified branch into the current branch, ensuring a new merge commit is created, even if the merge could be resolved as a fast-forward.
- When to use: Use this command when you want to maintain the branch history clearly and explicitly, showing that a merge has occurred.

git merge --squash <branch>
- Example: git merge --squash feature-branch
- Description: Combines all changes from the specified branch into the current branch as a single commit, without retaining the individual commit history from the feature branch.
- When to use: Use this command when you want to merge changes from a feature branch but want to keep a cleaner history by squashing multiple commits into one.

git merge --abort
- Example: git merge --abort
- Description: Cancels a merge process that is currently in progress, reverting to the state before the merge started.
- When to use: Use this command when you encounter conflicts during a merge and decide to abandon the merge attempt.

git rebase --onto <newbase> <upstream> <branch>
- Example: git rebase --onto newbase upstream branch
- Description: Rebases the specified branch onto a new base, effectively applying its commits to the new base starting from a specific upstream commit.
- When to use: Use this command when you want to move a feature branch to a different base without including changes from upstream.

git rebase -i HEAD~<n>
- Example: git rebase -i HEAD~4
- Description: Opens an interactive rebase session for the last specified number of commits, allowing you to edit, squash, or reorder them.
- When to use: Use this command to clean up commit history or make changes to multiple recent commits before pushing them.

git rebase --continue
- Example: git rebase --continue
- Description: Continues the rebase process after resolving conflicts.
- When to use: Use this command after you have resolved any conflicts that arose during a rebase.

git rebase --skip
- Example: git rebase --skip
- Description: Skips the current commit during a rebase, effectively removing it from the history.
- When to use: Use this command when you encounter a problematic commit during a rebase that you want to exclude from the final history.

git cherry-pick --no-commit <commit>
- Example: git cherry-pick --no-commit abc1234
- Description: Applies the changes from the specified commit without committing them, allowing further modifications before finalizing.
- When to use: Use this command when you want to apply changes from another branch but need to make additional adjustments before committing.

git reflog
- Example: git reflog
- Description: Shows a log of all references and updates to the HEAD pointer, including commits, checkouts, and resets.
- When to use: Use this command to recover lost commits or branches by viewing the recent history of HEAD movements.