le Retour de la Copie de Travail le Plus Récent s'Engager

pour revenir à une propagation précédente, en ignorant tout changement:

git reset --hard HEAD

où HEAD est le dernier commit dans votre branche actuelle

Retourner La Copie de Travail d'un ancien Commit

pour revenir À une révision qui est plus ancien que le plus récent s'engager:

# Resets index to former commit; replace '56e05fced' with your commit code
git reset 56e05fced 

# Moves pointer back to previous HEAD
git reset --soft HEAD@{1}

git commit -m "Revert to 56e05fced"

# Updates working copy to reflect the new commit
git reset --hard

les crédits vont à une question similaire sur le débordement de la pile, Revenir à une validation par un hachage SHA dans Git? .

beaucoup de réponses compliquées et dangereuses ici, mais c'est en fait facile:

git revert --no-commit 0766c053..HEAD
git commit

cela va tout ramener de la tête en arrière au hachage de propagation, ce qui signifie qu'il va recréer cet état de propagation dans l'arbre de travail comme si chaque propagation depuis avait été repoussée. Vous pouvez alors propager l'arbre courant, et il créera une nouvelle propagation essentiellement équivalente à la propagation à laquelle vous êtes "retourné".

(la Le drapeau --no-commit permet à git de revenir sur toutes les commits à la fois - sinon vous serez invité à un message pour chaque commit dans la gamme, salissant votre histoire avec de nouvelles commits inutiles.)

il s'agit d'un moyen sûr et facile de revenir à un état précédent . Aucune histoire n'est détruite, de sorte qu'elle peut être utilisée pour des commits qui ont déjà été rendus publics.

la meilleure option pour moi et probablement d'autres est l'option de réinitialisation Git:

git reset --hard <commidId> && git clean -f

Cela a été la meilleure option pour moi! C'est simple, rapide et efficace!

Note : comme mentionné dans les commentaires ne faites pas cela si vous partagez votre branche avec d'autres personnes qui ont des copies de l'ancien commits

aussi des commentaires, si vous voulez un de moins " ballzy méthode, vous pourriez utiliser

git clean -i

avant de répondre, ajoutons un contexte expliquant ce qu'est ce HEAD .

First of all what is HEAD?

HEAD est simplement une référence à la propagation actuelle (la dernière) sur la branche courante. Il ne peut y avoir qu'un seul HEAD à tout moment (sauf git worktree ).

le contenu de HEAD est stocké à l'intérieur de .git/HEAD , et il contient les 40 octets SHA-1 de la propagation courante.

detached HEAD

si vous n'êtes pas sur le dernier commit-ce qui signifie que HEAD pointe vers un commit antérieur dans l'histoire il est appelé detached HEAD .

sur la ligne de commande il ressemblera à ceci-SHA-1 au lieu du nom de la branche puisque le HEAD ne pointe pas vers le bout de la branche actuelle:

quelques options sur la façon de récupérer à partir d'un décollement de la TÊTE:

git checkout

git checkout <commit_id>
git checkout -b <new branch> <commit_id>
git checkout HEAD~X // x is the number of commits t go back

ceci va vérifier la nouvelle branche pointant vers la propagation désirée. Cette commande va passer à une validation donnée.

À ce stade, vous pouvez créer une branche et commencer à travailler à partir de ce point:

# Checkout a given commit.
# Doing so will result in a `detached HEAD` which mean that the `HEAD`
# is not pointing to the latest so you will need to checkout branch
# in order to be able to update the code.
git checkout <commit-id>

# Create a new branch forked to the given commit
git checkout -b <branch name>

git reflog

Vous pouvez toujours utiliser le reflog . git reflog affichera toute modification qui a mis à jour le HEAD et en cochant l'entrée de recharge désirée, le HEAD retournera à cette propagation.

chaque fois que la tête est modifiée il y aura une nouvelle entrée dans le reflog

git reflog
git checkout HEAD@{...}

Cela va vous ramener à votre souhaité s'engager

git reset HEAD --hard <commit_id>

Déplacer " de votre tête en arrière pour l'souhaité s'engager.

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

• Note: ( depuis Git 2.7 ) vous pouvez également utiliser le git rebase --no-autostash ainsi.

ce schéma illustre quelle commande fait quoi. Comme vous pouvez le voir il reset && checkout modifier le HEAD .

si vous voulez "uncommit", effacer le dernier message de propagation, et remettre les fichiers modifiés dans la mise en scène, vous utiliserez la commande:

git reset --soft HEAD~1

• --soft indique que les fichiers non engagés devraient être conservés en tant que fichiers de travail par opposition à --hard qui les éliminerait.
• HEAD~1 est le dernier commit. Si vous voulez faire reculer 3 commits, vous pouvez utiliser HEAD~3 . Si vous souhaitez reprendre à un numéro de révision, vous pouvez également le faire en utilisant son hachage SHA.

c'est une commande extrêmement utile dans les situations où vous avez commis la mauvaise chose et vous voulez défaire cette dernière commit.

Source: http://nakkaya.com/2009/09/24/git-delete-last-commit /

j'ai essayé beaucoup de façons d'inverser les changements locaux dans Git, et il semble que cela fonctionne le mieux si vous voulez simplement revenir à l'état de propagation le plus récent.

git add . && git checkout master -f

brève description:

• il ne créera pas de commits comme git revert le fait.
• il ne détachera pas votre tête comme git checkout <commithashcode> le fait.
• il annulera toutes les modifications locales et supprimera toutes les modifications ajoutées fichiers depuis le dernier commit dans la branche.
• cela ne fonctionne qu'avec les noms de branches, donc vous ne pouvez revenir qu'à la dernière propagation dans la branche de cette façon.

j'ai trouvé un moyen beaucoup plus pratique et simple d'atteindre les résultats ci-dessus:

git add . && git reset --hard HEAD

où la tête pointe vers le dernier commit à votre branche courante.

C'est le même code que boulder_ruby suggéré, mais j'ai ajouté git add . avant git reset --hard HEAD pour effacer tous les nouveaux fichiers créés depuis la dernière propagation puisque c'est ce que la plupart des gens attendent de moi quand je reviens à la dernière propagation.

Vous pouvez le faire par les deux commandes suivantes:

git reset --hard [previous Commit SHA id here]
git push origin [branch Name] -f

il supprimera votre précédent git commit.

Si vous voulez conserver vos modifications, vous pouvez également utiliser:

git reset --soft [previous Commit SHA id here]

alors il enregistrera vos modifications.

dites que vous avez les commits suivants dans un fichier texte nommé ~/commits-to-revert.txt (j'ai utilisé git log --pretty=oneline pour les obtenir)

fe60adeba6436ed8f4cc5f5c0b20df7ac9d93219
0c27ecfdab3cbb08a448659aa61764ad80533a1b
f85007f35a23a7f29fa14b3b47c8b2ef3803d542
e9ec660ba9c06317888f901e3a5ad833d4963283
6a80768d44ccc2107ce410c4e28c7147b382cd8f
9cf6c21f5adfac3732c76c1194bbe6a330fb83e3
fff2336bf8690fbfb2b4890a96549dc58bf548a5
1f7082f3f52880cb49bc37c40531fc478823b4f5
e9b317d36a9d1db88bd34831a32de327244df36a
f6ea0e7208cf22fba17952fb162a01afb26de806
137a681351037a2204f088a8d8f0db6e1f9179ca

créer un Bash script shell pour revenir à chacun d'eux:

#!/bin/bash
cd /path/to/working/copy
for i in `cat ~/commits-to-revert.txt`
do
    git revert $i --no-commit
done

cela renvoie tout à l'état précédent, y compris les créations de fichiers et de répertoires, et les suppressions, les commit à votre branche et vous conservez l'historique, mais vous l'avez fait revenir à la même structure de fichiers. Je ne comprends pas pourquoi Git n'a pas de git revert --to <hash> .

Solutions de rechange supplémentaires aux Solutions de Jefromi

Jefromi solutions sont certainement les meilleurs, et vous devriez certainement utiliser. Cependant, dans un souci d'exhaustivité, j'ai également voulu montrer ces autres solutions alternatives qui peuvent également être utilisées pour inverser un commit (dans le sens où vous créer un nouveau commit qui annule les changements dans le commit précédent , exactement comme ce que git revert fait).

pour être clair, ces alternatives ne sont pas la meilleure façon de revenir en arrière commits , les solutions de Jefromi sont , mais je tiens à souligner que vous pouvez également utiliser ces autres méthodes pour atteindre la même chose que git revert .

variante 1: redémarrage dur et mou

il s'agit d'une version très légèrement modifiée de la solution de Charles Bailey à revenir à une commission par un SHA hash en Git? :

# Reset the index to the desired commit
git reset --hard <commit>

# Move the branch pointer back to the previous HEAD
git reset --soft HEAD@{1}

# Commit the changes
git commit -m "Revert to <commit>"

cela fonctionne essentiellement en utilisant le fait que les réinitialisations soft quitteront l'état du commit précédent mis en scène dans l'index/staging-area, que vous pouvez ensuite commuter.

variante 2: Supprimer L'arbre actuel et le remplacer par le nouvel

Cette solution vient de svick solution à l' Checkout ancien commit et d'en faire un nouveau commit :

git rm -r .
git checkout <commit> .
git commit

comme dans la variante no 1, cela reproduit l'état de <commit> dans la copie de travail actuelle. Il est nécessaire de faire git rm d'abord parce que git checkout ne supprimera pas les fichiers qui ont été ajoutés depuis <commit> .

voici un beaucoup plus simple façon de revenir à une commission précédente (et de l'avoir dans un état non engagé, à faire avec ce que vous voulez):

git reset HEAD~1

Donc, pas besoin de commettre des id et ainsi de suite :)

OK, revenir à la commit précédente en git est assez facile...

revenir en arrière sans garder les changements:

git reset --hard <commit>

Revenir en arrière avec le maintien de les changements:

git reset --soft <commit>

expliquer: en utilisant la réinitialisation git, vous pouvez réinitialiser à un état spécifique, il est commun de l'utiliser avec un hash commit comme vous voyez ci-dessus.

mais comme vous voyez la différence est d'utiliser les deux drapeaux --soft et --hard , par défaut git reset en utilisant --soft drapeau, mais c'est une bonne pratique toujours en utilisant le drapeau, j'explique chaque drapeau:

--doux

le drapeau par défaut comme expliqué, pas besoin de le fournir, ne change pas l'arbre de travail, mais ajoute tous les fichiers de changements prêts à commettre, donc vous retournez à l'état de propagation qui change à les fichiers unstaged.

--dur

soyez prudent avec ce drapeau, il réinitialise l'arbre de travail et toutes les modifications aux fichiers suivis et tout sera parti!

j'ai aussi créé l'image ci-dessous qui peut se produire dans une vraie vie de travail avec git:

en supposant que vous parlez de maître et sur cette branche respective (cela dit, cela pourrait être n'importe quelle branche de travail dont vous êtes concerné):

# Revert local master branch to November 3rd commit ID
git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50

# Revert remote master branch to November 3rd commit ID
git push -f origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master

j'ai trouvé la réponse dans l'article de blog Supprimer git repo à distance à commit spécifique .

rien ici n'a fonctionné pour moi à part cette combinaison exacte:

git reset --hard <commit_hash>
git push origin <branch_name> --force

ici, la clé est de forcer la poussée, pas de messages supplémentaires de commit / commit, etc.

après tous les changements, lorsque vous appuyez sur toutes ces commandes, vous pourriez avoir à utiliser:

git push -f ...

et pas seulement git push .

il y a une commande (qui ne fait pas partie du noyau Git, mais elle est dans le paquet git-extras ) spécifiquement pour revenir en arrière et mettre en scène les vieilles commits:

git back

Par le l'homme page , il peut également être utilisé en tant que tel:

# Remove the latest three commits
git back 3

Sélectionnez votre commit requis, et vérifiez-le par

git show HEAD
git show HEAD~1
git show HEAD~2 

jusqu'à ce que vous obtenir l'engager. Pour faire la tête à cela, faire

git reset --hard HEAD~1

ou git reset --hard HEAD~2 ou autre.

Revenir les plus récentes s'engager et d'ignorer toutes les modifications locales:

git reset --hard HEAD

conserver les modifications à partir de la précédente livraison de la TÊTE et de passer à la précédente livraison, le faire:

git reset <SHA>

si des modifications ne sont pas nécessaires par rapport à la précédente, faites:

git reset --hard <SHA>

pour nettoyer complètement le répertoire d'un codeur de quelques changements accidentels, nous avons utilisé:

git add -A .
git reset --hard HEAD

juste git reset --hard HEAD permettra de supprimer les modifications, mais pas les" nouveaux " fichiers. Dans leur cas, ils avaient accidentellement traîné un dossier important quelque part au hasard, et tous ces fichiers étaient traités comme nouveaux par Git, donc un reset --hard ne l'a pas corrigé. En exécutant le git add -A . avant, il les a explicitement suivi tous avec git, pour être effacé par le réinitialiser.

C'est une façon de plus de réinitialiser directement à une commit récente

git stash
git stash clear

il efface directement tous les changements que vous avez faits depuis la dernière propagation.

PS: il a un petit problème; il supprime aussi tous les changements de planque que vous avez récemment stockés. Ce qui, dans la plupart des cas, ne devrait pas avoir d'importance.

je crois que certaines personnes peuvent venir à cette question voulant savoir comment faire reculer les changements engagés qu'ils ont faits dans leur maître - c'est-à-dire tout jeter et retourner à l'origine/maître, dans ce cas, faire ceci:

git reset --hard origin/master

https://superuser.com/questions/273172/how-to-reset-master-to-origin-master

vous pouvez effectuer toutes ces étapes initiales vous-même et de repousser à git repo.

1. "151910920 de la commande".

2. lancez la commande git log avec-n 4 depuis votre terminal. Le nombre après le-n détermine le nombre de commits dans le log à partir du commit le plus récent dans votre histoire locale.

   $ git log -n 4

3. réinitialisez la tête de l'histoire de votre dépôt en utilisant le git reset --hard HEAD~N où N est le nombre de propagations que vous voulez reprendre la tête. Dans l'exemple suivant, la tête de être un s'engager, pour le dernier commit dans le référentiel de l'histoire:

4. Pousser le changement de repo git à l'aide de git push --force à force de pousser changement.

si vous vous voulez un dépôt git vers une propagation précédente

git pull --all
git reset --hard HEAD~1
git push --force

Revert est la commande pour faire reculer les commits.

git revert <commit1> <commit2> 

échantillon:

git revert 2h3h23233

il est capable de prendre la portée de la tête comme ci-dessous. Ici 1 dit " revenir sur le dernier engagement."

git revert HEAD~1..HEAD

et ensuite faire git push

si la situation est un urgent un , et vous voulez juste faire ce que l'auteur de la question a demandé dans un rapide et sale façon, en supposant que votre projet est dans le répertoire "mon projet":

1. copiez tout le répertoire et appelez-le autrement, comme "My project - copy"

2. :

   git reset --hard [first-4-letters&numbers-of-commit's-SHA]
   

vous alors deux versions de votre système... vous pouvez examiner ou copier ou modifier les fichiers d'intérêt, ou n'importe quoi, de la propagation précédente. Vous pouvez jeter les fichiers sous "mon projet" copie, si vous avez décidé que le nouveau travail n'allait nulle part...

la chose évidente si vous voulez continuer avec l'état du projet sans réellement rejeter le travail puisque cette propagation récupérée est de renommer votre répertoire à nouveau: supprimer le projet contenant la propagation retrouvée (ou lui donner un nom temporaire) et renommer votre répertoire "my project - copy" de nouveau en "my project". Alors probablement faire un autre s'engager assez rapidement.

Git est une création brillante, mais vous ne pouvez pas simplement "ramasser sur la mouche": aussi des gens qui tentent de l'expliquer trop souvent suppose la connaissance préalable des autres VCS [Systèmes de Contrôle de Version] et plonger trop profond bien trop tôt, et de commettre d'autres crimes, comme l'utilisation des termes interchangeables pour "vérifier" - des façons qui semblent parfois presque calculées pour embrouiller un débutant.

pour vous épargner beaucoup de stress, vous avez à peu près à lire un livre sur Git - je recommande " contrôle de Version avec Git " . Et si vous pouvez me faire confiance (ou plutôt mes cicatrices) quand je dis "doit", il s'ensuit que vous pourriez aussi bien le faire maintenant . Une grande partie de la complexité du Git vient de la ramification et du remergage. Mais à partir de votre question il y a aucune raison pour que les gens devraient vous aveugler avec la science .

surtout si, par exemple, c'est une situation désespérée et que vous êtes un débutant avec Git!

PS: une autre pensée: il est (maintenant) en fait assez simple de garder le dépôt Git ("repo") dans un répertoire autre que celui avec les fichiers de travail. Cela signifierait que vous n'auriez pas à copier l'intégralité du dépôt Git en utilisant la procédure rapide ci-dessus. & sale solution. Voir la réponse de Fryer en utilisant -- separate-git-dir ici . soyez averti , cependant: si vous avez un dépôt de" répertoire séparé "que vous ne copiez pas, et que vous faites une réinitialisation sur papier, toutes les versions postérieures à la réinitialisation seront perdues à jamais, à moins que vous ayez, comme vous le devriez absolument, sauvegardé régulièrement votre dépôt, de préférence dans le cloud (par exemple Google Drive ) entre autres.

essayer de réinitialiser à la propagation désirée -

git reset <COMMIT_ID>

(pour vérifier L'utilisation de COMMIT_ID git log )

cela réinitialisera tous les fichiers modifiés en état non ajouté.

Maintenant vous pouvez checkout tous les fichiers non ajoutés par

git checkout .

cochez git log pour vérifier vos modifications.

mise à JOUR

Si vous avez seul et unique s'engager dans votre pension, essayez

git update-ref -d HEAD

Que vos commits sont poussés à distance, vous devez les supprimer. Laissez-moi supposer que votre branche se développe et qu'elle est poussée au-dessus de l'origine.

vous devez d'abord supprimer développer d'origine:

git push origin :develop (note the colon)

alors vous devez obtenir développer au statut que vous voulez, laissez-moi supposer que le hash de commit est EFGHIJK:

git reset --hard EFGHIJK

enfin, push développer à nouveau:

git push origin develop

si vous voulez corriger une erreur dans le dernier commit, une bonne alternative serait d'utiliser la commande git commit --amend . Si la dernière commit n'est pas pointée par une référence, cela fera l'affaire, car cela créera une commit avec le même parent que la dernière commit. S'il n'y a pas de référence à la dernière commission, elle sera simplement rejetée et cette commission sera la dernière. C'est une bonne façon de corriger les propagations sans les Inverser. Toutefois, il a ses propres limitation.

attention! cette commande peut causer la perte de l'historique de propagation, si l'Utilisateur a mis la mauvaise propagation par erreur. Toujours avoir en sauvegarde supplémentaire de votre git certains où d'autre, juste au cas où si vous faites des erreurs, que vous êtes un peu plus en sécurité. :)

j'ai eu un problème similaire et je voulais revenir à L'engagement précédent. Dans mon cas, je n'ai pas eu l'intention de conserver les nouveaux commits et j'ai donc utilisé Hard .

C'est comme ça que je l'ai fait:

git reset --hard CommitId && git clean -f

cela va revenir sur le dépôt local, ici après avoir utilisé git push -f va mettre à jour le dépôt distant.

git push -f

tout d'abord, obtenir la chaîne qui identifient le commit dans une certaine date, en faisant:

git rev-list -n 1 --before="2009-07-27 13:37" origin/master

il imprime l'identifiant de propagation, prend la chaîne (par exemple XXXX) et fait:

git checkout XXXX