Basic Git Commands

As a full-stack developer, I can confidently say that version control is one of the most critical skills for any programmer to master. And when it comes to version control systems, Git is the clear winner.

Since its creation by Linus Torvalds in 2005, Git has become the de facto standard for version control in the software industry. According to the Stack Overflow Developer Survey 2021, over 93% of professional developers use Git for version control. And it‘s not hard to see why – Git offers unparalleled flexibility, performance, and collaboration features that make it indispensable for modern software development.

In this article, we‘ll take a comprehensive look at the basic Git commands that every developer should know, along with some advanced tips and best practices for using Git in real-world projects. Whether you‘re a beginner just starting out with version control or an experienced developer looking to deepen your Git expertise, this guide has something for you.

What is Git?

At its core, Git is a distributed version control system that allows developers to track changes to their codebase over time. Unlike centralized version control systems like Subversion or CVS, Git is distributed, meaning that every developer has a complete copy of the repository on their local machine. This makes Git incredibly fast and allows developers to work offline or independently of a central server.

Git stores data as a series of snapshots, rather than a list of file-based changes. When you make a commit in Git, it takes a snapshot of all the files in your project at that point in time and stores a reference to that snapshot. If a file hasn‘t changed between commits, Git doesn‘t store the file again, but instead links to the previous version.

Under the hood, Git uses a directed acyclic graph (DAG) to represent the history of a project. Each node in the graph represents a commit, and each edge represents a parent-child relationship between commits. This allows Git to efficiently store and retrieve snapshots of a project at any point in its history.

Git also uses SHA-1 hashes to uniquely identify each commit. A SHA-1 hash is a 40-character hexadecimal string that serves as a unique identifier for a particular snapshot of the codebase. This makes it easy to refer to specific commits and ensures the integrity of the repository.

Now that we have a basic understanding of how Git works, let‘s dive into the basic commands you‘ll use to interact with a Git repository.

git init

The git init command is used to initialize a new Git repository in the current directory. This creates a new .git subdirectory that contains all the necessary metadata for the repository.

$ mkdir my-project
$ cd my-project
$ git init

git clone

The git clone command is used to create a copy of an existing repository, either from a remote server or another location on your local machine. This is useful when you‘re starting to work on an existing project or need to collaborate with other developers.

$ git clone https://github.com/username/my-project.git

git add

The git add command is used to stage changes in your working directory for the next commit. You can stage individual files or entire directories at once.

$ git add file.txt  # stages a single file
$ git add .         # stages all changes in the current directory

git commit

The git commit command is used to save your staged changes as a new snapshot in the repository‘s history. Each commit requires a message describing the changes being made.

$ git commit -m "Add new feature"

It‘s important to write clear and descriptive commit messages that convey the intent behind each change. This makes it easier for other developers (and your future self) to understand the history of the project.

git push

The git push command is used to upload your local commits to a remote repository, such as GitHub or GitLab. This allows other developers to access your changes and enables collaboration on the project.

$ git push origin main

Here, origin refers to the remote repository, and main is the branch being pushed. If you‘re working on a feature branch, you‘d replace main with the name of your branch.

git pull

The git pull command is used to fetch changes from a remote repository and merge them into your local branch. This is important to do before starting work on a new feature or bug fix, to ensure you have the latest changes from other developers.

$ git pull origin main

Again, origin refers to the remote repository, and main is the branch being pulled from.

git branch

The git branch command is used to create, list, or delete branches in a Git repository. Branches are an essential feature of Git that allow developers to work on multiple features or bug fixes simultaneously without affecting the main codebase.

$ git branch                # lists all branches in the repository
$ git branch new-feature    # creates a new branch called "new-feature"
$ git branch -d new-feature # deletes the "new-feature" branch

git merge

The git merge command is used to integrate changes from one branch into another. This is typically done when a feature branch is complete and needs to be merged back into the main branch.

$ git checkout main         # switch to the main branch
$ git merge new-feature     # merge the "new-feature" branch into main

Merging can sometimes result in conflicts if the same lines of code were modified in both branches. In this case, you‘ll need to manually resolve the conflicts before the merge can be completed.

Advanced Git Commands

While the basic commands covered above are sufficient for most day-to-day Git usage, there are also some more advanced commands that can be useful in certain situations.

git rebase

The git rebase command is used to reapply a series of commits on top of another base commit. This can be useful for keeping a feature branch up to date with changes in the main branch, or for cleaning up a messy commit history before merging.

$ git checkout feature      # switch to the feature branch
$ git rebase main           # rebase the feature branch onto the main branch

Rebasing can be a powerful tool, but it‘s important to use it carefully. Rebasing changes the commit history and can cause conflicts if not done properly.

git cherry-pick

The git cherry-pick command is used to apply a single commit from one branch to another. This can be useful if you only need to include a specific change from a feature branch, rather than merging the entire branch.

$ git checkout main         # switch to the main branch
$ git cherry-pick 1a2b3c    # apply the commit with hash 1a2b3c to the main branch

git stash

The git stash command is used to temporarily save changes that are not yet ready to be committed. This can be useful if you need to switch branches or pull changes from a remote, but don‘t want to lose your current work.

$ git stash                 # save the current changes to the stash
$ git stash pop             # restore the most recent changes from the stash

Git Workflows and Best Practices

While the basic Git commands are relatively straightforward, using Git effectively in a real-world project requires some additional planning and best practices. Here are some tips and strategies that I‘ve found helpful in my work as a full-stack developer.

Branching Strategy

One of the most important aspects of using Git in a team environment is having a clear branching strategy. A branching strategy defines how new features, bug fixes, and releases are managed within the repository.

A popular branching strategy is the Gitflow workflow, which was first described by Vincent Driessen in 2010. Gitflow involves two main branches: main and develop, as well as three types of supporting branches: feature, release, and hotfix.

The main branch represents the production-ready state of the project, while the develop branch serves as an integration branch for new features. Feature branches are created from develop and merged back in when the feature is complete. Release branches are used to prepare the project for a new release, and hotfix branches are used for critical bug fixes that need to be deployed immediately.

While Gitflow is a popular and well-defined strategy, it may not be the best fit for every project. Other common branching strategies include GitHub Flow, GitLab Flow, and the Forking Workflow. The key is to choose a strategy that aligns with your team‘s goals and development process.

Commit Messages

Another important aspect of using Git effectively is writing clear and descriptive commit messages. A good commit message should concisely describe the changes being made and why they were necessary.

Here are some tips for writing effective commit messages:

Keep the subject line short and descriptive (50 characters or less)
Use the imperative mood in the subject line ("Add feature" instead of "Added feature")
Separate the subject from the body with a blank line
Wrap the body at 72 characters
Use the body to explain what and why, not how

Here‘s an example of a well-formatted commit message:

Add support for user authentication

- Implement basic login and registration forms
- Store user credentials securely in database
- Add tests for authentication functionality

Closes #123

Code Reviews

Code reviews are an essential part of any collaborative development process, and Git makes it easy to facilitate code reviews through pull requests.

A pull request is a way to propose changes to a repository and request feedback from other developers. When you open a pull request, you‘re asking other developers to review your changes and provide feedback before merging them into the main branch.

Here are some best practices for conducting effective code reviews:

Keep pull requests small and focused on a single feature or bug fix
Provide clear and constructive feedback, focusing on the code and not the person
Use automated tools like linters and code formatters to catch common issues
Encourage discussion and collaboration, but avoid bikeshedding or nitpicking
Merge pull requests promptly once they‘ve been approved

Continuous Integration and Deployment

Another key advantage of using Git is that it enables continuous integration and deployment (CI/CD) practices. CI/CD allows developers to automatically build, test, and deploy their code changes, reducing the risk of errors and speeding up the release process.

There are many CI/CD tools available that integrate with Git repositories, such as Jenkins, Travis CI, CircleCI, and GitLab CI/CD. These tools can automatically run tests, build artifacts, and deploy changes to staging or production environments based on specific triggers or events.

Implementing CI/CD can be a significant undertaking, but it pays off in the long run by reducing manual effort, increasing confidence in the codebase, and enabling faster release cycles.

Conclusion

Git is a powerful and essential tool for modern software development, and mastering its basic commands and best practices is a critical skill for any developer.

By understanding how Git works under the hood, using branching strategies effectively, writing clear commit messages, conducting code reviews, and implementing CI/CD practices, you can take your development workflow to the next level and collaborate more effectively with your team.

Of course, Git is a complex and ever-evolving tool, and there‘s always more to learn. But by focusing on these core concepts and continually improving your skills, you can become a Git expert and a more effective developer overall.

Basic Git Commands – How to Use Git in a Real Project

What is Git?