Wat zijn samenvoegingsconflicten?
Hier bespreken we hoe samenvoegingsconflictoplossing ontwikkelaars helpt het beste resultaat te produceren van twee overlappende bronnen.
De GitHub-stroom
Naast een platform voor gezamenlijke softwareontwikkeling biedt GitHub ook een voorgeschreven werkstroom die ervoor zorgt dat u optimaal gebruik kunt maken van de verschillende functies. Hoewel deze les specifiek betrekking heeft op samenvoegingsconflicten, raden we u aan eerst inzicht te krijgen in de GitHub-stroom.
Vertakkingen samenvoegen
Denk aan een scenario waarin een ontwikkelaar een vertakking met de naam feature-branch maakt die is gebaseerd op main en twee doorvoeringen maakt. Terwijl hij hiermee bezig is, voegt iemand anders een niet-gerelateerde pull-aanvraag samen in main. Wat gebeurt er wanneer onze ontwikkelaar probeert feature-branch weer samen te voegen in main?
Het antwoord: dat hangt ervan af.
Hoewel feature-branch het is gemaakt op basis van main, was het niet gebaseerd op de vertakking zelf. Het was eerder gebaseerd op de HEAD-doorvoering van main op dat moment. Het is niet op de hoogte van alle doorvoeringen die sindsdien zijn toegepast main . De doorvoeringen die momenteel worden bijgehouden, worden niet noodzakelijkerwijs opgenomen in de huidige status van de vertakking zonder recente wijzigingen te overschrijven.
Als blijkt dat de feature-branch doorvoeringen niet overlappen met parallelle doorvoeringen die zijn gemaakt main sinds de vertakking is gemaakt, zijn er geen problemen. Nieuwe bestanden kunnen worden toegevoegd. Ongewijzigde bestanden kunnen worden verwijderd. Regels met code die in main zijn gewijzigd, kunnen in feature-branch worden gewijzigd, zolang het parallelle werk deze niet heeft gewijzigd sinds feature-branch is gemaakt.
Maar wat gebeurt er als beide sets doorvoeringen wijzigingen bevatten in dezelfde coderegels? Deze samenvoegingspoging mislukt vanwege een samenvoegingsconflict.
Wat zijn samenvoegingsconflicten?
Er worden samenvoegingsconflicten gegenereerd wanneer een ontwikkelaar wijzigingen probeert samen te voegen die onbedoeld parallelle wijzigingen zouden overschrijven. Het maakt niet uit hoe deze andere wijzigingen zijn samengevoegd in de basisvertakking. Git overschrijft niet automatisch een set wijzigingen ten gunste van een andere. In plaats daarvan verwijst het hen naar de persoon die probeert samen te voegen, zodat ze ze kunnen oplossen in hun vergelijkingsvertakking voordat ze opnieuw proberen samen te voegen.
Samenvoegingsconflicten oplossen
Om u te helpen bij het oplossen van samenvoegingsconflicten, genereert GitHub een tijdelijk hybride bestand dat de verschillen van elke vertakking bevat. Het is gebruikelijk dat de tekst van de vergelijkingsvertakking wordt weergegeven boven de basisvertakking, gescheiden door een regel van gelijktekens (=======).
U kunt deze weergave gebruiken om het bestand rechtstreeks te bewerken als de wijzigingen niet ingrijpend zijn. Als u besluit het te behouden, wordt het uiteindelijke resultaat doorgevoerd in de vergelijkingsbranch. Als de samenvoeging meer betrokken is, kunt u er ook beter aan werken met andere ontwikkelhulpprogramma's. Vergeet hoe dan ook niet om eventuele vertakkingsmarkeringen uit uw code te verwijderen voordat u de wijzigingen doorvoert. Als u vergeet deze markeringen te verwijderen wanneer u uw conflictoplossing doorvoert, blijven ze in het bestand staan en worden ze niet uitgecommentarieerd.
Notitie
In dit gedeelte wordt het oplossen van samenvoegingsconflicten in de context van een browser behandeld. Er zijn ook tal van ontwikkelplatforms, zoals Visual Studio, die over een geïntegreerde functie voor samenvoegingsconflictoplossingen beschikken.
Zodra alle samenvoegingsconflicten zijn opgelost in uw vertakking, kunt u de samenvoegbewerking opnieuw proberen.
Samenvoegingsconflicten vermijden
Bepaalde samenvoegingsconflicten kunnen niet worden voorkomen. Eventuele samenvoegingen kunnen leiden tot samenvoegingsconflicten voor andere pull-aanvragen die wachten op goedkeuring. Een efficiënte manier om de complexiteit van samenvoegingsconflicten te verminderen, is een regelmatige pull van uw vertakking.
Vroeg en vaak een pull uitvoeren
Met de git pull opdracht worden alle doorvoeringen van de basisbranch opgehaald die nog niet zijn toegepast op uw huidige vertakking. Het is conceptueel vergelijkbaar met de opdracht Nieuwste ophalen die door veel versiebeheersystemen wordt gebruikt om uw lokale code bij te werken naar de nieuwste versie. Wanneer u updates voor uw vertakking ophaalt, worden alle wijzigingen samengevoegd die zijn opgetreden sinds de vertakking is gemaakt (of voor het laatst is opgehaald).
Het ophalen van updates aan uw vertakking kan leiden tot samenvoegingsconflicten, maar dat is geen probleem. U krijgt ze later toch en door ze eerder te krijgen, zijn ze vaak gemakkelijker te adresseren.
Naast het beperken van de impact van samenvoegingsconflicten, kunt u door updates op te halen ook doorgevoerde wijzigingen in uw vertakking integreren terwijl u werkt. Als u dit doet, kunt u eerder problemen constateren. Er kunnen bijvoorbeeld klassedefinitiewijzigingen zijn in andere bestanden die ervoor zorgen dat uw code niet meer wordt gecompileerd. Deze wijziging veroorzaakt geen samenvoegingsconflict wanneer u later samenvoegt, maar de build wordt verbroken als u deze niet eerst hebt getest. Het is best practice om vaak updates op te halen, zodat uw vertakking zo dicht mogelijk bij de basis blijft.
Geschiedenis opruimen met git-rebase
Met de opdracht git rebase (of git pull --rebase) herschrijft u uw vertakkingsgeschiedenis om de huidige HEAD-doorvoering van de basisvertakking als basis te gebruiken. Met andere woorden, uw vertakking wordt bijgewerkt zodat deze zich gedraagt alsof deze alleen is vertakt vanaf de huidige status van de basisbranch. Deze rebase betekent dat al uw wijzigingen worden vergeleken met de meest recente status van de basisvertakking en niet de oorspronkelijke doorvoering waarvan u oorspronkelijk vertakt bent. Met het opnieuw maken van de basis kunt u de geschiedenis gemakkelijker bijhouden na de uiteindelijke samenvoeging, omdat uw doorvoeringen de vorige parallelle doorvoeringen op lineaire wijze volgen. Een rebase van uw vertakking is raadzaam direct voordat u upstream samenvoegt.
Meer informatie over Git-rebase en het oplossen van samenvoegingsconflicten na een Git-rebase.