5 Git Commands You Should Know: A Full-Stack Developer‘s Guide

Git is an essential tool for modern software development, enabling version control, collaboration, and code management at scale. According to the 2021 Stack Overflow Developer Survey, Git is the most popular version control system, used by 93.9% of professional developers.

As a full-stack developer with years of experience, I‘ve found that mastering a core set of Git commands can greatly improve your productivity and workflow. In this in-depth guide, we‘ll explore five essential Git commands, complete with code examples, best practices, and real-world use cases.

Whether you‘re a beginner or an experienced developer, understanding these commands will help you collaborate more effectively, manage your codebase with confidence, and avoid common pitfalls. Let‘s dive in!

1. Adding and Managing Remote Repositories

Remote repositories are a fundamental concept in Git, allowing you to collaborate with others and backup your work. Adding a remote repository is typically one of the first things you‘ll do when starting a new project or contributing to an existing one.

To add a new remote, use the git remote add command followed by a shortname and the repository‘s URL:

git remote add origin https://github.com/your-username/your-repo.git

In this example, we‘re adding a remote named "origin" that points to a GitHub repository. The shortname is arbitrary, but "origin" is a common convention for the primary remote.

To view your current remotes, use git remote -v:

origin  https://github.com/your-username/your-repo.git (fetch)
origin  https://github.com/your-username/your-repo.git (push)

Sometimes you may need to change a remote‘s URL, for example if you‘ve moved your repository to a different hosting platform or want to switch from HTTPS to SSH. To do this, use git remote set-url:

git remote set-url origin [email protected]:your-username/your-repo.git

Here, we‘re updating the URL for "origin" to use SSH instead of HTTPS. Using SSH can be more secure and convenient, as it allows you to authenticate with your SSH key instead of entering your username and password each time.

Takeaways

• Use git remote add to add a new remote repository
• View current remotes with git remote -v
• Update a remote‘s URL with git remote set-url
• Choose a consistent and meaningful naming convention for your remotes

2. Creating, Merging and Deleting Branches

Branches are a powerful feature of Git that allow you to work on multiple features or bug fixes in parallel without affecting the main codebase. Understanding how to create, merge, and delete branches is crucial for effective collaboration and code management.

To create a new branch, use git branch followed by the branch name:

git branch feature/login

This will create a new branch named "feature/login" based on your current branch. To start working on the new branch, you‘ll need to switch to it using git checkout:

git checkout feature/login

You can also create and switch to a new branch in one command with git checkout -b:

git checkout -b feature/login

Once you‘ve finished working on your feature branch, you‘ll typically want to merge it back into the main branch (e.g. "master" or "main"). To do this, first switch to the main branch:

git checkout main

Then use git merge followed by the name of your feature branch:

git merge feature/login

Git will attempt to automatically merge the changes from your feature branch into the main branch. If there are any merge conflicts, Git will prompt you to resolve them before completing the merge.

After merging a branch, you may want to delete it to keep your repository clean. To delete a branch locally, use git branch -d:

git branch -d feature/login

To delete a branch on a remote repository, use git push --delete:

git push origin --delete feature/login

Be cautious when deleting branches, especially if they haven‘t been fully merged yet, as this can result in lost work. Always communicate with your team before deleting branches on shared repositories.

Takeaways

• Create new branches to work on features or bug fixes in isolation
• Use git branch to create a branch, git checkout to switch branches
• Merge branches with git merge after reviewing and testing changes
• Delete unneeded branches with git branch -d (locally) and git push --delete (remote)
• Communicate with your team and follow established branching workflows

3. Selectively Merging Files with git checkout --patch

Sometimes you may want to merge changes from a specific file in one branch into another branch, without merging the entire branch. This can be useful for applying hotfixes or sharing code between feature branches.

To selectively merge files, use git checkout with the --patch flag:

git checkout --patch source-branch file/to/merge.js

Git will display each changed "hunk" in the file and prompt you to decide whether to apply, skip, or edit each hunk. This allows you to carefully review and select which changes to merge.

For example, let‘s say you have a bug fix in the "hotfix" branch that you want to apply to the "main" branch. To selectively merge the fixed file:

git checkout main
git checkout --patch hotfix path/to/file.js

Git will display the diff hunks from path/to/file.js and prompt you to select which changes to apply to the "main" branch. After selecting the desired changes, commit them as usual with git commit.

Alternatively, if you want to completely overwrite the file in the target branch with the version from the source branch, you can omit the --patch flag:

git checkout hotfix path/to/file.js

Be careful when using this method, as it will discard any changes made to the file in the target branch.

Takeaways

• Use git checkout --patch to selectively merge changes from one branch to another
• Review each diff hunk and decide which changes to apply
• Omit --patch to completely overwrite the target file with the source version
• Be cautious when overwriting files, as it may discard important changes

4. Undoing and Recovering from Mistakes

Mistakes happen, and Git provides several ways to undo changes and recover from errors. Two key commands for undoing commits are git reset and git revert.

To undo the last commit in your local repository and keep the changes in your working directory, use git reset --soft:

git reset --soft HEAD~1

This will move the branch pointer back one commit, but preserve the changes from that commit in your working directory. You can then modify the changes and re-commit them as needed.

If you want to completely discard the changes from the last commit, use git reset --hard:

git reset --hard HEAD~1

Be very cautious when using --hard, as it will permanently delete any changes made in the undone commit.

If you‘ve already pushed a commit to a remote repository and need to undo it, you can use git revert to create a new commit that undoes the changes:

git revert abc1234

Replace abc1234 with the hash of the commit you want to revert. This will create a new commit that undoes the specified commit, which you can then push to the remote repository.

In more complex situations, such as undoing multiple commits or recovering deleted branches, you may need to use advanced techniques like git reflog and git cherry-pick. Always research and fully understand these commands before using them, as they can have unintended consequences if used incorrectly.

Takeaways

• Use git reset --soft to undo a commit while keeping changes in your working directory
• Use git reset --hard to completely discard changes from a commit
• Use git revert to create a new commit that undoes a previous commit
• Be cautious when using git reset --hard and undoing pushed commits, as it can cause data loss and conflicts with collaborators
• Research and understand advanced recovery techniques before using them

5. Git Productivity Tips and Best Practices

In addition to mastering essential Git commands, adopting best practices and productivity techniques can help you work more efficiently and collaboratively. Here are a few tips I‘ve learned over the years:

1. Use meaningful commit messages: Clear and descriptive commit messages make it easier for you and your collaborators to understand the purpose and context of each change. Follow conventions like using the imperative mood and limiting the first line to 50 characters.

2. Commit early and often: Make small, focused commits that encapsulate a single logical change. This makes it easier to review, revert, and merge changes later on. Avoid large, monolithic commits that mix unrelated changes.

3. Use branches for feature development: Create a new branch for each feature, bug fix, or experiment you work on. This keeps your main branch stable and allows for parallel development and easier code review.

4. Rebase your feature branches: Before merging a feature branch, use git rebase to apply your changes on top of the latest changes from the main branch. This keeps your branch up to date and makes the eventual merge simpler and cleaner.

5. Review changes before pushing: Use git diff and git log to review your changes before pushing them to a remote repository. This helps catch mistakes and ensures that you‘re only pushing intended changes.

6. Integrate Git with your IDE: Many IDEs and code editors have built-in Git integration or plugins that allow you to perform common Git operations directly from the editor. Learn and use these features to save time and streamline your workflow.

7. Automate with Git hooks: Git hooks are scripts that run automatically before or after certain Git events, such as committing or pushing. You can use hooks to automate tasks like running tests, linting code, or enforcing commit message conventions.

Remember, these are just a few examples of Git best practices and productivity tips. The most important thing is to find a workflow that works for you and your team, and to consistently follow and refine it over time.

Conclusion

In this guide, we‘ve covered five essential Git commands that every full-stack developer should know: managing remotes, creating and merging branches, selectively merging files, undoing changes, and rebasing commits. We‘ve also explored some best practices and productivity tips to help you work more efficiently with Git.

Mastering these commands and concepts will give you a solid foundation for using Git effectively in your projects. However, Git is a vast and powerful tool, and there‘s always more to learn. Don‘t be afraid to explore advanced features and techniques as you encounter new challenges and use cases.

Remember, the key to becoming proficient with Git is practice and repetition. Incorporate these commands into your daily workflow, and take the time to understand how they work under the hood. When you encounter a new problem or need, consult the official Git documentation and experiment in a safe environment.

As a final tip, I encourage you to share your knowledge and experiences with others. Collaborate with your teammates, participate in code reviews, and mentor junior developers. Teaching others is one of the best ways to solidify your own understanding and discover new perspectives.

With dedication and practice, you‘ll soon become a confident and effective Git user, ready to tackle any version control challenge that comes your way. Happy coding!