1
00:00:00,000 --> 00:00:04,402
[MUSIC]

2
00:00:04,402 --> 00:00:08,751
Esaminiamo ora alcuni comandi Git di base che sono molto utili per

3
00:00:08,751 --> 00:00:10,660
noi in questa specializzazione.

4
00:00:11,670 --> 00:00:15,299
C' è molto di più in Git rispetto a quello che copriamo in questo esercizio.

5
00:00:18,380 --> 00:00:23,779
Per iniziare, vai alla posizione comoda sul tuo computer e

6
00:00:23,779 --> 00:00:27,029
crea una cartella denominata git-test.

7
00:00:30,340 --> 00:00:35,090
Quindi, apri questa cartella nel tuo editor preferito.

8
00:00:37,935 --> 00:00:42,875
Qui, ho la cartella GIT-TEST che abbiamo appena creato aperta nel

9
00:00:42,875 --> 00:00:45,390
mio codice di Visual Studio.

10
00:00:45,390 --> 00:00:51,399
Permettetemi di aggiungere un file a questa cartella denominata index.html,

11
00:00:51,399 --> 00:00:55,869
ora potete vedere che ho aggiunto un

12
00:00:55,869 --> 00:01:00,504
codice HTML in questo file index.html.

13
00:01:00,504 --> 00:01:02,580
Salviamo le modifiche.

14
00:01:02,580 --> 00:01:05,240
Ora passiamo alla nostra riga di comando,

15
00:01:06,740 --> 00:01:11,320
alla riga di comando vai alla cartella git-test e

16
00:01:11,320 --> 00:01:15,860
inizializziamo questa cartella per essere un repository git.

17
00:01:15,860 --> 00:01:19,800
Quindi per farlo alla riga di comando digitare git init.

18
00:01:21,620 --> 00:01:26,020
Ora, questa cartella è stata inizializzata per essere un repository git.

19
00:01:27,120 --> 00:01:32,650
Quindi questo è il nostro primo comando git che abbiamo imparato, git init.

20
00:01:32,650 --> 00:01:36,320
Questo inizializza la cartella corrente come repository git e

21
00:01:36,320 --> 00:01:42,380
quando inizializza la cartella, contrassegnerà quella cartella come master.

22
00:01:42,380 --> 00:01:45,690
Questo è il ramo principale del mio kit.

23
00:01:45,690 --> 00:01:48,210
Ora non preoccupatevi dei rami e così via,

24
00:01:48,210 --> 00:01:50,665
non ci occuperemo di questo in questo corso.

25
00:01:50,665 --> 00:01:56,240
Lavoreremo solo con il ramo master, in questa particolare specializzazione.

26
00:01:56,240 --> 00:01:58,500
Quindi questo sarebbe contrassegnato come un maestro.

27
00:01:58,500 --> 00:02:02,060
Ora questo è il punto iniziale del nostro repository.

28
00:02:03,770 --> 00:02:08,410
Il prossimo comando che vedremo è git status.

29
00:02:08,410 --> 00:02:10,510
Se digiti git status nella riga di comando,

30
00:02:10,510 --> 00:02:13,740
ti dirà lo stato corrente della cartella.

31
00:02:13,740 --> 00:02:17,460
Quindi facciamolo alla riga di comando e vediamo cosa mostra.

32
00:02:19,470 --> 00:02:23,395
Alla riga di comando, digita git status e

33
00:02:23,395 --> 00:02:28,945
leggi le informazioni che vengono toccate nella finestra di comando.

34
00:02:28,945 --> 00:02:34,390
Vedete che dice sul master ramo, quindi questo è il ramo master che aggiungiamo.

35
00:02:34,390 --> 00:02:40,690
E dice, file non tracciati, e poi mostra index.html in rosso.

36
00:02:40,690 --> 00:02:43,790
Sul tuo computer specifico, potrebbe usare colori diversi o

37
00:02:43,790 --> 00:02:49,040
rappresentarlo in modo diverso o questo è ciò che mostra sul mio Mac.

38
00:02:49,040 --> 00:02:54,040
Così ora, questo file index.html che abbiamo appena creato in questa cartella

39
00:02:54,040 --> 00:02:58,100
non è stato aggiunto al nostro repository git.

40
00:02:58,100 --> 00:03:01,680
Quindi andiamo avanti e aggiungiamo quel file al repository git.

41
00:03:01,680 --> 00:03:07,510
Quindi per farlo, diciamo, git add, e puoi semplicemente dire dot, il

42
00:03:07,510 --> 00:03:12,350
che significa che tutti i file nella directory corrente verranno aggiunti a quella

43
00:03:12,350 --> 00:03:17,680
che viene chiamata area di staging del mio repository git.

44
00:03:17,680 --> 00:03:21,740
Quindi ora, se digito di nuovo git status,

45
00:03:21,740 --> 00:03:27,780
vedrai che il file index.html è contrassegnato in verde.

46
00:03:27,780 --> 00:03:34,202
E dice, le modifiche da commettere lì e poi mostra il nome del file e quindi questo

47
00:03:34,202 --> 00:03:40,161
significa che questo file è ora pronto per essere impegnato nel mio repository git.

48
00:03:41,647 --> 00:03:46,100
Quindi, il prossimo comando che abbiamo visto era git add.

49
00:03:46,100 --> 00:03:51,190
Usando git add puoi aggiungere file o cartelle a quell'area di gestione temporanea.

50
00:03:51,190 --> 00:03:57,250
Quindi, una volta aggiunto all'area di staging, puoi commettere quell'istantanea

51
00:03:57,250 --> 00:04:03,100
dello stato della nostra cartella nel nostro repository git.

52
00:04:03,100 --> 00:04:06,460
Ciò significa che quando fai il commit git,

53
00:04:08,130 --> 00:04:12,610
ciò che questo comando farà è commettere lo

54
00:04:12,610 --> 00:04:17,250
stato attuale delle nostre cartelle nei nostri repository git.

55
00:04:17,250 --> 00:04:20,380
Quindi tutti i file così come esistono al momento,

56
00:04:20,380 --> 00:04:24,720
una volta che sono stati messi in scena usando git add, allora saranno impegnati nel nostro

57
00:04:24,720 --> 00:04:29,510
repository git quando eseguiamo la cartella dei comandi git.

58
00:04:29,510 --> 00:04:34,650
Quindi, a questo punto, quando eseguiamo il comando git, allora il nostro

59
00:04:34,650 --> 00:04:40,750
stato iniziale sarà ora cambiato al primo commit nel repository git.

60
00:04:40,750 --> 00:04:42,650
Quindi andiamo avanti e facciamolo.

61
00:04:45,470 --> 00:04:51,950
Tornando al prompt dei comandi, digitiamo git commit.

62
00:04:51,950 --> 00:04:54,888
E poi possiamo anche aggiungere un messaggio al nostro commit.

63
00:04:54,888 --> 00:05:00,010
Quindi dirò git commit -m «first

64
00:05:00,010 --> 00:05:04,160
commit» perché questo è il nostro commit al nostro repository git.

65
00:05:04,160 --> 00:05:10,630
Quindi, quando lo faccio, dice, va bene, 1 file è stato aggiunto al repository git e

66
00:05:10,630 --> 00:05:15,300
alcune altre informazioni verranno digitate nella finestra di comando.

67
00:05:15,300 --> 00:05:20,790
Quindi ora controlliamo di nuovo, lo stato git e

68
00:05:20,790 --> 00:05:26,220
ora vedi che non dice nulla da commettere, la directory di lavoro è pulita.

69
00:05:26,220 --> 00:05:31,230
Quindi ciò che significa è che lo stato corrente della mia directory di

70
00:05:31,230 --> 00:05:36,390
lavoro o della mia cartella di lavoro è stato impegnato nel repository git, quindi

71
00:05:36,390 --> 00:05:39,330
un'istantanea è stata impegnata nel mio repository git.

72
00:05:39,330 --> 00:05:47,200
Ora, posso digitare il prossimo comando chiamato git log —oneline,

73
00:05:47,200 --> 00:05:53,020
e vedere che mostra un numero lì, un numero di otto cifre lì,

74
00:05:53,020 --> 00:05:57,850
e poi mostra anche il messaggio che abbiamo inserito nel nostro commit dicendo primo commit.

75
00:05:57,850 --> 00:06:03,340
Quindi questo è il registro di tutti i commit che sono stati inseriti nel mio repository git.

76
00:06:05,120 --> 00:06:08,900
Quindi, tornando al nostro prossimo comando git,

77
00:06:08,900 --> 00:06:14,094
abbiamo visto che git log —oneline

78
00:06:14,094 --> 00:06:18,540
ci mostrerà un breve log di tutti i commit.

79
00:06:18,540 --> 00:06:20,080
Se si digita semplicemente git log,

80
00:06:21,200 --> 00:06:26,220
visualizzare informazioni molto più dettagliate su tutti i commit.

81
00:06:26,220 --> 00:06:31,344
Ma questo è sufficiente per ottenere informazioni di cui abbiamo bisogno.

82
00:06:33,350 --> 00:06:40,248
Torniamo ora al nostro editor qui, in Visual Studio Code,

83
00:06:40,248 --> 00:06:46,141
quindi aggiungerò altre modifiche al mio file index.html.

84
00:06:54,501 --> 00:06:57,790
Ho cambiato il mio file index.html.

85
00:06:57,790 --> 00:07:02,450
Ora, lasciami aggiungere un'altra cartella sotto la cartella di test git, quindi

86
00:07:02,450 --> 00:07:07,990
creerò una sottocartella qui denominata template, e all'interno di queste

87
00:07:07,990 --> 00:07:13,450
cartelle template, creerò un altro nome file, test.html.

88
00:07:13,450 --> 00:07:16,230
Questo è solo per mostrarti come git

89
00:07:16,230 --> 00:07:21,120
può impegnare l'intera gerarchia di cartelle nel suo repository.

90
00:07:21,120 --> 00:07:26,002
Quindi con test.html ora lì, ho

91
00:07:26,002 --> 00:07:31,173
intenzione di copiare tutto dal mio index.html

92
00:07:31,173 --> 00:07:36,499
nel mio test.html e salvare le modifiche.

93
00:07:39,447 --> 00:07:41,484
Tornando alla riga di comando,

94
00:07:41,484 --> 00:07:46,480
diamo ora un'occhiata allo stato del nostro repository git e di questa cartella.

95
00:07:46,480 --> 00:07:51,740
Quindi digita lo stato git, mostra che

96
00:07:51,740 --> 00:07:56,020
il file html di stato dell'indice che abbiamo già consegnato prima al repository è

97
00:07:56,020 --> 00:08:00,570
stato modificato, quindi c'è una versione più recente del file index.html.

98
00:08:00,570 --> 00:08:03,220
Inoltre, mostra che ci sono alcuni

99
00:08:03,220 --> 00:08:05,530
file non tracciati in questa cartella chiamati template.

100
00:08:06,620 --> 00:08:11,794
Aggiungiamo tutte queste modifiche alla messa in scena

101
00:08:11,794 --> 00:08:16,114
dell'area, quindi di nuovo, digita git add.

102
00:08:16,114 --> 00:08:21,620
E poi tutti questi file verranno aggiunti all'area di gestione temporanea.

103
00:08:21,620 --> 00:08:23,940
Di nuovo, controllando lo stato.

104
00:08:23,940 --> 00:08:29,490
È ora possibile vedere che le modifiche che sono state aggiunte all'area di gestione temporanea.

105
00:08:29,490 --> 00:08:32,850
Quindi tutti questi file sono stati aggiunti all'area di gestione temporanea.

106
00:08:32,850 --> 00:08:36,850
Facciamo un altro commit, quindi

107
00:08:36,850 --> 00:08:42,930
direi git commit -m, secondo commit e

108
00:08:42,930 --> 00:08:47,096
poi diamo un'occhiata al registro.

109
00:08:50,874 --> 00:08:55,246
Se controlli il registro, ora vedrai che ci sono due commit

110
00:08:55,246 --> 00:08:58,930
nel mio repository git, il primo e il secondo commit.

111
00:08:58,930 --> 00:09:03,040
E nota che a ciascuno di loro viene dato un numero diverso lì.

112
00:09:03,040 --> 00:09:07,130
Se vuoi vedere i loro dettagli completi del log,

113
00:09:07,130 --> 00:09:12,510
puoi digitare semplicemente, git log e poi riceverai più dettagli lì dentro.

114
00:09:12,510 --> 00:09:15,132
Allora a cosa ti interesserebbe.

115
00:09:15,132 --> 00:09:20,114
Quindi, si noti che il commit oneline fornisce solo i

116
00:09:20,114 --> 00:09:24,405
primi caratteri del mio numero di commit lì.

117
00:09:24,405 --> 00:09:27,028
Questo è sufficiente per poter operare.

118
00:09:29,245 --> 00:09:34,721
Permettetemi ora di tornare al mio Visual Studio e quindi aggiungerne uno in più.

119
00:09:43,885 --> 00:09:47,140
Un' altra riga al mio file index.html.

120
00:09:47,140 --> 00:09:49,800
Quindi ora il mio file index.html è stato modificato.

121
00:09:51,660 --> 00:09:53,170
E salviamo le modifiche.

122
00:09:55,310 --> 00:09:58,530
Tornando alla riga di comando, facendo

123
00:09:59,870 --> 00:10:04,490
lo stato git mostra che il file index.html è stato modificato.

124
00:10:04,490 --> 00:10:10,650
Quindi aggiungiamo questo all'area di staging e quindi facciamo un terzo commit.

125
00:10:10,650 --> 00:10:15,716
Quindi diciamo, git add. ,

126
00:10:15,716 --> 00:10:18,720
git status,

127
00:10:18,720 --> 00:10:22,700
ora vedi che index.html è stata aggiunta la versione modificata.

128
00:10:22,700 --> 00:10:27,722
Ora possiamo dire git commit.

129
00:10:31,231 --> 00:10:36,825
« third commit» e git log —oneline,

130
00:10:36,825 --> 00:10:43,810
e vedi che ci sono tre commit nel nostro repository.

131
00:10:43,810 --> 00:10:48,220
Quindi ora il nostro repository contiene istantanee di tre punti diversi,

132
00:10:48,220 --> 00:10:51,370
alla fine del primo commit, alla fine del secondo commit, e

133
00:10:51,370 --> 00:10:53,250
alla fine del terzo commit.

134
00:10:53,250 --> 00:10:56,930
Ora, possiamo anche ripristinare le modifiche,

135
00:10:56,930 --> 00:11:01,590
possiamo ripristinare il repository a una versione precedente.

136
00:11:01,590 --> 00:11:04,780
Possiamo estrarre un file da un commit precedente, e

137
00:11:04,780 --> 00:11:09,180
quindi sostituire la directory esistente dal vecchio commit.

138
00:11:09,180 --> 00:11:12,370
Quindi, vediamo come possiamo operare con queste cose

139
00:11:12,370 --> 00:11:14,120
imparando un paio di comandi in più.

140
00:11:15,820 --> 00:11:21,450
In questa fase, il nostro file index.html è nello stato corrente.

141
00:11:21,450 --> 00:11:24,795
Quindi puoi notare che ha un h1 e due ps.

142
00:11:26,530 --> 00:11:29,365
Diamo ora un'occhiata al prossimo comando git.

143
00:11:30,815 --> 00:11:36,185
Il prossimo comando git che impareremo è git checkout.

144
00:11:36,185 --> 00:11:40,300
Quindi questo comando checkout ci permette di controllare un file

145
00:11:40,300 --> 00:11:44,040
da un precedente commit nel nostro repository git.

146
00:11:44,040 --> 00:11:48,050
Quindi, se non ci piace il file corrente che abbiamo nella nostra cartella e

147
00:11:48,050 --> 00:11:51,160
vogliamo tornare alla tua versione precedente del file,

148
00:11:51,160 --> 00:11:55,090
possiamo sempre controllare il file da un commit precedente o

149
00:11:55,090 --> 00:12:00,230
dal commit corrente e quindi continuare a lavorare con quel file.

150
00:12:00,230 --> 00:12:07,431
Quindi facciamo uso di questo e vediamo alcune ulteriori modifiche al nostro repository git.

151
00:12:09,228 --> 00:12:15,366
Tornando alla nostra riga di comando, ricordiamo che, tra il secondo e

152
00:12:15,366 --> 00:12:20,235
il terzo commit, ho apportato modifiche al mio file index.html.

153
00:12:20,235 --> 00:12:25,735
Supponiamo di voler tornare al file index.html dal mio secondo commit.

154
00:12:25,735 --> 00:12:29,885
Quindi, posso semplicemente dire,

155
00:12:29,885 --> 00:12:34,039
git checkout 900cfcf.

156
00:12:34,039 --> 00:12:41,035
Quindi questo è commit identifichi il numero che identifichi il particolare commit,

157
00:12:41,035 --> 00:12:46,971
e quindi posso dire index.html, e quello che noteresti è che,

158
00:12:46,971 --> 00:12:53,662
quel file più vecchio verrà ora estratto nella mia directory di lavoro corrente.

159
00:12:55,845 --> 00:12:58,018
Andando al mio codice di Visual Studio,

160
00:12:58,018 --> 00:13:03,811
ora noterai che il mio file index.html è tornato al lavoro precedente, quindi

161
00:13:03,811 --> 00:13:08,580
la modifica che ho apportato prima del terzo commit è ora sparita.

162
00:13:08,580 --> 00:13:16,690
Quindi il mio file index.html è stato ripristinato al suo stato alla fine del secondo commit.

163
00:13:18,920 --> 00:13:23,042
Ora, alla riga di comando, se provo git status,

164
00:13:23,042 --> 00:13:28,403
noterai che questo file index.html che è stato ripristinato

165
00:13:28,403 --> 00:13:35,470
a quello che era alla fine del secondo commit, ora è già stato messo in scena.

166
00:13:35,470 --> 00:13:40,930
Quindi, usando questo checkout git, estrarremo una versione precedente del file,

167
00:13:40,930 --> 00:13:44,390
quindi

168
00:13:44,390 --> 00:13:47,670
sostituiremo ciò che è nella directory corrente, e poi lo controllerà anche nell'area di gestione temporanea.

169
00:13:48,970 --> 00:13:53,400
Quindi ora se lo faccio e poi mi rendo conto che questo è quello che voglio,

170
00:13:53,400 --> 00:13:56,450
posso semplicemente fare un altro commit a questo punto.

171
00:13:56,450 --> 00:14:02,445
E poi quel file può essere commesso come quarto commit.

172
00:14:02,445 --> 00:14:07,812
Ma supponiamo che non mi piaccia, voglio

173
00:14:07,812 --> 00:14:12,641
raddoppiare per tornare al file index.html alla fine

174
00:14:12,641 --> 00:14:18,291
del terzo commit, quindi tutto ciò che posso fare è dire git reset,

175
00:14:20,339 --> 00:14:25,698
HEAD e index.html.

176
00:14:28,236 --> 00:14:33,356
Quindi a questo punto, quello che succede è che index.html,

177
00:14:33,356 --> 00:14:38,796
la versione modificata che avevo estratto è ancora lì, ma

178
00:14:38,796 --> 00:14:43,397
questo file è stato dismesso dall'area di staging.

179
00:14:43,397 --> 00:14:49,803
Se torni indietro e guardi index.html nel tuo editor,

180
00:14:49,803 --> 00:14:56,680
mostrerà comunque lo stato alla fine del secondo commit.

181
00:14:56,680 --> 00:15:01,250
Perché avevamo estratto il file usando il checkout per questo.

182
00:15:01,250 --> 00:15:06,900
Ora, se vuoi tornare a quello che era alla fine del terzo commit,

183
00:15:06,900 --> 00:15:11,956
allora facciamo un altro checkout dal terzo commit andando alla nostra

184
00:15:11,956 --> 00:15:18,900
finestra di comando, digita git status e

185
00:15:18,900 --> 00:15:23,920
noteresti che index.html è contrassegnato come modificato.

186
00:15:23,920 --> 00:15:28,870
Ma mostra anche questa particolare affermazione qui.

187
00:15:28,870 --> 00:15:32,270
Dice git checkout - e

188
00:15:32,270 --> 00:15:35,310
il nome del file, per scartare le modifiche nelle directory di lavoro.

189
00:15:35,310 --> 00:15:39,270
Quindi questo è un modo per scartare le modifiche che hai fatto a un particolare

190
00:15:39,270 --> 00:15:43,095
file corrispondente al commento precedente.

191
00:15:43,095 --> 00:15:46,875
Quindi lasciami ripristinare quel index.html a quello che era alla fine

192
00:15:46,875 --> 00:15:48,205
del terzo commit.

193
00:15:48,205 --> 00:15:52,455
Quindi, per farlo, potrei semplicemente dire git, checkout,

194
00:15:52,455 --> 00:15:58,540
- index.html e poi,

195
00:15:58,540 --> 00:16:05,480
se faccio lo stato git, mostra che la mia directory è pulita.

196
00:16:05,480 --> 00:16:08,130
E fondamentalmente la mia directory è stata ripristinata

197
00:16:08,130 --> 00:16:10,520
allo stato alla fine del terzo commit.

198
00:16:12,370 --> 00:16:17,580
Andando al file nel mio codice Virtual Studio, vedo che

199
00:16:17,580 --> 00:16:21,060
il loro file è stato ripristinato a quello che era alla fine del terzo cap.

200
00:16:21,060 --> 00:16:24,740
Quindi questo è un modo in cui puoi, se hai apportato modifiche al tuo

201
00:16:24,740 --> 00:16:27,740
file dopo il commit e vuoi semplicemente scartare quelle modifiche,

202
00:16:27,740 --> 00:16:31,810
puoi semplicemente estrarre il file dall'ultimo commit, e quindi tutte le

203
00:16:31,810 --> 00:16:36,220
modifiche che hai fatto dopo l'ultimo commit verranno scartate sul posto.

204
00:16:36,220 --> 00:16:40,960
Quindi questi sono alcuni comandi di base che sono molto utili per

205
00:16:40,960 --> 00:16:44,510
te mentre passi attraverso i corsi in questa specializzazione

206
00:16:44,510 --> 00:16:49,160
perché potresti voler impegnarti alla fine di ogni esercizio.

207
00:16:49,160 --> 00:16:56,220
E mentre procedi in avanti, avresti comunque una visione guidata

208
00:16:56,220 --> 00:17:01,790
dello stato della tua cartella alla fine dell'esercizio precedente.

209
00:17:01,790 --> 00:17:06,180
In questo modo, se stai eseguendo un nuovo esercizio e hai scoperto che hai

210
00:17:06,180 --> 00:17:10,320
commesso degli errori e vuoi tornare al commit precedente,

211
00:17:10,320 --> 00:17:18,000
hai sempre un modo per farlo usando i comandi che abbiamo appena lasciato.

212
00:17:18,000 --> 00:17:24,430
Quindi, con questa comprensione di base di questi pochi comandi git,

213
00:17:24,430 --> 00:17:29,260
sarai in grado di procedere con la comprensione e

214
00:17:29,260 --> 00:17:33,570
l'uso di git nei corsi di questa specializzazione.

215
00:17:35,560 --> 00:17:41,685
Così ora, abbiamo esaminato il git reset per un file specifico o git reset in generale.

216
00:17:41,685 --> 00:17:47,970
Se digiti semplicemente git reset, ti ripristinerà all'ultimo commit.

217
00:17:47,970 --> 00:17:50,680
Quindi ripristinerà l'area di staging all'ultimo commit,

218
00:17:50,680 --> 00:17:55,270
senza disturbare le modifiche che hai fatto alla tua directory di lavoro.

219
00:17:55,270 --> 00:17:58,390
Quindi, una volta ripristinato, puoi controllare

220
00:17:58,390 --> 00:18:02,140
la versione precedente del file che hai commesso nel commit precedente.

221
00:18:02,140 --> 00:18:07,380
Quindi questa settimana, puoi ripristinare la tua cartella nel punto in cui ti trovavi

222
00:18:07,380 --> 00:18:10,450
al punto di partenza del commit precedente.

223
00:18:10,450 --> 00:18:15,300
Quindi, a volte, quando stai attraversando un esercizio e ti rendi conto che hai perso un segnale.

224
00:18:15,300 --> 00:18:20,174
Hai sempre un modo per tornare a una versione precedente.

225
00:18:20,174 --> 00:18:25,027
Quindi con questi comandi, penso che tu sia tutto pronto per andare avanti ad

226
00:18:25,027 --> 00:18:28,849
usare git nei corsi di questa specializzazione.

227
00:18:31,070 --> 00:18:34,395
Quindi, alla fine di questo esercizio, l'hai Git?

228
00:18:34,395 --> 00:18:37,459
[ MUSIC]