Se stai utilizzando Git per la gestione del codice sorgente, potresti dover unire diverse branch di sviluppo per un progetto in una singola branch. Questo articolo ti guiderà su come combinare due branch di sviluppo con il comando di merge di Git.
Ti mostreremo come creare un progetto Git, creare diverse branch e unire una branch con un’altra. Inoltre, imparerai cos’è un merge veloce e un merge a tre vie, e come unire una branch in un repository remoto.
Cos’è il merge Git?
Git è un popolare strumento DevOps che gli sviluppatori possono utilizzare per tracciare e gestire le modifiche al codice scritte da diverse squadre. Con il comando di merge Git, puoi prendere la tua attuale branch di sviluppo (che hai derivato dalla branch principale) e unire le modifiche al codice di essa nella branch principale.
Il merge di Git è un comando che userai più spesso quando lavori in un team. Potrebbero esserci momenti in cui tu e un altro sviluppatore collaborate su una funzionalità su due branch separati. Tuttavia, quando arriverà il momento, dovrai combinare il tuo lavoro in una sola branch, testare quelle modifiche e poi unire il tuo sviluppo collaborativo nella branch di sviluppo principale.
Mentre la branch principale di sviluppo viene aggiornata, la branch separata di feature su cui stai lavorando insieme ad altri sviluppatori non verrà aggiornata con le modifiche del tuo team. Pertanto, come migliore pratica, quando sarà il momento di presentare una pull request, dovresti sempre iniziare aggiornando la tua versione locale della branch principale con le ultime modifiche. Quindi, puoi unire la branch principale aggiornata nella tua branch di sviluppo prima di effettuare il commit e presentare una pull request per unire quest’ultima nella branch principale di sviluppo.
Come combinare due branch Git con Git merge
Come sviluppatore, essere competenti in Git può davvero aiutarti ad essere più produttivi. Per iniziare, è fondamentale capire come eseguire comandi Git dalla riga di comando. Prima di iniziare, vediamo cosa dovrai configurare prima di poter iniziare ad unire diversi branch Git.
Prerequisiti
Per iniziare, avrai bisogno degli elementi seguenti:
- A Windows, Mac, or Linux machine to run Git.
- L’app Git, che è disponibile per scaricare qui.
- A GitHub or Gitlab account.
- Software di editing del codice come Visual Studio Code.
Corriamo velocemente attraverso i diversi passaggi necessari per installare Git su un PC Windows (abbiamo anche una guida separata su come installare Git su Ubuntu):
- Segui il link per scaricare Git per la tua macchina e installare i file.
- Una volta installato, apri il terminale e digita git –version:
git –version
Se ricevi un numero di versione restituito, ottimo! Tuttavia, se ricevi un messaggio “comando non trovato”, potresti dover aggiungere Git alla tua variabile $PATH. Questo è di solito un problema di Windows.
Risolviamo rapidamente questo problema in modo da non dover vagare alla ricerca.
- Vai sulla barra delle applicazioni e fai clic con il tasto destro su Questo PC.
- Seleziona Proprietà.
- Fai clic su Impostazioni di sistema avanzate.
- In Proprietà di sistema, fai clic su Variabili d’ambiente. Qui puoi aggiungere valori alla variabile $PATH.
- Seleziona $PATH e clicca su Modifica.
- Clicca su Nuovo e aggiungi un percorso al git/cmd.
- Clicca su Nuovo e aggiungi il percorso al file git.exe.
Salva le modifiche, torna al terminale, e esegui nuovamente il comando git -version.
git -version
Dovresti ora ricevere il numero di versione restituito. Dopo aver completato il lavoro preliminare e impostato il tuo account GitHub o GitLab, dovresti essere pronto per iniziare.
Creazione di un progetto Git
In questa sezione, ti guiderò attraverso i diversi passaggi necessari per creare un nuovo repository.
Nel tuo account GitHub appena creato, fai clic su Nuovo sul lato sinistro dello schermo.
Successivamente, dovrai dare un nome al tuo repository e compilare alcuni altri dettagli. Aggiungi una breve descrizione se vuoi, rendilo pubblico e una prassi consigliata è aggiungere sempre un file ReadMe. Una volta completato, fai clic su Crea repository.
Ora, per iniziare a lavorare nel tuo editor di codice, vorrai clonare il tuo nuovo repository facendo clic sul pulsante Clona. Seleziona HTTPS, copia l’indirizzo, e apri il tuo terminale.
Nel terminale, utilizza il comando cd per scegliere dove creare una nuova directory per il tuo progetto.
cd user/desktop/repo/
Quando sei nel branch corretto, usa il comando mkdir per creare una nuova directory:
mkdir <name of your directory>
Ora, utilizziamo nuovamente il comando cd per passare a quella nuova directory appena creata:
cd <name of your newly created directory>
Una volta nella tua nuova directory, usa il comando git init per creare un nuovo repository:
git init
Successivamente, utilizza il comando git clone con l’indirizzo HTTPS corretto e premi Invio. Per impostazione predefinita, ciò creerà un branch principale nel tuo repository locale.
git clone <paste https address here>
Adesso, apri il tuo repository appena clonato con Visual Studio Code. Ora puoi iniziare a scrivere codice.
Dopo aver creato il tuo repository, sarai già nel branch principale. Come pratica consigliata, non dovresti mai, assolutamente, inviare codice direttamente al branch principale, che deve essere protetto.
Per quanto riguarda questo tutorial, non affronteremo branche Git protette. Ma sul campo, non sarai mai in grado di fare push del codice sul ramo principale senza una pull request.
Creare un’altra branca Git
Attualmente siamo sul ramo principale, hai codificato qualcosa per creare qualche contenuto e ora vuoi creare una nuova branca.
Nel terminale, usa il comando git checkout per creare una nuova branca e passare automaticamente ad essa:
git checkout -b <name of new branch>
Il comando dovrebbe automaticamente separare quella nuova branca dal tuo ramo principale, quindi il codice di quest’ultimo non dovrebbe cambiare.
Ora, ecco la parte divertente in cui saremo in grado di utilizzare il comando git merge. Sulla tua nuova branca appena creata, avrai bisogno prima di aggiungere altro codice in modo che il tuo ramo attuale sia avanti rispetto al ramo principale con alcune nuove modifiche.
Ora che desideri unire questa nuova branca al ramo principale, potresti incontrare un conflitto di merge, che è un’aggiunta di codice in conflitto con il codice che esiste già. Non è affatto divertente occuparsene.
Quindi, cosa fai? Vediamo come unire un ramo con l’altro.
Unire i tuoi due rami Git nel tuo repository locale
Mentre ti trovi sul tuo nuovo ramo, vai al terminale e utilizza il comando git branch per verificare il nome del ramo su cui ti trovi:
git branch
Ora sei sul tuo nuovo ramo, utilizza nuovamente il comando git checkout per passare al tuo ramo principale:
git checkout Main
Successivamente, utilizza il comando git pull per importare eventuali modifiche che il tuo team potrebbe aver apportato e aggiornare il tuo ramo principale locale:
git pull
Ora, utilizza di nuovo git checkout per passare al nuovo ramo che desideri unire con il ramo principale:
git checkout <your specified branch>
È ora il momento di utilizzare il comando git merge. Questo prenderà la versione attuale del tuo ramo principale e la unirà al tuo ramo di sviluppo:
git merge Main
Il risultato della fusione avrà l’ultima versione del codice più la funzionalità che hai sviluppato.
Altri modi per unire i rami Git
Dopo averti mostrato come unire un nuovo ramo con il nostro ramo principale, vediamo altri modi per unire i rami Git che potresti dover utilizzare.
Cos’è una fusione in avanti veloce?
A fast-forward merge is another way to merge multiple commits on one branch with one command rather than merging them all manually. Another advantage of using a fast-forward merge is that it will combine the histories of multiple commits while squashing the commit history.
Supponiamo di avere un ramo di funzionalità avanti rispetto al ramo principale di diversi commit. Vogliamo unire tutti questi commit senza doverli unire manualmente uno per uno. In questo caso, useremo una fusione in avanti.
Nel nostro esempio, inizieremo scrivendo del codice e aggiungendo un nuovo commit al nostro ramo con i comandi git add e git commit:
git add <filename>
git commit –m “added a thing”
Ora, aggiungeremo un altro commit al nostro nuovo ramo utilizzando nuovamente gli stessi comandi:
git add <filename>
git commit –m “added another thing”
Successivamente, vogliamo spingere questi due commit al nostro repository remoto senza dover fare due push. Per farlo, dobbiamo utilizzare il -ff sul comando di merge di git
git merge --ff
Questo unirà entrambi i commit contemporaneamente in uno solo e farà sì che il tuo codice raggiunga il ramo principale.
Cosa è una fusione a 3 vie?
Immagina un caso in cui il tuo team di sviluppo ha creato alcune nuove funzionalità su due rami separati. Ora sei pronto per aggiornare i rami e unirli al ramo principale in modo che quest’ultimo sia pronto per spingere il codice in un repository remoto.
Per garantire che le nuove funzionalità funzionino correttamente insieme, è una buona idea unire i rami delle funzionalità tra loro e quindi fare alcuni test. Una fusione a 3 vie ci permetterà di combinare due rami separati con il loro antenato comune.
Attraversiamo i passaggi necessari per eseguire una fusione a 3 vie sul ramo di destinazione. Nell’esempio seguente, inizieremo creando un nuovo ramo, aggiungendo due commit ad esso e lo combineremo con il nostro ramo principale utilizzando una fusione a 3 vie.
Prima di tutto, iniziamo creando un ramo ‘nuova-funzionalita’ e passando automaticamente ad esso con il comando git checkout. Specificare -b con questo comando fa sì che venga creato un nuovo ramo:
git checkout -b new-feature main
Successivamente, aggiungiamo alcuni file e un nuovo commit al nostro ramo con i seguenti comandi:
git add <file>
git commit -m "Start a feature"
Aggiungiamo poi un altro commit al nostro nuovo ramo con i seguenti comandi:
git add <file>
git commit -m "Finish a feature"
Dopo aver aggiunto nuovo codice al nostro nuovo ramo, immaginate una situazione in cui il nostro ramo principale continua a progredire. Prima di tutto, faremo ritorno ad esso con il comando git checkout:
git checkout main
Successivamente, aggiungeremo un nuovo commit al nostro ramo principale:
git add <file>
git commit -m "make some changes to Main"
Ora vogliamo unire il ramo ‘nuova-funzionalita’ che abbiamo creato in precedenza con il nostro ramo principale aggiornato. Poiché il lavoro continuerà sul nostro ramo principale, finiremo eliminando il ramo ‘nuova-funzionalita’ con il comando git branch.
git merge new-feature
git branch -d new-feature
Abbiamo ora unito i nostri due rami con un antenato comune nel nostro ramo principale. Quest’ultimo è ora pronto per essere unito nel repository remoto e per incrementare ulteriormente il nostro progetto software, e vedremo come fare questo prossimamente.
Come unire un ramo Git a un repository remoto
A volte potresti aver bisogno di unire un ramo in un repository remoto. Guidiamo i passaggi su come farlo.
Immaginiamo una situazione in cui hai scritto del nuovo codice per una nuova funzionalità che il tuo proprietario del prodotto voleva creare. Dopo aver testato il codice e averlo visionato con il tuo proprietario del prodotto, sei ora pronto per unire il tuo duro lavoro nel repository remoto del tuo team.
Come già menzionato, non dovresti mai essere in grado di fare push del tuo codice direttamente sul ramo principale. Devi sempre rispettare il flusso di lavoro di Git che abbiamo dettagliato all’inizio di questa guida.
Dopo aver esaminato il processo di Git, uniamo il tuo codice. Riprendendo da dove abbiamo lasciato, ora abbiamo un ramo aggiornato: gli ultimi aggiornamenti del ramo principale sono stati tirati giù nel tuo repository locale.
Ti trovi ora di fronte al cancello del repository remoto. Come ci arrivi? Semplice, useremo altri comandi git.
Come pratica ottimale, dovresti sempre controllare lo stato del tuo ramo con il comando git status. Questo comando mostrerà quali file sono stati aggiunti, rimossi, tracciati o non tracciati.
git status
Dovresti anche controllare se hai aggiunto file che non sono tracciati. In tal caso, devi aggiungerli affinché siano tracciati e aggiunti al commit.
Puoi utilizzare il comando git add per aggiungere tutti i file che hai creato nello sviluppo. Ora, potresti essere tenuto a scrivere alcuni nomi di file se desideri aggiungere solo file specifici. Se desideri aggiungere tutti i file usa “.” per aggiungere tutti i file.
Successivamente, useremo il comando git commit per effettuare il commit di tutti i file aggiunti nel passaggio precedente. Dovrai utilizzare il flag -m per scrivere un messaggio, altrimenti ti verrà aperto l’editor di testo per scrivere un messaggio, il che non è un processo scorrevole.
Per il tuo messaggio, puoi scrivere una breve nota su ciò che hai fatto. Ad esempio, “creato una nuova funzionalità interessante, aggiunto un nuovo icona al menu e apportate correzioni di bug.”
git commit -m “<your commit message goes here>”
Infine, puoi utilizzare il comando git push per inviare il tuo ramo al repository remoto.
git push --set-upstream origin <<your branch name>>
Ora, dopo aver inviato il tuo ramo, dovrai andare su GitHub o dove sono ospitati i tuoi repository remoti, trovare il tuo ultimo invio e fare clic su Crea richiesta di pull.
Una volta fatto clic su questo pulsante, verrai indirizzato a una pagina per aggiungere revisori e membri del tuo team che approveranno o respingeranno la tua richiesta di merge. In quest’ultimo caso, saranno in grado di aggiungere commenti su ciò che deve essere corretto prima di consentirti di unire il tuo ramo al ramo principale remoto.
Una volta che la revisione è completa e la tua richiesta di merge è stata approvata, il pulsante Merge sarà disponibile. Clicca su questo pulsante per avviare il merge. Se il merge ha successo, riceverai un messaggio che conferma che il tuo nuovo codice è stato aggiunto.
Congratulazioni! Hai appreso le basi per utilizzare il comando di merge di git!
Conclusione
Git merge è un comando potente che ti permetterà a te e al tuo team di utilizzare branch diversi per lavorare su nuove funzionalità e poi unirle al repository principale.
Hai imparato i passaggi corretti necessari per creare branch, unirli, aggiungere file e commit ad essi, e, cosa più importante, pushare quei branch in un repository remoto. Inoltre, ora comprendi come fare un merge fast-forward per combinare diversi branch correlati usando un solo comando, il che può davvero aiutare a rendere più efficiente qualsiasi lavoro di sviluppo.
Git è uno strumento potente che può fare molto. Più impari sui diversi comandi che puoi utilizzare, migliore diventerai come sviluppatore. Ora che hai imparato tutto ciò che hai bisogno di sapere sul merge di branch, è tempo di andare a imparare altri comandi. Buona fortuna nella tua ricerca per padroneggiare Git!