Comment retourner un dépôt Git à une propagation précédente

comment revenir de mon état actuel à un instantané réalisé sur une certaine commit?

si je fais git log , alors j'obtiens la sortie suivante:

$ 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 à la commit à partir du 3 novembre, i.e. commit 0d1d7fc ?

6178
demandé sur Peter Mortensen 2010-11-06 19:58:14
la source

30 ответов

Cela dépend beaucoup de ce que vous entendez par "revenir en arrière".

passer temporairement à une autre commit

Si vous voulez temporairement revenir à elle, l'imbécile, alors revenez là où vous êtes, tout ce que vous avez à faire est de vérifier le souhaité s'engager:

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

ou si vous voulez faire des commits pendant que vous y êtes, allez-y et faites une nouvelle branche pendant que vous y êtes:

git checkout -b old-state 0d1d7fc32

pour retourner à là où tu étais, regarde juste la branche où tu étais encore. (Si vous avez fait des changements, comme toujours lorsque vous changez de branche, vous devrez les traiter comme il se doit. Vous pouvez réinitialiser les jeter; vous pourriez cachette, la caisse, stash pop de les prendre avec vous: vous pourriez vous engager à une branche de là, si vous voulez une branche.)

supprimer Dur inédits s'engage

Si, d'autre part, vous voulez vraiment vous débarrasser de tout ce que vous avez fait depuis, il y a deux possibilités. Un, si vous n'avez publié aucun 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 merdez, vous avez déjà jeté vos changements locaux, mais vous pouvez au moins revenir à ce que vous étiez avant en réinitialisant à nouveau.

Annuler publié s'engage avec les nouveaux commits

d'un autre côté, si vous avez publié le travail, vous ne voulez probablement pas réinitialiser la branche, puisque c'est effectivement réécriture de l'histoire. Dans ce cas, vous pouvez en effet revenir sur les propagations. Avec git, revert a une signification très spécifique: créer une propagation avec le patch inverse pour l'annuler. De cette façon, vous n'avez pas réécrire 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. Un autre lien utile est ce git-scm.com section discussion git-revert .

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

vous pouvez également trouver cette réponse utile dans ce cas:

comment déplacer HEAD back vers un emplacement précédent? (Tête détachée)

8014
répondu Cascabel 2018-04-04 20:54:07
la source

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 [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 similaire sur le débordement de la pile, Revenir à une validation par un hachage SHA dans Git? .

1308
répondu boulder_ruby 2017-05-23 15:18:27
la source

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.

1267
répondu Yarin 2014-06-29 00:12:34
la source

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

161
répondu Pogrindis 2015-07-16 18:31:10
la source

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 .

Enter image description here

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:

Enter image description here


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 [email protected]{...}

Cela va vous ramener à votre souhaité s'engager

Enter image description here


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 .

Enter image description here

115
répondu CodeWizard 2018-07-04 22:25:17
la source

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 /

107
répondu Stephen Ostermiller 2014-03-04 21:25:52
la source

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.

99
répondu Roman Minenok 2014-06-25 00:08:20
la source

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.

83
répondu kiran boghra 2016-07-03 09:30:27
la source

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

53
répondu Lance Caraccioli 2014-06-29 04:13:03
la source

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 [email protected]{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> .

50
répondu 2 revsuser456814 2017-05-23 14:47:32
la source

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 :)

48
répondu Paul Walczewski 2016-07-03 13:56:38
la source

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:

git reset to a commit

45
répondu Alireza 2017-08-02 16:41:55
la source

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 .

43
répondu markreyes 2016-07-03 13:58:59
la source

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.

43
répondu serdarsenay 2018-04-23 04:47:59
la source

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

git push -f ...

et pas seulement git push .

32
répondu sivi 2013-09-28 23:07:07
la source

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
31
répondu Shadow Man 2014-06-29 00:19:45
la source

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.

24
répondu tonythomas01 2014-06-28 23:51:32
la source

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

git reset --hard HEAD
22
répondu Mohammed Irfan Tirupattur 2018-07-04 22:28:44
la source

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>
19
répondu Vishnu Atrai 2016-07-03 13:21:53
la source

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.

19
répondu Chris Moschini 2016-07-03 13:55:25
la source

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.

19
répondu Point Networks 2016-07-03 13:57:18
la source

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

18
répondu nevster 2017-03-20 13:18:20
la source

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
18
répondu Nanhe Kumar 2018-07-05 23:56:59
la source

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

15
répondu Sireesh Yarlagadda 2016-05-27 09:05:57
la source

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.

12
répondu mike rodent 2017-05-23 14:55:13
la source

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

11
répondu optimistanoop 2018-04-17 13:02:40
la source

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
10
répondu George Ninan 2017-04-19 10:18:34
la source

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.

9
répondu Upul Doluweera 2015-07-01 14:35:54
la source

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
9
répondu maytham-ɯɐɥʇʎɐɯ 2018-02-02 16:51:57
la source

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
8
répondu Luca C. 2018-01-01 19:45:37
la source

Autres questions sur git git-checkout git-reset git-revert