I 20 migliori comandi Git con esempi: guida pratica

Lavorare con i repository remoti

GitHub ospita varie applicazioni sui suoi server remoti, permettendo agli sviluppatori di tracciarle e gestirle. In questa sezione vedremo come estrarre, trasferire e interagire con quei repository remoti usando i comandi Git. 

Vuoi capire come funziona GitHub? Inizia da un'Introduzione ai concetti di GitHub per comprendere repository, pull request e buone pratiche di collaborazione.

git remote add

Il comando git remote add crea una connessione tra il tuo repository Git locale e il repository Git remoto, consentendoti di eseguire push e pull delle modifiche tra loro:

git remote add <repo_name> <remote_url>

• <repo_name>: un alias per il repository remoto (“origin” per impostazione predefinita).
• <remote_url>: URL del repository remoto.

git push

Il comando git push sincronizza il repository remoto con quello locale. Una volta eseguito, il repository remoto rifletterà tutte le modifiche che hai fatto in locale.

git push <remote> <branch>

• <remote>: alias del repository remoto (“origin” per impostazione predefinita).
• <brach>: nome del branch che vuoi inviare.

Esistono alcune varianti di git push, per esempio:

git push ---all origin

Il comando sopra invia tutti i tuoi branch locali al repository remoto.

git push --force origin main

Il comando sopra sovrascrive il branch main sul repository remoto con il tuo branch main locale. Usalo con cautela, perché il branch main remoto potrebbe perdere tutta la sua cronologia. 

git pull

Il comando git pull recupera e unisce le modifiche nel repository remoto con quelle nel repository locale. 

Il comando git pull combina due comandi: git fetch e git merge. 

Prima, git fetch recupera tutte le modifiche dal repository remoto, inclusi nuovi commit, tag e branch. Poi, git merge viene eseguito integrando tali modifiche nel branch locale corrente. 

Ecco la sintassi:

git pull origin feature-branch

Il comando sopra recupera i dati da feature_branch sul repository remoto e li unisce al tuo branch locale corrente. 

git fetch

Il comando git fetch ti consente di rivedere le modifiche nel repository remoto prima di unirle nel tuo locale. Scarica le modifiche e le aggiorna nei branch di tracciamento remoti. Per chi non lo conoscesse, i branch di tracciamento remoti sono copie dei branch del repository remoto. 

Ad esempio, il seguente comando scarica le modifiche nel repository remoto e le aggiorna nei branch di tracciamento remoti sotto origin:

git fetch origin

Branching e merge in Git

Il branching in Git permette agli sviluppatori di lavorare in modo indipendente su nuove funzionalità o correzioni di bug senza influenzare il repository principale. Una volta pronte le modifiche, il merge le integra nel codebase principale. Esploriamo i comandi chiave coinvolti in questo processo.

git branch

Il comando git branch elenca, crea o elimina branch. Un branch è un'altra versione del tuo repository. 

Se stai sviluppando una nuova funzionalità per la tua applicazione, puoi creare e lavorare su un nuovo branch.Puoi unire questo nuovo branch al branch principale una volta che le modifiche sono pronte e testate. Questo ti consente di lavorare sulle nuove funzionalità in modo indipendente senza toccare direttamente la linea principale. 

• git branch: restituisce l'elenco di tutti i branch nel repository.
• git branch <branch_name>: crea un nuovo branch chiamato “branch_name”.
• git branch -d <branch_name>: elimina il branch chiamato “branch_name”.

git checkout

Il git checkout comando può fare due cose: passare tra branch o ripristinare file a uno stato precedente. 

• Passare tra branch: Prima di git 2.23, il comando git checkout branch_name veniva usato per passare dal branch corrente a un altro. Ma non serviva solo per passare da quello esistente; puoi anche creare e passare a un nuovo branch.

Il seguente comando crea un nuovo branch chiamato “feature_branch” e ci passa:

git checkout -b feature_branch

Tuttavia, nelle versioni più recenti di Git, git checkout è stato sostituito da git switch per ripristinare i file. 

• Ripristinare file: puoi scartare le modifiche che hai fatto a un file e ripristinarlo alla versione precedente con il seguente comando.

git checkout -- <file-name>

Puoi farlo anche con un file da un altro branch come segue:

git checkout <branch-name> -- <file-name>

git merge

Se hai fatto del lavoro in un nuovo branch, puoi unirlo al branch principale usando git merge per applicare le modifiche. Git esegue il merge in due modi:

• Fast-forward merge: Diciamo che hai creato un nuovo branch chiamato "feature_x" dal branch principale e ci hai lavorato. Se il branch principale non ha avuto aggiornamenti da quando hai creato "feature_x", invece di fare il commit delle modifiche di “feature_x” nel branch principale, Git aggiorna il branch principale puntando all'ultima versione di "feature_x". In questo caso, non viene creato alcun nuovo commit di merge. 
• Merge a tre vie: Se sia “feature_x” sia il branch principale hanno modifiche, Git combina i cambiamenti e crea un nuovo commit di merge sul branch principale. 

Per esempio: 

      C---D---F (feature-branch)
     /
A---B---E---G (main)

Al commit B viene creato il branch feature C. Il branch principale ha commit aggiuntivi, E e G, anche dopo la creazione del branch feature. Di conseguenza, la feature viene unita al principale creando un nuovo commit di merge M come segue:

      C---D---F (feature-branch)
     /         \         
A---B---E---G---M (main)

git rebase

git rebase è un altro modo per integrare modifiche tra branch, ma funziona in modo diverso rispetto a git merge. Il merge conserva l'intera cronologia sia del branch principale che di quello feature. Il rebase, invece, sovrascrive la cronologia dei commit per renderla lineare e pulita.

Inoltre, il merge richiede un commit di merge aggiuntivo, mentre il rebase non crea nuovi commit. Git rebase esegue due passaggi: 

1. Passare al branch feature 
2. Fare rebase sul principale.

Per esempio:

      C---D---F (feature-branch)
     /
A---B---E---G (main)

• Passo 1: esegue git checkout feature_branch.
• Passo 2: esegue git rebase main: spostando l'intero branch feature sul branch principale riapplicando i commit C, D, F come C’, D’ e F’ sopra l'ultimo commit G del branch principale. Questo crea una cronologia lineare dei commit come segue:

A---B---E---G---C'---D'---F' (main)

Poiché le operazioni di merge e rebase sono spesso confuse, ecco un riepilogo delle differenze:

Vuoi saperne di più sul lavoro con i branch remoti? Scopri come fare checkout e tracciare i branch remoti usando git checkout in questo tutorial passo passo.

Cronologia Git e annullamento delle modifiche

Git offre diversi comandi per visualizzare la cronologia e annullare le modifiche in varie fasi dello sviluppo. Qui vengono discussi i comandi pertinenti. 

git log

Il comando git log mostra l'intera cronologia dei commit del tuo branch corrente. Include quattro campi chiave: commit, autore, data e messaggio di commit. 

cronologia dei commit git

• Commit: un ID univoco.
• Autore: nome ed email della persona.
• Data: timestamp di quando la modifica è stata inviata.
• Messaggio di commit: descrizione del commit. 

git diff

Il comando git diff mostra le differenze tra vari stati del tuo repository — che tu stia confrontando la directory corrente con l'area di staging, l'area di staging con l'ultimo commit o anche due file o branch, a seconda di ciò che specifichi.

• git diff - mostra la differenza tra la directory di lavoro corrente e l'area di staging. 
• git diff -- cached: mostra le differenze tra l'area di staging e l'ultimo commit.
• git diff commit1 commit2 - la differenza tra commit 1 e commit 2.
• git diff branch1..branch2 - confronta le differenze tra branch 1 e branch 2.

git reset

Il comando git reset ti consente di annullare le modifiche reimpostando l'HEAD corrente a uno stato precedente specifico. Per spostare l'HEAD a un commit precedente, hai tre varianti: “soft”, “mixed” e “hard” da usare con il comando reset. 

• Soft: torna a un commit precedente ma mantiene le modifiche correnti in stage, permettendoti di ricommetterle più tardi quando serve. 

git reset --soft HEAD~1

• Mixed: torna a un commit precedente e rimuove le modifiche dell'ultimo commit dall'area di staging. Tuttavia, tali modifiche restano intatte nella tua directory di lavoro.

git reset --mixed HEAD~1

• Hard: punta a un commit precedente rimuovendo gli aggiornamenti dell'ultimo commit sia dalla directory di lavoro sia dall'area di staging. 

git reset --hard HEAD~1

Devi annullare modifiche in Git? Esplora le differenze tra git reset e git revert in questa guida dettagliata.

Git stash e pulizia

Quando lavori con Git, potresti dover mettere temporaneamente da parte delle modifiche senza fare commit o ripulire file non necessari che ingombrano il repository. Qui tornano utili i comandi di stash e pulizia di Git.

git stash

Supponiamo che tu voglia tornare a uno stato precedente ma non voglia fare commit dei progressi attuali; puoi usare git stash. Questo salva temporaneamente le modifiche non inviate e ripristina la directory di lavoro all'ultimo stato con commit. 

git stash pop

Se in passato hai messo in stash alcune modifiche e vuoi includerle nella tua directory di lavoro, usa il comando git stash pop. Applicherà le ultime modifiche in stash alla directory corrente e le rimuoverà dall'elenco degli stash. 

git clean

Il comando git clean elimina i file non tracciati dal repository Git. Usa il comando git clean -n per visualizzare in anteprima cosa verrà eliminato prima di eseguire la pulizia!

Cerchi di ripulire la cronologia Git? Impara come combinare più commit in uno con questo tutorial su git squash.

Configurazione di Git e impostazioni utente

Git ti permette di configurare le impostazioni utente a livelli diversi. Esploriamoli qui.

git config

Il comando git config ti consente di personalizzare le impostazioni di Git in base alle tue esigenze. Puoi configurare le impostazioni a tre livelli: locale, di sistema e globale. 

• Livello di sistema: è il livello di configurazione più ampio con accesso a livello root.
• Livello globale: le configurazioni a questo livello si applicano a tutti i repository per l'utente corrente. 
• Livello locale: le impostazioni rilevanti per il repository Git corrente possono essere personalizzate a questo livello. 

Questi sono alcuni comandi git config comuni:

• git config -list: mostra le impostazioni di Git di tutti i livelli.
• git config --global user.name "Your_name": imposta il nome utente Git per tutti i repository sul tuo sistema su “Your_name”.
• git config --global user.email "your.email@example.com": imposta l'indirizzo email per tutti i repository sul tuo sistema.

Sappiamo che master è il branch principale predefinito quando si inizializza un repository Git. Ma puoi rinominarlo come preferisci usando il seguente comando:

git config --global init.defaultBranch "srujana_master"

Nel comando sopra, abbiamo sostituito il branch master predefinito con "srujana_master" a livello globale (per tutti i repository nel sistema).

Puoi applicare altre impostazioni a livello globale. Ad esempio, per cambiare l'editor di testo predefinito in VS Code, esegui il seguente comando:

git config -global core.editor "code-w"

Puoi anche creare i tuoi comandi Git. Per esempio:

git config --global alias.slice branch

Il comando sopra crea un nuovo alias slice per branch. Quindi, se vuoi creare un nuovo branch, puoi eseguire git slice branch_name invece di git branch branch_name.

Riepilogo dei comandi Git

Ecco un riepilogo dei comandi Git che abbiamo esplorato, da tenere a portata di mano:

Buone pratiche per usare Git

Usare Git in modo efficace va oltre il tracciamento delle modifiche: significa mantenere un flusso di lavoro pulito, strutturato e collaborativo. Seguire le buone pratiche aiuta a garantire che il tuo repository resti organizzato, che la cronologia dei commit sia significativa e che il processo di sviluppo scorra senza intoppi.

Ecco alcune abitudini chiave da adottare quando lavori con Git:

• Fai commit spesso: Uno degli scopi principali di un sistema di controllo versione come Git è tracciare efficacemente le modifiche nel tempo. Quando invii ogni modifica separatamente invece di raggrupparne molte insieme, è più facile capire in seguito cosa è stato modificato in ciascun commit. 
• Scrivi messaggi di commit chiari: ogni volta che fai un commit, accompagnalo con un messaggio chiaro che descriva il contenuto del commit. La prossima volta che controllerai i commit, sarà molto più semplice capire quali cambiamenti ha introdotto ciascuno. 
• Usa i branch: per ogni nuova funzionalità o correzione di bug, crea un branch, lavoraci e fai il merge. È la pratica migliore per separare il nuovo sviluppo dal progetto principale. 
• Usa .gitignore: Un file .gitignore contiene file e directory legati al progetto che non è necessario tracciare. In genere includono file generati automaticamente, artefatti di build, log, file temporanei e specifici della piattaforma. Ignorarli evita log inutili e versioni da tracciare, mantenendo pulita la cronologia.

Conclusione

Git è uno strumento potente per tracciare le modifiche, collaborare con gli altri e mantenere un flusso di lavoro di sviluppo ben strutturato. In questo articolo ho trattato i comandi Git essenziali e le buone pratiche per aiutarti a gestire i tuoi progetti in modo più efficace.

C'è sempre altro da imparare, ovviamente! Se stai iniziando ora, dai un'occhiata a Introduction to Git per costruire basi solide. Se vuoi perfezionarti ulteriormente, Intermediate Git approfondisce flussi di lavoro e tecniche avanzate.

Ti serve un riferimento rapido a Git per i prossimi progetti? Tieni a portata di mano i comandi essenziali con questo Git cheat sheet!