Apprentissage Git : comprendre la commande git merge

Cet article vous apprendra les branches Git et vous présentera les commandes Git Merge pour utiliser les branches. J'espère qu'il vous sera utile !

Dans Git, la fusion est un moyen de reconstituer l'historique des commits forkés. La commande git merge permet d'intégrer la branche que vous avez créée précédemment à l'aide de la commande git branch et le contenu développé indépendamment sur cette branche en une seule branche. git merge命令用来将你之前使用git branch命令创建的分支以及在此分支上独立开发的内容整合为一个分支。

请注意下面的所有命令都会是将其他分支合并到当前所在工作分支上。当前工作分支的内容会由于merge操作产生更新，但是目标分支则完全不受影响。再次强调，这意味着git merge通常与其他几个git命令一起使用，包括使用git checkout命令来选择当前工作分支，以及使用git branch -d命令来删除已经合并过的废弃分支。

它是如何运行的

git merge会将多个提交序列合并进一个统一的提交历史。在最常见的使用场景中，git merge被用来合并两个分支。在本文档接下来的部分，我们会专注于这种合并场景。在这种场景中，git merge接受两个commit指针，通常是两个分支的顶部commit，然后向前追溯到这两个分支最近的一个共同提交。一旦找到这个共同提交，Git就会创建一个新的"merge commit"，用来合并两个分支上各自的提交序列。

比如说我们有一个功能分支由main分支派生出来，现在我们希望将这个功能分支合并回main分支。

执行合并命令会将指定分支合并到当前工作分支上，我们假设当前工作分支为main。Git根据两个分支自行决定合并提交的算法（将在下面具体讨论）。

合并commit与普通commit不一样，因为合并commit会有两个父提交。创建一个合并commit时Git会尝试自动将两个独立的提交历史合并为一个。不过当Git发现某一块数据在两边的提交历史中都含有变更，它将无法自动对其进行合并。这种情况被称为版本冲突，此时Git需要人为介入调整才能继续进行合并。

准备合并

在实际进行合并操作之前，需要进行一些准备步骤，以保证合并过程能够顺利进行。

确认接收合并的分支

执行git status命令查看当前分支的状态，确保HEAD指正指向的是正确的接收合并的分支。如果不是，执行git checkout命令切换到正确的分支。在我们的示例中，执行git checkout main。

获取最新的远程提交

确保合并操作涉及的两个分支都更新到远程仓库的最新状态。执行git fetch拉取远程仓库的最新提交。一旦fetch操作完成，为了保证main分支与远程分支同步，还需执行git pull命令。

合并

当上面提及的准备工作都已完备，合并就可以正式开始了。执行git merge <branch></branch>命令，其中为需要合并到当前分支的目标分支名称。

快进合并

当前工作分支到合并目标分支之间的提交历史是线性路径时，可以进行快进合并。在这种情况下，不需要真实的合并两个分支，Git只需要把当前分支的顶端指针移动到目标分支的顶端就可以了（也就是快进的意思）。在这种情况下快进合并成功的将提交历史合并至一处，毕竟目标分支中的提交此时都包含在当前分支的提交历史中了。对于将功能分支快进合并到main

Veuillez noter que toutes les commandes ci-dessous fusionneront les autres branches dans la branche de travail actuelle. Le contenu de la branche de travail actuelle sera mis à jour en raison de l'opération de fusion, mais la branche cible ne sera pas du tout affectée. Encore une fois, cela signifie que git merge est généralement utilisé conjointement avec plusieurs autres commandes git, notamment l'utilisation de la commande git checkout pour sélectionner la branche de travail actuelle, et git branch -d commande pour supprimer les branches abandonnées fusionnées.

Comment ça marche

git merge fusionnera plusieurs séquences de validation dans un historique de validation unifié. Dans le scénario d'utilisation le plus courant, git merge est utilisé pour fusionner deux branches. Dans la suite de ce document, nous nous concentrerons sur ce scénario de fusion. Dans ce scénario, git merge accepte deux pointeurs de validation, généralement la validation supérieure des deux branches, puis remonte à la validation commune la plus récente des deux branches. Une fois ce commit commun trouvé, Git crée un nouveau « commit de fusion » qui fusionne les séquences de commit respectives sur les deux branches.

Par exemple, nous avons une branche de fonctionnalités dérivée de la branche main, et nous souhaitons maintenant fusionner cette branche de fonctionnalités avec la branche main.

Exécuter La commande de fusion fusionnera la branche spécifiée dans la branche de travail actuelle. Nous supposons que la branche de travail actuelle est main. Git détermine son propre algorithme de fusion des commits en fonction des deux branches (discutées en détail ci-dessous). 🎜🎜🎜🎜Fusionner La validation est différente de la validation ordinaire car la validation de fusion aura deux validations parents. Lorsque vous créez une validation de fusion, Git essaiera de fusionner automatiquement deux historiques de validation distincts en un seul. Cependant, lorsque Git découvre qu'une certaine donnée contient des modifications dans l'historique de soumission des deux côtés, il ne pourra pas la fusionner automatiquement. Cette situation est appelée conflit de version et Git nécessite une intervention manuelle pour poursuivre la fusion. 🎜

Préparation de la fusion

🎜Avant l'opération de fusion proprement dite, certaines étapes de préparation doivent être effectuées pour garantir que le processus de fusion puisse se dérouler sans problème. 🎜

Confirmer la réception de la branche fusionnée

🎜Exécutez la commande git status pour vérifier l'état de la branche actuelle et assurez-vous que HEAD effectue des corrections Pointe vers la bonne branche pour recevoir la fusion. Sinon, exécutez la commande git checkout pour passer à la bonne branche. Dans notre exemple, exécutez git checkout main. 🎜

Obtenez la dernière validation à distance

🎜Assurez-vous que les deux branches impliquées dans l'opération de fusion sont mises à jour avec le dernier statut du référentiel distant. Exécutez git fetch pour extraire le dernier commit de l'entrepôt distant. Une fois l'opération de récupération terminée, afin de garantir que la branche main est synchronisée avec la branche distante, la commande git pull doit être exécutée. 🎜

Fusion

🎜Lorsque les préparatifs mentionnés ci-dessus seront terminés, la fusion pourra officiellement commencer. Exécutez la commande git merge <branch></branch>, où est le nom de la branche cible qui doit être fusionnée dans la branche actuelle. 🎜

Fusion rapide

🎜La fusion rapide peut être effectuée lorsque l'historique de soumission entre la branche de travail actuelle et la branche cible de la fusion est un chemin linéaire. Dans ce cas, il n'est pas nécessaire de fusionner les deux branches. Git doit simplement déplacer le pointeur supérieur de la branche actuelle vers le haut de la branche cible (c'est-à-dire avancer rapidement). Dans ce cas, la fusion rapide fusionne avec succès l'historique des validations en un seul endroit. Après tout, les validations dans la branche cible sont désormais incluses dans l'historique des validations de la branche actuelle. Pour le processus de fusion rapide de la branche de fonctionnalité dans la branche main, veuillez vous référer à la figure ci-dessous : 🎜🎜🎜🎜🎜Cependant, la fusion rapide n'est pas autorisée lorsque les deux branches ont bifurqué. . Lorsque l'historique de validation de la branche cible par rapport à la branche actuelle n'est pas linéaire, Git ne peut décider comment fusionner les deux branches que via l'algorithme de fusion à trois voies. L'algorithme de fusion à trois voies nécessite l'utilisation d'un commit dédié pour intégrer les historiques de commit des deux côtés. Ce terme vient du fait que pour que Git génère un commit de fusion, il doit utiliser trois commits : le commit supérieur des deux branches et leur commit ancêtre commun. 🎜🎜🎜🎜

Bien qu'il existe en fait des options pour utiliser ces différentes stratégies de fusion, la plupart des développeurs préfèrent la fusion rapide (en utilisant la commande rebasing ), en particulier pour le développement de petites fonctionnalités ou, à l'inverse, pour la fusion de développements à long terme pour les branches de fonctions, il est plus probable d'utiliser la fusion à trois. Dans le deuxième scénario, le commit de fusion généré par la fusion sera conservé dans l'historique des commits comme marque de la fusion des deux branches.

Ensuite, nous utilisons le premier exemple ci-dessous pour montrer comment effectuer une fusion rapide. La commande suivante créera d'abord une nouvelle branche, effectuera deux validations sur la nouvelle branche, puis utilisera la fusion rapide pour fusionner la nouvelle branche avec la branche main. main分支。

# Start a new feature
git checkout -b new-feature main
# Edit some files
git add <file>
git commit -m "Start a feature"
# Edit some files
git add <file>
git commit -m "Finish a feature"
# Merge in the new-feature branch
git checkout main
git merge new-feature
git branch -d new-feature

这个例子中的工作流程通常用于短期功能的开发，这种开发流程更多地被当做是比较独立的一次开发流程，与之对应的则是需要协调和管理的长期功能开发分支。

另外还需注意到，在此例中Git不会对git branch -d命令发出警告，因为new-feature的内容已经合并到主分支里了。

在某些情况下，虽然目标分支的提交历史相对于当前分支是线性的，可以进行快进合并，但你仍然希望有一个合并commit来标志合并在此commit发生过，那么可以在执行git merge命令时使用--no-ff选项。

git merge --no-ff <branch>

以上命令将指定分支合并到当前分支，但总会生成一个合并commit（即便这一合并操作可以快进）。当你需要在仓库的提交历史中标记合并事件时这一命令相当有用。

三路合并

接下来的例子与上面比较像，但是因为main分支在feature分支向前发展的过程中，自身也发生的改变，因此在合并时需要进行三路合并。在进行大的功能开发或者有多个开发者同时进行开发时这种场景相当常见。

Start a new feature
git checkout -b new-feature main
# Edit some files
git add <file>
git commit -m "Start a feature"
# Edit some files
git add <file>
git commit -m "Finish a feature"
# Develop the main branch
git checkout main
# Edit some files
git add <file>
git commit -m "Make some super-stable changes to main"
# Merge in the new-feature branch
git merge new-feature
git branch -d new-feature

需注意在这种情况下，由于没有办法直接把main的顶端指针移动到new-feature分支上，因此Git无法执行快进合并。

在大多数实际工作场景中，new-feature应该是一个很大的功能，开发过程持续了相当长的时间，这也就难免同时期在main分支上也有新的提交。如果你的功能分支大小像上面的例子一样小，则完全可以使用rebase将new-feature分支变基到main分支上，然后再执行一次快进合并。这样也会避免在项目提交历史中产生过多的冗余。

解决冲突

如果将要合并的两个分支都修改了同一个而文件的同一个部分内容，Git就无法确定应该使用哪个版本的内容。当这种情况发生时，合并过程会停止在合并commit提交之前，以便给用户留下机会手动修复这些冲突。

在Git的合并过程中，很棒的一点是它使用人们熟知的 编辑 / 暂存 / 提交 这样的工作流程来解决冲突。当碰到合并冲突时，执行git status命令会列出哪些文件含有冲突并需要手动解决。比如说当两个分支都修改了hello.py文件的同一部分，你会看到类似下面这样的信息：

On branch main
Unmerged paths:
(use "git add/rm ..." as appropriate to mark resolution)
both modified: hello.py

冲突是如何显示的

当Git在合并过程中碰到了冲突，它会编辑受影响的文件中的相关内容，并添加视觉标记用以展示冲突中双方在此部分的不同内容。这些视觉标记为：>>>>>>。要找到冲突发生的具体位置，在文件中搜索这些视觉标记会非常便捷地达成目的。

here is some content not affected by the conflict
<<<<<<< main
this is conflicted text from main
=======
this is conflicted text from feature branch
>>>>>>> feature branch;

通常来说在 ====== 标记之前的内容来自于接收合并的分支，而在这之后的内容来自于要合并的分支。

一旦找到冲突的部分，就可以根据需要来修正冲突。当你完成了冲突的修复并准备好继续进行合并，只需要执行git add命令把已经解决好冲突的文件添加暂存区，告诉Git这些冲突已经解决完毕即可。这之后就像正常提交代码一样执行git commitrrreee

Le workflow de cet exemple est généralement utilisé pour le développement de fonctionnalités à court terme. Ce processus de développement est davantage considéré comme un processus de développement relativement indépendant et correspond à des branches de développement de fonctionnalités à long terme qui nécessitent une coordination et une gestion.

Notez également que dans cet exemple, Git n'émettra pas d'avertissement pour la commande git branch -d car le contenu de new-feature a été fusionné dans la branche principale. 🎜🎜Dans certains cas, bien que l'historique de validation de la branche cible soit linéaire par rapport à la branche actuelle, une fusion rapide peut être effectuée, mais vous souhaitez toujours avoir une validation de fusion pour marquer que la fusion a eu lieu à cette validation, alors vous pouvez exécuter --no-ff lorsque vous utilisez la commande code>git merge. 🎜rrreee🎜La commande ci-dessus fusionnera la branche spécifiée dans la branche actuelle, mais générera toujours une validation de fusion (même si cette opération de fusion peut être avancée rapidement). Cette commande est utile lorsque vous devez marquer des événements de fusion dans l'historique de validation du référentiel. 🎜

Fusion à trois voies

🎜L'exemple suivant est similaire à celui ci-dessus, mais parce que la branche main est en cours de fonctionnalité La branche qui avance, elle-même a également changé, donc une fusion à trois est requise pendant la fusion. Ce scénario est assez courant lors du développement de fonctionnalités à grande échelle ou lorsque plusieurs développeurs développent en même temps. 🎜rrreee🎜Il convient de noter que dans ce cas, puisqu'il n'y a aucun moyen de déplacer directement le pointeur supérieur de main vers la branche new-feature, Git ne peut pas effectuer une fusion rapide. 🎜🎜Dans la plupart des scénarios de travail réels, new-feature devrait être une très grande fonction, et le processus de développement dure longtemps, il est donc inévitable que main soit développé en même temps. Il y a aussi de nouveaux commits sur la branche code>. Si la taille de votre branche de fonctionnalité est aussi petite que dans l'exemple ci-dessus, vous pouvez utiliser rebase pour rebaser la branche new-feature vers la branche main, puis effectuer une avance rapide. fusionner à nouveau. Cela évitera également de créer trop de redondance dans l'historique des validations du projet. 🎜

Résoudre les conflits

🎜Si les deux branches à fusionner ont modifié la même partie du fichier, Git ne peut pas déterminer quelle version du contenu doit être utilisée. Lorsque cela se produit, le processus de fusion est arrêté avant que la validation de fusion ne soit validée pour donner à l'utilisateur la possibilité de résoudre ces conflits manuellement. 🎜🎜L'avantage du processus de fusion de Git est qu'il utilise le workflow d'édition/stage/commit bien connu pour résoudre les conflits. Lorsqu'un conflit de fusion est rencontré, l'exécution de la commande git status répertoriera les fichiers contenant des conflits et devant être résolus manuellement. Par exemple, lorsque les deux branches modifient la même partie du fichier hello.py, vous verrez un message similaire au suivant : 🎜rrreee

Le conflit est Comment afficher

🎜Lorsque Git rencontre un conflit pendant le processus de fusion, il modifiera le contenu pertinent dans le fichier concerné et ajoutera des marqueurs visuels pour afficher le contenu différent des parties en conflit dans cette partie. Ces marqueurs visuels sont : >>>>>>. Pour trouver l'emplacement précis où un conflit s'est produit, il est facile de rechercher ces marqueurs visuels dans le fichier. 🎜rrreee🎜 De manière générale, le contenu avant la marque ====== provient de la branche recevant la fusion, et le contenu après vient de la branche à fusionner. 🎜🎜Une fois que vous avez trouvé la partie conflictuelle, vous pouvez corriger le conflit si nécessaire. Lorsque vous avez terminé de résoudre les conflits et que vous êtes prêt à continuer la fusion, il vous suffit d'exécuter la commande git add pour ajouter les fichiers avec des conflits résolus à la zone de préparation et indiquer à Git que ces conflits ont été résolus. . Après cela, exécutez git commit tout comme si vous soumettiez le code normalement pour terminer la validation de fusion. Ce processus est exactement le même que celui de la soumission de code dans des circonstances normales, ce qui signifie que la gestion des conflits est un jeu d'enfant pour les développeurs ordinaires. 🎜🎜 Notez également que les conflits de fusion ne peuvent survenir que lors d'une fusion à trois et ne se produiront pas lors d'une fusion à avance rapide. 🎜

Résumé

Cet article est un aperçu des git mergecommandes. Dans le processus d'utilisation de Git, la fusion est une opération très importante. Cet article traite des mécanismes derrière les opérations de fusion et des différences entre les fusions rapides et les fusions à trois. Les points clés dont les lecteurs doivent se souvenir sont les suivants :

• Le processus de fusion Git consiste à fusionner différentes séquences de validation dans un historique de validation unifié

• Il existe deux méthodes principales dans le processus de fusion Git : la fusion rapide et fusion à trois voies

• À moins qu'il n'y ait un conflit entre les deux séquences de commit, Git peut généralement fusionner automatiquement les commits

Apprentissage recommandé : "Tutoriel Git"

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!