Come risolvere i conflitti Git Merge sulla riga di comando e in un editor a tre vie

Per risolvere i conflitti di unione in Git, apri ogni file che Git segnala come in conflitto, decidi quale dovrebbe essere il codice tra i marcatori <<<<<<<, ======= e >>>>>>>, elimina i marcatori, metti in stage il file con git add e finisci con git commit (o git merge --continue). Per tornare indietro, invece, esegui git merge --abort. Questa guida attraversa questo ciclo sulla riga di comando, quindi in un editor visivo a tre vie e termina con le abitudini che rendono i conflitti più rari e facili da annullare. Per mettere in pratica le scelte che ti offre un'unione in pausa, un rebase o un cherry-pick, segui la lezione gratuita Continua, salta o interrompi un'operazione attiva.

Gli esempi visivi utilizzano GitTree, il client Git che creiamo per macOS, Windows e Linux. Esegue Git installato sul tuo computer, quindi facendo clic e digitando si ottiene lo stesso risultato; l'GitTree elenco delle funzionalità offre il quadro più ampio.

Che cos'è in realtà un conflitto di unione in Git

Git unisce riga per riga utilizzando tre versioni di ciascun file: base (l'ultimo commit condiviso da entrambi i rami), nostro (il tuo ramo corrente, HEAD) e loro (il ramo in entrata, MERGE_HEAD). Se solo una parte ha cambiato una regione, Git accetta quella modifica. Se entrambe le parti hanno modificato le stesse righe in modo diverso, Git si ferma, scrive entrambe le versioni nel file e lascia a te la decisione.

La stessa cosa può succedere in git pull, git rebase, git cherry-pick, git revert e git stash pop. La correzione è identica; differisce solo il comando finale. git status etichetta ciascun percorso in conflitto:

• entrambi modificati: entrambi i rami hanno cambiato le stesse righe. Questo è il caso comune.
• eliminato da noi / eliminato da loro: una parte ha eliminato il file e l'altra lo ha modificato, quindi mantieni il file modificato o confermi l'eliminazione.
• entrambi aggiunti: ogni ramo ha creato un file diverso nello stesso percorso.

Come risolvere i conflitti di unione sulla riga di comando

1. Trova i file in conflitto

Git elenca i conflitti nel momento in cui l'unione si interrompe e git status conserva l'elenco fino al termine. git diff --name-only --diff-filter=U stampa solo i percorsi non uniti.

$ git merge feature/login
Auto-merging src/auth.ts
CONFLICT (content): Merge conflict in src/auth.ts
Automatic merge failed; fix conflicts and then commit the result.

$ git status
On branch main
You have unmerged paths.

Unmerged paths:
  (use "git add <file>..." to mark resolution)
        both modified:   src/auth.ts

2. Leggete i segnalini conflitto

Tutto al di fuori dei marcatori si fondeva in modo pulito. Il blocco dopo <<<<<<< HEAD è il tuo ramo corrente, il blocco prima di >>>>>>> feature/login è quello in entrata e la riga ======= li separa.

export const retries = 3;
<<<<<<< HEAD
export const timeout = 45;
=======
export const timeout = 60;
>>>>>>> feature/login
export const debug = false;

Spesso due versioni non bastano per decidere. Imposta lo stile di conflitto zdiff3 di Git una volta e ogni conflitto mostrerà anche la base, dopo una riga |||||||:

$ git config --global merge.conflictStyle zdiff3

<<<<<<< HEAD
export const timeout = 45;
||||||| 556e564
export const timeout = 30;
=======
export const timeout = 60;
>>>>>>> feature/login

Ora puoi vedere che main ha aumentato il timeout da 30 a 45 e il ramo funzionalità a 60: decidi di quale valore ha bisogno il prodotto, non quale ramo vince.

3. Modifica il file e contrassegnalo come risolto

Scrivi il codice che desideri (un lato, l'altro, un mix o qualcosa di nuovo) ed elimina ogni riga di marcatura. Lascia che Git controlli gli avanzi prima di mettere in stage, perché un ======= commesso per sbaglio è una classica build rotta.

$ git diff --check          # lists any leftover conflict markers
$ git add src/auth.ts
$ git commit                # or: git merge --continue

Se la versione dell'intero file di una parte è corretta, prendila direttamente. Per fare in modo che Git preferisca un lato per ogni pezzo in conflitto durante la fusione, avvia invece la fusione con git merge -X ours o git merge -X theirs; i cambiamenti che non sono in conflitto provengono comunque da entrambi i rami.

$ git checkout --ours -- src/auth.ts     # keep the current branch's version
$ git checkout --theirs -- src/auth.ts   # keep the incoming version
$ git add src/auth.ts

4. Terminare l'operazione

Una volta eseguito lo stage di ogni file, continua ciò che è stato interrotto: git commit (o git merge --continue), git rebase --continue, git cherry-pick --continue o git revert --continue. Un rebase può interrompersi nuovamente in un commit successivo; ripetere il ciclo.

Risolvi i conflitti di unione in una GUI: un risolutore di conflitti Git a tre vie

I marcatori vanno bene per uno scontro su due linee. Con una dozzina di conflitti in un file lungo, un risolutore di conflitti della GUI è più veloce e molto più difficile da sbagliare. Un buon strumento di conflitto di unione Git mostra tutte e tre le versioni insieme, ti consente di decidere conflitto per conflitto e si rifiuta di salvare mentre rimangono i marcatori.

In GitTree, un'unione che si interrompe mostra un banner con il numero di conflitti e un elenco dei file in conflitto. Aprine uno e l'editor prende l'intera finestra: i rami corrente e in entrata uno accanto all'altro in alto, ciascuno etichettato con il nome del ramo, e l'Output, il file così come verrà salvato, sotto.

• Per conflitto: prendi il lato corrente, il lato in entrata, entrambi o nessuno dei due, oppure scegli singole righe da ciascuno.
• Modifica output manualmente per tutto ciò che i pulsanti non coprono.
• Mostra Base per vedere l'antenato comune (Git lo scrive quando merge.conflictStyle è diff3 o zdiff3).
• Annulla scelta per tornare indietro nelle tue decisioni.
• File eliminati: quando una parte elimina un file che l'altra modifica, conserva il file di quella parte o conferma l'eliminazione.

GitTree non salverà un risultato che contiene ancora linee di contrassegno. Può anche aprire il file nel tuo strumento di unione esterno: VS Code, Cursor, JetBrains IDE, Beyond Compare, Meld, KDiff3, P4Merge, WinMerge, un programma personalizzato o merge.tool di Git. Se lo strumento si chiude senza risolvere il file, il file rimane in conflitto.

Prevedi i conflitti di unione prima di unirli

A partire da Git 2.38, git merge-tree --write-tree esegue un'unione in memoria senza leggere o scrivere l'albero o l'indice di lavoro e senza effettuare un commit. Con --name-only elenca i file che potrebbero entrare in conflitto; lo stato di uscita è 1 in caso di conflitti e 0 quando l'unione sarebbe pulita.

$ git fetch
$ git merge-tree --write-tree --name-only HEAD origin/main
0d708adc4a836d088802870278cb1f3daf06355f
src/auth.ts

Auto-merging src/auth.ts
CONFLICT (content): Merge conflict in src/auth.ts

GitTree esegue questa anteprima per te: la finestra di dialogo di unione mostra il risultato previsto prima della conferma. Dopo ogni recupero, controlla anche il tuo ramo rispetto al suo upstream e al ramo base (principale o master a meno che non ne imposti un altro) e mostra un avviso accanto al nome del ramo, come "Sarebbe in conflitto con main in 2 file". Un secondo suggerimento segnala che i file che stai modificando verranno modificati anche da altri rami recuperati e non uniti.

Entrambi i controlli utilizzano solo ciò che hai già recuperato: nulla viene recuperato, unito o modificato per calcolarli e nulla lascia il tuo computer. Entrambi possono essere disattivati ​​nelle Preferenze.

Riutilizza le risoluzioni dei conflitti con git rerere

Rerere sta per “riutilizzare la risoluzione registrata”. Quando è attivo, Git registra ogni conflitto e il modo in cui lo hai risolto. Quando si ripresenta lo stesso conflitto, ad esempio su un rebase ripetuto di un ramo di lunga durata o su una fusione che riesegui, Git scrive la tua precedente risoluzione nel file.

$ git config --global rerere.enabled true
$ git rerere forget src/auth.ts   # drop a recorded resolution that was wrong

Git lascia il risultato riutilizzato non sottoposto a fase di revisione per la revisione a meno che non sia impostato rerere.autoUpdate. In GitTree, le impostazioni del repository hanno opzioni Riutilizza risoluzioni registrate (rerere) e Stage risoluzioni riutilizzate per le opzioni Git; la visualizzazione del conflitto etichetta una risoluzione riutilizzata e Dimentica risoluzione elimina quella sbagliata.

Come interrompere o annullare un'unione in Git

Per annullare un'unione che si è interrotta a causa di conflitti, esegui git merge --abort. Un rebase, un cherry-pick o un ripristino hanno la propria interruzione:

$ git merge --abort
$ git rebase --abort
$ git cherry-pick --abort
$ git revert --abort

La documentazione di Git avverte che git merge --abort non può sempre ricostruire le modifiche non salvate che avevi all'inizio dell'unione. Esegui il commit o l'archiviazione prima dell'unione e l'interruzione richiede solo il lavoro impegnato da ripristinare.

In GitTree, Abort Merge (o Abort Rebase, Cherry-Pick, Revert) spiega innanzitutto che Git ripristina il ramo, l'indice e la copia di lavoro precedenti all'operazione e annulla le risoluzioni prese finora. GitTree salva tutto ciò che viene eliminato dall'interruzione, messo in scena o meno, negli snapshot di ripristino, quindi Annulla può ripristinarlo.

Come annullare un'unione dopo averla confermata

Cosa fare dipende da se hai effettuato il push dell'unione:

# Not pushed yet, right after the merge:
$ git reset --hard ORIG_HEAD     # also discards uncommitted changes
$ git reset --merge ORIG_HEAD    # keeps uncommitted changes

# Already pushed:
$ git revert -m 1 <merge-commit> # a new commit that reverses it

Un'unione salva il suggerimento precedente del tuo ramo in ORIG_HEAD, quindi reimpostarlo rimuove l'unione, a meno che un successivo ripristino o rebase non abbia spostato ORIG_HEAD. Una volta che gli altri hanno eseguito l'unione, ripristina invece. Annullare un'unione dice a Git che non vorrai mai quelle modifiche: unire nuovamente quel ramo non le riporterà indietro a meno che non annulli il ripristino.

In GitTree, seleziona il primo genitore dell'unione (il commit su cui si trovava prima il tuo ramo) nel grafico e scegli un soft reset, misto o hard reset dal menu commit, ciascuno etichettato con ciò che mantiene. GitTree esegue uno snapshot di 19 tipi di operazioni prima che vengano eseguite, reimpostazioni incluse, in modo che Annulla possa annullare la reimpostazione e la visualizzazione reflog recupera gli stati precedenti. La guida per annullare un ripristino, un rebase o un commit tratta il ripristino in modo approfondito.

Come prevenire la maggior parte dei conflitti di unione

• Mantieni i rami piccoli e di breve durata. Più due rami sono lunghi e divergono, più linee si toccano.
• Inserisci spesso il ramo base, non una volta alla fine.
• Separa la formattazione dalla logica. Concorda un formattatore e riformatta l'intero file da solo.
• Rigenera i file di blocco invece di unirli manualmente. Prendi uno dei due lati, quindi esegui nuovamente il gestore dei pacchetti.
• Attiva zdiff3 e rerere una volta. Due comandi, vantaggio duraturo.
• Esegui il commit o l'archivio prima dell'integrazione, in modo che ogni interruzione e annullamento sia esatta.

Vuoi prima esercitarti su un repository sicuro? La lezione gratuita Unisci rami divergenti e verifica entrambi i genitori nei Tutorial Git illustra una vera unione. Stai ancora valutando il terminale rispetto a una GUI? Git GUI e riga di comando li confronta entrambi in modo onesto.

GitTree ha un piano gratuito che copre tutte le funzionalità Git, repository privati ​​inclusi, e Nour, l'assistente AI, viene fornito con GitTree Pro (vedi prezzi); sono necessari Git 2.39 o più recenti e un account GitTree per accedere. Acquistalo a macOS, Windows o Linux, oppure visualizza tutti i programmi di installazione nella GitTree pagina di download. Il giorno Ubuntu 22.04, aggiorna prima Git. Bloccato in un conflitto ostinato? Chiedi assistenza a GitTree.