Introduction à Git Interactive Rebase

Le rebasage interactif peut être particulièrement utile dans les tâches collectives, où divers développeurs travaillent sur une base de code identique. Il vous permet de nettoyer votre historique de validation avant de soumettre une demande d'extraction, ce qui permet aux autres de revoir plus facilement vos modifications et de comprendre votre processus de réflexion.

Cet article expliquera brièvement l'introduction à la rebase interactive de Git.

Introduction à Git Interactive Rebase

Git interactive rebase est un outil puissant pour gérer les commits dans un référentiel Git. Il permet aux développeurs/utilisateurs de modifier, réorganiser ou supprimer des commits dans l'historique d'une branche. Un rebase interactif est particulièrement utile lorsque les développeurs doivent nettoyer une branche avant de la fusionner dans une autre branche ou lorsqu'ils souhaitent apporter des modifications aux commits précédents.

Comment fonctionne Git Interactive Rebase ?

Pour commencer à travailler avec le rebase interactif Git, l'utilisateur peut effectuer plusieurs modifications répertoriées ci-dessous :

Réorganiser les commits
Engagements de fusion
Modifier les commits
Supprimer les commits

Réorganiser les commits

Pour réorganiser les commits, essayez la procédure ci-dessous :

Allez vers le dépôt Git local.
Vérifiez le journal Git.
Modifiez manuellement l'ordre des commits et vérifiez les modifications.

Étape 1 : Accédez au référentiel local

Dans un premier temps, accédez au référentiel Git local en spécifiant le chemin à l'aide du ' CD ' commande:

CD 'C:\Utilisateurs\utilisateur\Git \t projet d'esting'

Étape 2 : Vérifier le journal Git

Affichez le journal Git complet à l'aide de ' git log-oneline ”. Il affichera chaque commit sur une seule ligne :

journal git --en ligne

En conséquence, tous les commits sont affichés sur le terminal Git Bash :

Étape 3 : réorganiser les commits

Maintenant, exécutez le ' git rebase -i 'commande où' -je ' est utilisé pour le mode interactif, et ' TÊTE ~ 3 ” sélectionnera trois commits dans le journal Git :

git rebase -je TÊTE ~ 3

L'image résultante montre qu'elle remplace la position de tous les commits dans les éditeurs ouverts :

L'image ci-dessous montre que les commits ont été remplacés manuellement :

Enfin, les commits sont rebasés avec succès à l'aide de ' git rebase -i ”.

Étape 4 : Vérifier les modifications

Vérifiez les modifications en exécutant la commande indiquée :

journal git --en ligne

On peut remarquer que les commits sélectionnés ont été réordonnés avec succès :

Engagements de fusion

Pour fusionner deux commits ou plus, suivez les instructions données :

Consultez le journal Git.
Utilisez le ' git rebase -i HEAD~3 ” pour fusionner les commits en un seul commit.
Remplace le ' prendre ' mot clé avec ' squash ' fusionner.

Étape 1 : Vérifier le journal Git

Tout d'abord, affichez l'historique complet du journal Git en exécutant la commande fournie ci-dessous.

journal git --en ligne

L'image indiquée affiche les résultats de la commande ci-dessus :

Étape 2 : fusionner les commits

Maintenant, fusionnez les commits en utilisant le ' git rebase -i ' commande. Le ' TÊTE ~ 3 ” est utilisé pour sélectionner les trois commits et ouvrir l'éditeur spécifié :

git rebase -je TÊTE ~ 3

En conséquence, l'éditeur a été ouvert :

Étape 2 : remplacez « choisir » par « squash »

Remplace le ' prendre ' mot avec le ' squash ” qui sert à fusionner les commits dans le premier et enregistrer les changements :

Étape 3 : valider les modifications

Ensuite, un nouvel éditeur apparaîtra à l'écran. Ici écrit un message de validation pour valider les modifications et enregistrez-le en appuyant sur le ' Ctrl+s ” :

On peut remarquer que toutes les modifications ont été validées avec succès :

Étape 4 : Vérification

Vérifiez les modifications validées ci-dessus à l'aide de la commande mentionnée :

journal git --en ligne

On peut remarquer que tous les commits sélectionnés ont été fusionnés avec succès :

Supprimer les commits

Pour supprimer les commits de l'historique du journal Git, essayez l'étape indiquée ci-dessous :

Afficher l'historique du journal Git.
Supprimez manuellement un commit de l'éditeur.
Vérifiez en consultant l'historique du journal Git.

Étape 1 : Vérifier l'historique du journal Git

Exécutez la commande donnée pour vérifier le journal Git. Le ' git log-oneline ” est utilisée pour afficher chaque commit sur une seule ligne :

journal git --en ligne

L'image donnée montre l'historique complet du journal Git :

Étape 2 : Supprimer le commit

Ouvrez l'éditeur en appliquant le ' git rebase -i ' avec la commande ' TÊTE ~ 2 ” pour sélectionner deux commits dans l'historique du journal :

git rebase -je TÊTE ~ 2

Sélectionnez un commit et supprimez-le manuellement de l'éditeur :

Ici, supprimez le commit sélectionné de l'éditeur et appuyez sur ' Ctrl+s ” pour enregistrer les modifications :

L'image résultante indique que l'opération de rebase a été effectuée avec succès :

Étape 3 : Vérification

Exécutez la commande ci-dessous à des fins de vérification :

journal git --en ligne

Le commit sélectionné a été supprimé avec succès de l'historique du journal :

C'est tout à propos de la rebase interactive Git.

Conclusion

Git interactive rebase est l'opération la plus puissante pour gérer les commits dans un référentiel Git. Il permet aux développeurs/utilisateurs de modifier, réorganiser ou supprimer des commits dans l'historique d'une branche en utilisant le ' git rebase -i ' commande. De plus, il peut également être utilisé pour nettoyer l'historique Git en fusionnant tous les commits en un seul. Ce message a déclaré l'introduction de la rebase interactive Git.

Introduction à Git Interactive Rebase