how to undo changes in Git

Git not only allows you to undo recent edits, but also provides powerful tools for managing your entire change history. Using key commands, you can roll back changes, rename commits, undo merges, and much more.

Let’s look at examples.

How to rollback the last commit

Situation: You just made a commit, and then realized that you didn’t add a file or made a mistake in the code. The main command that comes to the rescue in such cases is git reset. It allows you to reset the commit history to a certain point.

Example:

This command rolls back history one commit, leaving the working directory and index unchanged.

There are three main modes for this command:

• soft – rolls back history but leaves changes in your workspace
• mixed – rolls back history and workspace, but leaves files unchanged
• hard – completely rolls back history, workspace and files

Example:

git reset –hard (hash_commit)

Where (commit_hash) is the unique identifier of the commit to which you want to rollback changes.

Tip: Before using git reset, especially with the –hard flag, create a backup copy of your code.

How to change the name of the last commit

Noticed an error in the title or description when creating a commit? With the command git commit –amend you can make changes to the last commit.

The command allows you to edit a commit message or set a new one.

Example:

git commit –amend -m “New commit name”

If you run this command without specifying a new message (-m), it opens an editor where you can edit the commit message.

A correct and clear commit name helps the developer and team better understand the history of changes. A good commit clearly describes what was done and why, making code review and debugging easier.

Tip: When writing a commit message, first briefly describe the nature of the changes (no more than 50 characters). Then, after the blank line, give a more detailed description if necessary.

How to rollback changes to a specific file

Sometimes it is necessary to roll back changes not for the entire project, but only for a specific file or set of files.

For example, you experimented with the code in one file, but decided that the old version was better. Or you accidentally deleted important information from a file and want to get it back.

In these cases, use the git checkout command. This will revert the file to the state of the last commit, or to the state of another commit if you provide a hash of it.

For example, you need to revert the example.txt file to the state of the last commit:

git checkout HEAD — example.txt

And if you want to return the file to the state of a specific commit:

git checkout (hash_commit) — example.txt

Here (commit_hash) is the unique identifier of the commit.

Tip: If you are not sure about the hash of the commit you need, use git log to view the commit history.

How to undo a merge

Merging is an important process in Git that allows you to combine changes from different branches. But sometimes a merge needs to be canceled – for this they use git reset.

Example:

git reset –hard ORIG_HEAD

ORIG_HEAD – a reference to the state of your repository before the last merge. Using git reset with this link will return the repository to its pre-merge state.

If you don’t want to completely delete the merge history and want to save it for future analysis, use git revert. It creates a new commit that undoes the changes introduced by the merge.

Example:

git revert -m 1 (merge_commit_hash)

Here -m 1 points to the “parent” commit from the merge that you want to keep, and (merge_commit_hash) is the ID of the merge commit that you want to undo.

Tip: Undoing a merge can be difficult, especially if there have been many other commits since the merge. It’s better to work in a copy of your repository when trying to undo complex actions in Git.

How to change commit history

Sometimes you need to change your commit history. For example, if you want to group several commits into one or change the order of commits.

Using git rebase’s interactive mode, you can easily edit, reorder, merge, and even delete commits.

Let’s say you want to change the last 4 commits:

This will open an interactive mode with a list of commits and available commands.

Now you can:

• pick (or p) – use the commit without changes
• reword (or r) – change the commit message
• edit (or e) – edit the contents of a commit
• squash (or s) – merge a commit with the previous one
• drop (or d) – delete a commit

It’s important to remember: changing the commit history of a branch that has already been published and is being used by other developers is a bad idea. If someone on the team, for example, syncs their local versions with an updated branch, they will encounter a version conflict because the commit histories no longer match.

How to merge commits

If you have multiple commits that need to be merged into one, git rebase -i is a great tool for this. Select the commits you want to merge using squash or s.

Tip: When merging commits, make sure the final commit message clearly and concisely reflects the changes made.

What to do if too much has been rolled back

Sometimes, while trying to fix one problem, you may end up with another. If you feel like you’ve rolled back your changes too far or done something wrong, don’t panic. Git keeps a log of all activity in your repository.

The git reflog command will show a list of all actions performed on your repository. Each action has an index that can be used to return to a specific point.

Example:

You will see a list of all actions with their indexes. To return to the desired moment, use:

git reset –hard HEAD@{index}

How to delete local and remote branches

Sometimes, after work on a certain feature or fix is ​​completed, branches become obsolete. Git provides commands to safely delete such branches.

If you are absolutely sure and want to delete the branch without first checking it out, use:

git branch -D branch_name

But beware -D – it won’t warn you about losing changes.

To delete a branch on a remote repository, enter:

git push origin –delete branch_name

What to do if everything goes wrong

• Reach out to the community. Git has one of the most active and supportive communities. If you have problems, most likely someone has already encountered this and is ready to help.
• Do not panic. Most problems in Git can be solved. With every mistake, you learn and become a more experienced developer.
• Always keep a backup copy. Before making major changes or experimenting with commands, back up your repository.

Conclusion

Git is a powerful tool that seems complex only at first glance. But with the right knowledge and practice, you can make the most of it, improving your workflow and project management.