Learn how to undo changes in Git using Bitbucket Cloud

As you progress through the tutorial you'll learn several other git commands as part of learning how to undo changes, so let's get started.

Let's begin by creating a unique repository with all the code from the original. This process is called “forking a repository”. Forking is an extended git process that is enabled when a shared repository is hosted with a 3rd party hosting service like Bitbucket.

1. Click or enter the following URL: https://bitbucket.org/atlassian/tutorial-documentation-tests/commits/all

2. Click the + symbol on the left sidebar, then select Fork this repository, review the dialog and click Fork repository.

3. You should be taken to the overview of the new repository.

4. Click the + symbol and select Clone this repository.

5. On your computer clone the repository.

6. Navigate to the directory containing the cloned repository.

Now that you've got a repository full of code and an existing history on your local system you're ready to begin undoing some changes.

You'll have to be able to find and reference the change you want to undo. This can be accomplished by browsing the commit UI on Bitbucket and there are a few command line utilities that can locate a specific change.

You'll have to be able to find and reference the change you want to undo. This can be accomplished by browsing the commit UI on Bitbucket and there are a few command line utilities that can locate a specific change.

The output of git status here shows us that everything is up-to-date with the remote main branch and there are no pending changes waiting to be committed. In the next example we will make some edits to the repository and examine it in a pending changes state. This means you have changes to files in the repository on your local system that you haven't prepared (or staged) to be added to the project history.

To demonstrate this next example,  first open the myquote2.html file. Make some modifications to the contents of myquote2.html, save and exit the file. Let us once again execute git status to examine the repository in this state.

The output here shows that the repository has pending modifications to myquote2.html. Good news! If the change you want to undo has, like the example above, not been added to the staging area yet you can just edit the file and keep going. Git only starts tracking a change when you add it to the staging area and then commit it to the project history.

Let us now “undo” the changes we have made to myquote2.html. Because this is a simplified example with minimal changes, we have two available methods for undoing the changes.  If we execute git checkout myquote2.html The repository will restore myquote2.html to the previously committed version. Alternatively, we can execute git reset --hard which will revert the whole repository to the last commit.

The git log command lets you list the project history, filter it, and search for specific changes. While git status lets you inspect the working directory and the staging area, git log only shows the committed history.

The same log of commited history can be found within the Bitbucket UI by accessing the “commits” view of a repository. The commits view for our demo repository can be found at: https://bitbucket.org/dans9190/tutorial-documentation-tests/commits/all. This view will have a similar output to the git log command line utility. It can be used to find and identify a commit to undo.

In the following example you can see several things in the history but each change is, at its root, a commit so that's what we'll need to find and undo.

Let's look a little closer at one of the commits in the list:

What you can see is each commit message has four elements:

Most likely the change you want to undo will be somewhere further back in the project history which can be quite extensive. So let's learn a couple basic operations using git log to find a specific change.

1. Go to your terminal window and navigate to the top level of your local repository using the cd (change directory) command.

Enter the git log --oneline command. Adding --oneline will display each commit on a single line that allows you to see more history in your terminal.

Press the q key to exit the commit log and return to your command prompt at any time.

You should see something like the following example:

2. Press the q key to return to your command prompt.

3. Locate the commit with the hash c5826da and more changes in the list the git log command produced. Someone didn't write a descriptive commit message so we'll have to figure out if that's got the changes we need.

4. Highlight and copy the commit hash c5826da from the git log result in your terminal window.

5. Type git show then paste or transcribe the commit hash you copied and press enter. You should see something like this:

The prompt at the bottom will continue to fill in until it shows the entire change. Press q to exit to your command prompt.

This was a very brief look at the git log command if you like working in the command like you'll probably want to check out the advanced git log tutorial.

1. Enter git log --oneline in your terminal window.

2. Copy the commit hash for the second commit in the log: 52f823c then press q to exit the log.

3. Enter git reset --soft 52f823c in your terminal window. The command should run in the background if successful.  That's it, you've undone your first change. Now let's see the result of this action.

4. Enter git status in your terminal window and you will see the commit was undone and is now an uncommitted change. It should look something like this:

5. Enter git log --oneline in your terminal window. You should see something like this:

6. You can see the new HEAD of the branch is commit 52f823c which is exactly what you wanted.

7. Press q to exit the log. Leave your terminal open because now that you've learned how to do a simple reset, let's try something a little more complex.

1. Enter git log --online

2. Copy the commit hash 1a6a403 (myquote edited online with Bitbucket)  which is the commit just below pull request #6 which has the changes we want to undo.

3. Enter git reset 1a6a403 in your terminal window. The output should look something like this:

You can see that the changes are now in an uncommitted state. This means that now we've removed several changes from both the history of the project and the staging area.

4. Enter git status in your terminal window. The output should look something like this:

Now you can see that the first change we undid (the bitbucket-pipelines.yml file) is now completely untracked by git. This is because invoking git reset removes the change from both the head of the branch and the tracking or index area of git. The underlying process is a bit more complex than we can cover here, you can read more in git reset.

5. Enter git log --oneline in your terminal window.

The log output now shows the commit history has also been modified and begins at commit 1a6a403. For the sake of demonstration and further example, let’s say we want to now undo the reset we just did. After further consideration, maybe we wanted to keep the contents of pull request #6. 

Git resets are one of a few “undo” methods git offers. Resets are generally considered an ‘unsafe’ option for undoing changes. Resets are fine when working locally on isolated code but become risky when shared with team members.

In order to share a branch that has been reset with a remote team a ‘forced push’ has to be executed. A ‘forced push’ is initiated by executing git push -f. A forced push will destroy any history on the branch that was built after the point of the push.

An example of this ‘unsafe’ scenario is as follows:

• Dev A has been working on a branch developing a new feature.
• Dev B has been working on the same branch developing a separate feature.
• Dev B decides to reset the branch to an earlier state before both Dev A and Dev B started work.
• Dev B then force pushes the reset branch to the remote repository.
• Dev A pulls the branch to receive any updates. During this pull Dev A receives the forced update. This resets Dev A’s local branch back in time before any of their feature work was done and loses their commits.

Your output from git reflog should be similar to the above. You can see a history of actions on the repo. The top line is a reference to the reset we did to reset pull request #6. Let us now reset the reset to restore pull request #6. The second column of this reflog output indicates a ref pointer to a modification action take on the repo. Here HEAD@{0} is a reference to the reset command we previously executed. We do not want to replay that reset command so we will restore the repo to HEAD@{1}.

Let us now examine the repos commit history with git log --oneline:

The log output now shows the commit history has also been modified and begins at commit 1a6a403. For the sake of demonstration and further example, let’s say we want to now undo the reset we just did. After further consideration, maybe we wanted to keep the contents of pull request #6.  

For this example let’s pick the most recent commit 1f08a70 as our commit to operate on. For this scenario let's say that we want to undo the edits made in that commit. Execute:

This will kick off a git merge workflow. Git will create a new commit thats content is a reverse of the commit that was specified for the revert. Git will then open up a configured text editor to prompt for a new commit message. Reverts are considered the safer undo option because of this commit workflow. The creation of revert commits leave a clear trail in the commit history of when an undo operation was executed.

Congratulations, you’re done! Come back to this tutorial any time or head to the Undoing Changes section to go more in depth. Keep up the good work in Bitbucket!