revenir - git supprimer fichier commit




Comment annuler les derniers commits dans Git? (20)

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

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


Annuler le dernier commit:

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

Cela annulera le dernier commit.

Ici - --soft signifie réinitialiser dans la mise en scène.

HEAD~ ou HEAD^ signifie se déplacer pour s'engager avant HEAD.

Remplacer le dernier commit par le nouveau commit:

git commit --amend -m "message"

Il remplacera le dernier commit par le nouveau commit.


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

Utilisez git-gui (ou similaire) pour effectuer 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

Il suffit de réinitialiser votre branche à l’emplacement précédent (par exemple, en utilisant gitk ou git rebase ). Réappliquez ensuite 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 la validation non désirée n’était jamais arrivée. Pour faire tout cela en une seule commande, utilisez git reset HEAD~1 .

Mot d'avertissement : Une utilisation négligente de la git reset de git reset est un bon moyen de rendre 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 une sélection inversée ( 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 d' une branche privée dans un 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, effectuez une squash-merge masquage pour masquer l'historique.


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 arborescence de travail (l'état de vos fichiers sur le disque) inchangée, mais annule le commit et laisse les modifications que vous avez commises non mises en scène (elles apparaîtront donc sous la forme "Modifications non gérées pour la validation" dans ajoutez-les à nouveau avant de vous engager). Si vous souhaitez uniquement ajouter d' autres modifications à la validation précédente ou modifier le message de validation 1 , vous pouvez utiliser git reset --soft HEAD~ , ce qui revient à git reset HEAD~ (où HEAD~ est identique à HEAD~1 ) mais laisse vos modifications existantes mises en scène.
  3. Apportez des corrections aux fichiers 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 l'ancienne tête .git/ORIG_HEAD 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à transféré sur votre serveur et que vous disposez des autorisations pour écraser l'historique (rebase), alors:

git push origin master --force

Vous pouvez également regarder cette réponse:

Comment déplacer HEAD à un emplacement précédent? (Tête détachée)

La réponse ci-dessus vous montrera que git reflog 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.

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


"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 -


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 ayez ceci, où C est votre HEAD et (F) l’état de vos fichiers.

   (F)
A-B-C
    ↑
  master

Vous voulez neutraliser le commit C et ne plus jamais le revoir . Tu fais cela:

git reset --hard HEAD~1

Le résultat est:

 (F)
A-B
  ↑
master

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

Ah, mais supposons que commit C n'était pas un désastre, mais juste un peu en retrait. Vous voulez annuler la validation mais garder vos modifications pour un peu de modification avant de faire une meilleure validation. 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 est juste un pointeur sur le dernier commit. Lorsque vous effectuez une git reset HEAD~1 par git reset HEAD~1 , vous indiquez à 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, le git status montre les changements que vous avez enregistrés dans C. Vous n'avez rien perdu!

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

git reset --soft HEAD~1

Cela laisse non seulement vos fichiers seuls, mais également votre index . Lorsque vous faites le 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 que vous en découvriez ensuite le besoin ? Pas de chance, non?

Non, il y a encore un moyen de le récupérer. Tapez git reflog et vous verrez une liste des shams (partiels) de commit que vous avez déplacés. Trouvez 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.


Autrement:

Vérifiez la branche que vous souhaitez rétablir, puis réinitialisez votre copie de travail locale sur le commit que vous souhaitez être le plus récent sur le serveur distant (tout ce qui suivra sera répété au-delà). 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.


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


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

git reset --soft HEAD~1

Expliquez ce que git reset fait, il est essentiellement reset sur n'importe quel commit --soft vous souhaitez revenir, puis si vous le combinez avec la touche --soft , il reviendra en arrière, mais gardez les modifications dans vos fichiers, vous revenez à l'étape où le fichier vient d'être ajouté, HEAD est le responsable de la branche et si vous combinez avec ~1 (dans ce cas, vous utilisez également HEAD^ ), il ne retournera qu'un seul commit avec ce que 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:


Il y a plusieurs façons de le faire:

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

Attention: N'utilisez pas --hard si vous ne savez pas ce que vous faites. --hard est trop dangereux et pourrait effacer vos fichiers.

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

$ git reset --hard <COMMIT -ID>

ou

$ git reset --hard HEAD~<n>

COMMIT-ID : identifiant du commit

n: est le nombre de derniers commits que vous voulez annuler

Vous pouvez obtenir l'identifiant de commit 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

d81d3f1 et be20eb8 sont l'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 des informations plus détaillées, vous pouvez vous référer et essayer d'autres commandes pour réinitialiser la tête à un état spécifié:

$ git reset --help

Je préfère utiliser git rebase -i pour ce travail, car une belle liste apparaît dans laquelle je peux choisir les commits à supprimer. Ce n'est peut-être pas aussi direct que d'autres réponses ici, mais cela 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.


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

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 souhaitez réinitialiser. L' option --soft supprimera la validation mais laissera tous vos fichiers modifiés "Les modifications à valider", comme le dirait le statut de git.

Si vous souhaitez vous débarrasser de toute modification apportée aux fichiers suivis dans l’arbre de travail depuis la validation avant l’utilisation de la tête, utilisez « --hard » à la place.

OU

Si vous avez déjà poussé et que quelqu'un ait tiré ce qui est généralement mon cas, vous ne pouvez pas utiliser la réinitialisation git . 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.


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, faites simplement la commande suivante.

git reset --hard HEAD^1

(Cette commande ignorera la totalité de votre commit 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 apportées dans la zone de préparation (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 un 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.

More


Si vous souhaitez supprimer des fichiers lors de la dernière validation, vous pouvez utiliser ceci:

git reset --hard HEAD~1

Et si besoin de fichiers dans le dernier commit, vous pouvez utiliser ceci:

git reset --soft HEAD~1

Simple, lancez ceci dans votre ligne de commande:

git reset --soft HEAD~ 

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.

Une seule commande:

git reset --soft 'HEAD^' 

Cela fonctionne bien pour annuler le dernier commit local!


Utiliser git revert commit-id

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


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 rapport HEAD sera réinitialisé sur ce HEADid. JOURNAL APRES RESET

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

REFLOG FINAL


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é.







git-revert