5 façons d'annuler les erreurs avec Git

Développement de logiciels, quelle que soit sa diffusion, il est inévitable de faire des erreurs. Mais la différence entre un bon programmeur et un programmeur ordinaire est qu'ils savent comment révoquer Erreur!

Si vous utilisez GIT comme système de contrôle de version, vous avez déjà un ensemble puissant "d'annuler des outils". Cet article vous montrera cinq façons puissantes d'annuler les erreurs avec Git!

points clés

• git permet aux utilisateurs d'annuler les erreurs de code en supprimant les modifications locales indésirables. Cela peut être fait en utilisant la commande git restore, qui réinitialise le fichier à son dernier état engagé. Pour plus de contrôle granulaire, vous pouvez utiliser le drapeau -p pour éliminer les modifications au niveau du patch.
La commande
• git log peut être utilisée pour restaurer un fichier spécifique à une version spécifique. L'utilisateur peut identifier le "commit d'erreur" d'un fichier corrompu, puis utiliser la commande git checkout pour restaurer le fichier dans une version avant le mauvais engagement.
L'outil
• git Reflog peut être utilisé pour restaurer les versions perdues ou les branches supprimées. Reflog enregistre le mouvement de tous les pointeurs de la tête dans le référentiel local, permettant à l'utilisateur de revenir à l'état précédent et de restaurer les données perdues.
• Les utilisateurs peuvent utiliser la commande git cherry-pick pour déplacer l'engagement dans une branche différente. Si le commit est dans la mauvaise branche, l'utilisateur peut consulter la branche correcte, déplacer le passé de validation, puis utiliser git reset pour supprimer le commit indésirable de la branche d'origine.

rejeter certains modifications locales

Le processus de codage est généralement déroutant. Parfois, cela ressemble à deux pas en avant et à un pas en arrière. En d'autres termes: une partie du code que vous écrivez est géniale… mais d'autres ne le sont pas. C'est là que Git peut vous aider: il vous permet de garder les bonnes pièces et de jeter les modifications dont vous n'avez plus besoin.

Regardons un exemple de scénario qui contient des changements "locaux" (c'est-à-dire des modifications qui n'ont pas encore été soumises).

Remarque: Pour une meilleure vue d'ensemble et une visualisation plus claire, j'ai utilisé le client Tower Git Desktop dans certaines captures d'écran. Vous n'avez pas besoin d'une tour pour apprendre ce tutoriel.

Résolvons d'abord le problème dans general.css. Les changements que nous avons apportés allaient complètement dans la mauvaise direction. Annuons tous les modifications et recréons le dernier statut de validation du fichier:

$ git restore css/general.css

Veuillez noter que, ou, je peux utiliser la commande git checkout pour obtenir le même résultat. Mais parce que git checkout a de nombreuses utilisations et significations différentes, je préfère utiliser la commande git restore légèrement mise à jour (elle se concentre uniquement sur ces types de tâches).

Notre deuxième question dans index.html est un peu délicate. Certaines des modifications que nous avons apportées dans ce fichier sont en fait bonnes, et seule une partie doit être sans papiers.

Idem, la commande git restore résoudra le problème - mais cette fois, vous devez utiliser le drapeau -p, car nous allons aller profondément dans le niveau "patch":

$ git restore css/general.css

git vous guidera alors et vous demandera - pour chaque changement dans dans ce fichier - si vous souhaitez le jeter.

Vous remarquerez que j'ai tapé "n" pour le premier changement de bloc (pour le garder) et "Y" pour le deuxième changement de bloc (pour le jeter). Une fois le processus terminé, vous verrez que seul le premier morceau de changements précieux est resté - comme nous le voulions!

Réinitialisez un fichier spécifique à son état précédent

Parfois, vous voudrez peut-être restaurer le fichier

spécifique dans la version spécifique . Par exemple, vous savez que a bien fonctionné à un moment donné dans le passé, mais pas maintenant. À ce stade, vous voulez revenir en arrière, mais seulement pour ce fichier spécifique, pas le projet entier! index.html

Nous devons d'abord savoir quelle version exacte que nous voulons restaurer. En utilisant l'ensemble de paramètres corrects, vous pouvez demander à la commande

afficher l'historique de votre fichier individuel: git log

$ git restore -p index.html

Cela montrera que les engins modifiés

, ce qui est très utile pour trouver la version "Bad Apple" qui fait apparaître le problème. index.html

Si vous avez besoin de plus d'informations et que vous souhaitez afficher le contenu

de ces engins , vous pouvez demander à Git d'utiliser le drapeau pour afficher les changements réels de ces engins: -p

$ git log -- index.html

Une fois que nous avons trouvé le mauvais engagement qui a provoqué la corruption de notre joli petit fichier, nous pouvons procéder à corriger l'erreur. Nous le ferons en restaurant la version

du fichier avant le commit! Ceci est important: au lieu de reprendre le fichier dans le commit incorrect, nous rétablissons le dernier bon état - celui avant l'engagement!

$ git log -p -- index.html

Assister à

à la valeur de hachage du mauvais engagement demandera à Git de faire ce qui suit: Accédez à une version du commit référencé ~1 avant .

Après avoir exécuté cette commande, vous constaterez que

a été modifié dans votre copie de travail locale: Git a restauré la dernière bonne version du fichier pour nous! index.html

Récupérer les versions perdues en utilisant le réflog

Un autre outil d'annulation puissant dans la trousse de premiers soins GIT est "Reflog". Vous pouvez le considérer comme un journal où GIT enregistre tous les mouvements de pointeur de tête qui se produisent dans le référentiel local, tels que commet, le cachée, la fusion et la révasion, la cueillette en cerisier et la réinitialisation. Toutes les opérations les plus importantes seront bien enregistrées ici!

Bien sûr, ces journaux sont parfaits pour les situations où les choses ne vont pas bien. Créons donc d'abord une petite catastrophe - alors nous pouvons le réparer avec Reflog.

Supposons que vous soyez sûr que vos derniers engagements ne sont pas bons: vous voulez vous en débarrasser, vous avez donc utilisé git reset pour revenir à la version précédente. En conséquence, le commit "erreur" a disparu de votre historique de validation - comme vous le souhaitez.

Mais comme la vie le fait parfois, vous remarquez que c'est une mauvaise idée: en fin de compte, ces soumissions ne sont pas si mauvaises! Mais la mauvaise nouvelle est que vous venez de les supprimer de l'historique des engagements de votre référentiel! ?

Il s'agit d'un cas classique de l'outil de réflog de Git! Voyons comment cela vous sauve:

$ git restore css/general.css

décomposons-le un par un:

• Tout d'abord, le réflog est très facile à ouvrir: un simple git reflog suffit.
• Deuxièmement, vous remarquerez que le statut enregistré est trié par ordre chronologique, avec le dernier statut en haut.
• Si vous regardez de près, vous constaterez que le projet supérieur (c'est-à-dire le dernier) est une opération "réinitialisée". C'est exactement ce que nous avons fait il y a 20 secondes. De toute évidence, ce journal est valide?
Si nous voulons annuler notre "réinitialisation" involontaire maintenant, nous pouvons simplement revenir à notre état précédent - c'est également bien documenté ici! Nous pouvons simplement copier le hachage de validation de cet état précédent dans le presse-papiers et commencer.

Pour restaurer cet état précédent, nous pouvons utiliser à nouveau

, ou simplement créer une nouvelle branche: git reset

$ git restore -p index.html

Comme nous pouvons le vérifier volontiers, notre nouvelle branche contient des commits que nous pensons être perdus grâce à une défaillance inattendue

! git reset

récupérer les branches supprimées

Le réflog peut également être utile dans d'autres situations. Par exemple, lorsque vous supprimez accidentellement une branche que vous ne devriez pas vraiment supprimer. Jetons un coup d'œil à notre exemple de scénario:

$ git log -- index.html

Supposons que notre client / chef d'équipe / chef de projet nous dit que les belles analyses que nous avons développées ne sont plus nécessaires. Nous sommes bien organisés et bien sûr, nous supprimerons la branche

correspondante! feature/analytics

ci-dessus, vous pouvez voir que dans notre exemple de scénario, nous avons actuellement vérifié la branche:

est notre branche de tête actuelle. Afin de pouvoir le supprimer, nous devons d'abord passer à une autre branche: feature/analytics

$ git restore css/general.css

Git nous dit que nous sommes sur le point de faire quelque chose de très sérieux: puisque feature/analytics contient des engins uniques qui n'existent pas ailleurs, la supprimer va détruire certaines données (probablement précieuses). OK ... comme cette fonctionnalité n'est plus nécessaire, nous pouvons continuer:

$ git restore -p index.html

Vous vous êtes peut-être attendu à ce qui se passera ensuite: notre client / chef d'équipe / chef de projet nous dit joyeusement que la fonctionnalité est de retour! ? Ils veulent continuer après tout! ?

De même, nous sommes confrontés à une mauvaise situation où nous avons peut-être perdu des données précieuses! Voyons donc si le réflog peut nous sauver à nouveau:

$ git log -- index.html

Si vous regardez attentivement, la bonne nouvelle sera évidente. Avant de pouvoir (désastreusement) de supprimer notre branche, nous devons faire git checkout pour passer à une autre branche (car Git ne vous permet pas de supprimer la branche actuelle). Bien sûr, ce paiement est également enregistré dans Reflog. Pour restaurer la branche que nous avons supprimée, nous pouvons maintenant simplement utiliser l'état de avant comme point de départ pour la nouvelle branche:

$ git log -p -- index.html

Regardez: Notre branche est revenue à la vie! ???

Si vous utilisez une interface graphique de bureau comme la tour, annuler de telles erreurs est généralement aussi simple que de presser cmd z .

Déplacer les engage vers différentes branches

Enfin, regardons un cas classique du département "Oh, non!"

Aujourd'hui, de nombreuses équipes ont formulé une règle qui interdit la soumission directe aux succursales à long terme telles que "Main", "Master" ou "Develop". En règle générale, les nouveaux engins ne devraient atteindre ces branches qu'en fusionnant / réduisant. Cependant, nous oublions et soumettons parfois directement ...

Prenons le scénario suivant comme exemple.

Nous aurions dû soumettre sur feature/newsletter mais déclenché par inadvertance le commit sur la succursale master. Jetons un coup d'œil à la solution étape par étape.

Tout d'abord, nous devons nous assurer que cette fois nous sommes sur la bonne branche, nous vérifions donc feature/newsletter:

$ git checkout <bad-commit-hash>~1 -- index.html

Maintenant, nous pouvons déplacer l'engagement en toute sécurité en utilisant la commande cherry-pick:

$ git reflog

Nous pouvons vérifier feature/newsletter et nous verrons que le commit est maintenant également présent ici.

Jusqu'à présent, tout s'est bien passé. Mais cherry-pick ne supprime pas l'engagement de la branche master (il pour toujours ne devrait pas être là). Nous devons donc aussi nettoyer notre gâchis:

$ git restore css/general.css

Nous revenons à master et utilisons git reset pour supprimer (ici) des validations indésirables de l'histoire.

fin, tout est revenu à la normale - vous pouvez donc commencer votre danse heureuse maintenant! ???

Déverrouiller l'erreur est une superpuissance

Je l'ai déjà dit, et malheureusement nous savons tous que c'est vrai: nous ne pouvons pas éviter les erreurs! Peu importe à quel point nous sommes des programmeurs, nous allons le gâcher de temps en temps. La question n'est donc pas de savoir si nous faisons des erreurs, mais comment les gérons-nous efficacement et résolvons-nous des problèmes? Si vous voulez en savoir plus sur les outils Git Undo, je recommande fortement la "trousse de premiers soins GIT". Il s'agit d'une courte collection de vidéos (gratuite) qui vous montre comment nettoyer et annuler les erreurs dans GIT.

Je vous souhaite un développement fluide, un courage à essayer, et bien sûr, vous devez être bon à réparer!

FAQ sur l'utilisation des erreurs GIT pour annuler (FAQ)

Quelle est la différence entre

et

?

git reset git revert et

sont deux commandes qui vous aident à annuler les changements dans votre référentiel GIT, mais ils fonctionnent différemment.

Déplacez votre pointeur de tête vers un engagement spécifique. Cela signifie qu'il "oublié" tous les engagements que vous avez après la réinitialisation de la commission. Il s'agit d'une opération destructrice et doit être utilisée avec prudence. D'un autre côté, git reset crée un nouvel engagement à annuler les modifications apportées dans un engagement spécifique. Il s'agit d'une opération sûre car elle ne change pas l'historique existant. git revert git reset Comment annuler l'opération git revert?

Si vous avez déjà utilisé git add pour enregistrer les modifications et que vous souhaitez annuler cela, vous pouvez utiliser la commande

. Par exemple, si vous souhaitez débarquer un fichier spécifique, vous pouvez utiliser la commande

. Si vous souhaitez débarrasser de toutes les modifications, vous pouvez utiliser git add sans spécifier le fichier. git reset git reset <file></file> Puis-je annuler git reset?

Oui, vous pouvez annuler l'utilisation de la commande git commit ou

.

Reprenez votre pointeur de tête vers le validation que vous souhaitez annuler, effaçant efficacement les validations indésirables. D'un autre côté, git reset créera un nouvel engagement pour annuler les modifications apportées dans le commit indésirable. git revert git commit Comment annuler les modifications dans un fichier spécifique? git reset git revert Si vous avez apporté des modifications à un fichier spécifique et que vous souhaitez annuler ces modifications, vous pouvez utiliser la commande

. Par exemple,

éliminera les modifications du répertoire de travail local du fichier spécifié.

git stash Qu'est-ce que c'est?

git stash est une commande qui vous permet d'enregistrer temporairement les modifications que vous ne souhaitez pas soumettre immédiatement. Ceci est utile si vous devez passer à une succursale différente mais que vous ne souhaitez pas commettre le changement actuel. Vous pouvez appliquer les modifications temporaires plus tard en utilisant git stash apply.

Comment voir mon histoire Git?

Vous pouvez utiliser la commande git log pour afficher votre historique GIT. Cela vous montrera une liste de tous les commits dans le référentiel, ainsi que leurs messages de validation.

Puis-je annuler git push?

Oui, vous pouvez annuler git push, mais c'est un peu plus compliqué que de l'annulation des changements locaux. Vous devez utiliser la commande -f avec les options --force ou git push pour écraser le référentiel distant avec votre référentiel local. Soyez prudent avec cette commande, car elle peut causer des problèmes pour d'autres personnes qui traitent du même référentiel.

Comment annuler plusieurs engins?

Si vous souhaitez annuler plusieurs engins, vous pouvez utiliser la commande git reset et la syntaxe HEAD~<number></number>. Par exemple, git reset HEAD~3 déplace votre pointeur de tête en arrière avant trois commits.

Quelle est la différence entre la réinitialisation en douceur et la réinitialisation dure?

Soft Reset déplace votre pointeur de tête vers un engagement spécifique, mais ne change pas votre répertoire de travail et votre zone de mise en scène. Cela signifie que vous verrez toujours des changements des engagements "oubliés" comme des changements non engagés. D'un autre côté, une réinitialisation dure éliminera toutes les modifications du répertoire de travail et de la zone de mise en scène, restaurant efficacement votre référentiel à l'État au moment de la validation spécifiée.

Puis-je reprendre le commit après une réinitialisation dure?

Oui, les engagements peuvent être repris après une réinitialisation dure, mais ce n'est pas facile. Git conserve des journaux pour toutes les mises à jour REF (telles que le déplacement des pointeurs de tête) dans le réflog. Vous pouvez utiliser la commande git reflog pour trouver l'engagement que vous souhaitez récupérer, puis utiliser git branch pour créer une nouvelle branche dans cette validation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!