Modern software development is primarily based on Git, which offers a system for distributed version control, facilitating successful teamwork. Learning how to use Git effectively will greatly improve your workflow regardless of your level of expertise with coding. It guides you through 50 fundamental Git commands, theory, syntax, and pragmatic examples all explained Git Cheat Sheet
Table of Contents
1. Setting Up Your Git Environment
1.1 git config
initially, Setting your Git environment. The Git config command lets you specify several Git configuration choices including your username, email, and additional preferences.
• Syntax: git config [--global | --system | --local] <name> <value>
• Example: git config --global user.name "Your Name"
git config --global user.email "you@example.com"
• Explanation:
While –local applies the configuration only to the current repository, the –global flag applies it to all locations on your machine. Setting configuration values for every user on the system is accomplished with the –system option It is advised to set your username and email globally since it identifies your commits over all repositories.
1.2 git init
Starting a fresh Git repository in your project’s directory by the git init command generates a.git folder tracking the version history of your project.
• Syntax: git init [<directory>]
• Example: git init my-project
• Explanation:
Running git init without any arguments initializes the current directory as a Git repository. Specifying a directory name will create that directory (if it doesn’t exist) and initialize it as a Git repository.
1.3 git clone
git clone copies an existing Git repository to your local machine, along with all its history and branches.
• Syntax: git clone <repository> [<directory>]
• Example: git clone https://github.com/user/repo.git
• Explanation:
The first argument is the URL of the repository you want to clone. The optional second argument is the directory name where the repository will be cloned. If not provided, Git will clone the repository into a directory named after the repository itself.
1.4 git config –list
This command lists all configuration settings that are currently applied to the Git environment.
• Syntax: git config --list
• Example: git config --list
• Explanation:
This command outputs a list of all Git configurations that have been set, which can be helpful for verifying your settings before starting work on a project.
2. Working with Repositories
2.1 git status
The git status command is used to display the state of the working directory and the staging area. It shows which changes have been staged, which haven’t, and which files aren’t being tracked by Git.
• Syntax: git status [<options>]
• Example: git status
• Explanation:
When you intend to find out about changes made to your project, this command truly helpful. It facilitates tracking of your development and knowledge of what the next commit will contain.
2.2 git log
The Git log command displays repository commit history. Understanding the background of the project, monitoring developments, and spotting particular commits depend on this command especially.
• Syntax: git log [<options>]
• Example: git log --oneline --graph --decorate --all
• Explanation:
With each commit onto a single line (–oneline), shown as a graph (–graph), ornamented with branch & tag names (–decorate), and displaying commits from all branches (–all), the choices used in the example above offer a brief overview of the commit history.
2.3 git show
The Git show command shows comprehensive details on a given commit including author, commit message, and changes.
• Syntax: git show [<options>] [<commit>]
• Example: git show commit_id
• Explanation:
Examine the specifics of a particular commit by running this command. Substitute the real commit hash you wish to view for commit_id.
2.4 git remote
The git remote command manages the set of remotes that you can push to and pull from.
• Syntax: git remote [<options>] [<name> [<url>]]
• Example: git remote add origin https://github.com/user/repo.git
• Explanation:
This commands an origin-based remote repository addition. After that, you can interact with the distant repository using origin as an alias—that is, pushing or pulling modifications.
3. Tracking and Staging Changes
3.1 git add
The git add command stages changes to be included in the next commit. This command is a crucial part of the Git workflow as it allows you to prepare specific changes for a commit.
• Syntax: git add <pathspec>
• Example: git add file.txt
git add .
• Explanation:
The first example stages a single file named file.txt, while the second example stages all changes in the current directory. The dot (.) is a wildcard representing all changes.
3.2 git diff
git diff shows the differences between various stages of your project, such as between your working directory and the staging area, or between the staging area and the last commit.
• Syntax: git diff [<options>] [<commit>] [--] [<path>…]
• Example: git diff
git diff --staged
• Explanation:
The first example shows differences between the working directory and the staging area, while the second example shows differences between the staging area and the last commit. This command helps you understand what changes you have made that are yet to be committed.
4. Committing Changes
4.1 git commit
The git commit command records changes to the repository. After staging changes with git add, you use git commit to permanently store those changes.
• Syntax: git commit -m "commit message"
• Example: git commit -m "Fixed bug in the authentication module"
• Explanation:
The -m option allows you to include a commit message inline, which is a brief description of the changes. This message should be descriptive enough to understand the purpose of the commit.
4.2 git commit –amend
git commit –amend is used to modify the most recent commit. This command is useful if you forgot to include some changes or need to rewrite the commit message.
• Syntax: git commit --amend -m "new commit message"
• Example: git commit --amend -m "Updated documentation for the authentication module"
• Explanation:
This command rewrites the last commit with the staged changes or updates the commit message if no new changes are staged. It’s a powerful command that can correct small mistakes without creating additional commits.
5. Branching and Merging
5.1 git branch
The git branch command is used to list, create, or delete branches in your repository. Branching allows you to work on different features or fixes in isolation.
• Syntax: git branch [<options>] [branch_name]
• Example: git branch new-feature
git branch -d old-feature
• Explanation:
The first example creates a new branch named new-feature. The second example deletes the branch old-feature. Use branching to manage different lines of development.
5.2 git checkout
git checkout allows you to switch between branches or restore working tree files.
• Syntax: git checkout <branch>
• Example: git checkout new-feature
git checkout -b new-feature
• Explanation:
The first command switches to an existing branch called new-feature. The second command creates a new branch new-feature and switches to it immediately.
5.3 git merge
git merge integrates changes from one branch into another. This command is fundamental for combining the work of multiple branches into a single branch.
• Syntax: git merge <branch>
• Example: git merge new-feature
• Explanation:
The above command merges the new-feature branch into the current branch. Conflicts might arise during merging, which will need to be resolved manually before completing the merge.
6. Collaborating with Others
6.1 git fetch
The git fetch command downloads objects and refs from another repository. This command retrieves data from a remote repository without integrating it into your working directory.
• Syntax: git fetch <remote> [<refspec>...]
• Example: git fetch origin
• Explanation:
The above command fetches all the branches and tags from the origin remote repository, but it doesn’t modify the working directory. It’s useful for checking the latest updates from a remote repository before merging or pulling them.
6.2 git pull
git pull is a combination of git fetch and git merge. It fetches the changes from a remote repository and then immediately tries to merge them into the current branch.
• Syntax: git pull <remote> <branch>
• Example: git pull origin main
• Explanation:
This command fetches and integrates changes from the main branch of the origin repository into your current branch. If there are conflicts, Git will prompt you to resolve them before completing the merge.
6.3 git push
The git push command updates a remote repository with local changes. This command is commonly used to share changes with other developers.
• Syntax: git push <remote> <branch>
• Example: git push origin main
• Explanation:
This command pushes the changes in the main branch to the origin remote repository. It’s how you publish your commits to a shared repository.
6.4 git push –force
git push –force forces a push even if it would result in a non-fast-forward update, which rewrites history.
• Syntax: git push --force <remote> <branch>
• Example: git push --force origin main
• Explanation:
Use this command with caution as it can overwrite changes in the remote repository that others may be relying on. It’s generally used to correct mistakes or when you need to push an amended commit.
7. Undoing Changes
7.1 git reset
git reset moves the current branch to a different commit, effectively undoing commits.
• Syntax: git reset [--hard | --soft | --mixed] [<commit>]
• Example: git reset --hard HEAD~1
• Explanation:
The above command resets the current branch to the commit before the last one (HEAD~1). The –hard option discards all changes in the working directory and the staging area. –soft keeps changes in the working directory, and –mixed keeps them in the staging area.
7.2 git revert
git revert creates a new commit that undoes the changes from a previous commit.
• Syntax: git revert <commit>
• Example: git revert commit_id
• Explanation:
This command is safer than git reset as it doesn’t rewrite history. Instead, it creates a new commit that undoes the specified commit, preserving the project’s history.
8. Inspecting a Repository
8.1 git blame
The git blame command shows what revision and author last modified each line of a file.
• Syntax: git blame [<options>] <file>
• Example: git blame file.txt
• Explanation:
This command is useful for tracking down when a particular change was made to a file and who made it. It’s often used to identify the commit that introduced a bug.
8.2 git reflog
git reflog is a powerful command that records every change made to the tips of branches and enables you to recover commits that may have been lost due to a reset or commit amendment.
• Syntax: git reflog [<options>] [<ref>]
• Example: git reflog
• Explanation:
This command provides a log of all the actions that affect the reference, including commits, resets, checkouts, and more. It’s an essential tool for recovering lost commits.
9. Advanced Git Commands
9.1 git rebase
git rebase reapplies commits on top of another base tip. It’s commonly used to keep your branch up to date with another branch without creating a merge commit.
• Syntax: git rebase <branch>
• Example: git rebase main
• Explanation:
This command takes the commits from the current branch and replays them on top of the main branch. It’s a way to integrate changes from one branch into another more cleanly than merging.
9.2 git cherry-pick
git cherry-pick applies changes from a specific commit to your current branch.
• Syntax: git cherry-pick <commit>
• Example: git cherry-pick commit_id
• Explanation:
Use git cherry-pick when you want to introduce specific changes from another branch or commit without merging the entire branch. It’s useful for bug fixes or small feature additions.
10. Miscellaneous Commands
10.1 git stash
git stash temporarily shelves changes in your working directory so you can work on something else and then reapply the stashed changes later.
• Syntax: git stash [<options>]
• Example: git stash save "Work in progress"
git stash pop
• Explanation:
The first command saves your current changes in a stash, which you can apply later using git stash pop. This is helpful when you need to switch branches quickly but don’t want to commit unfinished work.
10.2 git tag
git tag is used to create a reference to a specific commit, usually used to mark release points.
• Syntax: git tag [<options>] <tag_name> [<commit>]
• Example: git tag v1.0.0
• Explanation:
Tags are useful for marking specific points in your repository’s history, such as releases. Tags can be lightweight (a simple pointer) or annotated (a full Git object containing a tagger, date, and message).
Conclusion
Mastering these 50 Git comands will significantly enhance your efficiency and effectiveness as a developer. Whether you’re setting up a new project, collaborating with others, or managing complex branching strategies, these commands provide a solid foundation for handling version control in Git. Keep this cheat sheet handy, and you’ll be navigating your repositories like a pro in no time!
