[MUSIC]
Esaminiamo ora alcuni comandi Git di base che sono molto utili per
noi in questa specializzazione.
C' è molto di più da ottenere di quello che copriamo in questo esercizio.
Per iniziare, vai in una posizione comoda sul tuo computer e
crea una cartella denominata git-test.
Quindi, apri questa cartella nel tuo editor preferito.
Qui, ho la cartella git-test che abbiamo appena creato aperta
nel mio codice Visual Studio.
Permettetemi di aggiungere un file a questa
cartella denominata index.html.
Ora puoi vedere che ho aggiunto un codice HTML in questo indice verso HTML5.
Salviamo le modifiche.
Ora passiamo alla nostra riga di comando.
Alla riga di comando, vai alla cartella git-test e
inizializziamo questa cartella per essere un repository git.
Quindi, per farlo, alla riga di comando, digita git init.
Ora questa cartella è stata inizializzata per essere un repository git.
Questo è il nostro primo comando git che abbiamo imparato, git init.
Questo intializza la cartella corrente come repository git e
quando inizializza la cartella, contrassegnerà quella cartella come master.
Questo è il ramo master per il mio git.
Ora non preoccupatevi dei rami e così via.
Non ci occuperemo di questo in questo corso.
Lavoreremo solo con il ramo master in questa particolare specializzazione.
Quindi questo sarebbe contrassegnato come un maestro.
Ora questo è il punto iniziale del nostro repository.
Il prossimo comando che vedremo è git status.
Se digiti git status nella riga di comando,
ti dirà lo stato corrente della cartella.
Quindi facciamolo alla riga di comando e vediamo cosa mostra.
Alla riga di comando, digita git status e
leggi le informazioni che vengono tracciate nella finestra di comando.
Vedete che dice sul ramo master.
Quindi, questo è il ramo master su cui siamo e dice,
file non tracciati, e quindi mostra index.html in rosso.
Sul tuo computer specifico, potrebbe usare colori diversi o
rappresentarlo in modo diverso, ma questo è ciò che mostra nel mio Mac.
Così ora, questo file index.html che abbiamo appena creato in questa cartella
non è stato aggiunto al nostro repository git.
Quindi andiamo avanti e aggiungiamo quel file al repository git.
Quindi per farlo diciamo git add e puoi semplicemente dire
dot, il che significa che tutti i file nella directory corrente verranno aggiunti a quella
che viene chiamata area di staging del mio repository git.
Quindi ora se digito di nuovo git status,
vedrai che il file index.html è contrassegnato in verde.
E dice che le modifiche devono essere commesse lì, e poi mostra il nome del file.
E poi, questo significa che questo file è pronto per essere impegnato nel mio
repository git.
Quindi il comando successivo che abbiamo visto era git add,
usando git add puoi aggiungere file o cartelle a quell'area di staging.
Quindi, una volta aggiunto all'area di staging, puoi commettere quell'istantanea
dello stato della nostra cartella nel nostro repository git.
Quindi ciò significa che quando fai quel commit git.
Ciò che questo comando farà è commettere lo
stato attuale delle nostre cartelle nel nostro repository git.
Quindi tutti i file, come esistono al momento,
una volta che sono stati stadi usando git add, allora saranno impegnati nel
nostro repository git quando eseguiamo la cartella dei comandi git.
Quindi su questo punto, quando eseguiamo il comando git, il nostro
stato iniziale sarà ora cambiato al primo commit nel repository git.
Quindi andiamo avanti e facciamolo.
Tornando al prompt dei comandi, scriviamo,
git commit e poi possiamo mai aggiungere un messaggio al nostro commit.
Quindi dirò git commit -m first commit,
perché questo è il nostro primo commit nel nostro repository git.
Quindi, quando lo faccio, dice, va bene un file è stato aggiunto al repository git e
alcune altre informazioni verranno digitate su quella finestra di comando.
Quindi ora controlliamo di nuovo, lo stato git.
E ora vedi che non dice nulla da commettere, la directory di lavoro è pulita.
Quindi ciò significa che lo stato corrente della mia directory di lavoro, o
cartella di lavoro, è stato impegnato nel repository git.
Quindi un'istantanea è stata impegnata nel mio repository git.
Ora posso digitare il prossimo comando chiamato git log —oneline.
E vedi che mostra un numero lì, un numero di otto cifre lì.
E poi mostra anche il messaggio che abbiamo messo nel nostro commit, dicendo primo commit.
Quindi questo è il registro di tutti i commit che sono stati inseriti nel mio repository di dati.
Quindi tornando al nostro prossimo comando git abbiamo visto quel git log —oneline che vedremo e
ci mostra un breve log di tutti i commit.
Se digiti semplicemente git log, visualizza molte più informazioni dettagliate su
tutti i commit.
Ma questo è sufficiente per ottenere informazioni di cui abbiamo bisogno.
Torniamo ora al nostro editor qui nel codice di Visual Studio.
Quindi aggiungerò altre modifiche al mio file index.html.
Quindi aggiungo.
Quindi ho cambiato il mio file index.html.
Ora lasciami aggiungere un'altra cartella sotto la cartella GIT-TEST.
Quindi creerò una sottocartella qui denominata template, e
all'interno di questa cartella template, creerò un altro file chiamato test.html.
Questo è solo per mostrarti come git può impegnare
l'intera gerarchia di cartelle nel suo repository.
Quindi con test.html ora lì,
ho intenzione di copiare tutto dal mio index.html
nel mio test.html e salvare le modifiche.
Tornando alla riga di comando,
diamo ora un'occhiata allo stato del nostro repository git e di questa cartella.
Quindi digitando lo stato git mostra che il
file index.html che abbiamo già aggiunto in precedenza al repository è stato modificato.
Quindi se c'è una nuova versione del file di indice index.html.
Inoltre mostra che ci sono alcuni file non tracciati in
questa cartella chiamati template.
Aggiungiamo tutte queste modifiche al nostro repository, all'area di gestione temporanea.
Quindi di nuovo digita git add dot e poi tutti questi
file verranno aggiunti all'area di staging.
Ancora una volta, controllando lo stato,
ora si vede che le modifiche che sono stato aggiunto all'area di gestione temporanea.
Quindi tutti questi file sono stati aggiunti all'area di gestione temporanea.
Facciamo un altro commit.
Quindi direi git commit -m.
Secondo commit e poi controlliamo il registro.
Se controlli il registro ora vedi che ci sono due commit nel mio repository git.
Il primo e il secondo commit e
nota che a ciascuno di essi viene dato un numero diverso lì.
Se vuoi vedere i dettagli completi del log, puoi digitare semplicemente git log e
poi vedrai più dettagli lì dentro quindi a cosa saresti interessato.
Quindi nota che il commit oneline
fornisce solo i primi caratteri del mio numero di commit lì.
Questo è sufficiente per poter operare.
Lasciami ora tornare di nuovo al mio Visual Studio e aggiungerne un altro.
Un' altra riga al mio file index.html.
Quindi ora il mio file index.html è stato modificato.
E salviamo le modifiche.
Tornando alla riga di comando,
vai in git status mostra che il file index.html è stato modificato.
Quindi aggiungiamo questo all'area di staging e quindi facciamo un terzo commit.
Quindi diciamo git add dot git status.
Ora si vede che il index.html, la versione modificata è stata aggiunta.
Ora possiamo dire git commit.
Terzo commit.
E git log oneline, e vedrai che ci sono tre commit nel nostro repository.
Quindi ora il nostro repository contiene istantanee di tre tipi diversi.
Alla fine del primo commit, alla fine del secondo commit e
alla fine del terzo commit.
Ora possiamo anche ripristinare le modifiche.
Siamo in grado di ripristinare il repository a una versione precedente.
Possiamo estrarre un file da un commit più vecchio e
quindi ripple questo file esistente nel nostro direttamente dal commit precedente.
Quindi vediamo come possiamo operare con queste cose imparando un paio di comandi in più.
In questa fase, il nostro file index.HTML è nello stato corrente.
Quindi puoi notare che ha un h1 e due p.
Diamo ora un'occhiata al prossimo comando git.
Il prossimo comando git che impareremo è git checkout.
Quindi questo comando checkout ci permette di controllare un file
da un precedente commit nel nostro repository git.
Quindi, se non ci piace il file corrente che abbiamo nella nostra cartella e
vorremo tornare a una versione precedente del file,
possiamo sempre controllare il file da un commit precedente, o
dal commit corrente e poi continuare a lavorare con quel file.
Quindi facciamo uso di questo e vediamo alcune modifiche alla cartella nel nostro repository git.
Tornando alla nostra riga di comando, ricordiamo che tra il secondo e
il terzo commit ho apportato modifiche al mio file index.html.
Supponiamo di voler tornare al file index.html dal mio secondo commit.
Quindi posso semplicemente dire git checkout 900cfcf.
Quindi questo è l'identificatore di commit, il numero che identificherà quel particolare commento.
E poi posso dire, index.html e quello che noteresti
è che il file precedente verrà ora controllato nella mia directory di lavoro corrente.
Andando al mio codice di Visual Studio,
ora noti che il mio file index.html è tornato alla versione precedente.
Quindi la modifica che ha fatto prima del terzo commit è ora sparita.
Quindi il mio file index.html è stato ripristinato
allo stato alla fine del secondo commento.
Ora alla riga di comando se digito git status.
Noterai come questo file index.html.
Che è tornato a quello che era alla fine del secondo commit.
Ora è già stato messo in scena, quindi usando il checkout git
tireremo fuori una versione precedente del file e poi sostituiremo ciò che
è nella directory corrente e poi lo controllerà anche nell'area di staging.
Quindi ora se lo faccio e poi mi rendo conto che questo è quello che voglio posso semplicemente
fare un altro commit a questo punto.
E poi quel file può essere commentato come il quarto commit.
Ma supponiamo che non mi piaccia, voglio tornare a quel
file index.html alla fine del terzo commit.
Quindi tutto quello che posso fare è dire git reset HEAD e
index.html.
Quindi a questo punto ciò che accade è che index.html,
la versione modificata che controllo è ancora lì.
Ma questo file non è stato messo in scena dall'area di gestione temporanea.
Se torni indietro e guardi index.html nel tuo editor,
mostrerà comunque lo stage alla fine del secondo commit
perché avevamo tirato giù quel file usando il check out per quello.
Ora, se vuoi ripristinarlo a quello che era alla fine del terzo commit
, facciamo un altro check out dal terzo commit.
Andando alla nostra finestra di comando digita git status e
noteresti che index.html è contrassegnato come modificato,
ma mostra anche questa particolare istruzione qui, dice git checkout -
e il link del file per scartare le modifiche nella directory di lavoro.
Quindi questo è un modo in cui puoi scartare le modifiche che
non hai bisogno di un particolare file corrispondente al commit precedente.
Quindi fammi ripristinare questo index.html
a quello che era alla fine del terzo commit.
Quindi per farlo dirò semplicemente git
checkout - index.html.
E poi, se faccio lo stato git, mostra che la mia directory è pulita e, fondamentalmente
la mia directory era stata ripristinata allo stato della fine del terzo commit.
Andando al file nel mio codice di Visual Studio vedo che
il file è stato ripristinato a quello che era alla fine del terzo commit.
Quindi questo è un modo in cui puoi, se hai apportato modifiche a un file dopo il commit e
vuoi semplicemente scartare quelle modifiche puoi semplicemente
estrarre il file dall'ultimo commit.
E poi tutte le modifiche che hai fatto dopo l'ultimo commit
verranno scartate sul posto.
Quindi questi sono alcuni comandi di base che sono molto utili per
te mentre vai ai corsi in questa specializzazione,
perché potresti voler impegnarti alla fine di ogni esercizio.
E mentre procedi in avanti, avrai ancora una versione di commit
dello stato della tua cartella alla fine dell'esercizio precedente.
In questo modo, se stai uscendo un nuovo esercizio e hai scoperto di
aver commesso degli errori e vuoi tornare al commit precedente,
hai sempre un modo per farlo usando i comandi che abbiamo appena imparato.
Quindi, con questa comprensione di base di questi pochi comandi git,
saremo in grado di procedere con la comprensione e
l'uso di git nei corsi di questa specializzazione.
Quindi ora, abbiamo esaminato il git reset per file specifici o git reset
in generale se si digita semplicemente git reset, ti ripristinerà all'ultimo commit.
Quindi reimposterebbe l'area di staging all'ultimo commit
senza disturbare le modifiche che hai fatto alla tua directory di lavoro.
Quindi, una volta ripristinato, puoi controllare
la versione precedente del file che hai commesso nel commit precedente.
Quindi in questo modo puoi ripristinare la tua cartella dove eri
al punto di partenza del commit precedente.
Quindi, a volte, quando si sta andando un esercizio e ti
rendi conto che hai fatto un errore hai sempre un modo per tornare a una versione precedente.
Quindi con questi comandi, penso che tu sia tutto pronto per usare git
nei corsi di questa specializzazione Quindi
alla fine di questo esercizio, l'hai Git?
[ MUSIC]