Mastering Git Basics: The Top Commands Every Newbie Should Learn

Git, a powerful version control system, is an essential tool for software developers. Whether you’re working on personal projects or collaborating with a team, the basics of Git are required. If you’re new to software development and version control, Git can seem complex. However, understanding the basics of Git is essential for collaborating on projects, tracking changes, and ensuring the integrity of your codebase. In this guide, I’ll walk you through the top Git commands that every newbie should learn to kickstart their journey into the world of version control. These top git commands will be very useful while working on a project. By exploring these top git commands you can reach out at a professional level.

Before moving ahead to the Top Git commands, let me give you some briefs on Git.

What is Git?

Git is a distributed version control system (DVCS). This is designed to help developers to track the changes in their codebase. It was created by Linus Torvalds in 2005 and has since become the industry standard for managing source code.

Why Learn Git?

Git offers several advantages for developers, including:

• Collaboration: Git allows multiple developers to work on the same project simultaneously. Hence, makes collaboration seamless.
• Version Control: It keeps a historical record of change. So, you can quickly revert to the previous state of your project if something goes wrong.
• Branching: Git’s branching system enables you to work on new features or bug fixes in isolation without affecting the main codebase.
• Open Source: Many open-source projects use Git. Therefore understanding Git is crucial for contributing to these projects.

Now, let’s dive into the post of top Git commands that every newbie should learn.

Recommended: How to Install and Setup VS Code in Ubuntu 20.04 LTS For Beginners

1. git init

This command is the very first command of Git. The git init command initializes a new Git repository in your project folder. It creates a hidden .git directory that stores all the version control information.

git init

2. git clone

This command is used to copy any repository from a remote repository to the local. Whenever you begin working on existing projects hosted on platforms like GitHub or GitLab, you need to create a local copy using the git clone This command downloads the entire repository to your local machine.

git clone <repository_url>

3. git status

The git status command is used to see the changes that are untracked, modified, or staged for commit in your repository.

git status

4. git add

Before committing any changes, you must stage them using git add. This command prepares files for the next commit. You can add any single file or one by one using this way.

git add <fileName>

However, this command can stage all the files which are tracked at once. In order to do that you can simply add a dot (.) after the add.

git add .

5. git commit

Once you’ve staged your changes, you need to commit those changes. Hence, commit them using git commit. Be sure to include a meaningful commit message summarizing the changes you made.

git commit -m "Your commit message here"

6. git log

Sometimes, you need to check the log or history. So, to view the commit history, you can use this command. It displays a chronological list of commits with their unique hashes, authors, dates, and commit messages.

git log

7. git pull

You can use this command to fetch changes from a remote repository and merge them into your current branch. It ensures your local copy is up to date with the latest changes from the remote repository.

git pull

Sometimes, you need to pull from a specific branch. Then in that case, you can mention that branch name as well.

git pull origin <source_branch>

8. git push

When you want to share your local changes with others or update a remote repository, use git push command.

git push

Similar to git pull, you can specify your current branch name as well in which you want to push.

git push origin <current_branch>

9. git branch

git branch lists all branches in your repository, indicating the current branch with an asterisk.

git branch

10. git checkout

To switch between branches or create new ones, use git checkout command.

# Create and switch to a new branch
git checkout <existing_branch>
 
# Will create a new branch and switch to that branch
git checkout -b <new_branch>

11. git merge

If you want to merge any changes from one branch to another then use git merge. The changes from your current active branch will be merged with the specified branch.

git merge <branch_name>

12. git remote -v

This command is used to view the list of remote repositories which are associated with your Git project along with their URLs. This is helpful when you want to check your local connected repository with remote repositories. Also, it displays the fetch and push URLs for each remote.

git remote -v

13. git fetch

The command is used in Git to retrieve changes from a remote repository. However, it does not automatically merge or apply those changes to your working branch. Instead, it updates your local repository with the latest changes from the remote. Also, it allows you to inspect and integrate them manually if you want.

git fetch <remote_name>

14. git reset

If you want to reset the current branch to a specific commit, you can use git reset. This effectively moves the branch pointer to a different commit.

In other words, it is often used to undo changes or move the branch pointer to a previous state in your commit history. It can be a powerful and sometimes destructive command, so it should be used with caution.

There are three main modes of using this command, each with different use cases:

Soft reset

A soft reset moves the branch pointer to a different commit while keeping the changes from the moved commits staged (i.e., in the index).

• It doesn’t change the working directory, so your changes remain in your local files.
• This mode is typically used when you want to uncommit your changes but keep them for further editing or to recommit them.

git reset --soft <commit>

Mixed Reset (Default)

A mixed reset is the default behavior of git reset and moves the branch pointer while resetting the staging area (i.e., unstaging changes).

• Your changes are preserved in your working directory but not staged.
• This mode is often used when you want to unstage changes that you accidentally added.

git reset <commit>

Hard Reset

A hard reset moves the branch pointer and discards all changes in the staging area and working directory, resetting them to the state of the specified commit.

git reset --hard <commit>

This mode is used when you want to completely discard your changes and start over from the specified commit. Be cautious, as this is a destructive operation.

15. git diff

It can be used to compare changes between various entities in your Git repository, such as commits, branches, or files. Here’s how you can use the git diff command.

Comparing Commits

To view the differences between two specific commits, you can provide their commit hash.

git diff <commit1> <commit2>

Comparing Branches

To compare changes between two branches, you can use the branch names.

git diff <branch1> <branch2>

Comparing the Working Directory with the Staging Area

To see the differences between the files in your working directory and what is currently staged (i.e., in the index).

git diff

Comparing the Working Directory with the Last Commit

You can use this to view the differences between your working directory and the last commit.

git diff HEAD

Comparing Files

To get the difference between two specific files.

git diff <file1> <file2>

16. git stash

This command in Git is used to temporarily save changes in your working directory that are not ready to be committed. This is useful when you need to switch to a different branch, apply updates, or work on another task without committing your current changes.

git stash save "Your stash message"

To check all the list of stashes, you can hit the below command.

git stash list

Sometimes, you need to remove the stashes. So, you can remove the stashes using the below command.

git stash clear

17. git tag

This Git command is used to create, list, and manage tags in a Git repository. Tags are typically used to mark specific points in your commit history, such as releases or significant milestones.

git tag <tag_name>

18. git remote add

You can use this command to add a new remote repository to your Git configuration. You can use the Remote repositories to collaborate with others. Also, you can interact with remote hosting services like GitHub, GitLab, or Bitbucket. By adding a remote, you can push your changes to it or fetch changes from it.

git remote add <remote_name> <remote_url>

19. git rebase

You can use this powerful command to integrate changes from one branch onto another by moving, or “rebasing,” a series of commits onto a different base commit. This effectively rewrites the commit history and creates a linear sequence of commits. Rebasing is commonly useful when you want to incorporate changes from one branch into another. Typically when working on feature branches or when synchronizing with a main branch.

git rebase <base_branch>

These are the top Git commands which are the foundation of Git knowledge. They will empower you to start collaborating on projects, tracking changes, and contributing to open-source communities effectively.

Conclusion

Mastering Git basics is a crucial step in your journey as a developer. It enables you to work seamlessly in teams, keep track of your code changes, and contribute to open-source projects. Remember, Git is a powerful tool, and while these commands provide a strong starting point, there’s much more to explore. Continue to learn and experiment with Git to become a proficient developer with efficient version control skills. Happy coding!