How can I revert multiple Git commits?

Question

I have a Git repository that looks like this:

A <- B <- C <- D <- HEAD

I want the head of the branch to point to A, i.e., I want B, C, D, and HEAD to disappear and I want head to be synonymous with A.

It sounds like I can either try to rebase (doesn't apply, since I've pushed changes in between), or revert. But how do I revert multiple commits? Do I revert one at a time? Is the order important?

Seriatim

If you just want to reset the remote, you can clobber it with anything! But let us use the fourth commit ago: git push -f HEAD~4:master (assuming the remote branch is master). Yes, you can push any commit like that. – Synapse

If people have pulled you have to make a commit that reverts changes using git revert. – Simpatico

Use git show HEAD~4 to ensure you are pushing to right one to the remote – Edveh

Possible duplicate of How to undo last commit(s) in Git? – Gerfalcon

"Is the order important?" Yes, if the commits affect the same lines in the same files. Then you should start reverting the most recent commit, and work your way back. – Relay

Please note that git revert will leave the intervening work in history. Use git checkout with git reset --hard to nuke the history as well: see answer https://mcmap.net/q/12035/-how-can-i-revert-multiple-git-commits – Mceachern

Answer 1

Expanding what I wrote in a comment

The general rule is that you should not rewrite (change) history that you have published, because somebody might have based their work on it. If you rewrite (change) history, you would make problems with merging their changes and with updating for them.

So the solution is to create a new commit which reverts changes that you want to get rid of. You can do this using git revert command.

You have the following situation:

A <-- B  <-- C <-- D                                  <-- master <-- HEAD

(arrows here refers to the direction of the pointer: the "parent" reference in the case of commits, the top commit in the case of branch head (branch ref), and the name of branch in the case of HEAD reference).

What you need to create is the following:

A <-- B  <-- C <-- D <-- [(BCD)-1]                   <-- master <-- HEAD

where [(BCD)^-1] means the commit that reverts changes in commits B, C, D. Mathematics tells us that (BCD)^-1 = D^-1 C^-1 B^-1, so you can get the required situation using the following commands:

$ git revert --no-commit D
$ git revert --no-commit C
$ git revert --no-commit B
$ git commit -m "the commit message for all of them"

Works for everything except merge commits.

---

Alternate solution would be to checkout contents of commit A, and commit this state. Also works with merge commits. Added files will not be deleted, however. If you have any local changes git stash them first:

$ git checkout -f A -- . # checkout that revision over the top of local files
$ git commit -a

Then you would have the following situation:

A <-- B  <-- C <-- D <-- A'                       <-- master <-- HEAD

The commit A' has the same contents as commit A, but is a different commit (commit message, parents, commit date).

---

Alternate solution by Jeff Ferland, modified by Charles Bailey builds upon the same idea, but uses git reset. Here it is slightly modified, this way WORKS FOR EVERYTHING:

$ git reset --hard A
$ git reset --soft D # (or ORIG_HEAD or @{1} [previous location of HEAD]), all of which are D
$ git commit

Freeliving

If you added files in B, C or D. the git checkout -f A -- . Will not delete these, you will have to do it manually. I applied this strategy now, thanks Jakub – Modify

Those solutions are not equivalent. The first one doesn't delete newly created files. – Regression

FWIW, if you need to delete those new files, git clean is your friend. – Marinna

hi, can you explain all the flags and switches do here? git checkout -f A -- . --> what does '--' and '.' mean? – Harmonicon

@mastah: the -- might be needed to separate branch name from pathspec. The . means "current directory", and because paths are relative to top irectory of a project here, it means to check out the whole project, all files of a project. – Simpatico

@JakubNarębski What does "might" mean? I too find this command very mysterious... – Unpin

@Jerry: git checkout foo might mean checkout branch foo (switch to branch) or checkout file foo (from index). -- is used to disambiguate, e.g. git checkout -- foo is always about file. – Simpatico

In addition to great answer. This shorthand works for me git revert --no-commit D C B – Lilylivered

@welldan97: Thanks for a comment. When writing this answer git revert didn't accept multiple commits; it is quite new addition. – Simpatico

This answer explains all the options very well, but shouldn't we put the git reset --soft @{1} solution at the top? It's clearly the best solution to the problem. – Laverne

To clarify git checkout -f A -- . I think it means "check out the changes of commit A to the current directory without going into detached HEAD mode", basically, you stay in master, but bring the changes of commit A to the current place in time. At least that's how I interpret it, please, correct me if I'm wrong. – Kip

@Flatline: git checkout -f A -- . means checkout the state of commit A to current directory, overwriting files... but it does not delete files to bring it into A state. – Simpatico

This is the most effective and responsible way to do rollbacks on git. – Bespoke

Only do rebase locally! As we’ve discussed with git commit --amend and git reset, you should never rebase commits that have been pushed to a public repository. The rebase would replace the old commits with new ones, and it would look like that part of your project history abruptly vanished. link – Ugrian

git checkout -f A -- . didn't work well for me. When I tried to push it, I couldn't without merging the remote version, which isn't what I wanted. I'm trying to undo the last few commits, so I don't want the remote version merged in. – Lamebrain

Just want to add one thing that helped us. Do not ever commit between reverts. Key part is --no-commit. If you do commits between reverts, at the end you can end up with having strange compares between different commits. – Earthnut

The third solution was what worked for my complicated case involving several commits and merges and added and deleted files. – Hexapod

I went with git checkout -f A -- . as I had 8 commits and liked the 1 step idea. This mostly worked, however I would note that new files were not deleted, just changed files undone, I compared remote head to my cherry picked branch after running this command and pushing and saw only new files, after deleting these, and then committing/pushing, the branches were identical. – Nonah

$ git revert --no-commit D fatal: bad revision 'D' – Wendolyn

you are my hero you save my day you help me a lot this is a great answer your solution is great i want to say thank you you are so professional <3 <3 <3 <3 <3 <3 <3 – Karyn

git revert fails on merge commits, however checking out the contents of the earlier hash and committing those is brilliant, thanks! – Fr

More broken Git shit... As soon as the first revert is performed it results in error: your index file is unmerged. This tool is a broken joke. – Gypsum

git revert also does not accept merge commits. I used the git checkout -f A -- . and it worked great. – Ahola

@DanielRCarletti : in the case of merge commit git revert needs to know which change (against which parent) you want to revert, with -m option. But in this case other solution might be better. – Simpatico

Another thing to be careful of with git checkout -f A -- . is that it will discard any un-staged changes you have. Do a git stash first if you want to save those. – Ptolemaist

@JiZHANG The -- would be needed in the case that your file name begins with one or more hyphens. Jakub was being thorough. – Taproot

git checkout -f A -- . works well for me, while running this command, make sure you're on the correct branch as i tried attempted different method and was detached from the branch i wanna run – Berar

> Mathematics tells us that (BCD)-1 = D-1 C-1 B-1. This is from which rule? – Analects

You could also just revert each individually and then do a rebase -i HEAD~3 to squash the 2 commits together (so you can even keep the generated revert commit messages). – Codeclination

I pursued second option $ git checkout -f A -- . followed by $ git commit -a since I had merged commits. Finally I had to forcefully push it to git to see the changes. I used git push -f origin master. – Usance

@Analects This rule applies for linear transformations a.k.a matrices. Pretty sure he was making a joke with this one. – Boldface

@Analects : group theory tells us that $(BC)^{-1} = C^{-1} B^{-1}$; check how both sides act on $(BC)$: $(BC)^{-1} (BC) = 1$ by definition of $x^{-1}$, and $C^{-1}B^{-1}BC = C^{-1} 1 C = C^{-1}C = 1$, so both are equal. – Simpatico

The hard/soft reset technique was the easiest and most intuitive one for me, thanks. – Leggat

Answer 2

Clean way which I found useful

git revert --no-commit HEAD~3..
git commit -m "your message regarding reverting the multiple commits"

This command reverts last 3 commits with only one commit.

Also doesn't rewrite history, so doesn't require a force push.

The .. helps create a range. Meaning HEAD~3.. is the same as HEAD~3..HEAD

Lacking

how can this work if there is no commit? What needs to be done in addition to the above command? what git commands are needed before/after this command? – Miner

@JohnLittle it stages the changes. git commit from there will actually do the commit. – Tracheitis

This will not work if some commits are merge commits. – Looby

What do the two dots at the end do? – Foyer

@Foyer Those specify a range. HEAD~3.. is the same as HEAD~3..HEAD – Duralumin

is a merge but no -m option was given. fatal: revert failed – Rumania

I get a Unlink of file failed. Should I try again? (y/n) – Tonguelashing

@Foyer Thanks for asking! I wasn't seeing the dots! – Loblolly

Answer 3

For doing so you just have to use the revert command, specifying the range of commits you want to get reverted.

Taking into account your example, you'd have to do this (assuming you're on branch 'master'):

git revert master~3..master

or git revert B...D or git revert D C B

This will create a new commit in your local with the inverse commit of B, C and D (meaning that it will undo changes introduced by these commits):

A <- B <- C <- D <- BCD' <- HEAD

Faa

git revert --no-commit HEAD~2.. is a slightly more idiomatic way to do it. If you're on master branch, no need to specify master again. The --no-commit option lets git try to revert all the commits at once, instead of littering the history with multiple revert commit ... messages (assuming that's what you want). – Bogard

@Faa I fixed your commit range. The beginning of the range is exclusive, meaning it's not included. So if you want to revert the last 3 commits, you need to start the range from the parent of the 3rd commit, i.e. master~3. – Joust

@Bogard is there no way of including the SHAs in a commit message, using a single commit (your method but without having to manually enter the commits that were reverted)? – Oldwife

@ChrisS My first thought would be to not use --no-commit (so you get a separate commit for each revert), and then squash all of them together in an interactive rebase. The combined commit message will contain all of the SHAs, and you can arrange them however you like using your favorite commit message editor. – Neely

Sure enough, if you do this without --no-commit it does them one at a time and you have to keep typing git revert --continue over and over for each one...dang I was hoping git would have a friendly commit option like "do them all and list all the hashes for me in a single commit" but appears not :| – Centistere

If this includes merge commits then git revert D C B -m 1 worked for me. The -m option specifies the mainline parent, which is usually the branch you merged into. For most cases, you'll want to use -m 1. – Maitilde

Answer 4

git reset --hard a
git reset --mixed d
git commit

That will act as a revert for all of them at once. Give a good commit message.

Mitchell

If he wants HEAD to look like A then he probably want the index to match so git reset --soft D is probably more appropriate. – Mcclimans

--soft resetting doesn't move the index, so when he commits, it would look like the commit came directly from a instead of from D. That would make the branch split. --mixed leaves the changes, but moves the index pointer, so D will become the parent commit. – Mitchell

Yes, I think git reset --keep is exactly what I have above. It came out in version 1.7.1, released in April of 2010, so the answer wasn't around at that time. – Mitchell

git checkout A then git commit above did not work for me, but this answer did. – Kiangsu

Why is git reset --mixed D required? Specifically why reset? Is it because, without resetting to D, that, HEAD would point at A, causing B, C, and D to be "dangling" and garbage-collected -- which is not what he wants? But then why --mixed? You already answered "--soft resetting doesn't move the index..." So by moving the index, this means index will contain D's changes, while Working Directory will contain A's changes -- this way a git status or git diff (which compares Index [D] to Working Directory [A]) will show the substance; that user is going from D back to A? – Gest

--mixed doesn't work for the case of a revert of a commit that removed a file, but --soft works well... – Centistere

git reset --hard a then git reset --soft d worked perfectly for me. It seems a neat and simple solution, much better than reverting commits b, c, and d separately. A two-step process no matter how many commits you want to revert. – Thebault

This worked well for me, except I had to also do a git add before the git commit because I was left with unstaged changes after git reset --mixed d. – Yarvis

Warning: reset will not revert the commits, it will discard them (after they fall out of the reflog and a git gc). This includes a possible need to force push the result. Revert as in stack the inverse commit on top, is annihilating the changes but keeps both commits. – Tectonics

Answer 5

Similar to Jakub's answer, this allows you to easily select consecutive commits to revert.

# Revert all commits from and including B to HEAD, inclusively
git revert --no-commit B^..HEAD
git commit -m 'message'

Shit

Your solution worked fine for me, but with a slight modification. If we have this case Z -> A -> B -> C -> D -> HEAD and if I would want to return to the A state, then weirdly I would have to execute git revert --no-commit Z..HEAD – Bobbee

Agree with @Bogdan, the revert range is like that: SHA_TO_REVERT_TO..HEAD – Iotacism

The range is wrong. It should be B^..HEAD, otherwise B is excluded. – Vedda

Agree with @tessus, so the right thing to do would be: git revert --no-commit B^..HEAD or git revert --no-commit A..HEAD – Gisser

Answer 6

I'm so frustrated that this question can't just be answered. Every other question is in relation to how to revert correctly and preserve history. This question says "I want the head of the branch to point to A, i.e. I want B, C, D, and HEAD to disappear and I want head to be synonymous with A."

git checkout <branch_name>
git reset --hard <commit Hash for A>
git push -f

I learned a lot reading Jakub's post, but some guy in the company (with access to push to our "testing" branch without a Pull-Request) pushed like five bad commits, trying to fix and fix and fix a mistake he made five commits ago. Not only that, but one or two pull requests were accepted, which were now bad. So forget it; I found the last good commit (abc1234) and just ran the basic script:

git checkout testing
git reset --hard abc1234
git push -f

I told the other five guys working in this repository that they better make note of their changes for the last few hours and wipe/rebranch from the latest testing. End of the story.

Amalia

I hadn't published the commits, so this was the answer I needed. Thanks, @Suamere. – Ascension

The better way to do this is git push --force-with-lease, which will rewrite history only if no one else has committed to the branch after or within the range of the commits to vapourize. If other people have used the branch, then its history should never be rewritten, and the commit should simply be visibly reverted. – Unisexual

@Unisexual "history should never be rewritten", only the sith deal in absolutes. The question of this thread, and the point of my answer, is exactly that for a particular scenario, all history should be wiped. – Amalia

@Amalia Sure, that's the question. But as your answer mentions about what you had to tell the other guys, there is potential for trouble. From personal experience, push -f can mess up your code-base if other people have committed after what you're trying to erase. --force-with-lease achieves the same result, except that it saves your ass if you were about to mess up your repo. Why take the chance? If --force-with-lease fails, you can see which commit gets in the way, assess properly, adjust, and try again. – Unisexual

@Unisexual Ah! You were saying that, instead of the third line git push -f to instead git push --force-with-lease Seems obvious, but that's not how your comment read. It moreso seemed like it was your one-line, nothing-else-required, exact solution. I agree that altering the last line of my answer would offer that extra protection (and extra work). I just personally wouldn't do it unless there were people who I did not control working on the code. So your point is good for anything open-source or multi-departmental for sure. Though I'm no Git Savant, and don't even know that command, lol. – Amalia

@Amalia Thank you! I agree the question clearly states it wants to rewrite history. I'm in the same situation as you and I'm guessing the OP in that someone made dozens of ugly reverts and odd commits and reverts of reverts by accident (while I was on vacation) and the state needs to be reverted. In any event along with a good healthy warning this should be the accepted answer. – Promptitude

Thanks @Amalia this is also the answer I needed, as I had not pushed to the remote yet. I had a large file in a commit I had later ignored and I had to just get rid of the first commit because I was stuck not being able to push. I literally needed the commit to just go away. This did the trick :). – Peppergrass

This is where I needed to be - since history needs to go bye-bye along with the changes . Clean, correct, decisive, concise. And done. – Mceachern

This is the answer especially as the question doesn't say that the commits in question have been pushed to any remote. – Parlormaid

@BradStell, git push --force-with-lease seems to work still even when the commits are already pushed to remote. – Banian

Again though: --force-with-lease is a protection. So while it allows you to overwrite your own commits that are pushed to remote, you won't accidentally overwrite commits of others that you might not have noticed. That is not the point of the OP or my answer. The OP, and my answer, are to ignore all such restrictions, and to reset to a particular commit. End of the requirement, no restrictions. – Amalia

Answer 7

First be sure that your working copy is not modified.

Then:

git diff --binary HEAD commit_sha_you_want_to_revert_to | git apply

And then just commit. Don't forget to document what the reason is for the revert.

Contingence

Won't work with binary files: error: cannot apply binary patch to 'some/image.png' without full index line error: some/image.png: patch does not apply – Inductee

This is a much more flexible solution than the accepted answer. Thanks! – Slime

re: binary files use --binary option: git diff --binary HEAD commit_sha_you_want_to_revert_to | git apply – Vieva

This will work even if you want to revert a range of commits that contains merge commits. When using git revert A..Z you'd get error: commit X is a merge but no -m option was given. – Lardner

Wow cool, just what i was looking for. So it's reverse diff and then applying these changes over existing code. Very clever, thank you. ;) – Deliadelian

This helped me out with reverting a whole batch of commits which were already pushed to the remote - great solution! – Freeman

Using this command you don't have to worry about merge commits. Very useful – Angrist

Nice! This is simpler than my long handed approach which was to clone the repository again, check out the specific good commit in MyRepo2, then use a file compare tool to see what files changed between MyRepo and MyRepo2, then copy the changed files from MyRepo2 to MyRepo. – Instinct

That's the best answer in cause you have merge commits in the list of commits you want to revert. – Samphire

Answer 8

Using Git Restore

You can also use the restore command:

A <- B <- C <- D <- HEAD

Let's say you want HEAD to look exactly like A. Make sure you've pulled the latest main. Then cut a new branch.

git switch -c feature/flux-capacitor  # synonymous with checkout -b
git restore --source A .
git add .
git commit
git push

The restore command changes everything (.) to what it was at the --source commit. Then you commit that to your local branch and push it to the origin. You can then open a PR against it.

This has the benefit of not changing any history that others might have based work on. It also leaves a useful history for folks in the future.

Docs: git restore

Turnstone

The restore method worked clean and simple for me. – Pevzner

This worked great for me because I didn't want to use Reset which deletes commits. After running those commands, I of course just switched to master and merged. Thanks. – Garcia

But restore changes the PR branch and that is not expected. PR has source of comments or notes etc so the approach should work in the same branch. – Aleksandr

@vgdub, thanks for your comment. Git itself has no concept of a PR. PR is a construct of GitHub. With a bit of creativity you can use restore on your desired branch, just as you would with any of the other approaches mentioned in this list. – Turnstone

Answer 9

This is an expansion of one of the solutions provided in Jakub's answer.

I was faced with a situation where the commits I needed to roll back were somewhat complex, with several of the commits being merge commits, and I needed to avoid rewriting history. I was not able to use a series of git revert commands because I eventually ran into conflicts between the reversion changes being added. I ended up using the following steps.

First, check out the contents of the target commit while leaving HEAD at the tip of the branch:

git checkout -f <target-commit> -- .

(The -- makes sure <target-commit> is interpreted as a commit rather than a file; the . refers to the current directory.)

Then, determine what files were added in the commits being rolled back, and thus need to be deleted:

git diff --name-status --cached <target-commit>

Files that were added should show up with an "A" at the beginning of the line, and there should be no other differences. Now, if any files need to be removed, stage these files for removal:

git rm <filespec>[ <filespec> ...]

Finally, commit the reversion:

git commit -m 'revert to <target-commit>'

If desired, make sure that we're back to the desired state:

git diff <target-commit> <current-commit>

There should be no differences.

Knock

Are you sure you can git HEAD with just the tip of the branch? – Amalia

This was a much better solution for me, since in mine I had merge commits. – Babbie

Answer 10

The easy way to revert a group of commits on shared repository (that people use and you want to preserve the history) is to use git revert in conjunction with git rev-list. The latter one will provide you with a list of commits, the former will do the revert itself.

There are two ways to do that. If you want the revert multiple commits in a single commit use:

for i in `git rev-list <first-commit-sha>^..<last-commit-sha>`; do git revert --no-commit $i; done

this will revert a group of commits you need, but leave all the changes on your working tree, you should commit them all as usual afterward.

Another option is to have a single commit per reverted change:

for i in `git rev-list <first-commit-sha>^..<last-commit-sha>`; do git revert --no-edit -s $i; done

For instance, if you have a commit tree like

 o---o---o---o---o---o--->    
fff eee ddd ccc bbb aaa

to revert the changes from eee to bbb, run

for i in `git rev-list eee^..bbb`; do git revert --no-edit -s $i; done

Composite

Just to add: `<first-commit-sha>^..<last-commit-sha>`` is inclusive range. Besides, excellent answer. It worked for me in Git Bash. – Dogged

this won't work most of the times: error: commit XXX is a merge but no -m option was given. fatal: revert failed. I'm starting to think the best general way to do this is git checkout <first commit> then git archive and then manually create a commit unzipping the archived version... – Meghan

Answer 11

None of those worked for me, so I had three commits to revert (the last three commits), so I did:

git revert HEAD
git revert HEAD~2
git revert HEAD~4
git rebase -i HEAD~3 # pick, squash, squash

Worked like a charm :)

Outwear

This is a viable option only if your changes aren't pushed yet. – Unpromising

Answer 12

In my opinion a very easy and clean way could be:

go back to A

git checkout -f A

point master's head to the current state

git symbolic-ref HEAD refs/heads/master

save

git commit

Resnatron

Can you please explain the reason of downvoting? – Resnatron

This works fine. What is the point of giving downvote for this useful answer or can anybody explain what is the best-practice? – Karame

Is that the same as git checkout master; git reset --hard A ? Or if not could you explain a bit more about what this does? – Chanson

Answer 13

Probably less elegant than other approaches here, but I've always used get reset --hard HEAD~N to undo multiple commits, where N is the number of commits you want to go back.

Or, if unsure of the exact number of commits, just running git reset --hard HEAD^ (which goes back one commit) multiple times until you reach the desired state.

Gastrology

Answer 14

I found myself needing to revert a long range of commits and then re-revert them to help a team present a clear pull request without having to force-push over their target branch (which was committed directly to)

# checkout the branch that should be targeted
git checkout $branch_target

# revert the commits in $branch_target to some $count where
#   $count is the number of commits to revert
#   cut is used to slice just the commit hash field from each line of output
#   xargs runs the command once for each line of input, reversing the commits!
git log --oneline -n $count | cut -d' ' -f1 | xargs git revert

# check out the branch which should be the source of the pull request
git checkout -b $branch_for_pull

# revert the revert commits
# $count is that same number of commits being reverted (again)
git log --oneline -n $count | cut -d' ' -f1 | xargs git revert

# push branches up and go off to create PR in whatever web UI
git push --set-upstream origin $branch_for_pull  # it's new!
git checkout $branch_target
git push  # if this branch wasn't pushed, just fix the issue locally instead..

Because this reverts all of the commits from HEAD to git log -n $count in reverse order, it'll work well and cleanly with any number of commits

View from $branch_target at this state

% git log --oneline origin/$branch_target
ffff006 (origin/$branch_target, $branch_target) Revert "first commit"
ffff005 Revert "second commit"
ffff004 Revert "third commit"
ffff003 third commit
ffff002 second commit
ffff001 first commit

View from $branch_for_pull at this state

% git log --oneline origin/$branch_for_pull
ffff009 (origin/$branch_for_pull, $branch_for_pull) Revert "Revert "third commit""
ffff008 Revert "Revert "second commit""
ffff007 Revert "Revert "first commit""
ffff006 (origin/$branch_target, $branch_target) Revert "first commit"
ffff005 Revert "second commit"
ffff004 Revert "third commit"
ffff003 third commit
ffff002 second commit
ffff001 first commit

---

If the intention was to create N branches with changesets, but they were all committed to the same branch, you can still revert all of them back to the base commit, then only revert the reverts needed as the changesets should be ordered logically (try saying that 5x fast)

Using a syntax like HEAD~7..HEAD~5 may help with describing the ranges to precisely split the revert-revert branches

Here, it would make sense when reverting the last 7 commits (git log -n 7), but restoring 5 with in one branch (git log -n 5) and 2 then the top-most 2 in another git log HEAD~12..HEAD~10 (12 is 7 commits + 5 commits, assuming the new PR branch is based off either the branch "before" it, or the result of a FF (non-squashed) merge the branch "before" it into the original target branch)

Tandratandy

This is better than all the --hard commands, If you're reverting a commit then it should be logged in history. – Volk

Answer 15

I really wanted to avoid hard resets, this is what I came up with.

A -> B -> C -> D -> HEAD

To go back to A (which is 4 steps back):

git pull                  # Get latest changes
git reset --soft HEAD~4   # Set back 4 steps
git stash                 # Stash the reset
git pull                  # Go back to head
git stash pop             # Pop the reset 
git commit -m "Revert"    # Commit the changes

Ruddy

Answer 16

If you

1. have a merged commit and
2. you are not able to revert, and
3. you don't mind squashing the history you are to revert,

then you can

git reset --soft HEAD~(number of commits you'd like to revert)
git commit -m "The stuff you didn't like."
git log
# copy the hash of your last commit
git revert <hash of your last (squashed) commit>

Then when you want to push your changes remember to use the -f flag because you modified the history

git push <your fork> <your branch> -f

Rumania

Answer 17

Other way we can clone the branch

and then run below command.

git reset --hard commitID
git push -f branchname

Ammerman

Answer 18

If you want to temporarily revert the commits of a feature, then you can use the series of following commands.

Here is how it works

git log --pretty=oneline | grep 'feature_name' | cut -d ' ' -f1 | xargs -n1 git revert --no-edit

Fallacy