dépot - git push




Comment convertir un dépôt Git en un commit précédent (20)

Mise en garde! Cette commande peut entraîner la perte de l’historique des validations si l’utilisateur commet une erreur par erreur. Ayez toujours une sauvegarde supplémentaire de votre git ailleurs qu'au cas où vous feriez des erreurs, vous serez un peu plus en sécurité. :)

J'ai eu le même problème et je voulais revenir à la version précédente de Commit. Dans mon cas, je n'étais pas intetessered pour garder le plus récent commettre par conséquent j'ai utilisé Hard.

Voici comment je l'ai fait:

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

Cela reviendra sur le référentiel local, ici après utilisation, git push -fmettra à jour le référentiel distant.

git push -f

Comment revenir de mon état actuel à un instantané créé sur un certain commit?

Si je fais un git log , j'obtiens le résultat suivant:

$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <[email protected]>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <[email protected]>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <[email protected]>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <[email protected]>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

Comment revenir au commit à partir du 3 novembre, c.-à-d. Commit 0d1d7fc ?


Alternatives supplémentaires aux solutions de Jefromi

Les solutions de Jefromi sont définitivement les meilleures et vous devez absolument les utiliser. Cependant, par souci d'exhaustivité, je voulais également montrer ces autres solutions alternatives qui peuvent également être utilisées pour annuler un commit (en ce sens que vous créez un nouveau commit qui annule les modifications du commit précédent , comme ce que fait git revert ). .

Pour être clair, ces alternatives ne sont pas le meilleur moyen de revenir en arrière , tout comme les solutions de Jefromi , mais je tiens à souligner que vous pouvez également utiliser ces autres méthodes pour obtenir le même résultat que git revert .

Alternative 1: réinitialisations matérielles et logicielles

Ceci est une version très légèrement modifiée de la solution de Charles Bailey pour Revenir à un commit 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 [email protected]{1}

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

Cela fonctionne essentiellement en utilisant le fait que les réinitialisations logicielles laisseront l'état de la validation précédente dans la zone d'index / staging, que vous pouvez ensuite valider.

Alternative 2: Supprimer l'arborescence actuelle et la remplacer par la nouvelle

Cette solution provient de la solution de svick pour Checkout old commit et en faire un nouveau commit :

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

De manière similaire à la variante n ° 1, ceci reproduit l'état de <commit> dans la copie de travail actuelle. Il est nécessaire de faire d'abord git rm car git checkout ne supprimera pas les fichiers ajoutés depuis <commit> .


Rétablissement de la copie de travail à la plus récente validation

Pour revenir à un commit précédent, en ignorant les modifications:

git reset --hard HEAD

où HEAD est le dernier commit de votre branche actuelle

Rétablir la copie de travail sur une ancienne publication

Pour revenir à un commit plus ancien que le plus récent:

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

# Moves pointer back to previous HEAD
git reset --soft [email protected]{1}

git commit -m "Revert to 56e05fced"

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

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


Après toutes les modifications, lorsque vous appuyez sur toutes ces commandes, vous devrez peut-être utiliser:

git push -f ...

Et pas seulement git push .


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 retourner du HEAD au hash de commit, ce qui signifie qu'il va recréer cet état de commit dans l'arbre de travail comme si chaque commit avait été repris depuis. Vous pouvez ensuite valider l’arborescence en cours et créer une nouvelle validation essentiellement équivalente à la validation que vous avez "rétablie".

(Le drapeau --no-commit permet à git de revenir en arrière sur tous les commits. Sinon, un message vous sera demandé pour chaque commit de la plage, incrustant votre historique de nouveaux commits inutiles.)

C'est un moyen sûr et facile de revenir à un état antérieur . Aucune histoire n'est détruite, elle peut donc être utilisée pour des commits déjà rendus publics.


Cela dépend beaucoup de ce que vous entendez par "revenir".

Passer temporairement à un commit différent

Si vous voulez y retourner temporairement, batifoler, puis revenir à votre position actuelle, il vous suffit de vérifier le commit voulu:

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

Ou si vous voulez vous engager pendant que vous y êtes, allez-y et créez une nouvelle branche pendant que vous y êtes:

git checkout -b old-state 0d1d7fc32

Pour revenir à l'endroit où vous étiez, vérifiez simplement la branche dans laquelle vous vous trouviez. (Si vous avez apporté des modifications, comme toujours lorsque vous changez de branche, vous devrez les gérer comme il convient. Vous pouvez réinitialiser pour les jeter. Vous pouvez stocker, sortir, cacher des pop pour les emporter; vous pouvez commettre si vous voulez une succursale là-bas)

Supprimer durement les commits non publiés

Si, par contre, vous voulez vraiment vous débarrasser de tout ce que vous avez fait depuis lors, il existe deux possibilités. Premièrement, si vous n'avez publié aucune de ces commits, réinitialisez simplement:

# 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à rejeté vos modifications locales, mais vous pouvez au moins retrouver votre état antérieur en réinitialisant à nouveau.

Annuler les commits publiés avec les nouveaux commits

D'un autre côté, si vous avez publié le travail, vous ne voudrez probablement pas réinitialiser la branche, car il s'agit en réalité d'une réécriture de l'historique. Dans ce cas, vous pouvez en effet annuler les commits. Avec Git, revert a une signification très spécifique: créez un commit avec le patch inverse pour l'annuler. De cette façon, vous ne réécrivez aucune 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

La page de manuel git-revert couvre en fait beaucoup de choses dans sa description. Un autre lien utile est cette section de git-scm.com traitant de git-revert .

Si vous décidez que vous ne voulez pas revenir après tout, vous pouvez annuler le retour (comme décrit ici) ou le rétablir avant le retour (voir la section précédente).

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


Il existe une commande (qui ne fait pas partie du noyau Git, mais qui se trouve dans le paquetage git-extras ) spécifiquement pour annuler et mettre en place les anciens commits:

git back

Par la page de manuel , il peut également être utilisé comme tel:

# Remove the latest three commits
git back 3

J'ai essayé de nombreuses manières de restaurer les modifications locales dans Git, et il semble que cela fonctionne le mieux si vous souhaitez simplement revenir au dernier état de validation.

git add . && git checkout master -f

Brève description:

  • Il ne créera pas de commits comme le fait git revert .
  • Il ne détachera PAS votre tête comme le fait git checkout <commithashcode> .
  • Il annulera toutes vos modifications locales et supprimera tous les fichiers ajoutés depuis la dernière validation de la branche.
  • Cela fonctionne uniquement avec les noms de branches, vous pouvez donc revenir uniquement à la dernière validation dans la branche.

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

git add . && git reset --hard HEAD

où HEAD pointe sur le dernier commit dans votre branche actuelle.

C'est le même code que celui suggéré par boulder_ruby, mais j'ai ajouté git add . avant la git reset --hard HEAD pour effacer tous les nouveaux fichiers créés depuis le dernier commit puisque c’est ce à quoi la plupart des gens s’attendent, je crois, lors du retour au dernier commit.


Rien ici ne fonctionnait pour moi en dehors de cette combinaison exacte:

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

La clé ici est de forcer le push, pas de commits / commits de commit supplémentaires, etc.


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 obteniez le commit requis. Pour faire le point HEAD à cela, faites

git reset --hard HEAD~1

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


Supposons que vous ayez 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éez un script shell Bash pour rétablir 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 ramène tout à l’état précédent, y compris les créations de fichiers et de répertoires, et les suppressions, le commet dans votre branche et vous conservez l’historique, mais vous le rétablissez dans la même structure de fichiers. Pourquoi Git n'a pas de git revert --to <hash> me dépasse.


Voici un moyen beaucoup plus simple de revenir à un commit précédent (et de le laisser dans un état non dédié, pour en faire ce que vous voudrez):

git reset HEAD~1

Donc, pas besoin d'identifiants de commit, etc. :)


OK, revenir au commit précédent dans git est assez facile ...

Revenir en arrière sans conserver les modifications:

git reset --hard <commit>

Revenez en gardant les modifications:

git reset --soft <commit>

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

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

--doux

L'indicateur par défaut comme expliqué, il n'est pas nécessaire de le fournir, ne modifie pas l'arborescence de travail, mais ajoute tous les fichiers de modifications prêts à être validés, de sorte que vous reveniez au statut de validation des modifications apportées aux fichiers sans décomposition.

--difficile

Soyez prudent avec cet indicateur, il réinitialise l'arborescence de travail et toutes les modifications apportées aux fichiers suivis et tout sera parti!

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


Essayez de réinitialiser le commit désiré -

git reset <COMMIT_ID>

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

Cela réinitialisera tous les fichiers modifiés à l'état non ajouté.

Maintenant, vous pouvez checkouttous les fichiers non ajoutés par

git checkout .

Vérifiez git logpour vérifier vos modifications.

METTRE À JOUR

Si vous avez un seul et unique commit dans votre repo, essayez

git update-ref -d HEAD


Pour conserver les modifications du commit précédent dans HEAD et passer au commit précédent, procédez comme suit:

git reset <SHA>

Si des modifications ne sont pas requises de la précédente validation dans HEAD et que vous les supprimez, procédez comme suit:

git reset --hard <SHA>

Pour le retour en arrière (ou pour revenir en arrière):

  1. git revert --No-commit "code-à-supprimer" HEAD (par exemple, git revert --no-commit d57a39d HEAD)
  2. git commit
  3. git push

Essayez ci-dessus deux étapes, et si vous trouvez que c'est ce que vous voulez, alors git push.

Si vous trouvez quelque chose qui ne va pas, faites:

git revert --aide


Revenir est la commande pour annuler les commits.

git revert <commit1> <commit2> 

Échantillon:

git revert 2h3h23233

Il est capable de prendre une plage de la tête comme ci-dessous. Ici, 1 dit "rétablir le dernier commit".

git revert HEAD~1..HEAD

et ensuite faire git push


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

  1. Extrayez la dernière version de votre référentiel à partir de Bitbucket à l'aide de la git pull --allcommande.

  2. Exécutez la commande git log avec -n 4 à partir de votre terminal. Le nombre après le -n détermine le nombre de validations dans le journal à partir de la validation la plus récente de votre historique local.

    $ git log -n 4

  3. Réinitialisez la tête de l'historique de votre référentiel en utilisant git reset --hard HEAD~Noù N est le nombre de commits que vous souhaitez récupérer. Dans l'exemple suivant, l'en-tête serait initialisé d'une sauvegarde, à la dernière validation de l'historique du référentiel:

  4. Poussez le changement vers git repo en utilisant git push --forcepour forcer le changement.

Si vous voulez que le dépôt git soit à un commit précédent

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

Revenez à la dernière validation en ignorant tous les changements locaux:

git reset --hard HEAD

Si la situation est urgente et que vous souhaitez simplement faire ce que l’interrogateur a demandé de manière rapide et sans fondement , en supposant que votre projet se trouve dans le répertoire "mon projet":

  1. Copiez tout le répertoire et appelez-le autrement, par exemple "mon projet - copier"

  2. Faire:

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

Vous avez alors deux versions sur votre système ... vous pouvez examiner, copier ou modifier des fichiers d’intérêt, ou autre, de la précédente validation. Vous pouvez complètement supprimer 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 abandonner le travail puisque ce commit récupéré est de renommer votre répertoire: Supprimez le projet contenant le commit extrait (ou donnez-lui un nom temporaire) et renommez votre mon projet - copie "répertoire vers" mon projet ". Ensuite, faites probablement un autre commit assez rapidement.

Git est une création brillante, mais vous ne pouvez pas simplement "le maîtriser à la volée": les personnes qui tentent de l'expliquer beaucoup trop souvent supposent avoir une connaissance préalable des autres [systèmes de contrôle de version] de VCS et plonger beaucoup trop tôt et trop profondément, et commettre d'autres crimes, comme utiliser des termes interchangeables pour «vérifier» - d'une manière qui semble parfois presque risquer de confondre un débutant.

Pour vous épargner beaucoup de stress, vous devez lire un livre sur Git. Je vous recommanderais "Contrôle des versions avec Git" . Et si vous pouvez vous fier à moi (ou plutôt à mes cicatrices) lorsque je dis "devoir", il en découle que vous pourriez aussi bien le faire MAINTENANT . Une grande partie de la complexité de Git provient de la création de branches, puis de la fusion. Mais d'après votre question, il n'y a aucune raison pour que les gens vous 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) très simple de conserver le référentiel Git ("repo") dans un répertoire autre que celui contenant les fichiers de travail. Cela signifierait que vous n'auriez pas à copier le référentiel Git entier à l'aide de la solution rapide et sale ci-dessus. Voir la réponse de Fryer en utilisant --separate-git-dir here . Soyez averti cependant: si vous avez un référentiel "répertoire séparé" que vous ne copiez pas et que vous effectuez une réinitialisation matérielle, toutes les versions ultérieures à la validation de la réinitialisation seront définitivement perdues, à moins que vous n'ayez, comme vous devez absolument, sauvegardez régulièrement votre référentiel, de préférence vers le cloud (par exemple, Google Drive ), entre autres.







git-revert