How to remove last commit git

Remove last commit and push

3 Answers 3

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

If you have already pushed this commit, then it is possible that someone else has pulled the branch. In this case, rewriting your branch’s history is undesirable and you should instead revert this commit:

Here is the commit hash of the commit you want to remove. To find this hash value, simply type git log on your branch and inspect the first entry.

Using git revert actually adds a new commit which is the mirror image of the commit you want to remove. It is the preferred way of undoing a commit on a public branch because it simply adds new information to the branch.

If you are certain that you are the only person using this branch, then you have another option:

But you should only use this option if no one else is sharing this branch.

Then, you’ll see something like this:

So, this tells us that commit aa09a82f is your last one, and commit 41177183 is the one before it, then:

. brings us back to that commit, retaining the remote backup. With another git status to make sure that everything is all set for the double push (I’m personally a bit obsessive compulsive about verifying my current branch, especially when multitasking):

At this point, you should be all set, but it’s always good to follow that up with:

. which cleans up your branch list and shows you both local and remote to compare the commit messages.

Also, if working with a team, make sure that they’re aware of this before moving forward. You don’t want them to pull or push the branch on their end before you remove the last commit and push.

How to remove last commit git

Given one or more existing commits, revert the changes that the related patches introduce, and record some new commits that record them. This requires your working tree to be clean (no modifications from the HEAD commit).

See «Reset, restore and revert» in git[1] for the differences between the three commands.

OPTIONS

With this option, git revert will let you edit the commit message prior to committing the revert. This is the default if you run the command from a terminal.

Usually you cannot revert a merge because you do not know which side of the merge should be considered the mainline. This option specifies the parent number (starting from 1) of the mainline and allows revert to reverse the change relative to the specified parent.

Reverting a merge commit declares that you will never want the tree changes brought in by the merge. As a result, later merges will only bring in tree changes introduced by commits that are not ancestors of the previously reverted merge. This may or may not be what you want.

With this option, git revert will not start the commit message editor.

Usually the command automatically creates some commits with commit log messages stating which commits were reverted. This flag applies the changes necessary to revert the named commits to your working tree and the index, but does not make the commits. In addition, when this option is used, your index does not have to match the HEAD commit. The revert is done against the beginning state of your index.

This is useful when reverting more than one commits’ effect to your index in a row.

Add a Signed-off-by trailer at the end of the commit message. See the signoff option in git-commit[1] for more information.

Use the given merge strategy. Should only be used once. See the MERGE STRATEGIES section in git-merge[1] for details.

Pass the merge strategy-specific option through to the merge strategy. See git-merge[1] for details.

Allow the rerere mechanism to update the index with the result of auto-conflict resolution if possible.

SEQUENCER SUBCOMMANDS

Skip the current commit and continue with the rest of the sequence.

Forget about the current operation in progress. Can be used to clear the sequencer state after a failed cherry-pick or revert.

Cancel the operation and return to the pre-sequence state.

EXAMPLES

Revert the changes specified by the fourth last commit in HEAD and create a new commit with the reverted changes.

Revert the changes done by commits from the fifth last commit in master (included) to the third last commit in master (included), but do not create any commit with the reverted changes. The revert only modifies the working tree and the index.

Undo possibilities in Git

Nothing in Git is deleted, so when you work in Git, you can undo your work.

All version control systems have options for undoing work. However, because of the de-centralized nature of Git, these options are multiplied. The actions you take are based on the stage of development you are in.

When you can undo changes

Undo local changes

Until you push your changes to a remote repository, changes you make in Git are only in your local development environment.

Undo unstaged local changes

When you make a change, but have not yet staged it, you can undo your work.

Confirm that the file is unstaged (that you did not use git add ) by running git status :

Choose an option and undo your changes:

To overwrite local changes:

To save local changes so you can re-use them later:

To discard local changes to all files, permanently:

Undo staged local changes

If you added a file to staging, you can undo it.

Confirm that the file is staged (that you used git add ) by running git status :

Choose an option and undo your changes:

To unstage the file but keep your changes:

To unstage everything but keep your changes:

To unstage the file to current commit (HEAD):

To discard all local changes, but save them for later:

To discard everything permanently:

Quickly save local changes

Use git stash list to list all previously stashed commits.

Undo committed local changes

When you commit to your local repository ( git commit ), Git records your changes. Because you did not push to a remote repository yet, your changes are not public (or shared with other developers). At this point, you can undo your changes.

Undo staged local changes without modifying history

You can revert a commit while retaining the commit history.

Choose an option and undo your changes:

To swap additions and deletions changes introduced by commit B :

Undo multiple committed changes

You can recover from multiple commits. For example, if you have done commits A-B-C-D on your feature branch and then realize that C and D are wrong.

To recover from multiple incorrect commits:

Create a new branch.

Add, push, and commit your changes.

Alternatively, with GitLab, you can cherry-pick that commit into a new merge request.

Undo staged local changes with history modification

The following tasks rewrite Git history.

Delete a specific commit

Rebase the range from current commit D to B :

Modify a specific commit

Rebase the range from current commit D to B :

Open the file in your editor, make your edits, and commit the changes:

Redoing the undo

You can recall previous local commits. However, not all previous commits are available, because Git regularly cleans the commits that are unreachable by branches or tags.

Undo remote changes without changing history

To undo changes in the remote repository, you can create a new commit with the changes you want to undo. You should follow this process, which preserves the history and provides a clear timeline and development structure. However, you only need this procedure if your work was merged into a branch that other developers use as the base for their work.

To revert changes introduced in a specific commit B :

Undo remote changes while changing history

You can undo remote changes and change history.

Even with an updated history, old commits can still be accessed by commit SHA. This is the case at least until all the automated cleanup of detached commits is performed, or a cleanup is run manually. Even the cleanup might not remove old commits if there are still refs pointing to them.

When changing history is acceptable

You should not change the history when you’re working in a public branch or a branch that might be used by other developers.

When you contribute to large open source repositories, like GitLab, you can squash your commits into a single one.

How to change history

A feature branch of a merge request is a public branch and might be used by other developers. However, the project rules might require you to use git rebase to reduce the number of displayed commits on target branch after reviews are done.

Use git rebase carefully on shared and remote branches. Experiment locally before you push to the remote repository.

Delete sensitive information from commits

You can use Git to delete sensitive information from your past commits. However, history is modified in the process.

To remove a file from the history altogether use:

The git filter-branch command might be slow on large repositories. Tools are available to execute Git commands more quickly. These tools are faster because they do not provide the same feature set as git filter-branch does, but focus on specific use cases.

Refer to Reduce repository size to learn more about purging files from repository history and GitLab storage.

How to remove not-last commit in Git?

I recently created a new branch, lets call it «branch1», which is based on another branch, lets call it «master». I then made a bunch of commits to branch1, and now I´ve realised that the first couple of commits was actually a mistake, The ones after those first few however are still great commits! So what I´m trying to do here is basically remove those first few commits, so that the ones after them basically gets rebased on master. how would one do this?

4 Answers 4

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

Say this is your commit history from latest to earliest:

So, say you want to get rid of only the code from 1XXXX and 2XXXX and don’t really care if the commits stay or go. Thus, you can now do :

git revert 1XXXX This makes a new commit that has a message similar to reverts 1XXXX

git revert 2XXXX This makes a new commit that has a message similar to reverts 2XXXX

git push origin branch1

Thus, your commits will now be :

If you want to get rid of the commits themselves, then you can do :

Fix any merge conflicts if they come up and BOOM! 1XXXX and 2XXXX never existed!!

Your best option would probably be to use git revert (docs here) for the commits you want to cancel.

3 notes about it:

Delete commits from a Git branch

This post will discuss how to delete commits from a Git branch.

1. git reset

Here, the idea is to force reset the working directory to remove all commits which come after the specified commit and then do a force push:

You can refer to a commit via its ancestry, using its full SHA-1 hash, or providing the partial hash, which should be at least 4 characters long and unambiguous.

If those commits are present in the remote repository, you will need to force push the hard reset to the remote repository.

Here’s a live example:

This is demonstrated below:

2. git revert

It is not a good idea to do a force push on a public or a shared repository; do a git-revert instead. It creates a new commit that undoes all the specified commit changes, then applies it to the current branch.

# Revert the commit 87859b5
git revert 87859b5

# Push to the remote
git push

Here’s a live example:

3. Interactive Rebasing

Another plausible way of removing comments is using the git-rebase command.

Executing the above command will open up an editor with all the commits in your current branch, which come after the specified commit. To drop a commit, simply replace the command ‘pick’ with ‘drop’ and close the editor. You can also delete the matching line.

That’s all about deleting commits from a Git branch.

Average rating 4.96 /5. Vote count: 23

No votes so far! Be the first to rate this post.

We are sorry that this post was not useful for you!

Tell us how we can improve this post?

Thanks for reading.

Please use our online compiler to post code in comments using C, C++, Java, Python, JavaScript, C#, PHP, and many more popular programming languages.

Like us? Refer us to your friends and help us grow. Happy coding 🙂