[MUSIC]
Esaminiamo ora alcuni comandi Git di base che sono molto utili per
noi in questa specializzazione.
C' è molto di più in Git rispetto a quello che copriamo in questo esercizio.
Per iniziare, vai alla 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 di Visual Studio.
Permettetemi di aggiungere un file a questa cartella denominata index.html,
ora potete vedere che ho aggiunto un
codice HTML in questo file index.html.
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 digitare git init.
Ora, questa cartella è stata inizializzata per essere un repository git.
Quindi questo è il nostro primo comando git che abbiamo imparato, git init.
Questo inizializza la cartella corrente come repository git e
quando inizializza la cartella, contrassegnerà quella cartella come master.
Questo è il ramo principale del mio kit.
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 toccate nella finestra di comando.
Vedete che dice sul master ramo, quindi questo è il ramo master che aggiungiamo.
E dice, file non tracciati, e poi mostra index.html in rosso.
Sul tuo computer specifico, potrebbe usare colori diversi o
rappresentarlo in modo diverso o questo è ciò che mostra sul 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, le modifiche da commettere lì e poi mostra il nome del file e quindi questo
significa che questo file è ora pronto per essere impegnato nel mio repository git.
Quindi, il prossimo comando che abbiamo visto era git add.
Usando git add puoi aggiungere file o cartelle a quell'area di gestione temporanea.
Quindi, una volta aggiunto all'area di staging, puoi commettere quell'istantanea
dello stato della nostra cartella nel nostro repository git.
Ciò significa che quando fai il commit git,
ciò che questo comando farà è commettere lo
stato attuale delle nostre cartelle nei nostri repository git.
Quindi tutti i file così come esistono al momento,
una volta che sono stati messi in scena usando git add, allora saranno impegnati nel nostro
repository git quando eseguiamo la cartella dei comandi git.
Quindi, a questo punto, quando eseguiamo il comando git, allora il nostro
stato iniziale sarà ora cambiato al primo commit nel repository git.
Quindi andiamo avanti e facciamolo.
Tornando al prompt dei comandi, digitiamo git commit.
E poi possiamo anche aggiungere un messaggio al nostro commit.
Quindi dirò git commit -m «first
commit» perché questo è il nostro commit al nostro repository git.
Quindi, quando lo faccio, dice, va bene, 1 file è stato aggiunto al repository git e
alcune altre informazioni verranno digitate nella 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ò che significa è che lo stato corrente della mia directory di
lavoro o della mia 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 vedere che mostra un numero lì, un numero di otto cifre lì,
e poi mostra anche il messaggio che abbiamo inserito nel nostro commit dicendo primo commit.
Quindi questo è il registro di tutti i commit che sono stati inseriti nel mio repository git.
Quindi, tornando al nostro prossimo comando git,
abbiamo visto che git log —oneline
ci mostrerà un breve log di tutti i commit.
Se si digita semplicemente git log,
visualizzare informazioni molto più dettagliate su tutti i commit.
Ma questo è sufficiente per ottenere informazioni di cui abbiamo bisogno.
Torniamo ora al nostro editor qui, in Visual Studio Code,
quindi aggiungerò altre modifiche al mio file index.html.
Ho cambiato il mio file index.html.
Ora, lasciami aggiungere un'altra cartella sotto la cartella di test git, quindi
creerò una sottocartella qui denominata template, e all'interno di queste
cartelle template, creerò un altro nome file, 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 digita lo stato git, mostra che
il file html di stato dell'indice che abbiamo già consegnato prima al repository è
stato modificato, quindi c'è una versione più recente del file index.html.
Inoltre, mostra che ci sono alcuni
file non tracciati in questa cartella chiamati template.
Aggiungiamo tutte queste modifiche alla messa in scena
dell'area, quindi di nuovo, digita git add.
E poi tutti questi file verranno aggiunti all'area di gestione temporanea.
Di nuovo, controllando lo stato.
È ora possibile vedere che le modifiche che sono state aggiunte 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 diamo un'occhiata al registro.
Se controlli il registro, ora vedrai che ci sono due commit
nel mio repository git, il primo e il secondo commit.
E nota che a ciascuno di loro viene dato un numero diverso lì.
Se vuoi vedere i loro dettagli completi del log,
puoi digitare semplicemente, git log e poi riceverai più dettagli lì dentro.
Allora a cosa ti interesserebbe.
Quindi, si noti che il commit oneline fornisce solo i
primi caratteri del mio numero di commit lì.
Questo è sufficiente per poter operare.
Permettetemi ora di tornare al mio Visual Studio e quindi aggiungerne uno in più.
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, facendo
lo stato git 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. ,
git status,
ora vedi che index.html è stata aggiunta la versione modificata.
Ora possiamo dire git commit.
« third commit» e git log —oneline,
e vedi che ci sono tre commit nel nostro repository.
Quindi ora il nostro repository contiene istantanee di tre punti diversi,
alla fine del primo commit, alla fine del secondo commit, e
alla fine del terzo commit.
Ora, possiamo anche ripristinare le modifiche,
possiamo ripristinare il repository a una versione precedente.
Possiamo estrarre un file da un commit precedente, e
quindi sostituire la directory esistente dal vecchio commit.
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 ps.
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
vogliamo tornare alla tua versione precedente del file,
possiamo sempre controllare il file da un commit precedente o
dal commit corrente e quindi continuare a lavorare con quel file.
Quindi facciamo uso di questo e vediamo alcune ulteriori modifiche al 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 è commit identifichi il numero che identifichi il particolare commit,
e quindi posso dire index.html, e quello che noteresti è che,
quel file più vecchio verrà ora estratto nella mia directory di lavoro corrente.
Andando al mio codice di Visual Studio,
ora noterai che il mio file index.html è tornato al lavoro precedente, quindi
la modifica che ho apportato prima del terzo commit è ora sparita.
Quindi il mio file index.html è stato ripristinato al suo stato alla fine del secondo commit.
Ora, alla riga di comando, se provo git status,
noterai che questo file index.html che è stato ripristinato
a quello che era alla fine del secondo commit, ora è già stato messo in scena.
Quindi, usando questo checkout git, estrarremo una versione precedente del file,
quindi
sostituiremo ciò che è nella directory corrente, e poi lo controllerà anche nell'area di gestione temporanea.
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 commesso come quarto commit.
Ma supponiamo che non mi piaccia, voglio
raddoppiare per tornare al file index.html alla fine
del terzo commit, quindi tutto ciò che posso fare è dire git reset,
HEAD e index.html.
Quindi a questo punto, quello che succede è che index.html,
la versione modificata che avevo estratto è ancora lì, ma
questo file è stato dismesso dall'area di staging.
Se torni indietro e guardi index.html nel tuo editor,
mostrerà comunque lo stato alla fine del secondo commit.
Perché avevamo estratto il file usando il checkout per questo.
Ora, se vuoi tornare a quello che era alla fine del terzo commit,
allora facciamo un altro checkout 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 affermazione qui.
Dice git checkout - e
il nome del file, per scartare le modifiche nelle directory di lavoro.
Quindi questo è un modo per scartare le modifiche che hai fatto a un particolare
file corrispondente al commento precedente.
Quindi lasciami ripristinare quel index.html a quello che era alla fine
del terzo commit.
Quindi, per farlo, potrei semplicemente dire git, checkout,
- index.html e poi,
se faccio lo stato git, mostra che la mia directory è pulita.
E fondamentalmente la mia directory è stata ripristinata
allo stato alla fine del terzo commit.
Andando al file nel mio codice Virtual Studio, vedo che
il loro file è stato ripristinato a quello che era alla fine del terzo cap.
Quindi questo è un modo in cui puoi, se hai apportato modifiche al tuo
file dopo il commit e vuoi semplicemente scartare quelle modifiche,
puoi semplicemente estrarre il file dall'ultimo commit, e quindi 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 passi attraverso i corsi in questa specializzazione
perché potresti voler impegnarti alla fine di ogni esercizio.
E mentre procedi in avanti, avresti comunque una visione guidata
dello stato della tua cartella alla fine dell'esercizio precedente.
In questo modo, se stai eseguendo un nuovo esercizio e hai scoperto che hai
commesso degli errori e vuoi tornare al commit precedente,
hai sempre un modo per farlo usando i comandi che abbiamo appena lasciato.
Quindi, con questa comprensione di base di questi pochi comandi git,
sarai in grado di procedere con la comprensione e
l'uso di git nei corsi di questa specializzazione.
Così ora, abbiamo esaminato il git reset per un file specifico o git reset in generale.
Se digiti semplicemente git reset, ti ripristinerà all'ultimo commit.
Quindi ripristinerà 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 questa settimana, puoi ripristinare la tua cartella nel punto in cui ti trovavi
al punto di partenza del commit precedente.
Quindi, a volte, quando stai attraversando un esercizio e ti rendi conto che hai perso un segnale.
Hai sempre un modo per tornare a una versione precedente.
Quindi con questi comandi, penso che tu sia tutto pronto per andare avanti ad
usare git nei corsi di questa specializzazione.
Quindi, alla fine di questo esercizio, l'hai Git?
[ MUSIC]