Supprimer valide à partir d’une succursale dans Git

Je voudrais savoir comment supprimer un commit.

Par delete , je veux dire que c’est comme si je n’avais pas fait ce commit, et quand je ferais une poussée à l’avenir, mes modifications ne seront pas transmises à la twig distante.

J’ai lu l’aide de git et je pense que la commande que je devrais utiliser est git reset --hard HEAD . Est-ce correct?

Attention: git reset --hard SUPPRIMERA VOS CHANGEMENTS DE REPERTOIRE DE TRAVAIL . Veillez à conserver les modifications locales à conserver avant d’exécuter cette commande.

En supposant que vous êtes assis sur ce commit, alors cette commande le mettra en danger …

 git reset --hard HEAD~1 

Le HEAD~1 signifie le commit avant la tête.

Ou, vous pouvez regarder la sortie de git log , trouver l’ID de validation de la validation sur laquelle vous voulez sauvegarder, puis procédez comme suit:

 git reset --hard  

Si vous l’avez déjà poussé, vous devrez faire une poussée pour vous en débarrasser …

 git push origin HEAD --force 

Cependant , si d’autres personnes l’ont tiré, il serait préférable de créer une nouvelle succursale. Parce que quand ils tirent, il va simplement le fusionner dans leur travail, et vous allez le faire reculer.

Si vous avez déjà appuyé, il peut être préférable d’utiliser git revert , pour créer une validation “image miroir” qui annulera les modifications. Cependant, les deux commits seront dans le journal.


FYI – git reset --hard HEAD est génial si vous voulez vous débarrasser de WORK IN PROGRESS. Il vous ramènera à la validation la plus récente et effacera toutes les modifications de votre arborescence de travail et de votre index.


Enfin, si vous avez besoin de trouver un commit que vous “supprimez”, il est généralement présent dans git reflog moins que vous n’ayez collecté des ordures dans votre référentiel.

Si vous n’avez pas encore poussé la validation, vous pouvez utiliser git rebase -i pour supprimer cette validation. Tout d’abord, découvrez à quelle distance de la validation est (approximativement). Alors fais:

 git rebase -i HEAD~N 

Le ~N signifie rebaser les N derniers commits ( N doit être un nombre, par exemple HEAD~10 ). Ensuite, vous pouvez modifier le fichier que Git vous présente pour supprimer le commit incriminé. Lors de l’enregistrement de ce fichier, Git réécrira alors toutes les commandes suivantes, comme si celle que vous avez supprimée n’existait pas.

Le Git Book a une bonne section sur le rebasage avec des images et des exemples.

Soyez prudent avec cela, car si vous modifiez quelque chose que vous avez poussé ailleurs, une autre approche sera nécessaire à moins que vous envisagiez de faire une poussée forcée.

Une autre possibilité est l’une de mes commandes favorites:

 git rebase -i ~1 

Cela lancera le rebase en mode interactif -i au point juste avant la validation que vous voulez commettre. L’éditeur va commencer à lister tous les commits depuis lors. Supprimez la ligne contenant la validation à effacer et enregistrez le fichier. Rebase fera le rest du travail, supprimant uniquement ce commit et relançant tous les autres dans le journal.

J’ajoute cette réponse parce que je ne vois pas pourquoi quelqu’un qui vient d’essayer de commettre un travail voudrait supprimer tout ce travail à cause d’une erreur avec Git!

Si vous voulez garder votre travail et simplement “annuler” cette commande de validation (vous avez intercepté avant de pousser à repo):

 git reset --soft HEAD~1 

N’utilisez pas l’ indicateur –hard à moins que vous ne souhaitiez détruire votre travail en cours depuis le dernier commit.

Supprimer un commit entier

 git rebase -p --onto SHA^ SHA 

Remplacez évidemment “SHA” par la référence dont vous voulez vous débarrasser. Le “^” dans cette commande est littéral.

http://sethrobertson.github.io/GitFixUm/fixup.html

Si vous n’avez pas publié de modifications, pour supprimer la dernière validation, vous pouvez le faire.

 $ git reset --hard HEAD^ 

(Notez que cela supprime également tous les changements non validés; utilisez-les avec précaution).

Si vous avez déjà publié un commit à supprimer, utilisez git revert

 $ git revert HEAD 
 git reset --hard commitId git push   --force 

PS: CommitId désigne celui auquel vous souhaitez revenir

Si vous souhaitez corriger votre dernière validation, vous pouvez annuler la validation et décompresser les fichiers qu’elle contient en procédant comme suit:

 git reset HEAD~1 

Cela ramènera votre référentiel à son état avant que git ajoute des commandes qui mettent en scène les fichiers. Vos modifications seront dans votre répertoire de travail. HEAD ~ 1 se réfère à la validation en dessous de la pointe actuelle de la twig.

Si vous souhaitez annuler la validation de N commits, conservez les modifications de code dans votre répertoire de travail:

 git reset HEAD~N 

Si vous souhaitez vous débarrasser de votre dernier commit et ne souhaitez pas conserver les modifications de code, vous pouvez effectuer une réinitialisation “matérielle”.

 git reset --hard HEAD~1 

De même, si vous souhaitez ignorer les N derniers commits et ne souhaitez pas conserver les modifications de code:

 git reset --hard HEAD~N 

Changer avec force l’histoire

En supposant que vous ne voulez pas simplement supprimer le dernier commit, mais que vous souhaitiez supprimer des validations spécifiques des n derniers commits, allez avec:

git rebase -i HEAD~ , alors git rebase -i HEAD~5 si vous voulez voir les cinq derniers commits.

Ensuite, dans l’éditeur de texte, modifiez le pick mots pour les drop côté de chaque validation que vous souhaitez supprimer. Enregistrez et quittez l’éditeur. Voila!

Changer l’historique

Essayez git revert . Revert créera un nouveau commit qui annule le commit spécifié.

Disons que nous voulons supprimer les commits 2 et 4 du repository.

 commit 0 : b3d92c5 commit 1 : 2c6a45b commit 2 :  commit 3 : 77b9b82 commit 4 :  

Note: Vous devez avoir des droits d’administrateur sur le repo puisque vous utilisez --hard et -f .

  • git checkout b3d92c5 Checkout le dernier commit utilisable.
  • git checkout -b repair Créer une nouvelle twig sur laquelle travailler.
  • git cherry-pick 77b9b82 Run through commit 3.
  • git cherry-pick 2c6a45b Run through commit 1.
  • git checkout master master.
  • git reset --hard b3d92c5 Réinitialiser le maître à la dernière validation utilisable.
  • git merge repair Merge git merge repair Fusionner notre nouvelle twig sur master.
  • git push -f origin master Poussez le maître sur le repo distant.
 git rebase -i HEAD~2 

Ici, “2” est le nombre de commits que vous souhaitez rebaser.

 'git rebase -i HEAD` 

si vous voulez rebaser tous les commits.

Vous pourrez alors choisir l’une de ces options.

p, pick = use commit

r, reword = use commit, but edit the commit message

e, edit = use commit, but stop for amending

s, squash = use commit, but meld into previous commit

f, fixup = like "squash", but discard this commit's log message

x, exec = run command (the rest of the line) using shell

d, drop = remove commit

Ces lignes peuvent être réorganisées; ils sont exécutés de haut en bas. Si vous supprimez une ligne ici, cette opération sera perdue. Cependant, si vous supprimez tout, le rebase sera annulé. Notez que les validations vides sont commentées

Vous pouvez simplement supprimer cette validation en utilisant l’option “d” ou Supprimer une ligne qui a votre commit.

Pour supprimer dans une twig locale, utilisez

 git reset --hard HEAD~1 

Pour supprimer dans une twig distante, utilisez

 git push origin HEAD --force 

Voici une autre façon de procéder:

Examinez la twig que vous souhaitez rétablir, puis réinitialisez votre copie de travail locale sur le commit que vous souhaitez voir être le dernier sur le serveur distant (tout ce qui suit sera envoyé). Pour ce faire, dans SourceTree, j’ai cliqué avec le bouton droit de la souris et sélectionné “Réinitialiser BRANCHNAME à ce commit”. Je pense que la ligne de commande est la suivante:

 git reset --hard COMMIT_ID 

Comme vous venez de vérifier votre succursale à distance, vous n’allez pas avoir de changements locaux à craindre de perdre. Mais cela les perdrait si vous le faisiez.

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 tous les commits après le courant dans votre repository local, mais seulement pour cette twig.

L’erreur:

Je git rebase -i --root sur ma twig, pensant par ignorance que je pourrais reformuler le premier commit en différant du master (la vue par défaut de GitHub pour Windows est la comparaison avec master, masquant son intégralité).

J’ai fait pousser une barbe dans la Silicon Valley alors que plus de 900 commits se sont embarqués dans Sublime. En quittant sans changement, j’ai chargé ma batterie puis procédé au rasage, car plus de 900 personnes se sont engagées nonchalamment rebasées – réinitialisant leurs temps de validation à maintenant.

Déterminé à battre Git et à préserver les temps d’origine, j’ai supprimé ce référentiel local et re-cloné depuis la télécommande.

Maintenant, il avait rajouté un des derniers engagements inutiles à maîsortingser que je souhaitais supprimer.

Épuiser les options:

Je ne voulais pas git revert – cela créerait un engagement supplémentaire, donnant à Git la main haute.

git reset --hard HEAD n’a rien fait, après avoir vérifié le reflog , le dernier et seul HEAD était le clone – Git gagne.

Pour obtenir le plus récent SHA, j’ai vérifié le repository distant sur github.com – victoire mineure.

Après avoir pensé que git reset --hard avait travaillé, j’ai mis à jour une autre twig à maîsortingser et 1 … 2 … poof! le commit était de retour – Git gagne.

Revenir en arrière pour maîsortingser, le temps d’essayer git rebase -i , puis supprimez la ligne … en vain, sortingste à dire. ” Si vous supprimez une ligne ici, cette COMMANDE SERA PERDUE “. Ah … glacé sur la nouvelle fonctionnalité traquez le n00b dans les notes de version 2.8.3 .

La solution:

git rebase -i puis d, drop = remove commit .

Pour vérifier, j’ai vérifié à une autre twig, et le tour est joué – aucune dissimulation ne s’engage à aller chercher / retirer du maître.

https://twitter.com/holman/status/706006896273063936

Bonne journée.

Toutes les commandes ci-dessus restaurent l’état de votre arborescence de travail et l’index tel qu’il était avant de procéder à la validation, mais ne restaurent pas l’état du référentiel. Si vous le regardez, le commit “supprimé” n’est pas réellement supprimé, ce n’est simplement pas celui qui se trouve à l’extrémité de la twig en cours.

Je pense qu’il n’y a aucun moyen de supprimer un engagement avec des commandes en porcelaine . Le seul moyen est de le retirer du journal et de la redissortingbution et d’exécuter git prune --expire -now .

Si vous venez de bousiller votre dernier commit (mauvais message, oublié d’y append des modifications) et que vous souhaitez le corriger avant de le transférer à un repository public, pourquoi ne pas utiliser:

 git commit --amend -m "New message here" 

Si vous avez des changements nouvellement mis en place, ils seront combinés avec le dernier commit (que vous essayez de supprimer) et remplaceront ce commit.

Bien sûr, si vous modifiez un commit après l’avoir poussé, vous réécrivez l’historique, alors assurez-vous d’en comprendre les implications.

Vous pouvez également passer l’option ‘–no-edit’ au lieu de ‘-m’ si vous préférez utiliser le message de validation précédent.

Documents: http://git-scm.com/docs/git-commit.html

Si vous souhaitez conserver l’historique, en affichant le commit et le retour, vous devez utiliser:

 git revert GIT_COMMIT_HASH 

Entrez le message en expliquant pourquoi vous revenez et ensuite:

 git push 

Lorsque vous git log vous verrez les messages d’erreur et de journalisation “erronés”.

Qu’est-ce que je fais habituellement quand je commets et pousse (si quelqu’un a poussé son commit cela résout le problème):

 git reset --hard HEAD~1 git push -f origin 

j’espère que cette aide

Source: https://gist.github.com/sagarjethi/c07723b2f4fa74ad8bdf229166cf79d8

Supprimer le dernier commit

Par exemple, votre dernier engagement

git push origine + aa61ab32 ^: master

Maintenant, vous voulez supprimer cette validation puis un moyen facile de le faire après

Pas

  1. Commencez par réinitialiser la twig au parent du commit en cours

  2. Poussez-le sur la télécommande.

 git reset HEAD^ --hard git push origin -f 

Pour un commit particulier, vous souhaitez réinitialiser suit

 git reset bb676878^ --hard git push origin -f 

Réinitialiser sur une succursale locale

 git reset --hard HEAD~ So git reset --hard HEAD~3 

Force poussée à l’origine

 git push -f origin 

Si vous avez déjà appuyé sur cette touche , commencez par rechercher le commit que vous souhaitez placer dans HEAD ($ GIT_COMMIT_HASH_HERE) , puis exécutez les opérations suivantes:

 git reset --hard $GIT_COMMIT_HASH_HERE git push origin HEAD --force 

Ensuite, chaque endroit où le repo a été cloné, lancez:

 git reset --hard origin/master 

utilisez git revert https://git-scm.com/docs/git-revert . Il retournera tout le code, vous pourrez alors faire le prochain commit. Ensuite, la tête indiquera ce dernier commit. les validations annulées ne sont jamais effacées mais cela n’affecte pas votre dernière validation.

En supposant que vous n’avez pas poussé vers le référentiel distant, vous pouvez re-cloner le référentiel. Cela a été ma méthode de choix à quelques resockets.

git réinitialiser –hard

git push origine HEAD –force

Si un ou plusieurs des commits sont marqués, supprimez les tags en premier. Sinon, le commit marqué n’est pas supprimé.

supprimer le commit local

Comme vous pouvez le voir sur l’image ci-dessus, je veux supprimer la validation “test change 2” (ID SHA1: 015b5220c50e3dfbb1063f23789d92ae1d3481a2 (vous pouvez obtenir l’identifiant SHA1 en utilisant la commande gitk dans git bash)).

Pour cela, je peux utiliser (toutes les commandes ci-dessous fonctionnent uniquement sur local. Vous devez pousser après suppression):

  1. git reset --hard 515b5220c50e3dfbb1063f23789d92ae1d3481a2 // il vous sauvegarde à cette validation (l’identifiant SHA1 de la modification de test 4 est 515b5220c50e3dfbb1063f23789d92ae1d3481a2 )
  2. git reset --hard HEAD~1 // il vous sauvegarde avant que l’on ne commette.
  3. git reset --hard HEAD^ // Pour supprimer le dernier commit de git

après supprimer:

après effacer commit

Effectuez une sauvegarde de votre code dans le dossier temp. La commande suivante réinitialisera le même que le serveur.

 git reset --hard HEAD git clean -f git pull 

Si vous souhaitez conserver vos modifications et supprimer les validations récentes

 git reset --soft HEAD^ git pull