[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,
quindi 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 puoi 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, aggiungi la riga di comando, digita, 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 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 il master.
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 digitate nella finestra dei comandi.
Vedete che dice, Sul master ramo, quindi questo è il ramo principale 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 sul mio Mac.
Quindi 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 è ora pronto per essere impegnato nel mio repository Git.
Quindi il comando successivo che abbiamo visto era git add, usando git add,
è possibile aggiungere file o cartelle all'area di gestione temporanea.
Quindi, una volta aggiunto all'area di gestione temporanea, puoi commettere quella 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 nel nostro repository Git.
Quindi tutti i file, come esistono al momento, una volta che sono stati messi in scena
usando git add, allora saranno impegnati attraverso un repository Git,
quindi 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 farlo.
Tornando al prompt dei comandi, scriviamo git commit,
e quindi possiamo anche 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, ok, un 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 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
comando successivo, chiamato git log —oneline.
E vedi che mostra un numero lì, un numero di otto cifre lì, e
mostra anche il messaggio che mettiamo 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 digiti semplicemente git log,
mostrerà 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 ho intenzione di aggiungere ulteriori modifiche al mio file index.html, quindi aggiungerò,
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 dei modelli,
ho intenzione di creare 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 solo intenzione di copiare tutto dal
mio index.html nel mio test.html, e
salvare le modifiche Tornando alla riga di comando,
ora controlliamo lo stato del nostro repository Git e questa cartella.
Quindi digitando lo stato git mostra che il file index.html che abbiamo
già aggiunto in precedenza 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 al nostro repository, all'area di gestione temporanea.
Quindi, di nuovo, digita git add., e
poi tutti questi file verranno aggiunti all'area di staging.
Ancora una volta, il check-out dello stato, ora si vede che le modifiche che sono state
aggiunte all'area di gestione temporanea, in modo che 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 dettagli completi del registro, puoi digitare semplicemente, git log.
E poi vedrai più dettagli
di quello che ti interesserebbe.
Quindi nota che il commit di una riga
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 aggiungere
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,
quindi facciamo un terzo commit, quindi diciamo git add. ,
git status.
Ora vedrai che il index.html, la versione modificata, è stato aggiunto.
Ora, possiamo dire git commit,
«Terzo commit», E fare git log —oneline,
e vedrai 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 più vecchio e
quindi sostituire il file esistente nella nostra directory dal commit precedente.
Quindi vediamo come possiamo operare con queste cose imparando
un paio di altri comandi.
A questo punto, 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 estrarre 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 a una versione precedente del file.
Possiamo sempre estrarre 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 è l'identificatore di commit,
il numero che identifichi quel particolare commit.
E poi posso dire index.html, e quello che noteresti
è che tutto il file verrà ora estratto 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 ho fatto 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
digito git status, noti che questo file index.html, che è tornato a quello che era alla fine del secondo commit.
Ora è già stato messo in scena, quindi usando questo checkout git
estrarrà una versione precedente del file e quindi sostituirà 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 commesso come quarto commit,
ma supponiamo che non mi piaccia.
Voglio 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 ho 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 quel file usando il checkout per quello.
Ora, se vogliamo 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
noterai 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 nella directory di lavoro.
Quindi questo è un modo in cui puoi scartare
le modifiche apportate a 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 lo faccio,
lo stato Git, mostra che la mia directory è pulita, e fondamentalmente
la mia directory è stata ripristinata allo stato della fine del terzo commento.
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, se hai apportato modifiche a un file dopo un 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 in
questa parte..
Quindi questi sono alcuni comandi di base che sono molto utili per
te mentre passi attraverso i corsi e
la specializzazione perché potresti voler impegnarti alla fine di ogni esercizio.
E mentre si procede in avanti,
si avrà ancora una versione di commit
dello stato della cartella alla fine dell'esercizio precedente.
In questo modo se stai eseguendo un nuovo esercizio e scopri di aver
commesso degli errori e vuoi tornare al commit precedente.
Avrai sempre un modo per farlo usando i comandi
che abbiamo appena imparato.
Quindi, con questa comprensione di base di questi pochi comandi Git,
saremmo 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 get 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 estrarre 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 stai attraversando 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 pronto per andare avanti ad usare
Git nei corsi di questa specializzazione.
Quindi, alla fine di questo esercizio, l'hai Git?
[ MUSIC]