Ho appena preso un impegno perfetto per il ramo sbagliato. Come posso annullare l'ultimo commit nel mio ramo master e quindi prendere le stesse modifiche e inserirle nel mio ramo di aggiornamento?

Se non hai ancora inviato le modifiche, puoi anche eseguire un ripristino software:

git reset --soft HEAD^

Questo ripristinerà il commit, ma rimetterà le modifiche impegnate nel tuo indice. Supponendo che le filiali siano relativamente aggiornate l'una rispetto all'altra, git ti consentirà di effettuare un checkout nell'altra filiale, dopodiché puoi semplicemente impegnarti:

git checkout branch
git commit

Lo svantaggio è che è necessario reinserire il messaggio di commit.

4 anni di ritardo sull'argomento, ma questo potrebbe essere utile a qualcuno.

Se hai dimenticato di creare una nuova filiale prima di eseguire il commit e il commit di tutti i master, indipendentemente da quanti commit hai eseguito, il seguente approccio è più semplice:

git stash                       # skip if all changes are committed
git branch my_feature
git reset --hard origin/master
git checkout my_feature
git stash pop                   # skip if all changes were committed

Ora hai il tuo ramo principale uguale a origin/mastere tutti i nuovi commit sono attivi my_feature. Si noti che my_featureè un ramo locale, non remoto.

Se si dispone di una copia di lavoro pulita (non modificata)

Per ripristinare un commit (assicurati di annotare l'hash del commit per il passaggio successivo):

git reset --hard HEAD^

Per inserire quel commit in un altro ramo:

git checkout other-branch
git cherry-pick COMMIT-HASH

Se sono state apportate modifiche non modificate

Nota inoltre che git reset --hardverranno eliminate tutte le modifiche non monitorate e modificate che potresti avere, quindi se ne hai di quelle che preferisci:

git reset HEAD^
git checkout .

Se hai già spinto le tue modifiche, dovrai forzare la tua prossima spinta dopo aver ripristinato HEAD.

git reset --hard HEAD^
git merge COMMIT_SHA1
git push --force

Avviso: un hard reset annullerà tutte le modifiche non confermate nella copia di lavoro, mentre un push forzato sovrascriverà completamente lo stato del ramo remoto con lo stato corrente del ramo locale.

Per ogni evenienza, su Windows (utilizzando la riga di comando di Windows, non Bash) in realtà sono quattro ^^^^anziché uno, quindi lo è

git reset --hard HEAD^^^^

Di recente ho fatto la stessa cosa, in cui ho commesso accidentalmente una modifica al master, quando avrei dovuto impegnarmi in un'altra filiale. Ma non ho spinto nulla.

Se ti sei appena impegnato nel ramo sbagliato e da allora non hai cambiato nulla e non hai inviato il repository, puoi eseguire le seguenti operazioni:

// rewind master to point to the commit just before your most recent commit.
// this takes all changes in your most recent commit, and turns them into unstaged changes. 
git reset HEAD~1 

// temporarily save your unstaged changes as a commit that's not attached to any branch using git stash
// all temporary commits created with git stash are put into a stack of temporary commits.
git stash

// create other-branch (if the other branch doesn't already exist)
git branch other-branch

// checkout the other branch you should have committed to.
git checkout other-branch

// take the temporary commit you created, and apply all of those changes to the new branch. 
//This also deletes the temporary commit from the stack of temp commits.
git stash pop

// add the changes you want with git add...

// re-commit your changes onto other-branch
git commit -m "some message..."

NOTA: nell'esempio sopra, stavo riavvolgendo 1 commit con git reset HEAD ~ 1. Ma se vuoi riavvolgere n commit, allora puoi fare git reset HEAD ~ n.

Inoltre, se hai finito per impegnarti nel ramo sbagliato, e hai anche finito per scrivere un po 'di codice prima di capire che ti sei impegnato nel ramo sbagliato, allora potresti usare git stash per salvare il tuo lavoro in corso:

// save the not-ready-to-commit work you're in the middle of
git stash 

// rewind n commits
git reset HEAD~n 

// stash the committed changes as a single temp commit onto the stack. 
git stash 

// create other-branch (if it doesn't already exist)
git branch other-branch

// checkout the other branch you should have committed to.
git checkout other-branch

// apply all the committed changes to the new branch
git stash pop

// add the changes you want with git add...

// re-commit your changes onto the new branch as a single commit.
git commit -m "some message..."

// pop the changes you were in the middle of and continue coding
git stash pop

NOTA: ho usato questo sito Web come riferimento https://www.clearvision-cm.com/blog/what-to-do-when-you-commit-to-the-wrong-git-branch/

Quindi, se il tuo scenario è quello in cui ti sei impegnato masterma intendi impegnarti another-branch(che potrebbe non esistere già) ma che non hai ancora spinto, questo è abbastanza facile da risolvere.

// if your branch doesn't exist, then add the -b argument 
git checkout -b another-branch
git branch --force master origin/master

Ora tutti i tuoi impegni mastersaranno attivi another-branch.

Provenienti con amore da: http://haacked.com/archive/2015/06/29/git-migrate/

Per approfondire questo risposta, nel caso in cui si dispone di più impegna per spostarsi da, ad esempio, developa new_branch:

git checkout develop # You're probably there already
git reflog # Find LAST_GOOD, FIRST_NEW, LAST_NEW hashes
git checkout new_branch
git cherry-pick FIRST_NEW^..LAST_NEW # ^.. includes FIRST_NEW
git reflog # Confirm that your commits are safely home in their new branch!
git checkout develop
git reset --hard LAST_GOOD # develop is now back where it started

Se si verifica questo problema e si dispone di Visual Studio, è possibile effettuare le seguenti operazioni:

Fai clic con il tasto destro del mouse sul tuo ramo e seleziona View History:

Fare clic con il tasto destro del mouse su commit a cui si desidera tornare. E ripristina o ripristina secondo necessità.

Per più commit sul ramo sbagliato

Se per te è solo 1 commit, allora ci sono molte altre soluzioni di reimpostazione più facili disponibili. Per me, ho eseguito circa 10 commit per errore masterinvece di, chiamiamolo branch_xyz, e non volevo perdere la cronologia dei commit.

Quello che potresti fare e ciò che mi ha salvato è stato usare questa risposta come riferimento, usando un processo in 4 fasi, che è -

1. Crea un nuovo ramo temporaneo da master
2. Unisciti alla filiale originariamente destinata agli commit, ad es branch_xyz
3. Annulla si impegna master
4. Elimina il ramo temporaneo.

Ecco i passaggi precedenti in dettaglio -

1. Crea una nuova filiale da master(dove avevo accidentalmente apportato molte modifiche)

   git checkout -b temp_branch_xyz
   

   Nota: -bflag viene utilizzato per creare una nuova filiale
   Solo per verificare se abbiamo ottenuto questo diritto, farei un rapido git branchper assicurarmi di essere nella temp_branch_xyzfiliale e un git logper verificare se abbiamo eseguito correttamente i commit.

2. Unire il ramo temporaneo nel ramo originariamente destinato agli commit, ad es branch_xyz.
   Innanzitutto, passa al ramo originale branch_xyz(ad esempio, git fetchpotresti non averlo fatto)

   git checkout branch_xyz
   

   Nota: non usare -bflag
   Ora, uniamo il ramo temporaneo nel ramo che stiamo attualmente verificandobranch_xyz

   git merge temp_branch_xyz
   

   Potresti doverti occupare di alcuni conflitti qui, se ce ne sono. Puoi spingere (lo farei) o passare ai passaggi successivi, dopo aver eseguito correttamente l'unione.

3. Annulla l'impegno accidentale masterutilizzando questa risposta come riferimento, per prima cosa passa amaster

   git checkout master
   

   quindi annullare tutto indietro per abbinare il telecomando (o per eseguire il commit particolare, se lo si desidera)

   git reset --hard origin/master
   

   Ancora una volta, farei un git logprima e un dopo solo per assicurarmi che le modifiche previste abbiano avuto effetto.

4. Cancellare l'evidenza, che sta eliminando il ramo temporaneo. Per questo, prima devi controllare il ramo in cui è stata unita la temp, ovvero branch_xyz(se rimani masterattivo ed esegui il comando qui sotto, potresti ottenere un error: The branch 'temp_branch_xyz' is not fully merged), quindi cerchiamo di

   git checkout branch_xyz
   

   e quindi eliminare la prova di questo incidente

   git branch -d temp_branch_xyz
   

Ecco qua

Se il ramo a cui desideri applicare le modifiche esiste già ( sviluppo ramo , ad esempio), segui le istruzioni fornite da fotanus di seguito, quindi:

git checkout develop
git rebase develop my_feature # applies changes to correct branch
git checkout develop # 'cuz rebasing will leave you on my_feature
git merge develop my_feature # will be a fast-forward
git branch -d my_feature

E ovviamente potresti usare tempbranch o qualsiasi altro nome di filiale invece di my_feature se lo desideri.

Inoltre, se applicabile, ritarda il pop stash (applica) fino a quando non ti sei unito al ramo di destinazione.

Per me, questo è stato risolto ripristinando il commit che avevo spinto, quindi selezionando ciliegie quel commit sull'altro ramo.

git checkout branch_that_had_the_commit_originally
git revert COMMIT-HASH
git checkout branch_that_was_supposed_to_have_the_commit
git cherry pick COMMIT-HASH

Puoi usare git logper trovare l'hash corretto e puoi spingere queste modifiche quando vuoi!