The GIT commands cheat sheet is a handy reference for developers and contains the most commonly used commands for git projects.
What is GIT?
GIT is an open-source repository where users can place their files, including code, zips, text, or the entire project.
It has several features, like collaboration, version control, process control, etc. GIT stores file more efficiently and provide better integrity than other version control systems. Git is a command-line tool.
What is GitHub?
With its neat user interface, GitHub, a hub for developers, has become the most widely used version control system and can be accessed by anyone, anywhere.
Git has different workflows, and every project should have one based on its requirements. Git workflow is nothing but a lightweight, branch-based workflow that helps teams that deploy projects regularly.
For example, a forking Git workflow creates a local copy of the repository. So, each developer has a local workspace and a central repository. This kind of workflow is good when multiple developers are involved and allows developers to collaborate on the forked copy before making changes to the main repository.
Why do we need Git?
As Git is a version control system, developers constantly work on it to save their changes, make them viewable for others, merge their changes with others, and much more.
For any changes to the Git repository, developers need to know the right commands for the right action. Below is a list of the important and commonly used Git commands:
Common Git Commands
To add the specified file(s) to the staging
git add <file> -- add a specific file
git add * -- add all the files
Creates archives of commits, branches, and trees and combines multiple files into one. You can retrieve the contents by extracting the files when needed
git archive HEAD — create an archive from the HEAD ref of the repo
git archive output = ‘.tar’ — store the archived files in the given location
git archive --format=tar.gz — specifies the format of the archived file, like tar, zip, tar.gz
Lists all the branches in the repository. A new branch with the name will be created if a branch is specified. To delete a branch, use the -d option with the branch name. To rename a current branch, use -m.
git branch — lists all branches
<a href="https://geekflare.com/how-to-create-a-new-git-branch/">git branch</a> <branch_name> -- creates a new branch named 'branch_name' but doesn't check out the new branch.<br><br><code>git branch -d <branch_name> — deletes the branch, prevents the delete if any unmerged changes are there
git branch -D <branch_name> — force delete the branch even if unmerged changes are there
git branch -m <branch2> — rename the current branch
Display content or size/type information of repository objects
git cat-file <object> — shows object content
git cat-file -t <object> — displays the type of object
git cat-file -s <object> — shows the size of the object
git cat-file -p <object> — print the type of object in a pretty manner
git cat-file -e <object> — shows the error on stderr if the object has an invalid format or does not exist
git cat-file <type> <object> — shows the raw contents of an object
To switch between different branches of a repository, use it carefully, as there is no ‘undo’ for it.
git checkout <branch_name> — checks out the specified branch
git checkout -b <branch_name> — create a new branch and switch to this branch
C:\Users\geekflare>git checkout -b development_branch
Switched to a new branch 'development_branch'
Clean up the working director. Files that are committed will not be removed
git clean -n — lists the files that will be removed
git clean -f — removes the files
Create a copy of the existing repo into a new directory. Useful to get a development copy of a central repo.
git clone <central_repo> <new_dir> — create a copy of the central repo into a new directory
C:\Users\geek>git clone geekflare master
Cloning into 'master'…
git clone -branch <branch> <repo> — clones a branch from the mentioned repository
Saves the changes into a staging environment so that others can see it.
git commit — commit the changes to the staging
git commit -m <useful_msg> — gives a message upon commit to highlight the changes made
git commit -a — commit the changes directly, without staging
Let’s say you added a file named samplefile.txt to your working directory and want to commit the file. On giving the above command, you will get the output:
Please enter the commit message for your changes. Lines starting
with '#' will be ignored, and an empty message aborts the commit.
On branch master
Changes to be committed:
new file: samplefile.txt
Once you give the message, the changes are committed:
C:\Users\geekflare>git commit -m 'samplemsg'
[integration_branch (root-commit) ed52dd0] 'samplemsg'
1 files changed, 24 insertions(+)
create mode 100644 samplefile.txt
Specifies the configuration level to write a property value into. The ‘Local’ level is the default (when nothing is specified).
git config –local — saves the configuration in the .git directory of the repo
git config –global — saves the configuration in the user’s home directory
git config –system — contains the configuration of all users and repositories and is located in the git config file of the root.
Compare the changes in the git repo, which can be done before staging, at staging, and after staging (commit).
git diff — track repo changes that are not yet staged
git diff --staged — track changes of staged files (which are not committed)
git diff HEAD — track file changes after the commit
git diff <commit1_id> <commit2_id> — track changes between two commits; you can find out the commit_ids using ‘
git log -p --follow --filename‘
Fetch a branch or entire remote repository
git fetch <remote-url> — get the entire repository from the remote repository URL
git fetch <branch_url> <branchname> — fetch the specific branch
git fetch -all — fetch all the branches of a remote repo
git fetch origin — update and sync the local repo with the new changes in the remote repo
File System ChecK command checks for validity and connectivity of database objects. It checks the SHA-1ID of the objects and the connections they make. Fsck is useful for recovering lost commits and files.
git fsck –full
Runs garbage collection on the current repository and cleans up unused files.
Searches for specific content in the repository. Git provides many options to search in different ways
git grep -i ‘search_term’ — search by ignoring case [Man and man will be the same]
git grep -f <file_name> — show matching patterns of a particular file
git grep -e ‘search-term’ — use -e for pattern matching
git grep -E ‘regexp|multiple_exp’ –Search for regular expressions, we can search multiple by using the pipe (OR) operator
git grep -n ‘expr’ — prefix line number of the matching line
git grep -c ‘expr’ — show the count of lines that matched instead of each line
To list the contents of a tree object from the current directory.
git ls -tree -d <path> — show only the specified tree entry, not the children
git ls -tree -r — recurse into sub-trees
git ls -tree -l — show the size of file (blob) objects
git ls -tree --name-only — display only file names and not the long output
git ls -tree --full-name — show full path names and not just the path relative to the current directory
C:\Users\geek>git ls-tree --full-tree -r HEAD
100644 blob e883e60087e84f1660a9673ccb86eb0adc4f004d samplefile.txt
100644 blob 1426dc6fbff0677a484b248983a8740ff30fbb80 sample_jsindex.js
Create a new blank repository. It is the first command you execute to make a git project.
git init — creates a .git repository in the working directory,
For example, to create a new repo called ‘geekflare’, give the command as:
$ git init geekflare
Initialized empty Git repository in C:/Users/geek/geekflare/.git/
User Interface to browse the git repository through a browser. Uses the CGI script GitWeb for the same.
git instaweb --httpd=webrick — starts the server (httpd) and opens the web browser on the page.
To stop the server, use the above command with the –stop option.
Records every activity in the git repository.
git log — displays the last few commits
git log --oneline — shows the output as the first 7 characters of SHA and the commit message with one commit per line
git log stat — displays more information about the modified files, like the number of lines added/removed, a summary of total records changed, lines added/removed
git log --patch (or -p) — shows the files modified, the specific changes, and their location
git log --graph — View log results in graph form
git log -<n> — display the last ‘n’ number of commits
git log --after=<date/x days/yesterday> — display all commits after a specified date. You can use
--before to display commits before the specified date
git log --author=<author_name> — display commits of a particular author (user).
git log --grep=<commit message> — filter commits based on the commit message
Integrates all the development files into a single branch, combines two branches, and merges multiple commits into a single history. The merge stops if there is a conflict, and git presents the conflict files. Once the conflicts are resolved, the merge continues.
git checkout -b — first, checkout the branch to merge
git add <file>
git commit — add and commit the files
git checkout master
git merge — merge the branch with master
Deletes (Prunes) the files that are unreachable from the current branch. It is a cleaning process to remove unused files from the branch
git prune -n — don’t prune, just show what all can be pruned
git prune -v — shows the output of actions done by the prune
git prune --progress — shows the progress of the prune
git fetch --prune — prunes all the outdated branches
It receives data from a remote server to a working repository. It updates the local (working) branch with all the latest files from the remote repo.
git pull — pull the remote repo
git pull <repo URL> — pull a particular remote branch
Pushes all the local changes into the remote repository. It is an upload process exactly opposite to the pull and fetches commands
git checkout master — checkout the branch that has the latest changes
git push origin master — push the changes to the remote repo
C:\Users\geek>git checkout development_branch
Switched to branch 'development_branch'
C:\Users\geek>git push master development_branch
Enumerating objects: 4, done.
Counting objects: 100% (4/4), done.
Delta compression using up to 4 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (4/4), 612 bytes | 204.00 KiB/s, done.
Total 4 (delta 0), reused 0 (delta 0), pack-reused 0
[development_branch] development_branch -> development_branch
We can also use push to delete a remote branch using the command
git push --delete <branch>.
C:\Users\geek>git push master --delete development_branch
Combines multiple commits from different branches to create a new final base commit. Useful before merging all the changes, to commit changes from different branches one by one (linearly).
git rebase <branch name> — combine the commits into one final base
If any conflicts are there, resolve them and continue the rebase:
git rebase --continue
To skip any change:
git rebase --skip
Checks the configuration of the remote server and allows connection access between remote and local.
git remote — by default, it returns ‘origin’, the default name of the remote server given by Git
git remote -v — lists short names and URLs of all the available remote connections
git remote add <short name> <remote url> — explicitly add the remote server to the available connections. The short name can be used for git commands instead of giving the entire URL.
git remote remove <remote url/short name> — removes the remote server from the repository
Go back to a previous commit, and discard changes made after that commit
git reset <hash of the commit> — restores the repo to the specified commit. Git will retain the commit history, so you can do another reset with a different commit (hash) to undo a reset.
Removes the specific file from git. You can undo the effect of rm using the reset or checkout command
git rm <file_ name> — remove the specific file
To remove files from git but keep them in your local (staging), use:
git rm --cached
View any object such as blob, tree, commit, or tag by specifying its SHA1
git show — not specifying the <object> shows the details of the last commit on the branch.
git show <SHA1_id> — shows the object’s content specified by its SHA1 id, for example, blob id, tree id, etc. To check the type of object, use the command
git cat-file -t
git show –pretty — shows the output in a pretty format.
You can provide a custom format:
git show --pretty = ‘format:Name: <format>’ Or you can use one of the short, full, one line, medium, or fuller formats, for example:
git show --pretty= ‘medium’ — this will show the author, date, title, and full commit message
git show --abbrev-commit — to abbreviate SHA1
To switch branches without committing in the current branch, store the non-committed data safely
git stash — saves the work and index state
git stash save <message> — give a message while saving
git stash list — View the list of stashed content
git stash apply — commit the stashed changes. To apply the changes of a specific stash, use the stash index id along with apply
git stash show — view the contents of the stashed files
git stash drop — removes the most recent stash from the queue
View the status of the repository and staging, i.e., the status before the commit stage. You can use this command after any other git command, like adding, updating, or removing a file
git status — shows the changes that are to be committed, or untracked (no staged) changes
For example, if you add a file in your working directory named samplefile.txt and check if it’s added, you can give the above command. It will result in the output as follows:
On branch master
No commits yet
Changes to be committed:
(use "git rm --cached …" to unstage)
new file: samplefile.txt
Friendly references are used to indicate milestones or reference points in the code
git tag <tag_name> — create a tag with the given name
git tag — list all the available tags
git tag show <tag_name> — show details of the specified tag
git tag -l “.*” — show tags that match the specified pattern or characters
Launches the git user interface that displays the contents, commits, full diff, and other details in a window
gitk — open the git repo in a window for visualization
Use the git version command to check the version of the git you are using.
git version 2.38.0.windows.1
This post has listed the most commonly used git commands with their options.
Next, you can check out the GitHub credentials scanner.