Come posso completare l'unione dopo aver risolto i miei conflitti di unione?

Ho letto la sezione ramificazione e fusione di base del Git Community Book.

Quindi seguo e crearne un ramo: experimental.

Quindi io:

1. passa al ramo sperimentale (checkout git sperimentale)
2. apportare molte modifiche
3. commit (git commit -a)
4. passa al ramo principale (git checkout master)
5. apportare alcune modifiche e impegnarsi lì
6. torna a sperimentale (git checkout sperimentale)
7. unisci master change in sperimentale (git merge master)

8. ci sono alcuni conflitti ma dopo averli risolti, ho fatto 'git add myfile'

9. E ora sono bloccato, non posso tornare al maestro

quando io faccio

 $ git checkout master
error: Entry 'res/layout/my_item.xml' would be overwritten by merge. Cannot merge.

e ho fatto:

$ git rebase --abort

Nessun rebase in corso?

e ho fatto:

$  git add res/layout/socialhub_list_item.xml
$ git checkout master
error: Entry 'res/layout/my_item.xml' would be overwritten by merge. Cannot merge.

Cosa posso fare in modo da poter tornare al mio ramo principale?

Quando si verifica un conflitto durante un'unione, è necessario completare manualmente il commit di unione. Sembra che tu abbia fatto i primi due passaggi, per modificare i file in conflitto e quindi eseguirli git addper contrassegnarli come risolti. Infine, è necessario impegnare effettivamente l'unione con git commit. A quel punto sarai in grado di cambiare di nuovo i rami.

Come posso completare l'unione dopo aver risolto i miei conflitti di unione?

Con Git 2.12 (Q1 2017), avrai il comando più naturale:

git merge --continue

Vedi commit c7d227d (15 dic 2016) di Jeff King ( peff) .
Vedi commit 042e290 , commit c261a87 , commit 367ff69 (14 dic 2016) di Chris Packham ( cpackham) .
^{(Unita da Junio ​​C Hamano - gitster- in commit 05f6e1b , 27 dic 2016)}

Vedi le note di rilascio della 2.12 .

merge: aggiungi ' --continue' opzione come sinonimo di ' git commit'

Insegnare ' git merge' l' --continueopzione che consente di 'continuare' una fusione completandola.
Il modo tradizionale di completare una fusione dopo aver risolto i conflitti è usare ' git commit'.
Ora con comandi come ' git rebase' e ' git cherry-pick' avere --continueun'opzione ' ' che aggiunge tale opzione a ' git merge' presenta un'interfaccia utente coerente.

Nel caso in cui rimani bloccato durante un'unione / rebase, puoi sempre

git reset --hard

per ripristinare il tuo lavoro allo stato dell'ultimo commit. Questo perderà le tue modifiche dall'albero di lavoro, quindi se hai apportato modifiche locali prima dell'unione, queste verranno perse dopo questo, motivo per cui è consigliabile non iniziare un'unione quando si hanno modifiche locali. :)

Proprio git commitcosì

Opzionalmente git abort:
mi sono imbattuto in un conflitto di unione. Come posso interrompere l'unione?

Per semplificare la vita con on merges installa kdiff3 e configuralo come un mergetool. Istruzioni: http://doodkin.com/2016/05/29/git-merge-easy-github-this-branch-has-conflicts-that-must-be-resolved-use-the-command-line/

Quella pagina contiene questo video: https://www.youtube.com/watch?v=Cc4xPp7Iuzo

Ogni volta che unisci due rami usando il comando git merge brancha branchb, ci sono due possibilità:

1. Un ramo (diciamo brancha) può essere raggiunto dall'altro ramo (diciamo ramo b) seguendo la sua cronologia di commit. In questo caso git semplicemente avanzare rapidamente la testa per puntare al ramo recente (in questo caso ramo b).

   2. Ma se i due rami sono divergenti in un punto precedente, git crea una nuova istantanea e aggiunge un nuovo commit che punta ad esso. Quindi nel caso in cui non ci siano conflitti tra i rami che stai unendo, git crea senza problemi un nuovo commit.

Esegui git logper visualizzare il commit dopo aver unito due rami non in conflitto.

Ora torniamo al caso interessante quando ci sono conflitti di unione tra i rami che si fondono. Cito questo dalla pagina https://git-scm.com/book/en/v2/Git-Branching-Basic-Branching-and-Merging

Git non ha creato automaticamente un nuovo commit di unione. Ha sospeso il processo mentre si risolve il conflitto. Se si desidera vedere quali file non sono stati uniti in qualsiasi momento dopo un conflitto di unione, è possibile eseguiregit status

Quindi, in caso di conflitti di unione, è necessario risolvere il conflitto, quindi aggiungere le modifiche apportate all'area di gestione temporanea utilizzando git add filenamee quindi eseguire il commit delle modifiche utilizzando il comando git commit che è stato messo in pausa da Git a causa del conflitto. Spero che questo spieghi query. Visitate anche il link sopra per una comprensione dettagliata. In caso di domande, ti preghiamo di commentare qui sotto, sarò felice di aiutarti.

I passi successivi dopo la risoluzione manuale dei conflitti sono: -

1. git add.
2. stato git (questo ti mostrerà quali comandi sono necessari per continuare la procedura di unione automatica)
3. [comando git suggerisce, per esempio git merge --continue, git cherry-pick --continue, git rebase --continue]

Un conflitto di unione si verifica quando due rami che stai tentando di unire hanno entrambi cambiato la stessa parte dello stesso file. È possibile generare un elenco di conflitti congit status .

Quando viene rilevata la linea in conflitto, Git modificherà il contenuto dei file interessati con indicatori visivi che contrassegnano entrambi i lati del contenuto in conflitto.

<<<<<<< HEAD
conflicted text from HEAD
=======
conflicted text from merging_branch
>>>>>>> merging_branch

Quando si correggono i file in conflitto e si è pronti a unire, è sufficiente eseguire git adde git commitgenerare il commit di unione. Una volta effettuato il commit, git pushle modifiche al ramo.

Articolo di riferimento: Git merge .

Dopo aver aggiunto tutti i file, il passaggio successivo è un " git commit ".

"git status" suggerirà cosa fare: i file ancora da aggiungere sono elencati in fondo e, una volta terminati, suggeriranno un commit in alto, dove spiega lo stato di unione del ramo corrente.

La prima cosa che voglio chiarire è che i nomi dei rami sono solo un alias per un commit specifico. un commit è ciò che git funziona, quando tiri, spingi unione e così via. Ogni commit ha un ID univoco.

Quando esegui $ git merge, ciò che sta realmente accadendo è che git tenta di far avanzare rapidamente il tuo ramo corrente al commit su cui si trova il ramo di riferimento (in altre parole entrambi i nomi di ramo indicano lo stesso commit.) Questo scenario è il più semplice per git da gestire, dal momento che non esiste un nuovo commit. Pensa al maestro che salta sul lilipad sul quale il tuo ramo si sta rilassando. È possibile impostare il flag --no-ff, nel qual caso git creerà un nuovo commit indipendentemente dal fatto che ci siano stati conflitti di codice.

In una situazione in cui vi sono conflitti di codice tra i due rami che si sta tentando di unire (in genere due rami la cui cronologia di commit condivide un commit comune in passato), l'avanzamento rapido non funzionerà. git potrebbe essere ancora in grado di unire automaticamente i file, a condizione che la stessa riga non sia stata modificata da entrambi i rami in un file in conflitto. in questo caso, git unirà i file in conflitto per te e li commetterà automaticamente. Puoi vedere in anteprima come ha fatto git facendo $ git diff - nella cache. Oppure puoi passare il flag --no-commit al comando merge, che lascerà i file modificati nel tuo indice che dovrai aggiungere e eseguire il commit. Ma puoi $ git diff questi file per rivedere cosa cambierà l'unione.

Il terzo scenario è quando ci sono conflitti che git non può risolvere automaticamente. In questo caso dovrai unirli manualmente. Secondo me questo è più facile da fare con una fusione presa, come araxis merge o p4merge (gratuito). Ad ogni modo, devi fare ogni file uno per uno. Se l'unione sembra mai essere bloccata, usa $ git merge --continue, per spostarti. Git dovrebbe dirti se non può continuare, e se sì perché no. Se ritieni di aver sciolto l'unione a un certo punto, puoi fare $ git merge --abort, e qualsiasi fusione si annullerà e puoi ricominciare da capo. Al termine, ogni file che hai unito sarà un file modificato che deve essere aggiunto e sottoposto a commit. Puoi verificare dove sono i file con lo stato $ git. Se non hai ancora eseguito il commit dei file uniti. Devi farlo per completare l'unione.

Potrebbe essere tardi. È successo perché il tuo git HEAD non è aggiornato. questo encomio lo risolverebbe git reset HEAD.