Tutorial Git per principianti

Lo sviluppo del software è un lavoro collaborativo. In qualità di ingegnere del software, devi condividere il tuo lavoro con gli altri. Ma condividere il codice e collaborare può diventare complicato. È difficile tenere traccia dei vari cambiamenti che avvengono durante il ciclo di vita di un software. Quindi i team di sviluppo si affidano a strumenti di controllo della versione per aiutare con il processo di collaborazione software. Git è uno degli strumenti di controllo della versione più importanti nell'industria del software.

Mancia: In questo tutorial imparerai come utilizzare i fondamenti di Git. Ogni sezione termina con alcune domande. Puoi leggere le domande prima di iniziare a leggere la sezione. Questo ti aiuterà a capire e prestare attenzione ai punti importanti important.

Divertiti ad imparare Git!

Git: una breve panoramica

Git è un sistema di controllo di versione distribuito. Tiene traccia di tutte le modifiche apportate a file e cartelle. Semplifica il salvataggio dei tuoi lavori in corso. Se c'è un problema, puoi facilmente controllare una versione precedente del file o della cartella. Se necessario, puoi anche ripristinare l'intera base di codice a una versione precedente.

Lo sviluppo di Git è iniziato nel 2005. Il gruppo del kernel Linux utilizzato per mantenere il proprio codice in BitKeeper, un sistema di controllo di versione distribuito proprietario. Tuttavia, BitKeeper ha ritirato l'uso gratuito del prodotto. Così Linus Torvalds, il creatore e principale sviluppatore di Linux, ha progettato un nuovo sistema di controllo di versione distribuito open source che avrebbe soddisfatto i requisiti della comunità di sviluppo di Linux. E Git è nato.

Come sistema di controllo della versione distribuito, Git non richiede un'autorità centralizzata per tenere traccia del codice. I controlli delle versioni centralizzate precedenti come CVS, SVN o Perforce richiedono server centrali per mantenere la cronologia delle modifiche. Git può tenere traccia di tutte le modifiche localmente e lavorare peer-to-peer. Quindi è più versatile dei sistemi centralizzati.

Domande:

Perché dovresti usare Git?
Qual è il vantaggio del controllo di versione distribuito??

Installazione di Git

Per i sistemi Linux installare Git è facile. Se stai usando una distribuzione basata su Debian come Ubuntu, puoi usare apt install:

$ sudo apt install git-all

Per Fedora, RHEL o CentOS, puoi usare:

$ sudo dnf install git-all

Puoi controllare se Git è stato installato, usando il seguente comando:

$ git --version

Dovrebbe mostrarti la versione di Git che hai installato, ad esempio:

git versione 2.17.0

Una volta installato Git, è il momento di impostare il nome utente e l'e-mail:

$ git config --utente globale.nome "tuonomeutente"
$ git config --utente globale.e-mail "[e-mail protetta]"

Puoi verificare se le configurazioni sono state impostate correttamente utilizzando il seguente comando:

$ git config --list
utente.nome=nomeutente
[email protected]

Mancia: È importante impostare l'utente.nome e utente.email perché queste configurazioni vengono utilizzate per tenere traccia delle modifiche.

Domande

Qual è il comando per installare Git sul tuo sistema Linux?
Perché dovresti impostare l'utente?.nome e utente.configurazione e-mail? Come le imposti??

Capire Git concettualmente

Per utilizzare Git, devi prima comprendere questi quattro concetti:

Directory di lavoro
Area di sosta
Repository
Repository remoto

La directory di lavoro, l'area di staging e il repository sono locali sulla tua macchina. Il repository remoto può essere qualsiasi altro computer o server. Pensiamo a questi concetti come a quattro scatole che possono contenere fogli A1 standard.

Supponiamo che tu stia scrivendo un documento a mano su un foglio A1 alla tua scrivania. Conserva questo documento nella casella della directory di lavoro. Ad un certo punto del tuo lavoro, decidi di essere pronto a conservare una copia del lavoro che hai già fatto. Quindi fai una fotocopia del tuo documento attuale e lo metti nella scatola di stadiazione.

Il palco è un'area temporanea. Se decidi di scartare la fotocopia nella casella di staging e aggiornarla con una nuova copia del documento della directory di lavoro non ci sarà alcuna registrazione permanente di quel documento di staging.

Supponiamo che tu sia abbastanza sicuro di voler mantenere la registrazione permanente del documento che hai nella casella di staging. Quindi fai una fotocopia del documento della casella di staging e la sposti nella casella del repository.

Quando lo sposti nella casella del repository, accadono due cose:

Un'istantanea del documento viene salvata in modo permanente.
Viene inserita una voce nel file di registro per l'istantanea.

La voce di registro ti aiuterà a trovare quella particolare istantanea del tuo documento se ne avrai bisogno in futuro.

Ora, nella casella del repository locale, hai un'istantanea del tuo lavoro e una voce di registro. Ma è disponibile solo per te. Quindi fai una copia del documento del tuo repository locale insieme al file di registro e lo metti in una scatola nel magazzino dell'azienda. Ora chiunque nella tua azienda può venire a fare una copia del tuo documento e portarlo alla propria scrivania. La scatola nel magazzino sarebbe il deposito remoto.

Il repository remoto è come condividere il tuo documento utilizzando Google Docs o Dropbox.

Domande:

Puoi definire directory di lavoro, staging, repository e repository remoto??
Puoi disegnare come i documenti si spostano da una fase all'altra??

Il tuo primo repository Git

Una volta installato Git, puoi iniziare a creare i tuoi repository Git. In questa sezione, inizializzerai il tuo repository Git.

Supponiamo che tu stia lavorando a un progetto di sviluppo web. Creiamo una cartella chiamata project_helloworld e cambiamo nella directory:

$ mkdir project_helloworld
$ cd project_helloworld

Puoi dire a Git di monitorare questa directory con il seguente comando:

$ git init

Dovresti vedere un output come questo:

Repository Git vuoto inizializzato in /Users/zakh/_work/LearnGIT/git_tutorial/
progetto_ciaomondo/.idiota

Ora tutti i file e le cartelle all'interno di project_helloworld verranno tracciati da Git.

Domande:

Come si inizializza una directory per essere tracciata da Git?

Comandi Git di base: status, log, add e commit

Il comando status mostra la condizione attuale della tua directory di lavoro e il comando log mostra la cronologia. Proviamo il comando status:

$ git stato
Sul maestro di filiale
Impegno iniziale
niente da impegnare (crea / copia file e usa "git add" per tenere traccia)

L'output del comando git status dice che sei sul ramo principale. Questo è il ramo predefinito che Git inizializza. (Puoi creare i tuoi rami. Maggiori informazioni sui rami in seguito). Inoltre, l'output dice che non c'è nulla da impegnare.

Proviamo il comando log:

$ git log
fatale: il tuo attuale ramo 'master' non ha ancora alcun commit

Quindi, è il momento di creare del codice. Creiamo un file chiamato index.html:

La mia pagina web

Ciao mondo

Puoi usare l'editor di testo per creare il file. Una volta salvato il file, controlla di nuovo lo stato:

$ git stato
Sul maestro di filiale
Impegno iniziale
File non tracciati:
(usa "git add …” da inserire in quanto sarà impegnato)
indice.html
niente aggiunto al commit ma sono presenti file non tracciati (usa "git add" per tracciare)

Git ti sta dicendo che hai un file chiamato index.html nella tua directory di lavoro non tracciatatrack.

Assicuriamoci indice.html è tracciato. Dovrai usare il comando add:

$ git add index.html

In alternativa, puoi usare il "."Opzione per aggiungere tutto nella directory:

$ git add .

Ora controlliamo di nuovo lo stato:

$ git stato
Sul maestro di filiale
Impegno iniziale
Modifiche da commettere:
(usa "git rm --cached … "smontare)
nuovo file: indice.html

Il verde indica che l'indice.html viene monitorato da Git.

Mancia: Come menzionato nelle istruzioni sopra, se usi il comando:

$ git rm --cached index.html

Il tuo indice.html tornerà allo stato non tracciato. Dovrai aggiungerlo di nuovo per riportarlo alla messa in scena.]

Controlliamo di nuovo il registro:

$ git log
fatale: il tuo attuale ramo 'master' non ha ancora alcun commit

Quindi, anche se Git sta monitorando l'indice.html, non c'è ancora nulla nel repository Git sul file. Impegniamo le nostre modifiche:

$ git commit -m "Indice di commit.html"
L'output dovrebbe essere simile a questo:
[master (root-commit) f136d22] Indice di commit.html
1 file modificato, 6 inserimenti(+)
creare la modalità 100644 indice.html

Il testo all'interno delle virgolette dopo "-m" è un commento che andrà nel file di registro. Puoi usare git commit senza "-m", ma poi Git aprirà un editor di testo che ti chiederà di scrivere i commenti. È più semplice inserire i commenti direttamente sulla riga di comando.

Ora controlliamo il nostro file di registro:

$ git log
commit f136d22040ba81686c9522f4ff94961a68751af7
Autore: Zak H
Data: lun 4 giugno 16:53:42 2018 -0700
Indice di commit.html

Puoi vedere che mostra un commit. Hai confermato con successo le tue modifiche al tuo repository locale. Se vuoi vedere lo stesso log in modo conciso, puoi usare il seguente comando:

$ git log --oneline
f136d22 Indice di commit.html

Andando avanti, useremo questa forma del comando log perché rende più facile capire cosa sta succedendo.

Iniziamo a modificare l'indice.html. Apri l'indice.html in un editor e cambia la riga "Hello world" in "Hello world! Sono io!"e salvalo. Se controlli di nuovo lo stato, vedrai che Git ha notato che stai modificando il file:

$ git stato
Sul maestro di filiale
Modifiche non programmate per il commit:
(usa "git add … "per aggiornare ciò che verrà impegnato)
(usa "git checkout -- … "per annullare le modifiche nella directory di lavoro)
modificato: indice.html
nessuna modifica aggiunta al commit (usa "git add" e/o "git commit -a")

La modifica è ancora nella tua directory di lavoro. Devi spingerlo nell'area di sosta. Usa il comando add che hai usato prima:

$ git add .

Controlla di nuovo lo stato:

$ git stato
Sul maestro di filiale
Modifiche da commettere:
(usa "git reset HEAD … "smontare)
modificato: indice.html

Ora le tue modifiche sono nell'area di staging. Puoi impegnarlo nel repository per una custodia permanente:

$ git commit -m "Indice modificato.html per un messaggio più felice"
[master 0586662] Indice modificato.html per un messaggio più felice
1 file modificato, 1 inserimento(+), 1 cancellazione(-)

Puoi controllare il registro per le modifiche permanenti:

$ git log --oneline
0586662 Indice modificato.html per un messaggio più felice
f136d22 Indice di commit.html

In questa sezione, hai imparato a usare i comandi status, log, add e commit per tenere traccia dei tuoi documenti in Git.

Domande:

Cosa fa git status?
Cosa fa git log??
Cosa fa git add?
Cosa fa git commit?

Tornare a file precedenti utilizzando Checkout

Quando commetti un file in Git, crea un hash univoco per ogni commit. Puoi usarli come identificatori per tornare a una versione precedente.

Supponiamo che tu voglia tornare alla tua versione precedente di index.html. Per prima cosa, diamo un'occhiata all'indice.html nella condizione attuale:

$ indice di gatto.html

La mia pagina web

Ciao mondo! Sono io!

Puoi vedere che hai la versione più recente ("Hello world! Sono io!”). Controlliamo il registro:

$ git log --oneline
0586662 Indice modificato.html per un messaggio più felice
f136d22 Indice di commit.html

L'hash della versione precedente era f136d22 ("Hello world"). Puoi usare il comando checkout per arrivare a quella versione:

$ git checkout f136d22
Nota: controllando 'f136d22'.
Sei in stato di 'testa distaccata'. Puoi guardarti intorno, apportare modifiche sperimentali
e commettili, e puoi scartare qualsiasi commit che fai in questo stato
senza intaccare alcun ramo eseguendo un altro checkout.
Se vuoi creare un nuovo ramo per conservare i commit che crei, puoi
fallo (ora o più tardi) usando di nuovo -b con il comando checkout. Esempio:
git checkout -b
HEAD è ora a f136d22... Indice di commit.html

Se guardi il contenuto dell'indice.html, vedrai:

$ indice di gatto.html

La mia pagina web

Ciao mondo

Ha solo "Hello world". Quindi il tuo indice.html è cambiato nella versione precedente. Se controlli lo stato:

$ git stato
TESTA staccata a f136d22
niente da eseguire, pulizia della directory di lavoro

Git ti sta fondamentalmente dicendo che HEAD non è al commit più recente. Puoi tornare al commit più recente controllando il ramo principale usando il seguente comando:

$ git checkout master
La posizione HEAD precedente era f136d22... Indice di commit.html
Passato al ramo 'master'

Ora se controlli lo stato:

$ git stato
Sul maestro di filiale
niente da eseguire, pulizia della directory di lavoro

L'avvertimento rosso è sparito. Inoltre, se controlli il tuo indice.html, dovresti tornare all'ultima versione:

$ indice di gatto.html

La mia pagina web

Ciao mondo! Sono io!

Il comando checkout ti porta in vari stati. Impareremo di più sul checkout nella prossima sezione.

Domande:

Come si usa il comando git checkout per passare a una versione precedente di un file??
Come si usa git checkout per tornare all'ultima versione del file??

Checkout, ramificazione e unione

La ramificazione è una delle migliori funzionalità di Git. Ti aiuta a separare il tuo lavoro e sperimentare di più. In altri sistemi di controllo della versione, la ramificazione richiedeva tempo e difficoltà. Git ha semplificato la ramificazione e l'unione.

Come hai notato nel comando status, quando crei un nuovo repository Git, sei nel ramo principale.

$ git stato
Sul maestro di filiale
niente da eseguire, pulizia della directory di lavoro

Supponi di creare un sito web per il tuo amico David. Vuoi riutilizzare il codice del tuo sito web. La ramificazione è un'ottima soluzione. Chiamiamo la filiale david_website.

Puoi dare il seguente comando:

$ git branch david_website

Puoi usare il seguente comando per vedere tutti i rami:

$ git branch --list
david_website
* maestro

La stella (*) accanto al master significa che sei ancora nel ramo master. Puoi controllare il ramo david_website con il seguente comando:

$ git checkout david_website
Passato al ramo 'david_website'

Ora, se controlli di nuovo l'elenco dei rami, vedrai:

$ git branch --list
* david_website
maestro

Quindi sei nel ramo david_website.

Cambiamo l'indice.html da “Hello world! Sono io!” a “Ciao mondo! è David!” e poi stage e commit:

$ git add .
$ git commit -m "Sito web modificato per David"

Se controlli i log, dovresti vedere:

$ git log --oneline
345c0f4 Sito web modificato per David
0586662 Indice modificato.html per un messaggio più felice
f136d22 Indice di commit.html

E il tuo file indice dovrebbe assomigliare a questo:

$ indice di gatto.html

La mia pagina web

Ciao mondo! è David!

Ora controlliamo di nuovo il ramo principale:

$ git checkout master
Passato al ramo 'master'

Se controlli lo stato e registri:

$ git stato
Sul maestro di filiale
niente da eseguire, pulizia della directory di lavoro
$ git log --oneline
0586662 Indice modificato.html per un messaggio più felice
f136d22 Indice di commit.html

Nota che non hai il tuo terzo commit nel master. Perché quel commit viene mantenuto solo nel ramo david_website.

Questo è quello che è successo

Supponiamo che in questa fase tu decida di non voler continuare il tuo sito web. Sarai solo lo sviluppatore per David. Quindi vuoi unire le modifiche nel ramo david_website al master. Dal ramo master, devi solo dare i seguenti comandi (il comando status è usato per verificare se sei nel posto giusto):

$ git stato
Sul maestro di filiale
niente da eseguire, pulizia della directory di lavoro

$ git merge david_website
Aggiornamento 0586662… 345c0f4
Avanti veloce
indice.html | 2 +-
1 file modificato, 1 inserimento(+), 1 cancellazione(-)

Mancia: Stai apportando modifiche da david_website a master. Devi essere il maestro per raggiungere questo obiettivo.

Ora se controlli il log sul master, vedi che il terzo commit è lì:

$ git log --oneline
345c0f4 Sito web modificato per David
0586662 Indice modificato.html per un messaggio più felice
f136d22 Indice di commit.html

Hai unito con successo il ramo david_website in master. E il tuo indice.html per il ramo master è identico al ramo david_website:

$ indice di gatto.html

La mia pagina web

Ciao mondo! è David!

Puoi mantenere il ramo david_website:

$ git branch --list
david_website
* maestro

Oppure puoi eliminarlo:

$ git branch -d david_website
Ramo eliminato david_website (era 345c0f4).

Dopo la cancellazione, non dovresti più vedere il ramo david_website:

$ git branch --list
* maestro

Mancia: Durante un'unione, se Git non può unire automaticamente ti darà errori di conflitto di unione. In tal caso, devi risolvere manualmente i problemi di unione.

Domande:

Perché hai bisogno di ramificazioni??
Come diramare e unire file e cartelle??

Repository remoto

Fino ad ora, tutto il tuo lavoro è stato locale. Hai eseguito il commit delle tue modifiche in un repository locale. Ma è ora di condividere il tuo lavoro con il mondo.

Il repository remoto Git è fondamentalmente un'altra copia del tuo repository locale a cui possono accedere altri. Puoi configurare un server e renderlo il repository remoto. Ma la maggior parte delle persone usa GitHub o Bitbucket per questo scopo. Puoi creare repository pubblici gratuitamente lì a cui chiunque può accedere.

Creiamo un repository remoto su GitHub.

Innanzitutto, devi creare un account GitHub[]. Una volta che hai l'account, crea un nuovo repository usando il pulsante "Nuovo repository". Usa "project_website" come nome del repository (puoi scegliere qualcos'altro se vuoi).

Dovresti vedere una scheda Codice con istruzioni come queste:

… o crea un nuovo repository sulla riga di comando

echo "# sito_progetto" >> LEGGIMI.md
git init
git add LEGGIMI.md
git commit -m "primo commit"
git remote aggiungi origine [email protected]:nomeutente/sito_web_progetto.idiota
git push -u origine master

Copia il seguente comando "git remote add origin" ed eseguilo nella tua directory di lavoro:

$ git remote aggiungi origine [email protected]:nomeutente/sito_web_progetto.idiota

Nota: nel tuo caso, il tuo nome utente dovrebbe essere quello che hai usato per creare il tuo account GitHub.

Nel comando sopra, hai indicato a Git la posizione del repository remoto. Il comando sta dicendo a Git che l'"origine" per la tua directory di lavoro project_helloworld sarà "[email protected]:yourusername/project_website.idiota".

Ora spingi il tuo codice dal tuo ramo principale a origin (repository remoto):

$ git push origine master
Conteggio oggetti: 9, fatto.
Compressione delta utilizzando fino a 4 thread.
Comprimere oggetti: 100% (6/6), fatto.
Oggetti di scrittura: 100% (9/9), 803 byte | 0 byte/s, fatto.
Totale 9 (delta 2), riutilizzato 0 (delta 0)
remoto: risoluzione dei delta: 100% (2/2), fatto.
A [email protected]:nomeutente/sito_webprogetto.idiota
* [nuovo ramo] master -> master

Se aggiorni il browser in GitHub, dovresti vedere che l'indice.il file html è lassù. Quindi il tuo codice è pubblico e altri sviluppatori possono controllare e modificare il codice sul repository remoto.

Come sviluppatore, lavorerai con il codice di altre persone. Quindi vale la pena provare a controllare il codice da GitHub.

Andiamo in una nuova directory dove non hai nulla. Sul lato destro del repository GitHub, noterai il pulsante "Clona o scarica". Se fai clic su di esso, dovrebbe darti un indirizzo SSH. Esegui il seguente comando con l'indirizzo SSH:

$ git clone [email protected]:nomeutente/sito_web_progetto.idiota

L'output dovrebbe essere simile a questo:

$ git clone [email protected]:nomeutente/sito_web_progetto.idiota
Clonazione in 'project_website'..
remoto: Conteggio oggetti: 9, fatto.
remoto: Compressione di oggetti: 100% (4/4), fatto.
remoto: Totale 9 (delta 2), riutilizzato 9 (delta 2), pacco riutilizzato 0
Ricezione di oggetti: 100% (9/9), fatto.
Risoluzione dei delta: 100% (2/2), fatto.
Controllo della connettività... fatto.

Creerà un project_website nella tua cartella pulita. Se entri, dovresti vedere l'indice.html dal tuo project_helloworld.

Quindi hai ottenuto quanto segue:

Creato e apportato modifiche in project_helloworld
Ho caricato il codice su GitHub in project_website
Scaricato il codice da GitHub

Prendiamo un altro file dalla nuova directory di lavoro project_website:

$ tocca Leggimi.md
$ git add .
$ git commit -m "Aggiunto Leggimi.md"
$ git push origine master

Se aggiorni la pagina project_website di GitHub, dovresti vedere il file Leggimi.file md lì.

Nota: quando scarichi il codice da GitHub, la directory di lavoro conosce automaticamente l'origine. Non è necessario definirlo con il comando "git remote add origin".

Domande:

Perché è necessario utilizzare i repository remoti??
Come si imposta il repository locale corrente per connettersi al repository remoto??
Come clonare i repository remoti sul computer locale??

Conclusione

Puoi trovare maggiori informazioni su tutti i comandi nei documenti Git[]. Anche se sono disponibili strumenti per l'interfaccia utente di Git, la riga di comando è il modo migliore per padroneggiare Git. Ti darà una base più solida per il tuo lavoro di sviluppo.

Ulteriori studi:

https://git-scm.com/docs
https://git-scm.com/book/it/v2
https://git-scm.com/video