Le rebasage est un processus permettant de réappliquer des commits en plus d'un autre voyage de base. Il est utilisé pour appliquer une séquence de validations de branches distinctes dans une validation finale. C'est une alternative à la commande git merge. Il s'agit d'un processus linéaire de fusion.

Dans Git, le terme rebase fait référence au processus de déplacement ou de combinaison d'une séquence de validations vers une nouvelle validation de base. Le rebasage est très bénéfique et permet de visualiser le processus dans l'environnement d'un flux de travail de branchement de fonctionnalités.

Il est bon de rebaser votre branche avant de la fusionner.

Généralement, il s'agit d'une alternative à la commande git merge. La fusion est toujours un enregistrement évolutif. En comparaison, rebase est un outil de réécriture d’historique convaincant dans git. Il fusionne les différents commits un par un.

Supposons que vous ayez effectué trois commits dans votre branche master et trois dans votre autre branche nommée test. Si vous fusionnez ceci, tous les commits seront fusionnés en un temps record. Mais si vous le rebasez, il sera fusionné de manière linéaire. Considérez l'image ci-dessous :

L'image ci-dessus décrit le fonctionnement de git rebase. Les trois commits de la branche master sont fusionnés linéairement avec les commits de la branche test.

La fusion est le moyen le plus simple d’intégrer les succursales. Il effectue une fusion à trois voies entre les deux dernières validations de branche.

Comment rebaser

Lorsque vous avez effectué des commits sur une branche de fonctionnalités (branche de test) et d'autres dans la branche master. Vous pouvez rebaser n'importe laquelle de ces branches. Utilisez la commande git log pour suivre les modifications (historique des validations). Effectuez le paiement vers la branche souhaitée que vous souhaitez rebaser. Exécutez maintenant la commande rebase comme suit :

Syntaxe:

 $git rebase 

S'il y a des conflits dans la branche, résolvez-les et exécutez les commandes ci-dessous pour poursuivre les modifications :

 $ git status 

Il est utilisé pour vérifier l'état,

 $git rebase --continue 

La commande ci-dessus est utilisée pour poursuivre les modifications que vous avez apportées. Si vous souhaitez ignorer la modification, vous pouvez procéder comme suit :

énumérations Java

 $ git rebase --skip 

Lorsque le rebasage est terminé. Poussez le référentiel vers l'origine. Considérez l'exemple ci-dessous pour comprendre la commande git merge.

Supposons que vous ayez une branche, dites test2 sur lequel vous travaillez. Vous êtes maintenant sur la branche test2 et avez apporté quelques modifications au fichier du projet nouveaufichier1.txt .

Ajoutez ce fichier au référentiel :

 $ git add newfile1.txt 

Maintenant, validez les modifications. Utilisez la commande ci-dessous :

 $ git commit -m 'new commit for test2 branch.' 

Le résultat ressemblera à :

 [test2 a835504] new commitfor test2 branch 1 file changed, 1 insertion(+) 

Basculez la branche vers master :

 $ git checkout master 

Sortir:

 Switched to branch 'master.' Your branch is up to date with 'origin/master.' 

Vous êtes maintenant sur la branche master. J'ai ajouté les modifications à mon fichier, dit nouveau fichier.txt . La commande ci-dessous est utilisée pour ajouter le fichier dans le référentiel.

 $ git add newfile.txt 

Validez maintenant le fichier pour les modifications :

 $ git commit -m ' new commit made on the master branch.' 

Sortir:

 [master 7fe5e7a] new commit made on master 1 file changed, 1 insertion(+) HiMaNshU@HiMaNshU-PC MINGW64 ~/Desktop/GitExample2 (master) 

Pour vérifier l'historique du journal, exécutez la commande ci-dessous.

 $ git log --oneline 

Sortir:

Comme nous pouvons le voir dans l’historique des journaux, il y a un nouveau commit dans la branche master. Si je souhaite rebaser ma branche test2, que dois-je faire ? Voir le scénario de branche de rebase ci-dessous :

Branche de rebase

Si nous avons de nombreux commits provenant de branches distinctes et que nous souhaitons les fusionner en un seul. Pour ce faire, nous avons deux choix : soit le fusionner, soit le rebaser. C'est bien de rebaser votre branche.

À partir de l’exemple ci-dessus, nous nous sommes engagés sur la branche master et souhaitons la rebaser sur la branche test2. Voyons les commandes ci-dessous :

python, tri des tuples

 $ git checkout test2 

Cette commande vous fera basculer sur la branche test2 depuis le maître.

Sortir:

 Switched to branch 'test2.' 

Vous êtes maintenant sur la branche test2. Par conséquent, vous pouvez rebaser la branche test2 avec la branche master. Voir la commande ci-dessous :

 $ git rebase master 

Cette commande rebasera la branche test2 et s'affichera comme Candidature : nouveau commit sur la branche test2 . Considérez le résultat ci-dessous :

Sortir:

Rebasement interactif Git

Git facilite avec Interactive Rebase ; c'est un outil puissant qui permet diverses opérations comme éditer, réécrire, réorganiser, et plus sur les commits existants. Interactive Rebase ne peut être utilisé que sur la branche actuellement extraite. Par conséquent, définissez votre branche HEAD locale dans la barre latérale.

Le rebase interactif Git peut être invoqué avec la commande rebase, tapez simplement -je avec la commande rebase. Ici ' je ' signifie interactif. La syntaxe de cette commande est donnée ci-dessous :

Syntaxe:

 $ git rebase -i 

Il listera toutes les options interactives disponibles.

Sortir:

Après la sortie donnée, il ouvrira un éditeur avec les options disponibles. Considérez le résultat ci-dessous :

Sortir:

Lorsque nous exécutons la commande git interactive rebase, elle ouvrira votre éditeur de texte par défaut avec la sortie ci-dessus.

Les options qu'il contient sont répertoriées ci-dessous :

• Prendre
• Reformuler
• Modifier
• Squash
• Réparer
• Exécutif
• Casser
• Baisse
• Étiquette
• Réinitialiser
• Fusionner

Les options ci-dessus effectuent leurs tâches spécifiques avec git-rebase. Comprenons chacune de ces options en bref.

Choisir (-p) :

Pick signifie ici que le commit est inclus. L'ordre des commits dépend de l'ordre des commandes de sélection lors du rebase. Si vous ne souhaitez pas ajouter de commit, vous devez supprimer toute la ligne.

Reformuler (-r):

objet Java

La reformulation est assez similaire à la commande pick. L'option de reformulation a interrompu le processus de rebase et offre la possibilité de modifier le message de validation. Cela n’affecte pas les modifications apportées par le commit.

Modification(s) :

L'option d'édition permet de modifier le commit. Le moyen de modification, les commits, peut être ajouté ou modifié entièrement. Nous pouvons également effectuer des validations supplémentaires avant la commande rebase continue. Cela nous permet de diviser un gros commit en un plus petit commit ; de plus, nous pouvons supprimer les modifications erronées apportées dans un commit.

Courge(-s) :

L'option squash vous permet de combiner deux commits ou plus en un seul commit. Cela nous permet également d'écrire un nouveau message de validation pour décrire les modifications.

Correction (-f) :

C'est assez similaire à la commande squash. Il a supprimé le message du commit à fusionner. L'ancien message de validation est utilisé pour décrire les deux modifications.

Exécutif (-x) :

L'option exec vous permet d'exécuter des commandes shell arbitraires sur une validation.

Pause (-b) :

L'option break arrête le rebasage à la juste position. Il continuera à se rebaser plus tard avec ' git rebase --continuer ' commande.

Laisse tomber):

L'option drop est utilisée pour supprimer le commit.

Étiquette (-l) :

L'option label est utilisée pour marquer la position actuelle de la tête avec un nom.

Réinitialiser (-t) :

L'option de réinitialisation est utilisée pour réinitialiser la tête sur une étiquette.

scanner java suivant

GitMerge contre Rebase

C'est une question déroutante la plus courante pour les utilisateurs de git : quand utiliser la commande de fusion et quand utiliser rebase. Les deux commandes sont similaires et toutes deux sont utilisées pour fusionner les validations effectuées par les différentes branches d'un référentiel.

Le rebasage n'est pas recommandé dans une branche partagée car le processus de rebasage créera des référentiels incohérents. Pour les particuliers, le rebasage peut être plus utile que la fusion. Si vous souhaitez voir l'historique complet, vous devez utiliser la fusion. La fusion suit l'intégralité de l'historique des validations, tandis que le rebase en réécrit un nouveau.

Les commandes Git rebase sont indiquées comme alternative à git merge. Ils présentent cependant quelques différences essentielles :