Comment rétablir un dépôt Git à une précédente livraison?

https://stackoverflow.com/questions/4114095

29-09-2019
|

Question

Comment puis-je reviens de mon état actuel à un instantané pris sur un certain commets?

Si je fais git log, je reçois la sortie suivante:

$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <me@me.com>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <me@me.com>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <me@me.com>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <me@me.com>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

Comment Revert au commettras du 3 Novembre, à savoir commettras 0d1d7fc?

La solution

Cela dépend beaucoup de ce que vous entendez par « revert ».

passer temporairement à un autre allouent

Si vous voulez temporairement y revenir, imbécile, puis revenir à l'endroit où vous êtes, tout ce que vous devez faire est de vérifier la validation souhaitée:

# This will detach your HEAD, that is, leave you with no branch checked out:
git checkout 0d1d7fc32

Ou si vous voulez faire commits pendant que vous êtes là, allez-y et faire une nouvelle branche pendant que vous y êtes:

git checkout -b old-state 0d1d7fc32

Pour revenir à l'endroit où vous étiez, il suffit de cocher la branche que vous étiez à nouveau. (Si vous avez apporté des modifications, comme toujours lors du passage des branches, vous aurez à traiter avec eux le cas échéant, vous pouvez réinitialiser les jeter;. Vous pouvez cacher, la caisse, Stash pop pour les emmener avec vous, vous pourriez commettre les à une succursale si vous voulez une succursale.)

Hard supprimer non publié commits

Si, d'autre part, vous voulez vraiment débarrasser de tout ce que vous avez fait depuis lors, il y a deux possibilités. Un, si vous n'avez publié aucune de ces commits, il suffit de réinitialiser:

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

Si vous vous trompez, vous avez déjà JETTE vos changements locaux, mais vous pouvez au moins revenir à l'endroit où vous étiez avant en remettant à zéro à nouveau.

Annuler commits publié avec de nouveaux commits

Par contre, si vous avez publié le travail, vous ne voulez probablement pas réinitialiser la branche, puisque c'est de réécrire l'histoire de façon efficace. Dans ce cas, vous pouvez en effet revenir les commits. Avec Git, Revert a une signification très spécifique: créer un commettras avec le patch inverse pour annuler le. De cette façon, vous ne réécrivez pas l'histoire.

# This will create three separate revert commits:
git revert a867b4af 25eee4ca 0766c053

# It also takes ranges. This will revert the last two commits:
git revert HEAD~2..HEAD

#Similarly, you can revert a range of commits using commit hashes:
git revert a867b4af..0766c053 

# Reverting a merge commit
git revert -m 1 <merge_commit_sha>

# To get just one, you could use `rebase -i` to squash them afterwards
# Or, you could do it manually (be sure to do this at top level of the repo)
# get your index and work tree into the desired state, without changing HEAD:
git checkout 0d1d7fc32 .

# Then commit. Be sure and write a good message describing what you just did
git commit

Le git-revert manpage couvre en fait beaucoup de cela dans sa description. Autre lien utile est cette section git-scm.com discuter git -revert .

Si vous décidez ne voulais pas revenir après tout, vous pouvez revenir le Revert (comme décrit ici) ou remettre d'avant le retour en arrière (voir la section précédente).

Vous pouvez également trouver cette réponse utile dans ce cas:
Comment retourner HEAD à un emplacement précédent? (Tête Isolé)

Autres conseils

Beaucoup de réponses compliquées et dangereuses ici, mais il est en fait simple:

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

Cela reviendra tout à l'arrière de la tête de la commettras hachage, ce qui signifie qu'il va recréer l'état qui engage dans l'arbre de travail comme si tous les commits depuis avait été marchèrent en arrière. Vous pouvez ensuite engager l'arbre en cours, et il va créer une nouvelle marque commettez essentiellement équivalente à celle de vous engager « un retour arrière » à.

(Le drapeau --no-commit permet de revenir git tous les commits à passage unique, sinon vous serez invité à entrer un message pour chaque engagement dans la gamme, qui jonchent votre histoire avec de nouveaux commits inutiles.)

Ceci est un moyen sûr et facile à rollback à un état précédent . Aucune histoire est détruite, il peut donc être utilisé pour commits qui ont déjà été rendues publiques.

Rogue Coder?

travail sur votre propre et juste veulent travailler? Suivez ces instructions ci-dessous, ils ont travaillé de manière fiable pour moi et beaucoup d'autres pendant des années.

Travailler avec les autres? Git est compliquée. Lire les commentaires ci-dessous cette réponse avant de faire quelque chose d'irréfléchi.

Reverting CdT pour les plus récentes Engagez

Pour revenir à une validation précédente, sans tenir compte des modifications:

git reset --hard HEAD

où HEAD est la dernière validation dans votre branche courante

Le Revenant copie de travail à un ancien Engagez

Pour revenir à une commettras qui est plus ancienne que la plus récente commettras:

# 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

Crédits vont à une question similaire Stack Overflow, Revert à une validation par un hachage SHA dans Git? .

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! Il est simple, rapide et efficace!

Remarque: Comme mentionné dans les commentaires ne le faites pas si vous partagez votre succursale avec d'autres personnes qui ont des copies des anciens commits

En outre des commentaires, si vous vouliez une méthode moins « de Ballzy » vous pouvez utiliser

git clean -i

Avant de répondre à de let ajouter un peu de fond, expliquant que ce HEAD est.

`First of all what is HEAD?`

HEAD est tout simplement une référence à la validation en cours (dernier) sur la branche actuelle. Il ne peut y avoir un seul HEAD à un moment donné (à l'exception de git worktree).

Le contenu de HEAD est stocké à l'intérieur de .git/HEAD, et il contient 40 octets SHA-1 du commit courant.

`detached HEAD`

Si vous n'êtes pas sur le dernier commit -. Ce qui signifie que HEAD pointe vers un avant allouent 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 depuis le HEAD ne pointe pas au bout de la branche courante:

Quelques options sur la façon de récupérer d'une tête détachée:

`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

Cela checkout nouvelle branche pointant vers le désiré commettre. Cette commande à la caisse 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 aussi bien. git reflog affichera tout changement mis à jour le HEAD et vérifier l'entrée reflog souhaitée établira le dos de HEAD à ce commit.

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

git reflog
git checkout HEAD@{...}

Cela vous revenez à votre engagement souhaité

`git reset HEAD --hard <commit_id>`

« Déplacer » le dos de la tête à l'engagement souhaité.

# 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 qui commande fait quoi. Comme vous pouvez le voir il reset && checkout modifier le HEAD.

Si vous voulez « uncommit », effacer le dernier message de validation, et mettre les fichiers modifiés dans la mise en scène de retour, vous utilisez la commande:

git reset --soft HEAD~1

--soft indique que les fichiers non engagés doivent être conservés sous forme de fichiers de travail opposés à --hard qui les mettre au rebut.
HEAD~1 est la dernière livraison. Si vous voulez rollback 3 commits vous pouvez utiliser HEAD~3. Si vous souhaitez revenir à une numéro de révision spécifique, vous pouvez aussi le faire en utilisant son hachage SHA.

Cette commande est extrêmement utile dans les situations où vous avez commis la mauvaise chose et que vous voulez annuler cette dernière livraison.

Source: http://nakkaya.com/2009/09/24/git- suppression-dernière COMMIT /

J'ai essayé beaucoup de façons de revenir sur des changements locaux dans Git, et il semble que cela fonctionne le mieux si vous voulez juste de revenir au dernier état COMMIT.

git add . && git checkout master -f

Brève description:

Il ne crée aucun commits comme git revert fait.
Il ne se détache pas votre tête comme git checkout <commithashcode> fait.
il remplace tous vos changements locaux et supprimer tous les fichiers ajoutés depuis la dernière validation dans la branche.
Il ne fonctionne qu'avec les noms de branches, de sorte que vous pouvez revenir seulement à la dernière commettras dans la branche ainsi.

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

git add . && git reset --hard HEAD

où les points de la tête aux dernières engagent à vous branche actuelle.

Il est le même code que boulder_ruby suggéré, mais je l'ai ajouté git add . avant git reset --hard HEAD pour effacer tous les nouveaux fichiers créés depuis la dernière livraison depuis c'est ce que la plupart des gens attendent que je crois en revenir à la dernière commit.

Vous pouvez le faire par les deux commandes suivantes:

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

Il va supprimer votre Git précédente livraison.

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

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

Ensuite, il enregistrera vos modifications.

OK retour à précédente livraison en git est assez facile ...

retour Revert sans garder les modifications:

git reset --hard <commit>

retour Revert avec le maintien les modifications:

git reset --soft <commit>

Expliquez: avec git reset, vous pouvez réinitialiser à un état spécifique, il est courant de l'utiliser avec un hachage commit que vous voyez ci-dessus.

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

- douce

Le drapeau par défaut comme expliqué, pas besoin de fournir, ne change pas l'arbre de travail, mais ajouter tous les modifications de fichiers prêts à engager, vous allez revenir à l'état de validation qui change les fichiers se unstaged.

- dur

Soyez prudent avec ce drapeau, il remet à zéro l'arbre de travail et tous les changements apportés aux fichiers et tous chenillés sera parti!

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

En supposant que vous parlez maître et sur cette branche respective (qui a dit, cela pourrait être une branche de travail, vous êtes concernés par):

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

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

J'ai trouvé la réponse de dans un billet de blog (aujourd'hui n'existe plus)

Notez que ceci est Remise à zéro et forcer le changement à la télécommande, de sorte que si les autres membres de votre équipe ont déjà tiré git, vous causer des problèmes pour eux. Vous détruisez l'histoire du changement, ce qui est une raison importante pour laquelle les gens utilisent git en premier lieu.

Il vaut mieux utiliser Revert (voir d'autres réponses) que remise à zéro. Si vous êtes une équipe d'un homme, alors il n'a probablement pas.

Rien ici a fonctionné pour moi à part cette combinaison exacte:

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

clé ici est la force poussée, aucun commits supplémentaire / commits etc.

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 script shell Bash 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

Ce tout revient à l'état précédent, y compris vos créations de répertoire, et les suppressions, l'engager à votre succursale et vous conservez l'histoire, mais vous l'avez retourné de nouveau à la même structure de fichier. Pourquoi Git n'a pas de git revert --to <hash> est au-delà de moi.

Alternatives supplémentaires aux solutions de Jefromi

solutions de Jefromi sont certainement les meilleurs, et vous devriez certainement les utiliser. Cependant, par souci d'exhaustivité, je voulais aussi montrer ces autres solutions alternatives qui peuvent également être utilisés pour récupérer un commettras (dans le sens que vous Créer un commit que les changements de dénoue dans précédent engagent , tout comme ce que fait git revert).

Pour être clair, ces solutions de rechange ne sont pas la meilleure façon de revenir commits , Revert à une validation par un hachage SHA dans 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 doux quitteront réinitialisations l'état de la précédente livraison mis en scène dans l'index / mise en scène de la zone, que vous pouvez ensuite engager.

Alternative 2: Supprimer l'arborescence actuelle et remplacer par le nouveau

Cette solution vient de la solution de svick Commander vieux commit et faire un commit :

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

De même à l'alternative n ° 1, il reproduit l'état de <commit> dans la copie de travail en cours. Il est nécessaire de faire git rm d'abord parce que git checkout ne supprime pas les fichiers qui ont été ajoutés depuis <commit>.

Voici un beaucoup plus simple façon de revenir à une précédente livraison (et l'avoir dans un état UNCOMMITED, à voir avec ce que vous voulez):

git reset HEAD~1

Donc, pas besoin d'engager ids et ainsi de suite:)

Il existe une commande (pas une partie de Git de base, mais il est dans le paquet git-extra) spécifiquement pour revenir et mise en scène vieux commits:

git back

Par homme , il peut également être utilisé en tant que tel:

# Remove the latest three commits
git back 3

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

git push -f ...

Et non seulement git push.

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

Tirez la dernière version de votre dépôt de Bitbucket en utilisant la git pull --all commande.
Exécuter la commande git log avec -n 4 de votre terminal. Le nombre après l'-n détermine le nombre de commits dans le journal à partir de la plus récente validation dans votre histoire locale.

$ git log -n 4
Réinitialiser 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 commits que vous voulez prendre l'arrière de la tête. Dans l'exemple suivant la tête serait en retrait d'un engager, à la dernière commettras dans l'histoire du référentiel:
Appuyez sur la modification repo git en utilisant git push --force pour pousser la force le changement.

Si vous voulez dépôt git commit précédent

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

Revert les plus récents commit et en ignorant tous les changements locaux:

git reset --hard HEAD

Sélectionnez votre engagement requis, et le vérifier par

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

jusqu'à ce que vous obtenez le devez engager. Pour faire le point HEAD pour que, faire

git reset --hard HEAD~1

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

Pour conserver les modifications de la précédente engagent à HEAD et passer à la précédente livraison, faites:

git reset <SHA>

Si les modifications ne sont pas tenus de la précédente engager à HEAD et à seulement annuler toutes les modifications, faites:

git reset --hard <SHA>

Pour nettoyer complètement le répertoire d'un codeur à partir des modifications accidentelles, nous avons utilisé:

git add -A .
git reset --hard HEAD

Juste git reset --hard HEAD va se débarrasser des modifications, mais il ne se débarrassera pas de fichiers « nouveaux ». Dans leur cas, ils avaient accidentellement traîné un dossier quelque part importante au hasard, et tous ces dossiers ont été traités comme nouveau par Git, donc un reset --hard ne le répare pas. En exécutant le git add -A . avance, explicitement les suivis tout avec git, être effacé par la remise à zéro.

Ceci est une autre façon de directement remis à un récent engagement

git stash
git stash clear

Il efface directement tous les changements que vous avez fait des depuis la dernière validation.

PS: Il a un petit problème; il supprime également tous les changements vous stash récemment stockés. Ce que je pense que dans la plupart des cas ne devrait pas importer.

Je crois que certaines personnes peuvent venir à cette question qui veulent savoir comment procéder à la restauration des changements engagés qu'ils ont fait dans leur maître - à savoir tout jeter et revenir à l'origine / maître, auquel cas, faites ceci:

git reset --hard origin/master

https://superuser.com/questions/273172/how-to -reset-maître à l'origine maître

Si la situation est un un urgent , et vous voulez juste faire ce que le questionneur a demandé d'une manière rapide et sale , en supposant que votre projet est sous le répertoire « mon projet ":

Copiez le répertoire entier et l'appeler autre chose, comme "mon projet - copie"

Do:

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

Vous avez alors deux versions sur votre système ... vous pouvez examiner ou copier ou modifier les fichiers d'intérêt, ou autre, de la précédente commettre. Vous pouvez rejeter complètement les fichiers sous la rubrique « mon projet - copie », si vous avez décidé le nouveau travail allait nulle part ...

La chose évidente si vous voulez poursuivre l'état du projet, sans jeter réellement le travail puisque ce récupéré commit est de renommer à nouveau votre répertoire: Supprimer le projet contenant le Récupéré commettras (ou lui donner un nom temporaire) et renommer « mon projet - copier » back répertoire pour « mon projet ». Alors probablement faire une autre commettras assez rapidement.

Git est une création brillante mais vous ne pouvez pas simplement « ramasser à la volée »: aussi des gens qui tentent de l'expliquer beaucoup trop souvent prendre connaissance préalable d'autres VCS [Version Control Systems ] et Delve beaucoup trop profond beaucoup trop tôt, et commettre d'autres crimes, comme l'utilisation des termes interchangeables pour « vérifier » - des moyens qui semblent presque calculés parfois confondre un débutant.

Pour vous épargner beaucoup de stress que vous avez à peu près avoir à lire un livre sur Git - Je vous recommande " version Control with Git ". Et si vous pouvez me faire confiance (ou plutôt mes cicatrices) quand je dis « devoir », il suit que vous pourriez aussi bien le faire MAINTENANT . Une grande partie de la complexité de Git vient de ramification puis réémergentes. Mais à partir de votre question, il y a aucune raison pour laquelle les gens devraient être aveuglent avec la science .

Surtout si, par exemple, la situation est 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 pour garder le dépôt Git ( « repo ») dans un répertoire autre que celui avec les fichiers de travail. Cela signifie que vous n'auriez pas à copier l'intégralité du dépôt Git en utilisant la solution rapide et sale ci-dessus. Voir la réponse par Fryer en utilisant --separate-git-dir ici . Soyez averti , cependant: Si vous avez un référentiel « séparé-répertoire » que vous ne copiez pas, et vous faire un redémarrage à froid, toutes les versions ultérieures à la remise à zéro Livrer être perdu pour toujours, à moins que vous avez, comme vous devez absolument, sauvegarder régulièrement votre dépôt, de préférence vers le cloud (par exemple Google Drive ) entre autres.

Sur ce sujet de « la sauvegarde du Cloud », l'étape suivante consiste à ouvrir un compte (gratuit bien sûr) avec GitHub ou (mieux à mon avis) gitlab ce. Vous pouvez alors faire régulièrement une commande git push pour sauvegarder votre repo Cloud « correctement ». Mais encore une fois, en parlant de cela peut être trop trop tôt.

Revert est la commande rollback les commits.

git revert <commit1> <commit2>

Exemple:

git revert 2h3h23233

Il est capable de prendre vont de la tête comme ci-dessous. Ici, 1 dit "Revenir en arrière dernier commit".

git revert HEAD~1..HEAD

puis faire git push

Revert Les plus récentes Engagez:

git reset --hard HEAD

HEAD est tout simplement une référence à la validation en cours (dernier) sur la branche actuelle. Il ne peut y avoir un seul HEAD à un moment donné.

Revert à un ancien Commit: Le meilleur moyen de restaurer une ancienne version est d'utiliser la commande reset:

# Resets index to former commit
git reset 56e05fced 

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

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

rembobine votre branche HEAD à la version spécifiée. Tous les commits qui sont venus après cette version sont effectivement annulées; votre projet est exactement comme il était à ce moment.

La commande reset est livré avec deux options, l'une des plus intéressantes étant le drapeau --soft. Si vous l'utilisez au lieu de --hard, Git gardera tous les changements dans les commits de « défaits » comme les modifications locales.

La restauration d'une révision dans un Nouvelle branche locale

Comme l'a dit, en utilisant la commande reset sur votre branche HEAD est une action tout à fait drastique: il supprimera toute commits (sur cette branche) qui sont venus après la révision spécifiée. Si vous êtes sûr que ce soit ce que vous voulez, tout va bien.

Cependant, il y a aussi un plus sûr façon si vous préférez laisser votre branche HEAD actuelle intacte. Étant donné que « branches » sont si pas cher et facile à Git, on peut facilement créer une nouvelle branche qui commence à cette ancienne révision:

git checkout -b old-project-state 0ad5a7a6

Normalement, la commande de commande est utilisé pour les branches seulement de commutation. Cependant, en fournissant le paramètre -b, vous pouvez également laisser créer une nouvelle branche (appelée ancien projet Etat dans cet exemple). Si vous ne voulez pas commencer à la révision HEAD actuelle, vous devez également fournir une validation de hachage - l'ancienne révision du projet que nous voulons restaurer

Vous avez maintenant une nouvelle branche nommée ancien projet Etat qui reflète l'ancienne version de votre projet -. Sans toucher ou même enlever toute autre commits ou branches

Essayez de réinitialiser le désirer commettre -

git reset <COMMIT_ID>

(pour vérifier COMMIT_ID utilisation git log)

Ceci permet de réinitialiser tous les fichiers modifiés à l'état ajouté un.

Maintenant, vous pouvez checkout tous les fichiers ajoutés par l'ONU

git checkout .

Vérifier git log pour vérifier vos modifications.

UPDATE

Si vous avez unique commit dans votre repo, essayez

git update-ref -d HEAD

Comme vos commits sont poussés à distance, vous devez les supprimer. Permettez-moi de votre branche suppose est de développer et est emmanché sur l'origine.

Vous devez d'abord supprimer le développement d'origine:

git push origin :develop (note the colon)

Ensuite, vous devez obtenir développer le statut que vous voulez, laissez-moi suppose le hachage commettras est EFGHIJK:

git reset --hard EFGHIJK

Enfin, appuyez à nouveau développer:

git push origin develop

Attention! Cette commande peut provoquer la perte de commettre l'histoire, si l'utilisateur a mis le tort de commettre à tort. Toujours en sauvegarde supplémentaire de votre git certains où d'autre juste au cas où si vous le faites des erreurs, que vous êtes un peu plus sûr. :)

J'ai eu problème similaire et je voulais revenir au plus tôt engager. Dans mon cas, je n'intetessered garder plus récente commettras donc je Hard utilisé.

Voici comment je l'ai fait:

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

Cela reviendra sur dépôt local, ici après avoir utilisé git push -f mettra à jour dépôt distant.

git push -f

Si vous voulez corriger une erreur dans le dernier commit une bonne alternative serait d'utiliser git commit --amend commande . Si le dernier commit n'est pas dirigée par une référence, cela fera l'affaire, car il crée un commit avec le même parent que le dernier commit. S'il n'y a aucune référence à la dernière validation, il sera simplement jeté et ce commit sera la dernière validation. Ceci est un bon moyen de corriger commits sans revenir commits. Cependant, il a ses propres limites.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow