Git Merge Semplificato: Unire Branch Come un Professionista – techsyncer

La fusione dei rami in Git può talvolta essere un compito intimidatorio, ma il comando git merge semplifica significativamente il processo. In questo tutorial, imparerai gli elementi essenziali della combinazione dei rami utilizzando git merge, abbinato a GitHub, un importante strumento di gestione dei progetti.

Cominciamo questo viaggio nel mondo di Git e GitHub, concentrandoci sul potente comando git merge.

Prerequisiti per Padroneggiare la Fusione in Git

Prima di addentrarti nelle complessità di git merge, assicurati di avere il seguente setup:

Git (Versione 2.25.1 usata in questo tutorial) – Scarica dal sito ufficiale di Git.
A GitHub account – Sign up at GitHub.
Una macchina Ubuntu (Ubuntu 20.04 è utilizzato qui, ma qualsiasi sistema operativo con Git sarà sufficiente).

Inizializzazione di un Progetto per la Fusione in Git

Per utilizzare efficacemente git merge, è necessario prima avere un progetto Git. Creiamo un progetto di esempio per fare pratica.

1. Inizia creando una nuova directory chiamata ~/git-demo e naviga al suo interno:

mkdir git-demo && cd git-demo

2. Crea un file index.html nella directory ~/git-demo con il seguente contenuto. Questo file HTML di base mostra un messaggio su come iniziare con git merge.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Git Merge Demo</title>
</head>
<body>
    <h4>Let's get started with git merge</h4>
</body>
</html>

3. Inizializza un nuovo repository Git nella directory del tuo progetto:

Il comando git init viene utilizzato per convertire un progetto esistente e non versionato in un repository Git o per avviare un nuovo progetto con Git.

git init

Initializing a Git repository for git merge

4. Conferma la creazione della cartella .git nella directory del tuo progetto. Questa cartella è dove Git tiene traccia delle modifiche:

ls -la

Verifying the existence of the GIT repository in the directory.

5. Implementa il comando git add per preparare le tue modifiche nel progetto. Staging del file index.html, lo stai preparando per il prossimo commit nel workflow di Git.

git add index.html

6. Utilizza git status per confermare che il tuo file sia correttamente preparato. Questo comando fornisce uno snapshot dello stato attuale della tua directory di lavoro.

git status

Confirming the staging of changes for git merge.

7. Successivamente, esegui il commit delle tue modifiche utilizzando git commit. Questo comando salva le tue modifiche preparate nel repository locale, segnando un passaggio significativo nella tua cronologia delle versioni.

git commit -m "initial commit"

Executing the initial commit in preparation for git merge.

Imposta la tua identità Git con: git config --global user.email "[email protected]" e git config --global user.name "Your Name" se stai usando Git per la prima volta.

8. Controlla la cronologia dei tuoi commit con git log. Questo comando ti aiuta a tenere traccia delle modifiche ed è vitale quando ti prepari per un git merge.

git log

Checking commit history before performing git merge.

9. Conferma l’esistenza di rami nel tuo repository con git branch. Questo passaggio è cruciale prima di eseguire un git merge.

Nota: Il ramo predefinito è chiamato ‘main’ nelle versioni recenti di Git, sostituendo ‘master’.

git branch

Listing all branches in preparation for git merge.

Creazione di un ramo per il merge di Git

Con la tua configurazione iniziale di Git completa e il primo commit effettuato, è ora di creare un nuovo ramo. Questo ramo verrà utilizzato per dimostrare efficacemente il processo di git merge.

1. Aggiorna il file index.html con un nuovo contenuto per mostrare le modifiche nel tuo ramo. Questa versione include campi di input utente, preparandoti per una dimostrazione di git merge.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Git Merge Demo</title>
</head>
<body>
    <h4>Enhancing Git Merge Skills</h4>
    <form action="">
      <input type="text" name="username" placeholder="Username" />
      <input type="password" name="password" placeholder="Password" />
    </form>
</body>
</html>

2. Verifica lo stato del tuo repository con git status per visualizzare le modifiche in index.html. Dovrebbe indicare che il file è stato modificato e non è stato committato, pronto per i passaggi successivi nel processo di git merge.

Inspecting repository changes for git merge.

3. Crea un nuovo ramo chiamato “form” con git checkout -b form. Questo comando non solo crea il nuovo ramo, ma passa anche il tuo ramo di lavoro a “form”, essenziale per implementare git merge.

git checkout -b form

4. Conferma la creazione del nuovo ramo eseguendo git branch. Dovresti ora vedere sia i rami “form” che “master”, con “form” come ramo attivo indicato da un asterisco (*).

git branch

Confirming the active ‘form’ branch for git merge.

5. Stage e committa le tue modifiche al ramo form. Questa azione assicura che il ramo form rifletta gli aggiornamenti recenti apportati al file index.html, preparando il terreno per un efficace git merge.

## Fase del file aggiornato
git add index.html

## Eseguire il commit delle nuove modifiche
git commit -m "Added user input fields to form"

Committing updated index.html to the ‘form’ branch for git merge.

Fusione del branch locale con Git Merge

Ora che hai branch distinti nel tuo repository GitHub, il passo successivo è unirli. Questa sezione si concentra sulla fusione dei branch in locale utilizzando il comando git merge, un’operazione fondamentale di Git.

1. Per iniziare la fusione, passa al branch master, che riceverà gli aggiornamenti dal branch form:

git checkout master

2. Una volta sul branch master, esegui git merge form per combinare le modifiche dal branch form in master. Questo è un passaggio cruciale nel processo di git merge.

git merge form

Successfully merging branches using `git merge`.

3. Conferma la fusione assicurandoti di essere sul branch master e controllando che il contenuto di index.html sia stato aggiornato.

# Conferma il branch attuale
git branch
# Controlla il contenuto fuso
cat index.html

Reviewing *index.html* content post `git merge`.

Razionalizzazione con Git Squash

Lo squashing in Git è una tecnica utilizzata per pulire la cronologia dei commit. Quando hai più messaggi di commit non necessari individualmente, lo squashing ti permette di combinarli in un unico commit esaustivo. Questa pratica è particolarmente utile quando ci si prepara per una git merge.

Esploriamo il processo di squashing apportando ulteriori modifiche al file index.html sul branch form, e poi schiacciando queste modifiche.

1. Passa nuovamente al ramo form per apportare ulteriori modifiche:

git checkout form

2. Modifica il index.html aggiungendo un’intestazione del modulo. Questo passaggio creerà una modifica che successivamente schiacceremo durante il merge:

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <h4>Mastering Git Merge with Form Updates</h4>
    <form action="">
      <h4>Account Details</h4>
      <input type="text" name="username" placeholder="Username" />
      <input type="password" name="password" placeholder="Password" />
      <button>Submit</button>
    </form>
</body>
</html>

3. Fai lo stage e fai il commit delle modifiche con un messaggio chiaro che descrive l’aggiornamento:

git add index.html
git commit -m "Enhanced form with a header for git merge"

Staging and committing changes for squashing in `git merge`.

4. Migliora il index.html nel ramo form aggiungendo un nuovo campo di input. Questa modifica fa parte della preparazione per un efficace git merge.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Git Merge Example</title>
</head>
<body>
    <h4>Practicing Git Merge</h4>
    <form action="">
      <h4>Enter account details</h4>
      <input type="text" name="fullname" placeholder="Full Name" />
      <input type="text" name="username" placeholder="Username" />
      <input type="password" name="password" placeholder="Password" />
      <button>Submit</button>
    </form>
</body>
</html>

5. Fai lo stage e fai il commit di queste modifiche con un messaggio distinto, assicurandoti che ogni passaggio del tuo lavoro sia chiaramente documentato per il prossimo git merge.

git add index.html
git commit -m "Enhanced form with an additional input field"

Adding another input field to index.html for `git merge`.

6. Successivamente, inserisci un elemento di paragrafo sotto il modulo in index.html, modificando ulteriormente il file in preparazione per un git merge.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Git Merge Practice</title>
</head>
<body>
    <h4>Let's get started with git merge</h4>
    <form action="">
      <h4>Enter account details</h4>
      <input type="text" name="fullname" placeholder="Full Name" />
      <input type="text" name="username" placeholder="Username" />
      <input type="password" name="password" placeholder="Password" />
      <button>Submit</button>
    </form>
    <p>Already a user?</p>
</body>
</html>

7. Di nuovo, fai lo stage e fai il commit delle modifiche, utilizzando un messaggio che cattura l’essenza di questo aggiornamento, cruciale per il processo di git merge.

git add index.html
git commit -m "Added user status paragraph to form"

Further modifying index.html for `git merge`.

8. Utilizza git rebase in modalità interattiva per visualizzare e modificare i tuoi commit recenti. Questo passaggio è essenziale nel processo di schiacciamento dei commit per un git merge pulito.

git rebase -i HEAD~3

9. Nella modalità interattiva, scegli di reword il primo commit e squash quelli successivi. Quest’azione consolida la tua cronologia dei commit, rendendo il tuo git merge più pulito e organizzato.

Preparing commits for squashing in `git merge`.

10. Dopo aver riformulato e salvato, aggiorna il messaggio di commit consolidato per riflettere le modifiche cumulative. Questo passaggio finalizza il processo di schiacciamento, preparandoti per un git merge snello.

Finalizing the commit message for `git merge`.

Conferma il successo della tua operazione di schiacciamento, che è una parte integrante del processo di git merge quando si gestiscono più messaggi di commit.

Per schiacciare e fondere simultaneamente, utilizza git merge --squash. Questa tecnica fonde e schiaccia il ramo form nel ramo master, combinando efficacemente i commit.

git merge --squash form

Eseguendo il comando git merge --squash si combinano le modifiche dal ramo form in master mentre si condensano tutti i commit in uno solo. Questo approccio fa parte delle strategie efficaci di git merge.

Executing `git merge` with squash option.

Implementazione del Fast-Forward in Git Merge

Per una cronologia dei commit snella, il fast-forwarding è un metodo ideale, particolarmente per aggiornamenti minori o correzioni di bug. Consente di fondere i rami senza commit di merge aggiuntivi, mantenendo una cronologia pulita e lineare, fondamentale per processi di git merge efficienti.

Il fast-forwarding avviene quando non c’è divergenza nel ramo base, tipicamente il master, consentendo un’integrazione senza soluzione di continuità delle cronologie e degli aggiornamenti dei puntatori.

1. Cambia al ramo form per iniziare il processo di fast-forward:

git checkout form

2. Crea e aggiorna un file JavaScript, come index.js, nel ramo form, mettendo in stage e committando le modifiche:

git add index.js
git commit -m "Added JavaScript functionality"

3. Infine, fai il merge del ramo form in master utilizzando un approccio fast-forward. Questo passaggio allinea il ramo master con le ultime modifiche dal ramo form, creando un percorso di git merge fluido e lineare.

git checkout master
git merge form

Conclusioni

Questo tutorial ti ha guidato attraverso varie tecniche per combinare i rami usando git merge. Dallo schiacciamento dei commit al fast-forwarding, questi metodi migliorano la tua capacità di gestire progetti in collaborazione su Git.

Ora, dotato di queste competenze, considera di contribuire a progetti collaborativi su GitHub, applicando le tue conoscenze di git merge in scenari del mondo reale.