GitIniziare con Git


Osservazioni

Git è un sistema di controllo versione distribuito gratuito che consente ai programmatori di tenere traccia delle modifiche al codice, tramite "istantanee" (commit), nel suo stato attuale. L'utilizzo dei commit consente ai programmatori di testare, eseguire il debug e creare nuove funzionalità in modo collaborativo. Tutti i commit sono tenuti in un cosiddetto "Git Repository" che può essere ospitato sul tuo computer, server privati ​​o siti web open source, come Github.

Git consente inoltre agli utenti di creare nuovi "rami" del codice, che consente a diverse versioni del codice di vivere l'una accanto all'altra. Ciò consente scenari in cui un ramo contiene la versione stabile più recente, un ramo diverso contiene un set di nuove funzionalità in fase di sviluppo e un altro ramo contiene un diverso set di funzionalità. Git rende il processo di creazione di questi rami, e successivamente li fonde insieme, quasi indolore.

Git ha 3 diverse "aree" per il tuo codice:

  • Directory di lavoro : l'area in cui farai tutto il tuo lavoro (creazione, modifica, eliminazione e organizzazione dei file)
  • Area di gestione temporanea : l'area in cui verranno elencate le modifiche apportate alla directory di lavoro
  • Repository : dove Git memorizza in modo permanente le modifiche apportate come versioni diverse del progetto

Git è stato originariamente creato per gestire il sorgente del kernel Linux. Facilitandoli, incoraggia piccoli commit, biforcazione di progetti e fusione tra le forche, e molti rami di breve durata.

Il più grande cambiamento per le persone che sono abituate a CVS o Subversion è che ogni checkout contiene non solo l'albero dei sorgenti, ma anche l'intera storia del progetto. Operazioni comuni come la diffusione delle revisioni, il controllo di revisioni precedenti, il commit (sulla cronologia locale), la creazione di un ramo, il controllo di un ramo diverso, l'unione di rami o file di patch possono essere eseguiti localmente senza dover comunicare con un server centrale. Quindi la più grande fonte di latenza e inaffidabilità viene rimossa. La comunicazione con il repository "upstream" è necessaria solo per ottenere le ultime modifiche e per pubblicare le modifiche locali ad altri sviluppatori. Ciò trasforma ciò che prima era un vincolo tecnico (chiunque abbia il repository che possiede il progetto) in una scelta organizzativa (il tuo "upstream" è chiunque tu scelga di sincronizzare).

Versioni

Versione Data di rilascio
2.13 2017/05/10
2.12 2017/02/24
2.11.1 2017/02/02
2.11 2016/11/29
2.10.2 2016/10/28
2.10 2016/09/02
2.9 2016/06/13
2.8 2016/03/28
2.7 2015/10/04
2.6 2015/09/28
2.5 2015/07/27
2.4 2015/04/30
2.3 2015/02/05
2.2 2014/11/26
2.1 2014/08/16
2.0 2014/05/28
1.9 2014/02/14
1.8.3 2013/05/24
1.8 2012/10/21
1.7.10 2012-04-06
1.7 2010-02-13
1.6.5 2009-10-10
1.6.3 2009-05-07
1.6 2008-08-17
1.5.3 2007-09-02
1.5 2007-02-14
1.4 2006-06-10
1.3 2006-04-18
1.2 2006-02-12
1.1 2006-01-08
1.0 2005-12-21
0.99 2005-07-11

Crea il tuo primo repository, quindi aggiungi e invia file

Alla riga di comando, prima verifica di aver installato Git:

Su tutti i sistemi operativi:

git --version
 

Sui sistemi operativi UNIX-like:

which git
 

Se non viene restituito nulla o il comando non viene riconosciuto, potrebbe essere necessario installare Git sul sistema scaricando ed eseguendo il programma di installazione. Vedi la homepage di Git per istruzioni di installazione eccezionalmente chiare e facili.

Dopo aver installato Git, configura il tuo nome utente e indirizzo email . Fatelo prima di fare un commit.

Una volta installato Git, spostati nella directory che desideri posizionare sotto il controllo della versione e crea un repository Git vuoto:

git init
 

Questo crea una cartella nascosta, .git , che contiene l'impianto idraulico necessario per il funzionamento di Git.

Successivamente, controlla quali file Git aggiungerà al tuo nuovo repository; questo passaggio merita particolare attenzione:

git status
 

Rivedere l'elenco risultante di file; puoi dire a Git quale dei file inserire nel controllo di versione (evitare di aggiungere file con informazioni riservate come password o file che ingombrano il repository):

git add <file/directory name #1> <file/directory name #2> < ... >
 

Se tutti i file nell'elenco devono essere condivisi con chiunque abbia accesso al repository, un singolo comando aggiungerà tutto nella directory corrente e nelle sue sottodirectory:

git add .
 

Ciò "mette in scena" tutti i file da aggiungere al controllo della versione, preparandoli al commit nel primo commit.

Per i file che non si desidera mai sotto controllo di versione, creare e compilare un file denominato .gitignore prima di eseguire il comando add .

Configura tutti i file che sono stati aggiunti, insieme a un messaggio di commit:

git commit -m "Initial commit"
 

Questo crea un nuovo commit con il messaggio specificato. Un commit è come un salvataggio o un'istantanea dell'intero progetto. Ora puoi inviarlo o caricarlo su un repository remoto, e in seguito puoi tornare indietro se necessario.
Se ometti il ​​parametro -m , verrà aperto l'editor predefinito e potrai modificare e salvare il messaggio di commit lì.

Aggiunta di un telecomando

Per aggiungere un nuovo telecomando, utilizzare il comando git remote add sul terminale, nella directory in cui è archiviato il repository.

Il comando git remote add prende due argomenti:

  1. Un nome remoto, ad esempio, origin
  2. Un URL remoto, ad esempio, https://<your-git-service-address>/user/repo.git
    git remote add origin https://<your-git-service-address>/owner/repository.git
 

NOTA: prima di aggiungere il telecomando devi creare il repository richiesto nel tuo servizio git, sarai in grado di spingere / tirare i commit dopo aver aggiunto il tuo telecomando.

Clona un repository

Il comando git clone viene utilizzato per copiare un repository Git esistente da un server al computer locale.

Ad esempio, per clonare un progetto GitHub:

cd <path where you'd like the clone to create a directory>
git clone https://github.com/username/projectname.git
 

Per clonare un progetto BitBucket:

cd <path where you'd like the clone to create a directory>
git clone https://yourusername@bitbucket.org/username/projectname.git
 

Questo crea una directory chiamata projectname sul computer locale, che contiene tutti i file nel repository Git remoto. Ciò include i file di origine per il progetto, nonché una sottodirectory .git che contiene l'intera cronologia e la configurazione per il progetto.

Per specificare un nome diverso della directory, ad es. MyFolder :

git clone https://github.com/username/projectname.git MyFolder
 

O per clonare nella directory corrente:

git clone https://github.com/username/projectname.git .
 

Nota:

  1. Quando si clona su una directory specificata, la directory deve essere vuota o inesistente.

  2. Puoi anche usare la versione ssh del comando:

    git clone git@github.com:username/projectname.git
     

La versione https e la versione ssh sono equivalenti. Tuttavia, alcuni servizi di hosting come GitHub consigliano di utilizzare https piuttosto che ssh .

Installazione Git

Entriamo nell'uso di alcuni Git. Per prima cosa, devi installarlo. Puoi ottenerlo in diversi modi; i due principali sono installarlo dal sorgente o installare un pacchetto esistente per la tua piattaforma.

Installazione da origine

Se puoi, è generalmente utile installare Git dal sorgente, perché otterrai la versione più recente. Ogni versione di Git tende ad includere utili miglioramenti dell'interfaccia utente, quindi ottenere la versione più recente è spesso la scelta migliore se ti senti a tuo agio nella compilazione del software dall'origine. È anche il caso che molte distribuzioni Linux contengono pacchetti molto vecchi; quindi, a meno che tu non sia su una distribuzione molto aggiornata o stia usando i backport, l'installazione dalla fonte potrebbe essere la soluzione migliore.

Per installare Git, devi avere le seguenti librerie da cui Git dipende: curl, zlib, openssl, expat e libiconv. Per esempio, se sei su un sistema che ha yum (come Fedora) o apt-get (come un sistema basato su Debian), puoi usare uno di questi comandi per installare tutte le dipendenze:

$ yum install curl-devel expat-devel gettext-devel \
  openssl-devel zlib-devel

$ apt-get install libcurl4-gnutls-dev libexpat1-dev gettext \
  libz-dev libssl-dev
 

Quando hai tutte le dipendenze necessarie, puoi andare avanti e prendere l'ultima istantanea dal sito web Git:

http://git-scm.com/download Quindi, compila e installa:

$ tar -zxf git-1.7.2.2.tar.gz
$ cd git-1.7.2.2
$ make prefix=/usr/local all
$ sudo make prefix=/usr/local install
 

Dopo averlo fatto, puoi anche ottenere Git tramite Git stesso per gli aggiornamenti:

$ git clone git://git.kernel.org/pub/scm/git/git.git
 

Installazione su Linux

Se si desidera installare Git su Linux tramite un programma di installazione binario, in genere è possibile farlo tramite lo strumento di gestione dei pacchetti di base fornito con la propria distribuzione. Se sei su Fedora, puoi usare yum:

$ yum install git
 

Oppure se sei su una distribuzione basata su Debian come Ubuntu, prova apt-get:

$ apt-get install git
 

Installazione su Mac

Ci sono tre semplici modi per installare Git su un Mac. Il modo più semplice è utilizzare il programma di installazione di Git grafico, che è possibile scaricare dalla pagina SourceForge.

http://sourceforge.net/projects/git-osx-installer/

Figura 1-7. Installazione di Git OS X. L'altro modo importante è installare Git tramite MacPorts ( http://www.macports.org) . Se hai installato MacPorts, installa Git tramite

$ sudo port install git +svn +doc +bash_completion +gitweb
 

Non è necessario aggiungere tutti gli extra, ma probabilmente si vorrà includere + svn nel caso in cui si debba usare Git con repository Subversion (consultare il Capitolo 8).

Homebrew ( http://brew.sh/) è un'altra alternativa all'installazione di Git. Se hai installato Homebrew, installa Git via

$ brew install git
 

Installazione su Windows

Installare Git su Windows è molto semplice. Il progetto msysGit ha una delle procedure di installazione più semplici. Basta scaricare il file exe di installazione dalla pagina GitHub ed eseguirlo:

http://msysgit.github.io
 

Dopo l'installazione, è disponibile sia una versione da riga di comando (incluso un client SSH che sarà utile in seguito) sia la GUI standard.

Nota sull'uso di Windows: dovresti usare Git con la shell msysGit fornita (stile Unix), che permette di usare le complesse linee di comando fornite in questo libro. Se è necessario, per qualche motivo, utilizzare la shell nativa di Windows / console della riga di comando, è necessario utilizzare virgolette anziché virgolette singole (per i parametri con spazi in esse) ed è necessario citare i parametri che terminano con l'accento circonflesso (^ ) se sono ultimi sulla linea, in quanto è un simbolo di continuazione in Windows.

Imparare a conoscere un comando

Per ottenere maggiori informazioni su qualsiasi comando git, ad esempio dettagli su cosa fa il comando, opzioni disponibili e altra documentazione, utilizzare l'opzione --help o il comando help .

Ad esempio, per ottenere tutte le informazioni disponibili sul comando git diff , utilizzare:

git diff --help
git help diff
 

Allo stesso modo, per ottenere tutte le informazioni disponibili sul comando di status , utilizzare:

git status --help
git help status
 

Se vuoi solo un aiuto rapido che ti mostri il significato dei flag di riga di comando più usati, usa -h :

git checkout -h
 

Imposta SSH per Git

Se utilizzi Windows, apri Git Bash . Se stai usando Mac o Linux, apri il tuo terminale.

Prima di generare una chiave SSH, è possibile verificare se si dispone di chiavi SSH esistenti.

Elenca il contenuto della tua directory ~/.ssh :

$ ls -al ~/.ssh 
# Lists all the files in your ~/.ssh directory
 

Controlla l'elenco delle directory per vedere se hai già una chiave SSH pubblica. Per impostazione predefinita, i nomi file delle chiavi pubbliche sono uno dei seguenti:

id_dsa.pub
id_ecdsa.pub
id_ed25519.pub
id_rsa.pub
 

Se vedi una coppia di chiavi pubblica e privata esistente elencata che vorresti usare sul tuo account Bitbucket, GitHub (o simile), puoi copiare il contenuto del file id_*.pub .

In caso contrario, è possibile creare una nuova coppia di chiavi pubblica e privata con il seguente comando:

$ ssh-keygen
 

Premere il tasto Invio o A capo per accettare la posizione predefinita. Immettere e reinserire una passphrase quando richiesto, o lasciarlo vuoto.

Assicurarsi che la chiave SSH sia stata aggiunta a ssh-agent. Avvia lo ssh-agent in background se non è già in esecuzione:

$ eval "$(ssh-agent -s)"
 

Aggiungi la chiave SSH allo ssh-agent. Nota che avrai bisogno di sostituire id_rsa nel comando con il nome del tuo file di chiave privata :

$ ssh-add ~/.ssh/id_rsa
 

Se si desidera modificare l'upstream di un repository esistente da HTTPS a SSH, è possibile eseguire il seguente comando:

$ git remote set-url origin ssh://git@bitbucket.server.com:7999/projects/your_project.git
 

Per clonare un nuovo repository su SSH puoi eseguire il seguente comando:

$ git clone ssh://git@bitbucket.server.com:7999/projects/your_project.git
 

Configurazione del telecomando upstream

Se hai clonato un fork (ad es. Un progetto open source su Github) potresti non avere l'accesso push al repository upstream, quindi hai bisogno di entrambi i fork ma puoi recuperare il repository upstream.

Innanzitutto controlla i nomi remoti:

$ git remote -v
origin    https://github.com/myusername/repo.git (fetch)
origin    https://github.com/myusername/repo.git (push)
upstream  # this line may or may not be here
 

Se esiste già upstream (è su alcune versioni di Git) è necessario impostare l'URL (attualmente è vuoto):

$ git remote set-url upstream https://github.com/projectusername/repo.git
 

Se l'upstream non c'è, o se vuoi anche aggiungere il fork di un amico / collega (attualmente non esistono):

$ git remote add upstream https://github.com/projectusername/repo.git
$ git remote add dave https://github.com/dave/repo.git
 

Impostazione del nome utente e dell'e-mail

You need to set who you are *before* creating any commit.  That will allow commits to have the right author name and email associated to them.
 

Non ha nulla a che vedere con l'autenticazione quando si preme su un repository remoto (ad es. Quando si preme su un repository remoto usando il proprio account GitHub, BitBucket o GitLab)

Per dichiarare tale identità per tutti i repository, usa git config --global
Questo memorizzerà le impostazioni nel file .gitconfig dell'utente: ad es. $HOME/.gitconfig o per Windows, %USERPROFILE%\.gitconfig .

git config --global user.name "Your Name"
git config --global user.email mail@example.com
 

Per dichiarare un'identità per un singolo repository, utilizzare git config all'interno di un repository.
Questo memorizzerà l'impostazione all'interno del singolo repository, nel file $GIT_DIR/config . ad esempio /path/to/your/repo/.git/config .

cd /path/to/my/repo
git config user.name "Your Login At Work"
git config user.email mail_at_work@example.com
 

Le impostazioni memorizzate nel file di configurazione del repository avranno la precedenza sulla configurazione globale quando si utilizza quel repository.


Suggerimenti: se hai identità diverse (una per progetto open-source, una per lavoro, una per repository privato, ...), e non vuoi dimenticare di impostare quella giusta per ciascun repository su cui stai lavorando :

  • Rimuovere un'identità globale

    git config --global --remove-section user.name
    git config --global --remove-section user.email
     
2.8
  • Per forzare git a cercare la tua identità solo all'interno delle impostazioni di un repository, non nella configurazione globale:

      git config --global user.useConfigOnly true
     

In questo modo, se ti dimentichi di impostare user.name e user.email per un determinato repository e provare a eseguire un commit, vedrai:

no name was given and auto-detection is disabled
no email was given and auto-detection is disabled
 

Codice di condivisione

Per condividere il tuo codice, crei un repository su un server remoto su cui copierai il tuo repository locale.

Per ridurre al minimo l'uso di spazio sul server remoto, si crea un repository nudo: uno che ha solo gli oggetti .git e non crea una copia funzionante nel filesystem. Come bonus si imposta questo telecomando come server upstream per condividere facilmente gli aggiornamenti con altri programmatori.

Sul server remoto:

git init --bare /path/to/repo.git
 

Sulla macchina locale:

git remote add origin ssh://username@server:/path/to/repo.git
 

(Nota che ssh: è solo un modo possibile per accedere al repository remoto.)

Ora copia il tuo repository locale sul telecomando:

git push --set-upstream origin master
 

Aggiunta di --set-upstream (o -u ) ha creato un riferimento upstream (tracking) che viene utilizzato dai comandi Git senza argomento, ad esempio git pull .