Merge pull request #1622 from Chris54721/markdown-it

[git/it] Translated git.html.markdown into Italian

1 files changed, 498 insertions, 0 deletions

diff --git a/it-it/git-it.html.markdown b/it-it/git-it.html.markdown
new file mode 100644
index 00000000..521538a1
--- /dev/null
+++ b/it-it/git-it.html.markdown
@@ -0,0 +1,498 @@
+---
+category: tool
+tool: git
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Leo Rudberg" , "http://github.com/LOZORD"]
+    - ["Betsy Lorton" , "http://github.com/schbetsy"]
+    - ["Bruno Volcov", "http://github.com/volcov"]
+translators:
+    - ["Christian Grasso", "http://chris54721.net"]
+filename: LearnGit-it.txt
+lang: it-it
+---
+
+Git è un sistema di
+[controllo versione distribuito](https://it.wikipedia.org/wiki/Controllo_versione_distribuito)
+e di gestione del codice sorgente.
+
+Git esegue una serie di _snapshot_ per salvare lo stato di un progetto, così
+facendo può fornirti la possibilità di gestire il tuo codice e di salvarne lo
+stato assegnando delle versioni.
+
+## Basi del controllo versione
+
+### Cos'è il controllo versione?
+
+Il controllo versione (_Version Control_ o _Versioning_) è un sistema che
+registra le modifiche apportate a uno o più file nel tempo.
+
+### Controllo versione centralizzato e distribuito
+
+* Il controllo versione centralizzato si concentra sulla sincronizzazione, il
+  monitoraggio e il backup dei file.
+* Il controllo versione distribuito si concentra sulla condivisione delle
+  modifiche. Ogni modifica ha un identificatore univoco.
+* I sistemi distribuiti non hanno una struttura definita. Si potrebbe creare
+  ad esempio un sistema centralizzato simile a SVN utilizzando Git.
+
+[Ulteriori informazioni](http://git-scm.com/book/it/v1/Per-Iniziare-Il-Controllo-di-Versione)
+
+### Perchè usare Git?
+
+* Consente di lavorare offline.
+* Collaborare con altre persone è semplice!
+* Utilizzare i branch (rami di sviluppo) è semplice!
+* Git è veloce.
+* Git è flessibile.
+
+## Architettura di Git
+
+### Repository
+
+Un insieme di file, cartelle, registrazioni della cronologia e versioni.
+Immaginalo come una struttura dati del codice, con la caratteristica che ogni
+"elemento" del codice ti fornisce accesso alla sua cronologia delle revisioni,
+insieme ad altre cose.
+
+Un repository comprende la cartella .git e il working tree.
+
+### Cartella .git (componente del repository)
+
+La cartella .git contiene tutte le configurazioni, i log, i rami e altro.
+[Lista dettagliata](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### Working Tree (componente del repository)
+
+Si tratta semplicemente delle cartelle e dei file presenti nel repository.
+Spesso viene indicato come "directory di lavoro" ("working directory").
+
+### Index (componente della cartella .git)
+
+L'Index è l'area di staging di Git. Si tratta di un livello che separa il
+working tree dal repository. Ciò fornisce agli sviluppatori più controllo su
+cosa viene inviato al repository.
+
+### Commit
+
+Un commit è uno snapshot di una serie di modifiche apportate al working tree.
+Ad esempio, se hai aggiunto 5 file e ne hai rimossi 2, ciò sarà registrato in
+un commit. Il commit può essere pushato (inviato) o meno ad altri repository.
+
+### Branch (ramo)
+
+Un branch (ramo) è essenzialmente un puntatore all'ultimo commit che hai
+effettuato. Effettuando altri commit, il puntatore verrà automaticamente
+aggiornato per puntare all'ultimo commit.
+
+### Tag
+
+Un tag è un contrassegno applicato a un punto specifico nella cronologia dei
+commit. Di solito i tag vengono utilizzati per contrassegnare le versioni
+rilasciate (v1.0, v1.1, etc.).
+
+### HEAD e head (componenti della cartella .git)
+
+HEAD (in maiuscolo) è un puntatore che punta al branch corrente. Un repository
+può avere solo 1 puntatore HEAD *attivo*.
+
+head (in minuscolo) è un puntatore che può puntare a qualsiasi commit. Un
+repository può avere un numero qualsiasi di puntatori head.
+
+### Stadi di Git
+* _Modified_ - Un file è stato modificato, ma non è ancora stato effettuato
+  un commit per registrare le modifiche nel database di Git
+* _Staged_ - Un file modificato è stato contrassegnato per essere incluso nel
+  prossimo commit
+* _Committed_ - È stato effettuato un commit e le modifiche sono state
+  registrate nel database di Git
+
+## Comandi
+
+### init
+
+Crea un repository Git vuoto. Le impostazioni e le informazioni del repository
+sono salvate nella cartella ".git".
+
+```bash
+$ git init
+```
+
+### config
+
+Utilizzato per configurare le impostazioni, sia specifiche del repository, sia
+a livello globale. Le impostazioni globali sono salvate in `~/.gitconfig`.
+
+```bash
+$ git config --global user.email "email@example.com"
+$ git config --global user.name "Nome utente"
+```
+
+[Ulteriori informazioni su git config](http://git-scm.com/docs/git-config)
+
+### help
+
+Fornisce una documentazione molto dettagliata di ogni comando.
+
+```bash
+# Mostra i comandi più comuni
+$ git help
+
+# Mostra tutti i comandi disponibili
+$ git help -a
+
+# Documentazione di un comando specifico
+# git help <nome_comando>
+$ git help add
+$ git help commit
+$ git help init
+# oppure git <nome_comando> --help
+$ git add --help
+$ git commit --help
+$ git init --help
+```
+
+### Ignorare file
+
+Per impedire intenzionalmente che file privati o temporanei vengano inviati
+al repository Git.
+
+```bash
+$ echo "temp/" >> .gitignore
+$ echo "privato.txt" >> .gitignore
+```
+
+
+### status
+
+Mostra le differenza tra lo stato attuale del working tree e l'attuale commit
+HEAD.
+
+```bash
+$ git status
+```
+
+### add
+
+Aggiunge file alla staging area, ovvero li contrassegna per essere inclusi nel
+prossimo commit. Ricorda di aggiungere i nuovi file, altrimenti non saranno
+inclusi nei commit!
+
+```bash
+# Aggiunge un file nella directory attuale
+$ git add HelloWorld.java
+
+# Aggiunge un file in una sottocartella
+$ git add /path/to/file/HelloWorld.c
+
+# Il comando supporta le espressioni regolari
+$ git add ./*.java
+
+# Aggiunge tutti i file non ancora contrassegnati
+$ git add --all
+```
+
+Questo comando contrassegna soltanto i file, senza effettuare un commit.
+
+### branch
+
+Utilizzato per gestire i branch (rami). Puoi visualizzare, modificare, creare o
+eliminare branch utilizzando questo comando.
+
+```bash
+# Visualizza i branch e i remote
+$ git branch -a
+
+# Crea un nuovo branch
+$ git branch nuovoBranch
+
+# Elimina un branch
+$ git branch -d nomeBranch
+
+# Rinomina un branch
+$ git branch -m nomeBranch nuovoNomeBranch
+
+# Permette di modificare la descrizione di un branch
+$ git branch nomeBranch --edit-description
+```
+
+### tag
+
+Utilizzato per gestire i tag.
+
+```bash
+# Visualizza i tag esistenti
+$ git tag
+# Crea un nuovo tag
+# L'opzione -m consente di specificare una descrizione per il tag.
+# Se l'opzione -m non viene aggiunta, Git aprirà un editor per consentire
+# l'inserimento del messaggio.
+$ git tag -a v2.0 -m 'Versione 2.0'
+# Mostra informazioni relative a un tag
+# Include informazioni sul creatore del tag, la data di creazione, e il
+# messaggio assegnato al tag oltre alle informazioni sul commit.
+$ git show v2.0
+```
+
+### checkout
+
+Consente di cambiare branch o ripristinare i file a una revisione specifica.
+Tutti i file nel working tree vengono aggiornati per corrispondere alla versione
+presente nel branch o nel commit specificato.
+
+```bash
+# Effettua il checkout di un repository - il branch predefinito è 'master'
+$ git checkout
+# Effettua il checkout di un branch specifico
+$ git checkout nomeBranch
+# Crea un nuovo branch e ne effettua il checkout
+# Equivalente a "git branch <nomeBranch>; git checkout <nomeBranch>"
+$ git checkout -b nuovoBranch
+```
+
+### clone
+
+Clona, o copia, un repository esistente in una nuova directory. Inoltre,
+aggiunge dei branch _remote-tracking_, utilizzati per monitorare i branch
+remoti corrispondenti a quelli locali, e consentendo così di inviare le
+modifiche al repository remoto.
+
+```bash
+# Clona learnxinyminutes-docs
+$ git clone https://github.com/adambard/learnxinyminutes-docs.git
+# Clona solo l'ultima revisione di un repository
+$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
+# Clona solo un branch specifico
+$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
+```
+
+### commit
+
+Effettua uno _snapshot_ dello stato attuale del working tree e registra le
+modifiche in un nuovo commit. Il commit contiene, oltre alle modifiche apportate,
+anche l'autore e una descrizione.
+
+```bash
+# Crea un nuovo commit con un messaggio
+$ git commit -m "Aggiunta la funzione multiplyNumbers() in HelloWorld.c"
+
+# Aggiunge (git add) automaticamente i file modificati o eliminati (ESCLUSI
+# i nuovi file) e quindi effettua il commit
+$ git commit -a -m "Modificato foo.php e rimosso bar.php"
+
+# Modifica l'ultimo commit (il comando elimina il commit precedente e lo
+# sostituisce con uno nuovo)
+$ git commit --amend -m "Messaggio corretto"
+```
+
+### diff
+
+Mostra la differenza tra un file nel working tree e la sua versione nell'index,
+in un branch o ad un commit specifico.
+
+```bash
+# Mostra la differenza tra il working tree e l'index
+$ git diff
+
+# Mostra la differenza tra l'index e il commit più recente
+$ git diff --cached
+
+# Mostra la differenza tra il working tree e un commit specifico
+$ git diff <commit>
+
+# Mostra la differenza tra due commit
+$ git diff <commit1> <commit2>
+```
+
+### grep
+
+Consente di effettuare una ricerca veloce nel repository.
+
+```bash
+# Cerca "variableName" nei file Java
+$ git grep 'variableName' -- '*.java'
+
+# Cerca una riga contenente "arrayListName" E "add" oppure "remove"
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
+```
+
+Impostazioni relative a `git grep`:
+
+```bash
+# Mostra il numero delle righe
+$ git config --global grep.lineNumber true
+
+# Rende i risultati più leggibili
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+### log
+
+Mostra la cronologia dei commit inviati al repository.
+
+```bash
+# Mostra tutti i commit
+$ git log
+
+# Mostra ogni commit su una sola riga
+$ git log --oneline
+
+# Mostra solo i commit legati ai merge
+$ git log --merges
+```
+
+### merge
+
+Effettua un "merge", ovvero unisce le modifiche di un branch in quello attuale.
+
+```bash
+# Unisce il branch specificato a quello attuale
+$ git merge nomeBranch
+
+# Genera un commit in ogni caso dopo aver eseguito il merge
+$ git merge --no-ff nomeBranch
+```
+
+### mv
+
+Rinomina o sposta un file.
+
+```bash
+# Rinomina un file
+$ git mv HelloWorld.c HelloNewWorld.c
+
+# Sposta un file
+$ git mv HelloWorld.c ./new/path/HelloWorld.c
+
+# Forza l'esecuzione del comando
+# Se un file "nuovoNomeFile" esiste già nella directory, verrà sovrascritto
+$ git mv -f nomeFile nuovoNomeFile
+```
+
+### pull
+
+Aggiorna il repository effettuando il merge delle nuove modifiche.
+
+```bash
+# Aggiorna il branch attuale dal remote "origin"
+$ git pull
+
+# Di default, git pull aggiorna il branch attuale effettuando il merge
+# delle nuove modifiche presenti nel branch remote-tracking corrispondente
+$ git pull
+
+# Aggiorna le modifiche dal branch remoto, quindi effettua il rebase dei commit
+# nel branch locale
+# Equivalente a: "git pull <remote> <branch>; git rebase <branch>"
+$ git pull origin master --rebase
+```
+
+### push
+
+Invia ed effettua il merge delle modifiche da un branch locale ad uno remoto.
+
+```bash
+# Invia ed effettua il merge delle modifiche dal branch "master"
+# al remote "origin".
+# git push <remote> <branch>
+$ git push origin master
+
+# Di default, git push invia ed effettua il merge delle modifiche
+# dal branch attuale al branch remote-tracking corrispondente
+$ git push
+
+# Per collegare il branch attuale ad uno remoto, basta aggiungere l'opzione -u
+$ git push -u origin master
+```
+
+### stash
+
+Salva lo stato attuale del working tree in una lista di modifiche non ancora
+inviate al repository con un commit che possono essere applicate nuovamente
+in seguito.
+
+Questo comando può essere utile se, ad esempio, mentre stai effettuando delle
+modifiche non ancora completate, hai bisogno di aggiornare il repository locale
+con `git pull`. Poichè non hai ancora effettuato il commit di tutte le modifiche,
+non sarà possibile effettuare il pull. Tuttavia, puoi utilizzare `git stash` per
+salvare temporaneamente le modifiche e applicarle in seguito.
+
+```bash
+$ git stash
+```
+
+Ora puoi effettuare il pull:
+
+```bash
+$ git pull
+```
+
+A questo punto, come già suggerito dall'output del comando `git stash`, puoi
+applicare le modifiche:
+
+```bash
+$ git stash apply
+```
+
+Infine puoi controllare che tutto sia andato bene:
+
+```bash
+$ git status
+```
+
+Puoi visualizzare gli accantonamenti che hai effettuato finora utilizzando:
+
+```bash
+$ git stash list
+```
+
+### rebase (attenzione)
+
+Applica le modifiche effettuate su un branch su un altro branch.
+*Non effettuare il rebase di commit che hai già inviato a un repository pubblico!*
+
+```bash
+# Effettua il rebase di experimentBranch in master
+$ git rebase master experimentBranch
+```
+
+[Ulteriori informazioni](https://git-scm.com/book/it/v1/Diramazioni-in-Git-Rifondazione)
+
+### reset (attenzione)
+
+Effettua il reset del commit HEAD attuale ad uno stato specifico.
+Questo comando consente di annullare `merge`, `pull`, `commit`, `add` e altro.
+Tuttavia, può essere pericoloso se non si sa cosa si sta facendo.
+
+```bash
+# Effettua il reset della staging area (annullando le aggiunte e le rimozioni
+# di file dal repository, senza modificare il working tree)
+$ git reset
+
+# Effettua il reset completo della staging area, ovvero annulla qualsiasi
+# modifica al repository eliminando definitivamente anche tutte le modifiche
+# ai file non inviate e ripristinando il working tree
+$ git reset --hard
+
+# Effettua il reset del branch attuale al commit specificato (lasciando il
+# working tree intatto)
+$ git reset 31f2bb1
+
+# Effettua il reset completo del branch attuale al commit specificato,
+# eliminando qualsiasi modifica non inviata
+$ git reset --hard 31f2bb1
+```
+
+### rm
+
+Consente di rimuovere un file dal working tree e dal repository.
+Per eliminare un file solo dal working tree ma non dal repository, è invece
+necessario utilizzare `/bin/rm`.
+
+```bash
+# Elimina un file nella directory attuale
+$ git rm HelloWorld.c
+
+# Elimina un file da una sottocartella
+$ git rm /pather/to/the/file/HelloWorld.c
+```