Iniziare con Git: Inizializzare e Clonare Repository

Inizializzare e clonare repository sono i due modi fondamentali per iniziare a lavorare con Git. Puoi trasformare una cartella esistente in un repository Git, oppure copiare un repository esistente per lavorare con i suoi file e la sua cronologia.

Questi comandi sembrano semplici, ma le scelte che fai all'inizio influenzano i remote, i branch, i file ignorati e i flussi di lavoro del team. Una configurazione pulita previene confusione in seguito.

Cosa Contiene un Repository Git

Un repository Git è una cartella di progetto con una directory nascosta .git al suo interno. Questa directory .git memorizza la cronologia dei commit, i riferimenti ai branch, le informazioni sui remote, la configurazione e il database interno degli oggetti di Git.

Normalmente non modifichi i file .git a mano. Usi i comandi Git, e Git aggiorna quei dati interni per te.

Per verificare se una cartella è già un repository, esegui:

git status

Se Git dice che la cartella non è un repository, puoi inizializzarne uno. Se mostra un branch, file modificati o un albero di lavoro pulito, Git sta già tracciando quella cartella.

Aiuta capire tre aree comuni:

• Albero di lavoro: i file che puoi vedere e modificare.
• Area di staging: le modifiche selezionate per il prossimo commit.
• Cronologia del repository: i commit che Git ha già registrato.

Quando inizializzi o cloni un repository, Git imposta questi elementi in modo che tu possa iniziare a fare commit.

Inizializzare un Nuovo Repository

Usa git init quando hai una cartella di progetto locale che non è ancora tracciata da Git.

Crea una cartella e inizializzala:

mkdir my-app
cd my-app
git init

Git crea la directory nascosta .git. Ora puoi aggiungere file e fare il tuo primo commit:

echo "# My App" > README.md
git add README.md
git commit -m "Aggiungi README"

Se il tuo branch predefinito dovesse chiamarsi main, puoi impostarlo globalmente prima di creare nuovi repository:

git config --global init.defaultBranch main

Oppure rinominare il branch corrente dopo l'inizializzazione:

git branch -M main

Per un progetto reale, crea un .gitignore prima del tuo primo commit ampio. Questo impedisce che cartelle di dipendenze, output di build, log e segreti locali entrino nella cronologia:

node_modules/
dist/
.env
*.log

Una volta che un file è stato committato, aggiungerlo successivamente a .gitignore non lo rimuove dalla cronologia. Ecco perché le regole di esclusione iniziali sono importanti.

Se prevedi di pubblicare il repository su un servizio di hosting, crea prima lì il repository remoto vuoto, poi collegalo:

git remote add origin [email protected]:example/my-app.git
git push -u origin main

L'opzione -u imposta il tracciamento upstream. Dopo di ciò, semplici git push e git pull sanno quale branch remoto usare.

Clonare un Repository Esistente

Usa git clone quando un repository esiste già da qualche altra parte. La clonazione copia i file del progetto, la cronologia e la configurazione dei remote.

Il comando base è:

git clone [email protected]:example/my-app.git

Git crea una cartella con il nome del repository. Per scegliere un nome di cartella locale diverso, aggiungilo alla fine:

git clone [email protected]:example/my-app.git worktree-app

Dopo la clonazione, spostati nella cartella e ispezionala:

cd worktree-app
git status
git remote -v
git branch

Di default, il remoto è solitamente chiamato origin. Quel nome è convenzionale, non magico. Punta all'URL che Git userà per fetch e push.

Potresti vedere URL di clonazione HTTPS o SSH. HTTPS è facile da iniziare, specialmente per repository pubblici. SSH è comune per lo sviluppo quotidiano perché usa chiavi e evita richieste di password ripetute quando configurato correttamente.

Per un repository grande, potresti usare una clonazione superficiale:

git clone --depth 1 https://example.com/repo.git

Questo scarica solo la cronologia recente. È utile per lavori CI o ispezioni rapide, ma può limitare comandi che necessitano di commit più vecchi, tag o cronologia completa. Per lo sviluppo normale, una clonazione completa è solitamente migliore.

Se il repository usa sottomoduli, clona con:

git clone --recurse-submodules [email protected]:example/platform.git

Oppure inizializzali dopo la clonazione:

git submodule update --init --recursive

I sottomoduli aggiungono un altro livello di gestione del repository, quindi leggi la documentazione di configurazione del progetto prima di apportare modifiche.

Controlli Comuni Iniziali Dopo la Configurazione

Dopo aver inizializzato o clonato, esegui alcuni controlli prima di iniziare a programmare. Aiutano a individuare errori di configurazione precocemente.

Controlla la tua identità:

git config user.name
git config user.email

Se questo è un repository di lavoro, assicurati che l'email corrisponda al tuo account aziendale. Puoi impostarlo localmente:

git config --local user.email "[email protected]"

Controlla i remote:

git remote -v

Assicurati che gli URL di fetch e push puntino al repository previsto. Spingere accidentalmente su un fork o un mirror personale può far perdere tempo.

Controlla il branch corrente:

git branch --show-current

Se hai clonato un repository, leggi il README o la guida ai contributi prima di creare un branch. Molti team si aspettano nomi di branch come feature/ticket-123-breve-descrizione o fix/login-timeout.

Prima del tuo primo commit, controlla i file ignorati:

git status --ignored

Questo è un modo rapido per confermare che gli artefatti di build e i file segreti locali non stiano per essere committati.

Quando Chiedere Aiuto

Chiedi aiuto a un compagno di squadra o al manutentore del repository se non sei sicuro di quale URL remoto usare, se dovresti clonare un fork o il repository principale, o come dovrebbero essere gestiti i sottomoduli.

Dovresti anche fermarti se hai inizializzato Git nella directory sbagliata. Ad esempio, eseguire git init nella tua cartella home può far sì che Git veda migliaia di file non correlati. Non iniziare a cancellare cose a caso. Conferma dove è stato creato .git e rimuovi solo i metadati del repository sbagliato se sei sicuro che non contenga cronologia necessaria.

Iniziare con Git riguarda principalmente abitudini pulite. Usa git init per nuovi progetti locali, git clone per repository esistenti, e verifica il tuo branch, remoto, identità e file ignorati prima di iniziare un lavoro serio.