Comment annuler les derniers commits dans Git?

Question

J'ai accidentellement envoyé les mauvais fichiers dans Git , mais je n'ai pas encore envoyé le commit au serveur.

Comment puis-je annuler ces commits du référentiel local? 

Answer 1

Annuler un commit et refaire

$ git commit -m "Something terribly misguided"             # (1)
$ git reset HEAD~                                          # (2)
<< edit files as necessary >>                              # (3)
$ git add ...                                              # (4)
$ git commit -c ORIG_HEAD                                  # (5)

1. C'est ce que vous voulez annuler.
2. Cela laisse votre arbre de travail (l'état de vos fichiers sur le disque) inchangé, mais annule la validation et laisse les modifications que vous avez validées inchangées (elles apparaîtront donc comme "Modifications non mises en scène pour la validation" dans git status; à nouveau avant de commettre). Si vous seulement voulez ajouter d'autres modifications à la validation précédente ou modifier le message de validation¹, vous pouvez utiliser git reset --soft HEAD~ à la place, qui ressemble à git reset HEAD~ (où HEAD~ est identique à HEAD~1) mais laisse vos modifications existantes stockées.
3. Apportez des corrections aux fichiers d'arbre de travail.
4. git add tout ce que vous voulez inclure dans votre nouveau commit.
5. Validez les modifications en réutilisant l'ancien message de validation. reset a copié l'ancienne tête dans .git/ORIG_HEAD; commit avec -c ORIG_HEAD ouvrira un éditeur, qui contient initialement le message de journal de l'ancien commit et vous permet de le modifier. Si vous n'avez pas besoin de modifier le message, vous pouvez utiliser l'option -C.

Attention cependant que si vous avez ajouté de nouvelles modifications à l'index, l'utilisation de commit --amend les ajoutera à votre commit précédent.

Si le code est déjà poussé sur votre serveur et que vous avez le droit de remplacer l'historique (rebase), alors:

git Push Origin master --force

Vous pouvez aussi regarder cette réponse: 

_ { Comment déplacer HEAD vers un emplacement précédent? (Détaché) } _

La réponse ci-dessus vous montrera git reflog qui est utilisé pour déterminer le SHA-1 sur lequel vous souhaitez revenir. Une fois que vous avez trouvé le point que vous souhaitez annuler, utilisez la séquence de commandes décrite ci-dessus.

---

¹ Notez toutefois que vous n'avez pas besoin de réinitialiser une validation antérieure si vous venez de commettre une erreur dans votre message commit. L'option la plus simple consiste à git reset (pour annoncer les modifications que vous avez apportées depuis), puis à git commit --amend , qui ouvrira votre éditeur de message de validation par défaut pré-rempli avec le dernier message de validation. 

Answer 2

Annuler un commit est un peu effrayant si vous ne savez pas comment cela fonctionne. Mais c'est en fait incroyablement facile si vous comprenez.

Supposons que vous avez ceci, où C est votre HEAD et (F) est l’état de vos fichiers.

   (F)
A-B-C
    ↑
  master

Vous voulez nuke commettre C et ne plus jamais le voir. Tu fais cela:

git reset --hard HEAD~1

Le résultat est:

 (F)
A-B
  ↑
master

Maintenant, B est la tête. Comme vous avez utilisé --hard, vos fichiers sont réinitialisés à leur état lors de la validation B.

Ah, mais supposons que commit C n'était pas un désastre, mais juste un peu en retrait. Vous voulez annuler le commit, mais conservez vos modifications pour un peu de modification avant de faire un meilleur commit. En partant d’ici, avec C pour tête:

   (F)
A-B-C
    ↑
  master

Vous pouvez le faire en laissant le --hard:

git reset HEAD~1

Dans ce cas, le résultat est:

   (F)
A-B-C
  ↑
master

Dans les deux cas, HEAD n'est qu'un pointeur sur le dernier commit. Lorsque vous faites un git reset HEAD~1, vous dites à Git de déplacer le pointeur HEAD en arrière d'un commit. Mais (sauf si vous utilisez --hard), vous laissez vos fichiers tels qu’ils étaient. Alors maintenant, git status affiche les modifications que vous avez archivées dans C. Vous n’avez rien perdu!

Pour le toucher le plus léger, vous pouvez même annuler votre commit mais laisser vos fichiers et votre index:

git reset --soft HEAD~1

Non seulement cela laisse vos fichiers, mais même votre index. Lorsque vous faites git status, vous verrez que les mêmes fichiers sont dans l'index comme auparavant. En fait, juste après cette commande, vous pourriez faire git commit et refaire le même commit que vous venez de recevoir.

Une dernière chose: Supposons que vous détruisiez un commit comme dans le premier exemple, mais découvriez que vous en aviez besoin après tout? Pas de chance, non?

Non, il y a encore un moyen de le récupérer. Tapez git reflog et vous verrez une liste de commit (partiel) shas (c'est-à-dire de hachages) dans lesquels vous avez déplacé. Recherchez le commit que vous avez détruit, et procédez comme suit:

git checkout -b someNewBranchName shaYouDestroyed

Vous avez maintenant ressuscité ce commit. En réalité, les commits ne sont pas détruits à Git pendant environ 90 jours. Vous pouvez donc généralement y revenir et en sauver un dont vous ne vouliez pas vous débarrasser.

Answer 3

Cela m'a pris du temps à comprendre, alors peut-être que cela aidera quelqu'un ...

Il y a deux façons "d'annuler" votre dernier commit, selon que vous ayez déjà rendu public votre commit (poussé vers votre référentiel distant):

Comment annuler un commit local

Supposons que je commette localement, mais que je veuille maintenant supprimer ce commit.

git log
    commit 101: bad commit    # latest commit, this would be called 'HEAD'
    commit 100: good commit   # second to last commit, this is the one we want

Pour que tout redevienne comme avant le dernier commit, nous devons reset au commit avant HEAD:

git reset --soft HEAD^     # use --soft if you want to keep your changes
git reset --hard HEAD^     # use --hard if you don't care about keeping the changes you made

Maintenant, git log montrera que notre dernier commit a été supprimé.

Comment annuler un commit public

Si vous avez déjà rendu vos commits publics, vous voudrez créer un nouveau commit qui "annulera" les modifications que vous avez apportées à votre précédent commit (HEAD actuel).

git revert HEAD

Vos modifications seront maintenant annulées et prêtes à être validées:

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

Pour plus d'informations, consultez Bases de Git - Annuler des choses

Answer 4

Ajouter/supprimer des fichiers pour obtenir les choses comme vous le souhaitez:

git rm classdir
git add sourcedir

Puis modifiez le commit:

git commit --amend

Le commit précédent, erroné, sera édité pour refléter le nouvel état de l'index. En d'autres termes, ce sera comme si vous n'aviez jamais fait l'erreur en premier.

Notez que vous ne devriez faire cela que si vous n'avez pas encore poussé. Si vous avez poussé, alors vous devrez simplement commettre un correctif normalement.

Answer 5

git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

ou

git reset --hard HEAD~1

Avertissement: la commande ci-dessus supprimera définitivement les modifications apportées aux fichiers .Java (et à tout autre fichier) que vous vouliez valider.

Le hard reset à HEAD-1 définira votre copie de travail sur l’état du commit avant votre commit incorrect.

Answer 6

Pour changer le dernier commit

Remplacez les fichiers dans l'index:

git rm --cached *.class
git add *.Java

Ensuite, s'il s'agit d'une branche privée, amendez le commit:

git commit --amend

Ou, s'il s'agit d'une branche partagée, effectuez un nouveau commit:

git commit -m 'Replace .class files with .Java files'

(pour changer un commit précédent, utilisez le génial rebase interactive )

---

ProTip ™: Ajoutez *.class à un gitignore pour que cela ne se reproduise plus.

---

Pour annuler un commit

La modification d'un commit est la solution idéale si vous devez changer le dernier commit, mais une solution plus générale est reset.

Vous pouvez réinitialiser git à n’importe quel commit avec:

git reset @~N

Où N est le nombre de validations avant HEAD, et @~ rétablit la validation précédente.

Ainsi, au lieu de modifier le commit, vous pouvez utiliser:

git reset @~
git add *.Java
git commit -m "Add .Java files"

Consultez git help reset, en particulier les sections sur --soft--mixed et --hard, pour mieux comprendre ce que cela fait.

Reflog

Si vous vous trompez, vous pouvez toujours utiliser le reflog pour trouver les commits supprimés:

$ git reset @~
$ git reflog
c4f708b HEAD@{0}: reset: moving to @~
2c52489 HEAD@{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started

Answer 7

Utilisez git revert <commit-id>

Pour obtenir l'ID de validation, utilisez simplement git log

Answer 8

Si vous prévoyez d'annuler entièrement un commit local, quel que soit ce que vous avez changé, vous l'avez fait, et si vous ne vous inquiétez de rien, procédez comme suit.

git reset --hard HEAD^1

(Cette commande ignorera votre commit complet et vos modifications seront complètement perdues de votre arbre de travail local). Si vous souhaitez annuler votre validation mais que vous souhaitez que vos modifications soient effectuées dans la zone de transfert (avant la validation, exactement comme après git add), exécutez la commande suivante.

git reset --soft HEAD^1

Maintenant, vos fichiers validés entrent dans la zone de transfert. Supposons que si vous souhaitez créer des fichiers en amont, car vous devez modifier du contenu erroné, procédez comme suit:

git reset HEAD

Maintenant, les fichiers validés doivent provenir de la zone préparée dans la zone non préparée. Les fichiers sont maintenant prêts à être modifiés. Ainsi, quels que soient vos changements, vous souhaitez les modifier, les ajouter et effectuer un nouveau/nouveau commit.

Plus

Answer 9

Si vous avez Git Extras installé, vous pouvez exécuter git undo pour annuler le dernier commit. git undo 3 annulera les 3 derniers commits.

Answer 10

Je voulais annuler les 5 derniers commits de notre référentiel partagé. J'ai regardé l'identifiant de révision que je voulais restaurer. Ensuite, j'ai tapé ce qui suit.

Prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
Prompt> git Push Origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
Prompt>

Answer 11

Comment réparer le commit local précédent

Utilisez git-gui (ou similaire) pour exécuter un git commit --amend. À partir de l'interface graphique, vous pouvez ajouter ou supprimer des fichiers individuels du commit. Vous pouvez également modifier le message de validation.

Comment annuler le commit local précédent

Réinitialisez simplement votre succursale à l’emplacement précédent (par exemple, en utilisant gitk ou git rebase). Puis réappliquez vos modifications à partir d'une copie sauvegardée. Après la récupération de place dans votre référentiel local, ce sera comme si le commit non désiré n’était jamais arrivé. Pour faire tout cela en une seule commande, utilisez git reset HEAD~1.

Mot d'avertissement : L'utilisation négligente de git reset est un bon moyen de placer votre copie de travail dans un état confus. . Je recommande aux novices de Git d'éviter cela s'ils le peuvent.

Comment annuler un commit public

Effectuez un choix de recherche inverse ( git-revert ) pour annuler les modifications.

Si vous n'avez pas encore apporté d'autres modifications à votre branche, vous pouvez simplement le faire ...

git revert --no-edit HEAD

Poussez ensuite votre branche mise à jour vers le référentiel partagé.

L'historique des validations affichera les deux validations séparément .

---

Avancé: correction de la branche privée dans le référentiel public

Cela peut être dangereux - assurez-vous de disposer d'une copie locale de la branche à repush.

Remarque: vous ne voulez pas faire cela si quelqu'un d'autre travaille sur la branche.

git Push --delete (branch_name) ## remove public version of branch

Nettoyez votre branche localement puis repush ...

git Push Origin (branch_name)

Dans le cas normal, vous n'avez probablement pas à vous soucier de l'historique de vos commits de branche privée. Il suffit de pousser un commit ultérieur (voir "Comment annuler un commit public" ci-dessus), et plus tard, faites un fusionner-écraser pour masquer l'historique.

Answer 12

Je préfère utiliser git rebase -i pour ce travail, car une liste de Nice s'affiche, où je peux choisir les commits à supprimer. Cela n’est peut-être pas aussi direct que d’autres réponses ici, mais cela semble juste semble juste .

Choisissez le nombre de commits que vous voulez lister, puis appelez comme ceci (pour inscrire les trois derniers)

git rebase -i HEAD~3

Liste d'échantillons

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

Ensuite, Git supprimera les commits pour toutes les lignes que vous supprimez.

Answer 13

Si vous avez commis des junk mais pas poussé,

git reset --soft HEAD~1

HEAD ~ 1 est un raccourci pour le commit avant head. Sinon, vous pouvez vous référer au SHA-1 du hachage si vous voulez réinitialiser. L'option --soft supprimera la validation mais laissera tous vos fichiers modifiés "Modifications à valider", comme le dirait le statut de git.

Si vous souhaitez vous débarrasser des modifications apportées aux fichiers suivis dans l’arbre de travail depuis le commit avant l’en-tête, utilisez plutôt " --hard ".

OR

Si vous avez déjà poussé et que quelqu'un tire ce qui est généralement mon cas, vous ne pouvez pas utiliser git reset. Vous pouvez cependant faire un git revert,

git revert HEAD

Cela créera un nouveau commit qui annule tout ce qui a été introduit par le commit accidentel.

Answer 14

Si vous voulez l'annuler définitivement et que vous avez cloné un référentiel 

L'identifiant de commit peut être vu par 

git log 

Ensuite, vous pouvez faire -

git reset --hard <commit_id>

git Push Origin <branch_name> -f

Answer 15

Sur SourceTree (interface graphique pour GitHub), vous pouvez cliquer avec le bouton droit de la souris sur le commit et effectuer un «reverse commit». Cela devrait annuler vos modifications.

Sur le terminal:

Vous pouvez également utiliser:

git revert

Ou:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.

Answer 16

Une seule commande:

git reset --soft 'HEAD^' 

Cela fonctionne bien pour annuler le dernier commit local!

Answer 17

Il suffit de le réinitialiser en utilisant la commande ci-dessous en utilisant git:

git reset --soft HEAD~1

Explain: qu'est-ce que git reset fait, c'est fondamentalement reset pour tout commit auquel vous souhaitez revenir, puis si vous le combinez avec la clé --soft, cela reviendra en arrière, mais conservez les modifications dans votre fichier donc vous revenez à l'étape où le fichier vient d'être ajouté, HEAD est le chef de la branche et si vous combinez avec ~1 (dans ce cas, vous utilisez aussi HEAD^), il ne retournera qu'un seul commit avec lequel vous voulez. .

Je crée les étapes dans l'image ci-dessous de manière plus détaillée pour vous, y compris toutes les étapes pouvant se produire dans des situations réelles et commettant le code:

 

Answer 18

Comment annuler le dernier commit Git?

Pour que tout redevienne comme avant la dernière validation, nous devons rétablir le commit avant HEAD.

1. Si vous ne souhaitez pas conserver les modifications que vous avez apportées:

   git reset --hard HEAD^
   

2. Si vous souhaitez conserver vos modifications:

   git reset --soft HEAD^
   

Maintenant, vérifiez votre journal git. Cela montrera que notre dernier commit a été supprimé.

Answer 19

Utilisez reflog pour trouver un état correct

git reflog

REFLOG AVANT RESET

Sélectionnez le bon reflog (f3cb6e2 dans mon cas) et tapez 

git reset --hard f3cb6e2

Après cela, le référentiel HEAD sera réinitialisé sur cet HEADid LOG APRES RESET

Enfin, le reflog ressemble à l'image ci-dessous

REFLOG FINAL

Answer 20

"Réinitialiser l'arbre de travail au dernier commit"

git reset --hard HEAD^ 

"Nettoyer les fichiers inconnus de l'arbre de travail"

git clean    

voir - Référence rapide Git

NOTE: Cette commande supprimera votre commit précédent, donc utilisez avec précaution! git reset --hard est plus sûr -

Answer 21

Première exécution: 

git reflog

Il vous montrera toutes les actions possibles que vous avez effectuées sur votre référentiel, par exemple, valider, fusionner, extraire, etc.

Alors fais:

git reset --hard ActionIdFromRefLog

Answer 22

Annuler le dernier commit:

git reset --soft HEAD^ ou git reset --soft HEAD~

Cela annulera le dernier commit.

Ici, --soft signifie réinitialisation.

HEAD~ ou HEAD^ signifie passer à commit avant HEAD.

---

Remplacer le dernier commit par le nouveau commit:

git commit --amend -m "message"

Il remplacera le dernier commit par le nouveau commit.

Answer 23

Autrement:

Vérifiez la branche que vous souhaitez rétablir, puis réinitialisez votre copie de travail locale sur le commit que vous souhaitez utiliser comme dernier en date sur le serveur distant (tout ce qui suivra sera répété). Pour ce faire, dans SourceTree, j'ai cliqué avec le bouton droit de la souris sur et sélectionné "Réinitialiser BRANCHNAME à ce commit".

Ensuite, accédez au répertoire local de votre référentiel et exécutez cette commande:

git -c diff.mnemonicprefix=false -c core.quotepath=false Push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME

Cela effacera toutes les validations postérieures à celle en cours dans votre référentiel local mais uniquement pour cette branche.

Answer 24

Tapez git log et recherchez le dernier code de hachage de validation, puis entrez:

git reset <the previous co>

Answer 25

Dans mon cas, j'ai accidentellement commis des fichiers que je ne voulais pas Alors j'ai fait ce qui suit et cela a fonctionné:

git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD

Vérifiez les résultats avec gitk ou git log --stat

Answer 26

Utilisez SourceTree (outil graphique pour Git) pour voir vos commits et votre arbre. Vous pouvez le réinitialiser manuellement directement en faisant un clic droit dessus.

Answer 27

Simple, lancez ceci dans votre ligne de commande:

git reset --soft HEAD~ 

Answer 28

Pour revenir à la révision précédente, en supprimant définitivement toutes les modifications non validées: 

git reset --hard HEAD~1

Answer 29

Il y a deux scénarios principaux

Vous n'avez pas encore poussé le commit

Si le problème concerne des fichiers supplémentaires que vous avez validés (et que vous ne souhaitez pas qu'ils se trouvent dans le référentiel), vous pouvez les supprimer à l'aide de git rm, puis valider avec --amend.

git rm <pathToFile>

Vous pouvez également supprimer des répertoires entiers avec -r, ou même les combiner avec d’autres Bash commandes

git rm -r <pathToDirectory>
git rm $(find -name '*.class')

Après avoir supprimé les fichiers, vous pouvez commettre, avec l'option --amend

git commit --amend -C HEAD # the -C option is to use the same commit message

Cela réécrira votre récent commit local en supprimant les fichiers supplémentaires. Par conséquent, ces fichiers ne seront jamais envoyés en mode Push et seront également supprimés de votre référentiel .git local par le GC.

Vous avez déjà poussé le commit

Vous pouvez appliquer la même solution de l'autre scénario, puis utiliser git Push avec l'option -f, mais il est non recommandé car il écrase l'historique distant avec une modification divergente (cela peut déranger votre référentiel).

Au lieu de cela, vous devez faire le commit sans --amend (rappelez-vous ceci à propos de -amend`: Cette option réécrit l’historique du dernier commit).

Answer 30

Il y a plusieurs façons de le faire:

Commande Git pour annuler les derniers commits/commits précédents:

Attention: Ne pas utiliser - difficile si vous ne savez pas ce que vous faites .-- difficile, c'est trop dangereux, et il se peut que supprime vos fichiers.

(La commande de base pour annuler la validation dans Git est:}

$ git reset --hard <COMMIT -ID>

ou

$ git reset --hard HEAD~<n>

COMMIT-ID: ID de la validation

(n:} _ est le nombre de dernières validations que vous souhaitez annuler.

Vous pouvez obtenir l'identifiant de validation comme indiqué ci-dessous:

$ **git log --oneline**

d81d3f1 function to subtract two numbers

be20eb8 function to add two numbers

bedgfgg function to mulitply two numbers

où d81d3f1 _ et be20eb8 sont des ID de validation.

Voyons maintenant quelques cas:

Supposons que vous vouliez annuler le dernier commit 'd81d3f1'. Voici deux options:

$ git reset --hard d81d3f1

ou

$ git reset --hard HEAD~1

Supposons que vous vouliez annuler le commit 'be20eb8':

$ git reset --hard be20eb8

Pour plus d'informations, vous pouvez vous référer et essayer d'autres commandes pour réinitialiser la tête à un état spécifié:

$ git reset --help

Answer 31

Pour un commit local

git reset --soft HEAD~1

ou si vous ne vous rappelez pas exactement dans quel commit il est, vous pouvez utiliser

git rm --cached <file>

Pour un commit poussé

La méthode appropriée pour supprimer des fichiers de l'historique du référentiel consiste à utiliser git filter-branch. C'est,

git filter-branch --index-filter 'git rm --cached <file>' HEAD

Mais je vous recommande d’utiliser cette commande avec précaution. Plus d’informations sur git-filter-branch (1) Page de manuel.

Answer 32

QUOI UTILISER, reset --soft ou reset --hard?

J'ajoute juste deux centimes pour la réponse de @ Kyralessa:

Si vous ne savez pas quoi utiliser, utilisez --soft (j'ai utilisé cette convention pour m'en souvenir - s oft of safe).

Pourquoi ?

Si vous choisissez --hard par erreur, vous PERDEZ vos modifications car ce n'était pas le cas auparavant . Si vous choisissez --soft par erreur, vous pouvez obtenir les mêmes résultats que --hard en appliquant des commandes supplémentaires

git reset HEAD file.html
git checkout -- file.html

Exemple complet

echo "some changes..." > file.html
git add file.html
git commit -m "wrong commit"

# I need to reset
git reset --hard HEAD~1 (cancel changes)
# OR
git reset --soft HEAD~1 # Back to staging
git reset HEAD file.html # back to working directory
git checkout -- file.html # cancel changes

Les crédits vont à @Kyralessa.

Answer 33

Vous pouvez utiliser:

git reset HEAD@{1}

Cette commande supprimera votre commit incorrect sans un journal Git.

Answer 34

Pensez que nous avons le fichier code.txt . Nous y apportons quelques modifications et nous commettons .Nous pouvons annuler ce commit de trois manières, mais vous devez d’abord savoir quel est le fichier mis en scène .... Un fichier mis en scène est un fichier prêt à être validé et si vous exécutez git status, ce fichier sera affiché en vert et s'il n'est pas mis en attente pour la validation, il sera affiché en rouge:

 

Cela signifie que si vous validez votre modification, vos modifications sur ce fichier ne sont pas enregistrées . Vous pouvez ajouter ce fichier dans votre étape avec git add code.txt, puis valider votre modification:

 

Annuler le dernier commit:

1. Maintenant, si nous voulons simplement annuler la validation sans autre modification, nous pouvons utiliser

   git reset --soft HEAD^ 

    

2. Si nous voulons annuler la validation et ses modifications (THIS IS DANGER, car votre modification sera perdue), nous pouvons utiliser

   git reset --hard HEAD^

    

3. Et si nous voulons annuler la validation et supprimer les modifications de la scène, nous pouvons utiliser

   git reset --mixed HEAD^ ou sous forme abrégée git reset HEAD^

    

Answer 35

Habituellement, vous voulez annuler un commit parce que vous avez commis une erreur et que vous voulez y remédier - essentiellement ce que le PO a fait lorsqu'il a posé la question. Donc, vraiment, vous voulez réellement redo un commit.

La plupart des réponses ici se concentrent sur la ligne de commande. Bien que la ligne de commande soit le meilleur moyen d’utiliser Git lorsque vous êtes à l’aise, elle est probablement un peu étrangère à celles provenant d’autres systèmes de contrôle de version que Git. 

Voici comment le faire en utilisant une interface graphique. Si vous avez installé Git, vous avez déjà tout ce dont vous avez besoin pour suivre ces instructions.

NOTE: Je suppose ici que vous avez compris que le commit était faux avant de le pousser. Si vous ne savez pas ce que c'est que de pousser, vous n'avez probablement pas poussé, alors continuez avec les instructions. Si vous avez poussé le commit défectueux, le moyen le moins risqué est simplement de le suivre avec un nouveau commit qui corrige les choses, comme vous le feriez dans un système de contrôle de version qui ne vous permet pas de réécrire l'historique. 

Cela dit, voici comment résoudre votre dernier commit en utilisant une interface graphique:

1. Accédez à votre référentiel sur la ligne de commande et démarrez l'interface graphique avec git gui
2. Choisissez "Modifier le dernier commit". Vous verrez votre dernier message de validation, les fichiers que vous avez mis en scène et les fichiers que vous n'avez pas.
3. Modifiez maintenant l'apparence souhaitée et cliquez sur Valider. 

Answer 36

Annuler le dernier commit: 

git reset --soft HEAD~

Ou annulez l'heure avant la dernière validation: 

git reset --soft HEAD~2

Ou annuler tout commit précédent: 

git reset --soft <commitID>

(vous pouvez obtenir le commitID en utilisant git reflog)

Lorsque vous annulez un engagement précédent, n'oubliez pas de nettoyer le lieu de travail avec

git clean

Plus de détails peuvent être trouvés dans la documentation: git-reset

Answer 37

Si vous travaillez avec SourceTree, cela vous aidera.

Faites un clic droit sur la validation, puis sélectionnez "réinitialisation (branche actuelle)/maître pour cette validation" et le dernier sélectionnez _ ​​réinitialisation "logicielle" .

 

Answer 38

Annuler le dernier engagement

Il existe des tonnes de situations dans lesquelles vous voulez vraiment annuler cette dernière validation dans votre code. Par exemple. parce que vous voudriez le restructurer en profondeur - ou même le jeter complètement!

Dans ces cas, la commande "reset" est votre meilleur ami:

$ git reset --soft HEAD~1

La commande ci-dessus (réinitialiser) rembobinera votre branche HEAD actuelle vers la révision spécifiée. Dans notre exemple ci-dessus, nous aimerions revenir à celui qui précède la révision actuelle, ce qui annule effectivement notre dernier commit.

Notez l'indicateur --soft: cela garantit que les modifications des révisions annulées sont conservées. Après avoir exécuté la commande, vous retrouverez les modifications en tant que modifications locales non validées dans votre copie de travail.

Si vous ne souhaitez pas conserver ces modifications, utilisez simplement l'indicateur --hard. Assurez-vous de ne le faire que lorsque vous êtes certain de ne plus avoir besoin de ces modifications.

$ git reset --hard HEAD~1

 

Answer 39

Pour annuler votre engagement local, vous utilisez git reset <commit>. Aussi ce tutoriel est très utile pour vous montrer comment cela fonctionne.

Vous pouvez également utiliser git revert <commit>: reverting doit être utilisé lorsque vous souhaitez ajouter un autre commit qui annule les modifications (mais les conserve dans l'historique du projet).

Answer 40

Un cycle de git typique

En parlant des commandes liées à Git dans les réponses précédentes, j'aimerais partager mes cycles typiques de Git avec tous les lecteurs, ce qui peut être utile. Voici comment je travaille avec Git,

1. Cloner pour la première fois depuis le serveur distant

   git clone $project

2. Tirer de la télécommande (quand je n'ai pas de commit local en attente pour Push)

   git pull

3. Ajout d'un nouveau fichier local1 dans $ to_be_committed_list (imaginez que $ to_be_committed_list signifie que la zone staged)

   git add $file1

4. Suppression du fichier2 ajouté par erreur de $ to_be_committed_list (supposons que le fichier2 soit ajouté comme à l'étape 3, ce que je ne voulais pas)

   git reset $file2

5. Valider le fichier 1 qui est dans $ to_be_committed_list

   git commit -m "commit message description"

6. Synchroniser la validation locale avec le référentiel distant avant de pousser

   git pull --rebase

7. Résolution en cas de conflit prérequis configure mergetool

   git mergetool #resolve merging here, also can manually merge

8. Ajout de fichiers résolus par un conflit, disons file1:

   git add $file1

9. En continuant ma commande de rebase précédente

   git rebase --continue

10. Pousser prêt et déjà synchronisé dernier commit local

    git Push Origin head:refs/for/$branch # branch = master, dev, etc.

Answer 41

Dans mon cas, j'ai commis et poussé vers la mauvaise branche, donc ce que je voulais, c'était que toutes mes modifications soient restituées afin que je puisse les valider dans une nouvelle branche correcte. Je l'ai donc fait:

Sur la même branche que vous avez validée et poussée, si vous tapez "statut git", vous ne verrez rien de nouveau car vous avez commis et poussé, tapez maintenant:

git reset --soft HEAD~1

Ceci ramènera toutes vos modifications (fichiers) dans la zone de la scène, maintenant pour les récupérer dans le répertoire de travail (unstage), il vous suffit de taper:

git reset FILE

Où "Fichier" est le fichier que vous souhaitez valider à nouveau. Maintenant, ce fichier doit être dans le répertoire de travail (unstaged) avec toutes les modifications que vous avez apportées. Vous pouvez maintenant choisir la branche de votre choix et valider les modifications. J'espère que cela aide d'autres personnes qui ont commis la même erreur que moi. Bien sûr, la branche initiale que vous avez validée est toujours présente, avec toutes les modifications, mais dans mon cas, tout allait bien. Si ce n'est pas pour vous, vous pouvez rechercher le moyen de rétablir le commit dans cette branche.

Answer 42

UTILISATEURS VISUELS DE STUDIO (2015, etc.)

Si vous ne pouvez pas synchroniser dans Visual Studio car vous n'êtes pas autorisé à pousser vers une branche telle que "développement", autant que j'ai essayé, dans Visual Studio NI leREVIENTNOR leRESET(hard ou soft) fonctionnerait.

Par la réponse avec des tonnes de votes:

Utilisez ceci à l’invite de commande racine de votre projet pour supprimer tout ce qui va tenter d’être poussé:

git reset --hard HEAD~1

Sauvegardez ou compressez vos fichiers au cas où vous ne voudriez pas perdre de travail, etc.

Answer 43

J'ai reçu l'ID de commit de bitbucket et ensuite:

git checkout commitID .

Exemple:

git checkout 7991072 .

Et il est revenu à la copie de travail de ce commit.

Answer 44

Supposons que vous ayez fait une mauvaise validation localement et que vous l’ayez poussée dans un référentiel distant. Vous pouvez annuler le désordre avec ces deux commandes:

Premièrement, nous devons corriger notre référentiel local en revenant au commit que nous désirons:

git reset --hard <previous good commit id where you want the local repository  to go>

Maintenant, nous poussons avec force ce bon commit sur le référentiel distant en utilisant cette commande:

git Push --force-with-lease

La version 'avec bail' de l'option force empêchera la suppression accidentelle de nouveaux commits dont vous ignorez l'existence (c'est-à-dire venant d'une autre source depuis votre dernier tirage).

Answer 45

Annuler le dernier commit:

git reset --soft HEAD^ or git reset --soft HEAD~

Ceci annulera le dernier commit.

Ici, --soft signifie réinitialisation.

HEAD~ or HEAD^ signifie passer à commit avant HEAD.

Remplacer le dernier commit par le nouveau commit:

git commit --amend -m "message"

Il remplacera le dernier commit par le nouveau commit.

Answer 46

Vous devez faire le facile et rapide

    git commit --amend

si c'est une branche privée ou

    git commit -m 'Replace .class files with .Java files'

si c'est une branche partagée ou publique.

Answer 47

Vous avez plusieurs options pour annuler votre dernier commit. Voici certaines de vos options résumées en une seule réponse avec des extraits de code.

Tout d’abord, vous devez déterminer quels sont les "mauvais" commits que vous souhaitez ignorer. Nous allons utiliser git reflog pour le trouver.

---

git reflog

Vous pouvez aussi toujours utiliser la variable reflog.
git reflog affichera tout changement ayant mis à jour la HEAD et extrayant l'entrée de reflog désirée ramènera la HEAD à ce commit. 

Chaque fois que le HEAD est modifié, il y aura une nouvelle entrée dans la reflog.
La reflog est similaire à la commande unix history et est conservée localement sur votre ordinateur.

git reflog
git checkout HEAD@{...}
# or
git checkout <sha-1>

En utilisant la caisse, vous pouvez revenir à n'importe quel commit désiré et vous pouvez créer une branche ou toute autre option que git checkout vous permettra de faire.

 

---

git reset HEAD --hard <commit_id>

"Déplacez" votre tête vers le commit souhaité.
Git reset va extraire le contenu de commit souhaité dans votre zone de stockage intermédiaire et/ou dans votre répertoire de travail en fonction de la valeur --hard/--soft/--mixed que vous choisissez de choisir. --hard mettra à jour à la fois la zone d'étape et le répertoire de travail avec le contenu donné et "détachera" tout autre commit au-delà de ce point sur votre branche locale. 

Si ces commits ne font pas partie d'une autre branche, ils deviendront "pendants".
Le contenu "dangle" signifie qu'il existe un contenu inaccessible dans votre référentiel local qui ne fait partie d'aucune autre branche et qui peut être supprimé ou sera supprimé par la gc.

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.

---

Ce schéma illustre quelle commande fait quoi.
Comme vous pouvez le voir ici, reset && checkout modifie la HEAD.

 

Answer 48

Utilisez cette commande:

git checkout -b old-state number_commit

Answer 49

Utilisez cette commande

git checkout -b old-state 0d1d7fc32

Answer 50

Supprimer un commit incorrect qui est déjà poussé dans Github

git Push Origin +(previous good commit id):(branch name)

Veuillez spécifier le dernier identifiant de validation que vous souhaitez réinitialiser dans Github.

Par exemple. Si le dernier identifiant de validation est incorrect, spécifiez l'identifiant de validation précédent dans la commande git ci-dessus avec le nom de la branche. 

Vous pouvez obtenir l'ID de validation précédent en utilisant git log

Answer 51

Afin de se débarrasser de (tous les changements dans) le dernier commit, les 2 derniers commits et les n derniers commits:

git reset --hard HEAD~1
git reset --hard HEAD~2
...
git reset --hard HEAD~n

Et, pour se débarrasser de tout après un commit spécifique:

git reset --hard <commit sha>

par exemple., 

git reset --hard 0d12345

PS:
1- Attention, en raison de l'option "difficile", les modifications locales sont supprimées dans votre repo également et revient au commit mentionné précédemment. Vous devrait être exécuté si vous êtes sûr d’avoir commis une erreur dans vos derniers commit (s) et aimerait remonter dans le temps. 

2- Habituellement, 7 lettres de "commit sha" suffisent, mais en plus gros projets, vous aurez peut-être besoin de 12 lettres au maximum pour être unique. Vous peut également mentionner les 40 lettres entières sha.

3- Les commandes ci-dessus fonctionnent également dans Github pour Windows.

Answer 52

Vous pouvez toujours créer un git checkout <SHA code> de la version précédente, puis le réactiver avec le nouveau code.

Answer 53

Vous pouvez annuler vos commits Git de deux manières: Premièrement, vous pouvez utiliser git revert, si vous souhaitez conserver votre historique de validation:

git revert HEAD~3
git revert <hashcode of commit>

Deuxièmement, vous pouvez utiliser git reset, qui effacerait tout votre historique de validation et vous permettrait de valider où bon vous semble.

git reset <hashcode of commit>
git reset HEAD~3

Vous pouvez également utiliser le mot clé --hard si l'un d'entre eux commence à se comporter autrement. Mais, je le recommanderais seulement jusqu'à ce que ce soit extrêmement nécessaire.

Answer 54

Référence: Comment annuler le dernier commit dans Git?

Si vous avez installé Git Extensions, vous pouvez facilement annuler/annuler tout commit (vous pouvez télécharger les extensions git à partir de ici ).

Ouvrez Git Extensions, faites un clic droit sur la validation que vous souhaitez annuler, puis sélectionnez "Inverser la validation". 

 

Un popup sera ouvert (voir la capture d'écran ci-dessous)

 

Sélectionnez "Créer automatiquement une validation" si vous souhaitez valider directement les modifications annulées ou si vous souhaitez valider manuellement les modifications annulées, laissez la case non sélectionnée et cliquez sur le bouton "Annuler cette validation".

Answer 55

Utilisez simplement git reset --hard <last good SHA> pour réinitialiser vos modifications et donner un nouveau commit. Vous pouvez également utiliser git checkout -- <bad filename>.

Answer 56

J'ai trouvé this site qui décrit comment annuler les éléments que vous avez validés dans le référentiel.

Quelques commandes:

git commit --amend        # Change last commit
git reset HEAD~1 --soft   # Undo last commit

Answer 57

Voici le site: Oh shit, git! .

Voici de nombreuses recettes pour annuler des choses dans Git. Certains d'entre eux:

Oh merde, j'ai besoin de changer le message sur mon dernier commit!

git commit --amend
# follow prompts to change the commit message

Oh merde, j'ai accidentellement commis quelque chose à maîtriser qui aurait dû être sur une nouvelle branche!

# Create a new branch from the current state of master
git branch some-new-branch-name
# Remove the commit from the master branch
git reset HEAD~ --hard
git checkout some-new-branch-name
# Your commit lives in this branch now :)

Answer 58

Vous pouvez annuler vos commits à partir du référentiel local. Veuillez suivre le scénario ci-dessous.

Dans l'image ci-dessous, je vérifie la branche 'test' (à l'aide de la commande Git git checkout -b test) en tant qu'état local et vérifie l'état (à l'aide de la commande Git git status) de la branche locale pour laquelle il n'y a rien à valider.

 

Dans l'image suivante, vous pouvez voir que j'ai apporté quelques modifications à Filter1.txt, ajouté ce fichier à la zone de stockage intermédiaire, puis validé mes modifications avec un message (à l'aide de la commande Git git commit -m "Doing commit to test revert back").

"-m est pour le message de validation"

 

Dans l'image suivante, vous pouvez voir votre journal des commits tout ce que vous avez fait (à l'aide de la commande Git git log).

 

Ainsi, dans l'image ci-dessus, vous pouvez voir l'identifiant de validation avec chaque validation et avec votre message de validation maintenant, quelle que soit la validation que vous souhaitez restaurer ou annuler, copiez-le et validez avec la commande ci-dessous Git, git revert {"paste your commit id"}. Exemple:

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

 

J'ai annulé mon dernier commit. Maintenant, si vous vérifiez votre statut Git, vous pouvez voir le fichier modifié qui est Filter1.txt et qui n'a pas encore été validé.

 

Answer 59

Le moyen le plus simple d'annuler le dernier commit est

git reset HEAD^

Cela apportera l'état du projet avant que vous ayez fait le commit.

Answer 60

Dans IntelliJ IDEA, vous pouvez simplement ouvrir le journal du référentiel Git en appuyant sur Alt+9Cliquez avec le bouton droit de la souris sur une balise de la liste des validations et sélectionnez: "Réinitialiser la branche actuelle sur ici ...".

Answer 61

HEAD:

Avant de réinitialiser la validation, nous devrions savoir que HEAD ... HEAD n’est autre que votre état actuel dans votre répertoire de travail. Il est représenté par un numéro de commit.

Git commit:

Chaque modification affectée sous un commit qui est représenté par une balise unique. Les commits ne peuvent pas être supprimés. Donc, si vous voulez votre dernier commit, vous pouvez simplement vous y plonger en utilisant git reset.

Vous pouvez plonger dans le dernier commit en utilisant deux méthodes:

Méthode 1: (si vous ne connaissez pas le numéro de validation, mais souhaitez passer au premier)

git reset HEAD~1  # It will move your head to last commit

Méthode 2: (si vous connaissez le commit que vous avez simplement réinitialisé sur votre commit connu)

git reset 0xab3 # numéro de validation

Note: si vous voulez connaître une validation récente, essayez git log -p -1

Voici la représentation graphique:

 

Answer 62

La différence entre git reset --mixed, --soft et --hard

Condition préalable: lors d’une modification d’un fichier existant dans votre fichier référentiel est faite, cette modification est initialement considérée comme non mise en scène . Afin de valider les modifications, il doit être mis en scène, ce qui signifie en l'ajoutant à l'index à l'aide de git add. Au cours d'une opération de validation, le fichier les fichiers mis en scène sont ajoutés à un index.

Prenons un exemple: 

- A - B - C (master)

HEAD pointe sur C et l'index correspond à C.

--doux

• Lorsque nous exécutons git reset --soft B avec l'intention de supprimer le commit C et en pointant le maître/HEAD sur B. 
• Le maître/HEAD va maintenant pointer sur B, mais le index est toujours passé de C. 
• Lors de l'exécution de git status, vous pourriez voir les fichiers indexés dans commit C comme staged. 
• L'exécution d'un git commit à ce stade créera un nouveau commit avec les mêmes modifications que C

--mixte

• Exécutez git reset --mixed B. 
• À l'exécution, maître/HEAD pointera sur B et le index est également modifié pour correspondre à B en raison de l'indicateur mixte utilisé. 
• Si nous exécutons git commit à ce stade, rien ne se passera puisque index correspond à HEAD.
• Nous avons toujours les modifications dans le répertoire de travail, mais comme elles ne figurent pas dans l'index, l'état git les indique comme non mises en scène. 
• Pour les commettre, vous devez git add et ensuite commettre comme d'habitude.

--difficile

• Exécuter git reset --hard B
• À l'exécution, maître/HEAD pointera sur B et modifiera votre répertoire de travail
• Les modifications ajoutées dans C et toutes les modifications non validées seront enlevées.
• Les fichiers de la copie de travail correspondront à la validation B, ce qui entraînera la perte définitive de toutes les modifications apportées à la validation C ainsi que des modifications non validées.

J'espère que cette comparaison d'indicateurs disponibles avec la commande git reset aidera quelqu'un à les utiliser judicieusement. Reportez-vous à ceux-ci pour plus de détails link1 & link2

Answer 63

Il est préférable de redéfinir la base et de supprimer des commits lorsque vous souhaitez conserver l'historique propre Utile pour proposer des correctifs à une branche publique, etc.

Si vous devez abandonner le commit le plus élevé, le one-liner suivant aide

git rebase --onto HEAD~1 HEAD

Mais si vous voulez laisser tomber un des nombreux commits, vous avez dit

a -> b -> c -> d -> master

et vous voulez laisser tomber commit 'c'

git rebase --onto b c

Cela fera de «b» la nouvelle base de «d» éliminant «c»

Answer 64

Recherchez le dernier code de hachage de validation en consultant le journal par:

git log

Ensuite

git reset <the previous co>

Answer 65

Par souci d’exhaustivité, je vais donner la méthode la plus évidente qui avait été négligée dans les réponses précédentes.

Puisque le commit n'a pas été poussé, la télécommande était inchangée, donc:

1. Supprimer le référentiel local.
2. Cloner le référentiel distant.

Cela est parfois nécessaire si votre client Git fantaisie passe au revoir. (par ex. erreurs non-fast-forward)

N'oubliez pas de réengager vos sauvegardés changements depuis le dernier Push.

Answer 66

 

En supposant que vous travailliez dans Visual Studio, si vous consultez l'historique de votre branche et examinez tous vos commits, sélectionnez simplement l'événement avant celui que vous souhaitez annuler, cliquez dessus avec le bouton droit de la souris et sélectionnez Revert. Aussi simple que ça.

Answer 67

Si vous souhaitez éliminer les mauvais fichiers, vous devriez faire 

git reset --soft <your_last_good_commit_hash_here>Voici, si vous faites git status, vous verrez les fichiers dans la zone de stockage intermédiaire. Vous pouvez sélectionner les mauvais fichiers et les retirer de la zone intermédiaire.

Comme la suivante.

git reset wrongFile1 wrongFile2 wrongFile3

Vous pouvez maintenant simplement ajouter les fichiers dont vous avez besoin pour Push,

git add goodFile1 goodFile2

engage les 

git commit -v ou git commit -am "Message"

et pousser

git Push Origin master

Cependant, si vous ne vous souciez pas des fichiers modifiés, vous pouvez réinitialiser votre ordinateur à la dernière bonne validation et pousser tout sur le serveur.

par 

git reset --hard <your_last_good_commit_hash_here>

git Push Origin master

Si vous avez déjà publié vos mauvais fichiers sur le serveur, vous pouvez utiliser l'indicateur --force pour envoyer au serveur et éditer l'historique.

git Push --force Origin master

Answer 68

Essayez ceci, réinitialisation matérielle à la validation précédente où ces fichiers n’ont pas été ajoutés, puis:

git reset --hard <commit_hash>

Assurez-vous d'avoir une sauvegarde de vos modifications au cas où, car il s'agit d'une réinitialisation matérielle, ce qui signifie qu'elles seront perdues (à moins que vous ne l'ayez caché plus tôt).

Answer 69

git reset --soft HEAD~1

Réinitialiser ramènera votre branche actuelle HEAD à la révision spécifiée. Note le drapeau --soft: cela garantit que les modifications des révisions annulées sont conservées. Après avoir exécuté la commande, vous retrouverez les modifications en tant que modifications locales non validées dans votre copie de travail.

Si vous ne souhaitez pas conserver ces modifications, utilisez simplement le drapeau --hard. Assurez-vous de ne le faire que lorsque vous êtes certain de ne plus avoir besoin de ces modifications.

 git reset --hard HEAD~1

Annulation de plusieurs validations

git reset --hard 0ad5a7a6

gardez toutefois à l'esprit que l'utilisation de la commande de réinitialisation annule tous les commits postérieurs à celui que vous avez renvoyé:  

Answer 70

Ce que je fais chaque fois que j'ai besoin d'annuler un commit/commits sont:

1. git reset HEAD~<n> // le nombre de dernières commissions que je dois annuler

2. git status // facultatif. Tous les fichiers sont maintenant en rouge (non mis en scène).

3. Maintenant, je peux ajouter et valider uniquement les fichiers dont j'ai besoin:

   • git add <file names> & git commit -m "message" -m "details"
4. Facultatif: je peux annuler les modifications des fichiers restants, si besoin est, à leur état précédent, avec la vérification suivante:
   • git checkout <filename>
5. si je l'avais déjà poussé vers l'origine distante, auparavant:
   • git Push Origin <branch name> -f // utilise -f pour forcer le Push.

Answer 71

Si vous voulez annuler le tout premier commit dans votre repo

Vous rencontrerez ce problème:

$ git reset HEAD~
fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

L'erreur se produit car si le dernier commit est le commit initial (ou aucun parent) du référentiel, il n'y a pas de HEAD ~.

Solution

Si vous souhaitez réinitialiser le seul commit sur la branche "maître"

$ git update-ref -d HEAD
$ git rm --cached -r .

Answer 72

Faites comme les étapes suivantes. Cela pourrait vous aider.

étape 1

Hit git log

Dans la liste des journaux, recherchez le dernier code de hachage de validation, puis entrez:

étape: 2

git reset <hash code>

Answer 73

Obtenir le dernier ID de validation en utilisant cette commande (dans le premier journal, c'est le dernier)

git log

Obtenez l'ID de validation (GUID) et exécutez cette commande:

git revert <commit_id>

Answer 74

Comment éditer un commit précédent

En général, je ne veux pas annuler un groupe de commits, mais plutôt éditer un engagement précédent comme je l'aurais souhaité.

Je me suis souvent trouvé en train de réparer un passé, et j'en ai écrit un script.

Voici le flux de travail:

1. git commit-edit <commit-hash>
   

   Cela vous laissera tomber au commit que vous voulez éditer.

   Les modifications du commit seront un staged, prêtes à être mises en scène comme vous le souhaitez, c'était la première fois.

2. Fixez et organisez le commit comme vous le souhaitiez.

   (Vous pouvez utiliser git stash save --keep-index pour écarter tous les fichiers que vous ne validez pas)

3. Refaites le commit avec --amend, par exemple:

   git commit --amend
   

4. Terminez la rebase:

   git rebase --continue
   

---

Appelez le git-commit-edit suivant et mettez-le dans votre $PATH:

#!/bin/bash

# Do an automatic git rebase --interactive, editing the specified commit
# Revert the index and working tree to the point before the commit was staged
# https://stackoverflow.com/a/52324605/5353461

set -euo pipefail

script_name=${0##*/}

warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
die () { warn "$@"; exit 1; }

[[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"

# Default to editing the parent of the most recent commit
# The most recent commit can be edited with `git commit --amend`
commit=$(git rev-parse --short "${1:-HEAD~}")

# Be able to show what commit we're editing to the user
if git config --get alias.print-commit-1 &>/dev/null; then
  message=$(git print-commit-1 "$commit")
else
  message=$(git log -1 --format='%h %s' "$commit")
fi

if [[ $OSTYPE =~ ^darwin ]]; then
  sed_inplace=(sed -Ei "")
else
  sed_inplace=(sed -Ei)
fi

export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'
git rebase --quiet --interactive --autostash --autosquash "$commit"~
git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commit
git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed

echo
echo "Editing commit: $message" >&2
echo

Answer 75

Si vous voulez simplement supprimer tous vos changements/commits locaux et faire en sorte que votre branche locale ressemble à la branche Origin d'origine ...

git reset --hard Origin/branch-name

Answer 76

J'ai écrit à ce sujet il y a longtemps après avoir moi-même rencontré les mêmes problèmes:

https://ao.gl/how-to-delete-revert-a-git-commit/

Fondamentalement, il vous suffit de faire:

git log, obtenez les sept premiers caractères du SHA, puis effectuez un git revert <sha> suivi de git Push --force.

Vous pouvez également revenir en arrière en utilisant la commande Git revert comme suit: git revert <sha> -m -1 puis git Push.

Answer 77

git revert commit

Cela générera les modifications opposées à partir de la validation que vous souhaitez rétablir, puis ne validera que ces modifications. Je pense que c'est le moyen le plus simple.

https://git-scm.com/docs/git-revert

Answer 78

Vous pouvez utiliser git revert <commit-id>.

Et pour obtenir l'ID de validation, utilisez simplement git log.

Answer 79

remplacez votre version locale, y compris vos modifications, par la version du serveur. Ces deux lignes de code forceront git à extraire et à remplacer la version locale. Ouvrez la commande Invite et accédez à la racine du projet git. Si vous utilisez VS, cliquez sur Equipe, Synch et sur "Ouvrir l'invite de commande" (voir image) ci-dessous. 

 

Une fois dans l'invite Cmd, suivez les deux instructions suivantes. 

git fetch --all

alors tu fais

git reset --hard Origin/master

cela écrasera la version locale existante par celle du serveur git

Answer 80

git Push --delete (branch_name) //this will be removing the public version of your branch

git Push Origin (branch_name) //This will add the previous version back