Mastering Git: 36 Essential Commands for Programmers and Developers


Mastering Git, Git stands as a cornerstone for version control, enabling seamless collaboration and efficient project management. Whether you’re a seasoned programmer or just embarking on your coding journey, mastering Git commands is essential for optimizing your workflow and maximizing productivity. This comprehensive guide explores 36 indispensable Git commands, complete with practical command line examples, to empower programmers and developers at every level.

Mastering Git commands

  1. Configure User Profile:

Set up your user profile to ensure accurate tracking of contributions.

$ git config "USERNAME"
$ git config ""
$ git config --global "USERNAME"
$ git config --global ""

Configure your identity within Git globally or on a per-repository basis to accurately track your contributions

  1. Initialize Git Repositories:

Start version controlling your projects by initializing Git repositories.

$ git init
  1. Add Project Files:

Add files to the staging area in preparation for committing changes.

$ git add file
$ git add *.php
  1. Verify Added Files:

Check the status of your files to see which ones are staged for commit.

$ git status
  1. Commit Changes to the Repository:

Record changes to the repository along with a descriptive message.

$ git commit
$ git commit -m "First Commit"
  1. Display the Logs:

View commit history to track changes and understand project evolution.

$ git log
$ git log --file
  1. Verify Project Branches:

List existing branches in your repository to navigate between different versions.

$ git branch
  1. Reset Project Branches:

Reset branches to a previous state, undoing commits and changes as needed.

$ git reset
$ git reset --soft
$ git reset --hard
  1. Add a New Branch:

Create a new branch to isolate development efforts or work on a specific feature.

$ git branch new-feature
  1. Switch between Branches:

Switch between branches to access different versions of your project.

$ git checkout new-feature
  1. Delete a Project Branch:

Remove unnecessary branches once they have served their purpose.

$ git checkout master
$ git branch -D new-feature
  1. Check Differences among Commits, Trees, and Files:

Analyze differences between commits, trees, and individual files to understand changes.

$ git diff
$ git diff new-feature master
  1. Merge Two Branches:

Combine changes from one branch into another to integrate new features or bug fixes.

$ git merge fixes new-feature
$ git merge -s ours obsolete
$ git merge --no-commit main
  1. Revert Existing Commits:

Undo changes introduced by previous commits without altering commit history.

$ git revert ad9ef37d88ad4gfyg90aa6a23f71e77
$ git revert HEAD~3
  1. Stash Working Directory:

Temporarily store changes that are not ready to be committed.

$ git stash
$ git stash list
  1. Clone a Repository:

Duplicate an existing repository to your local machine for collaboration.

$ git clone
$ git clone git:// test-dir
  1. Pull New Updates:

Fetch and merge changes from a remote repository into your local branch.

$ git pull
  1. Push Your Updates:

Upload your local commits to a remote repository to share your work.

$ git push
  1. Display Remote Repositories:

List remote repositories associated with your local repository.

$ git remote
$ git remote --verbose
  1. Connect to Remote Repositories:

Establish connections to remote repositories for collaboration.

$ git remote add origin
  1. Add Tags to Your Project:

Tag specific commits to mark significant milestones or releases.

$ git tag 1.0.0
$ git push origin --tags
  1. Fetch Remote Data:

Download objects and refs from another repository to keep your local copy up to date.

$ git fetch origin
  1. Restore Non-Committed Changes:

Revert changes made to files that have not been staged or committed.

$ git restore --staged test.php
$ git restore --source=HEAD --staged --worktree test.php
  1. Remove Files:

Delete files from the working directory and stage the removal for the next commit.

$ git rm *.php
$ git rm -r dir/
$ git rm --cached *.php
  1. Move or Rename Files:

Change the name or location of files within your project while preserving their history.

$ git mv
$ mv
$ git add
$ rm
  1. Clean Untracked Files:

Remove untracked files from your working directory to keep it clean and organized.

$ git clean
$ git clean -n
  1. Optimize Local Repositories:

Optimize the local repository’s database to improve performance and reduce disk usage.

$ git gc
  1. Archive Local Repositories:

Create a compressed archive of the repository for sharing or backup purposes.

$ git archive --output=test --format=tar master
  1. Search for Patterns:

Search for specific text patterns within the repository’s contents.

$ git grep -iw 'import' master
$ git grep 'import' $(git rev-list --all)
  1. Manage Working Trees:

Create, list, add, and remove linked working trees to your repository.

$ git worktree list
$ git worktree add new-branch
$ git worktree remove new-branch
$ git worktree prune
  1. Prune Untracked Objects:

Remove unreachable objects from the repository to reclaim disk space.

$ git prune --dry-run
$ git prune --verbose --progress
  1. Pack Unpacked Objects:

Compress loose objects in the repository into pack files to save space and improve performance.

$ git repack
  1. List Unpacked Objects:

Display statistics about the repository’s object storage.

$ git count-objects
  1. Validate the Object Database:

Check the integrity of the repository’s object database to ensure it is not corrupted.

$ git fsck
  1. Display Changes for Each Commit:

View detailed information about each commit, including the files that were modified.

$ git whatchanged
  1. Summarize Log Information:

Generate summarized logs of commit history, optionally grouped by author or email.

$ git shortlog
$ git shortlog --email --summary

Consult Git Help

Mastering Git: 36 Essential Commands for Programmers and Developers


Mastering Git commands is a fundamental skill for programmers and developers seeking to streamline their workflow and collaborate effectively on projects. In this comprehensive guide, we’ve explored 39 essential Git commands, providing command-line examples for each one.

By understanding and incorporating these commands into your daily development routine, you’ll gain greater control over your version-controlled projects. From configuring user profiles to managing branches, committing changes, and collaborating with remote repositories, each Git command plays a crucial role in the software development lifecycle.

Whether you’re working solo on a personal project or collaborating with a team of developers on a large-scale application, Git empowers you to track changes, manage versions, and seamlessly integrate new features. With practice and dedication, you can harness the power of Git to enhance your productivity, streamline your workflow, and achieve greater success in your software development endeavors. . Thank you for reading the DevopsRoles page!

, ,

About HuuPV

My name is Huu. I love technology and especially Devops Skill such as Docker, vagrant, git so forth. I likes open-sources. so I created site to share the knowledge that I have learned. My Job: IT system administrator. Hobbies: summoners war game, gossip.
View all posts by HuuPV →

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.