Git: Common Errors and Corrections

If you have ever worked on a large project, in which, besides you, many other programmers are involved, then you obviously used Git as a version control system. In the course of using something that is similar in complexity to Git, everyone makes mistakes.


The author of the material, the translation of which we publish today, is going to discuss common mistakes that programmers make when working with Git, and talk about how to deal with these errors.

Error in last commit message

After a few hours of good work, it's easy to make a mistake in the commit message. Fortunately, this is easily fixed with the following command:

git commit --amend 

This command will open the editor and allow you to make changes to the latest commit message. No one except you should know that you wrote an “Initial commment” with three “m”.
')

Error in the name of the branch

Suppose that the clock is almost 15:00, and you have not had dinner yet. As a result, tormented by hunger, you called the new branch feature-brunch . Yummy, do not say anything.

This problem can also be solved. You can rename a branch in the same way that you rename files using the mv command. It is about moving it to a new place with the correct name:

 git branch -m feature-brunch feature-branch 

If you have already sent this thread to the repository, you need to do a couple more things to rename it. The old branch should be deleted, and the new one should be sent to the repository:

 git push origin --delete feature-brunch git push origin feature-branch 

Random commit changes to the master branch

Suppose you are working on a new opportunity, and, in a hurry, you forgot to create a new branch for it. You are already a bunch of files and it all lies in the master branch. You can move all these changes to a new branch using the following three commands. Note that if you do not use commit or stash commands for changes, they will be lost.

 git branch feature-branch git reset HEAD~ --hard git checkout feature-branch 

As a result, a new branch will be created, changes in the master branch will be rolled back to the state in which it was before the changes were made, and a transition will be made to the new branch, which will contain all changes made earlier in the master .

Work with files that you forgot to add to the last commit

Another common mistake when working with Git is that commits are done too early and they don’t get the necessary files. Let's say you missed a file, forgot to save it, or you need to make a small change to the file so that the last commit makes sense. In a situation like this, the --amend command will come in handy again. Add the missing file to the repository index and run this command:

 git add missed-file.txt git commit --amend 

After that you can change the commit message, or leave it the same as it was.

Adding the wrong file to the repository

What if your mistake is the exact opposite of the previous one? What if you added a file to the index that you are not going to commit? This could be some ENV file, project build directory, a photo of your dog that you accidentally saved in the wrong folder. All this can be fixed.

If your actions are limited to indexing a file, but you have not committed it yet, it will be very easy to deal with the problem using the reset command:

 git reset /assets/img/misty-and-pepper.jpg 

If you have advanced far enough and managed to commit the change, then know that this too is fixable. We'll just have to use a few more commands:

 git reset --soft HEAD~1 git reset /assets/img/misty-and-pepper.jpg rm /assets/img/misty-and-pepper.jpg git commit 

As a result, the last commit will be canceled, the image will be deleted, after which the new commit will be placed where it should be.

What if everything went wrong?

The technique that we will discuss now helps in situations where everything goes wrong. For example, this happens when you are too keen on copying ready-made solutions from StackOverflow, and, after work, your repository is in a worse state than it was at the very beginning. In this situation, perhaps, we all fell.

The git reflog shows a list of everything you did. It then allows you to use the Git tools to revert changes, to return to one of the past repository states. It is worth noting that this method should be considered as a last resort, and, before using it, you should think about it. So, the list of what has been done can be displayed with the following command:

 git reflog 

Git remembers all of our actions and as a result of this command, you can see something like the following:

 3ff8691 (HEAD -> feature-branch) HEAD@{0}: Branch: renamed refs/heads/feature-brunch to refs/heads/feature-branch 3ff8691 (HEAD -> feature-branch) HEAD@{2}: checkout: moving from master to feature-brunch 2b7e508 (master) HEAD@{3}: reset: moving to HEAD~ 3ff8691 (HEAD -> feature-branch) HEAD@{4}: commit: Adds the client logo 2b7e508 (master) HEAD@{5}: reset: moving to HEAD~1 37a632d HEAD@{6}: commit: Adds the client logo to the project 2b7e508 (master) HEAD@{7}: reset: moving to HEAD 2b7e508 (master) HEAD@{8}: commit (amend): Added contributing info to the site dfa27a2 HEAD@{9}: reset: moving to HEAD dfa27a2 HEAD@{10}: commit (amend): Added contributing info to the site 700d0b5 HEAD@{11}: commit: Addded contributing info to the site efba795 HEAD@{12}: commit (initial): Initial commit 

Pay attention to the leftmost column of this list. It contains indexes. If you need to go back to a certain moment of the past, run the following command, replacing {index} with a corresponding link, for example - dfa27a2 . This command looks like this:

 git reset HEAD@{index} 

Results

We looked at some of the ways to deal with errors that arise when working with Git. We hope that you will not allow such errors and these techniques of working with Git will not be useful to you. And if something goes wrong, you will know what to do.

Dear readers! Know about any interesting techniques for working with Git? If so, ask them to share.