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

2
00:00:04,425 --> 00:00:09,324
Esaminiamo ora alcuni comandi Git di base che sono molto utili per

3
00:00:09,324 --> 00:00:11,474
noi in questa specializzazione.

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

5
00:00:18,130 --> 00:00:23,231
Per iniziare, vai alla posizione comoda sul tuo computer,

6
00:00:23,231 --> 00:00:26,523
quindi crea una cartella denominata git-test.

7
00:00:30,140 --> 00:00:34,408
Quindi apri questa cartella nel tuo editor preferito.

8
00:00:37,895 --> 00:00:42,585
Qui ho la cartella git-test che abbiamo appena creato

9
00:00:42,585 --> 00:00:45,390
aperta nel mio codice di Visual Studio.

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

11
00:00:54,122 --> 00:01:00,430
Ora puoi vedere che ho aggiunto un codice HTML in questo file index.html.

12
00:01:00,430 --> 00:01:06,507
Salviamo le modifiche, ora passiamo alla nostra riga di comando.

13
00:01:06,507 --> 00:01:10,903
Alla riga di comando, vai alla cartella git-test e

14
00:01:10,903 --> 00:01:15,860
inizializziamo questa cartella per essere un repository Git.

15
00:01:15,860 --> 00:01:19,800
Quindi, per farlo, aggiungi la riga di comando, digita, git init.

16
00:01:21,620 --> 00:01:27,710
Ora questa cartella è stata inizializzata per essere un repository Git, quindi

17
00:01:27,710 --> 00:01:32,650
questo è il nostro primo comando Git che abbiamo imparato, git init.

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

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

20
00:01:42,380 --> 00:01:47,770
Questo è il ramo principale per il mio Git, ora non preoccupatevi dei rami e

21
00:01:47,770 --> 00:01:51,000
così via, non ci occuperemo di questo in questo corso.

22
00:01:51,000 --> 00:01:55,738
Lavoreremo solo con il ramo master in questa particolare specializzazione,

23
00:01:55,738 --> 00:01:58,500
quindi questo sarebbe contrassegnato come il master.

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

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

26
00:02:08,410 --> 00:02:12,600
Se digiti git status nella riga di comando, ti dirà lo stato corrente

27
00:02:12,600 --> 00:02:17,460
della cartella, quindi facciamolo alla riga di comando e vediamo cosa mostra.

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

29
00:02:23,395 --> 00:02:28,945
leggi le informazioni che vengono digitate nella finestra dei comandi.

30
00:02:28,945 --> 00:02:33,943
Vedete che dice, Sul master ramo, quindi questo è il ramo principale su cui siamo,

31
00:02:33,943 --> 00:02:40,690
e dice, file non tracciati, e quindi mostra index.html in rosso.

32
00:02:40,690 --> 00:02:44,458
Sul tuo computer specifico, potrebbe usare colori diversi o

33
00:02:44,458 --> 00:02:49,040
rappresentarlo in modo diverso, ma questo è ciò che mostra sul mio Mac.

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

35
00:02:54,040 --> 00:02:58,140
non è stato aggiunto al nostro repository Git.

36
00:02:58,140 --> 00:03:01,335
Quindi andiamo avanti e aggiungiamo quel file al repository Git.

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

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

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

40
00:03:17,680 --> 00:03:22,880
Quindi ora se digito di nuovo, git status, vedrai

41
00:03:22,880 --> 00:03:27,910
che il file index.html è contrassegnato in verde, e

42
00:03:27,910 --> 00:03:35,130
dice che le modifiche devono essere commesse lì, e poi mostra il nome del file.

43
00:03:35,130 --> 00:03:35,672
E poi, questo

44
00:03:35,672 --> 00:03:39,601
significa che questo file è ora pronto per essere impegnato nel mio repository Git.

45
00:03:41,438 --> 00:03:46,856
Quindi il comando successivo che abbiamo visto era git add, usando git add,

46
00:03:46,856 --> 00:03:51,190
è possibile aggiungere file o cartelle all'area di gestione temporanea.

47
00:03:51,190 --> 00:03:57,250
Quindi, una volta aggiunto all'area di gestione temporanea, puoi commettere quella istantanea

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

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

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

51
00:04:12,610 --> 00:04:17,200
stato attuale delle nostre cartelle nel nostro repository Git.

52
00:04:17,200 --> 00:04:21,780
Quindi tutti i file, come esistono al momento, una volta che sono stati messi in scena

53
00:04:21,780 --> 00:04:25,560
usando git add, allora saranno impegnati attraverso un repository Git,

54
00:04:25,560 --> 00:04:29,510
quindi eseguiamo la cartella dei comandi git.

55
00:04:29,510 --> 00:04:33,580
Quindi, a questo punto, quando eseguiamo il comando git,

56
00:04:33,580 --> 00:04:38,373
allora il nostro stato iniziale sarà ora cambiato al primo commit

57
00:04:38,373 --> 00:04:42,369
nel repository Git, quindi andiamo avanti e farlo.

58
00:04:45,208 --> 00:04:50,261
Tornando al prompt dei comandi, scriviamo git commit,

59
00:04:50,261 --> 00:04:54,880
e quindi possiamo anche aggiungere un messaggio al nostro commit.

60
00:04:54,880 --> 00:04:59,275
Quindi dirò git commit -m «first commit»,

61
00:04:59,275 --> 00:05:03,879
perché questo è il nostro primo commit nel nostro repository Git.

62
00:05:03,879 --> 00:05:10,106
Quindi, quando lo faccio, dice, ok, un file è stato aggiunto al repository Git e

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

64
00:05:15,300 --> 00:05:20,440
Quindi ora controlliamo, di nuovo, lo stato git,

65
00:05:20,440 --> 00:05:26,220
e ora vedi che dice, nulla da commettere, la directory di lavoro è pulita.

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

67
00:05:31,230 --> 00:05:35,860
cartella di lavoro è stato impegnato nel repository Git.

68
00:05:35,860 --> 00:05:41,050
Quindi un'istantanea è stata impegnata nel mio repository Git, ora posso digitare il

69
00:05:41,050 --> 00:05:47,200
comando successivo, chiamato git log —oneline.

70
00:05:47,200 --> 00:05:52,156
E vedi che mostra un numero lì, un numero di otto cifre lì, e

71
00:05:52,156 --> 00:05:57,545
mostra anche il messaggio che mettiamo nel nostro commit dicendo «primo commit».

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

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

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

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

76
00:06:18,540 --> 00:06:20,442
Se digiti semplicemente git log,

77
00:06:20,442 --> 00:06:25,658
mostrerà informazioni molto più dettagliate su tutti i commit, ma

78
00:06:25,658 --> 00:06:30,652
questo è sufficiente per ottenere informazioni di cui abbiamo bisogno.

79
00:06:33,013 --> 00:06:40,820
Torniamo ora al nostro editor qui in Visual Studio Code.

80
00:06:40,820 --> 00:06:45,379
Quindi ho intenzione di aggiungere ulteriori modifiche al mio file index.html, quindi aggiungerò,

81
00:06:54,307 --> 00:06:57,790
Quindi ho cambiato il mio file index.html.

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

83
00:07:02,453 --> 00:07:06,890
creerò una sottocartella qui denominata template.

84
00:07:06,890 --> 00:07:09,344
E all'interno di questa cartella dei modelli,

85
00:07:09,344 --> 00:07:13,039
ho intenzione di creare un altro file chiamato test.html.

86
00:07:13,039 --> 00:07:17,798
Questo è solo per mostrarti come Git può impegnare l'intera

87
00:07:17,798 --> 00:07:21,120
gerarchia di cartelle nel suo repository.

88
00:07:21,120 --> 00:07:24,734
Quindi con test.html ora lì,

89
00:07:24,734 --> 00:07:29,321
ho solo intenzione di copiare tutto dal

90
00:07:29,321 --> 00:07:34,047
mio index.html nel mio test.html, e

91
00:07:34,047 --> 00:07:41,422
salvare le modifiche Tornando alla riga di comando,

92
00:07:41,422 --> 00:07:46,187
ora controlliamo lo stato del nostro repository Git e questa cartella.

93
00:07:46,187 --> 00:07:51,079
Quindi digitando lo stato git mostra che il file index.html che abbiamo

94
00:07:51,079 --> 00:07:55,971
già aggiunto in precedenza al repository è stato modificato,

95
00:07:55,971 --> 00:08:00,570
quindi c'è una versione più recente del file index.html.

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

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

98
00:08:06,620 --> 00:08:11,720
Aggiungiamo tutte queste modifiche al nostro repository, all'area di gestione temporanea.

99
00:08:11,720 --> 00:08:16,350
Quindi, di nuovo, digita git add., e

100
00:08:16,350 --> 00:08:21,620
poi tutti questi file verranno aggiunti all'area di staging.

101
00:08:21,620 --> 00:08:27,820
Ancora una volta, il check-out dello stato, ora si vede che le modifiche che sono state

102
00:08:27,820 --> 00:08:32,850
aggiunte all'area di gestione temporanea, in modo che tutti questi file sono stati aggiunti all'area di gestione temporanea.

103
00:08:32,850 --> 00:08:37,735
Facciamo un altro commit, quindi direi git commit -m,

104
00:08:41,526 --> 00:08:46,595
«Secondo commit», e poi, diamo un'occhiata al registro.

105
00:08:50,794 --> 00:08:54,179
Se controlli il registro, ora vedrai che ci

106
00:08:54,179 --> 00:08:58,930
sono due commit nel mio repository Git, il primo e il secondo commit.

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

108
00:09:02,826 --> 00:09:09,700
Se vuoi vedere i dettagli completi del registro, puoi digitare semplicemente, git log.

109
00:09:09,700 --> 00:09:12,510
E poi vedrai più dettagli

110
00:09:12,510 --> 00:09:15,095
di quello che ti interesserebbe.

111
00:09:15,095 --> 00:09:19,115
Quindi nota che il commit di una riga

112
00:09:19,115 --> 00:09:24,405
fornisce solo i primi caratteri del mio numero di commit lì.

113
00:09:24,405 --> 00:09:26,674
Questo è sufficiente per poter operare.

114
00:09:29,000 --> 00:09:34,006
Lasciami ora tornare di nuovo al mio Visual Studio e aggiungere

115
00:09:43,821 --> 00:09:45,890
un'altra riga al mio file index.html.

116
00:09:47,140 --> 00:09:52,666
Quindi ora il mio file index.html è stato modificato e salviamo le modifiche.

117
00:09:55,066 --> 00:09:57,813
Tornando alla riga di comando,

118
00:09:57,813 --> 00:10:04,490
facendo lo stato git mostra che il file index.html è stato modificato.

119
00:10:04,490 --> 00:10:08,640
Quindi aggiungiamo questo all'area di staging,

120
00:10:08,640 --> 00:10:14,382
quindi facciamo un terzo commit, quindi diciamo git add. ,

121
00:10:14,382 --> 00:10:18,720
git status.

122
00:10:18,720 --> 00:10:22,700
Ora vedrai che il index.html, la versione modificata, è stato aggiunto.

123
00:10:22,700 --> 00:10:27,305
Ora, possiamo dire git commit,

124
00:10:31,164 --> 00:10:37,144
«Terzo commit», E fare git log —oneline,

125
00:10:37,144 --> 00:10:43,818
e vedrai che ci sono tre commit nel nostro repository.

126
00:10:43,818 --> 00:10:47,625
Quindi ora il nostro repository contiene istantanee di tre punti diversi,

127
00:10:47,625 --> 00:10:51,234
alla fine del primo commit, alla fine del secondo commit, e

128
00:10:51,234 --> 00:10:52,929
alla fine del terzo commit.

129
00:10:52,929 --> 00:10:56,297
Ora possiamo anche ripristinare le modifiche,

130
00:10:56,297 --> 00:11:01,417
possiamo ripristinare il repository a una versione precedente.

131
00:11:01,417 --> 00:11:04,366
Possiamo estrarre un file da un commit più vecchio e

132
00:11:04,366 --> 00:11:09,180
quindi sostituire il file esistente nella nostra directory dal commit precedente.

133
00:11:09,180 --> 00:11:13,604
Quindi vediamo come possiamo operare con queste cose imparando

134
00:11:13,604 --> 00:11:15,608
un paio di altri comandi.

135
00:11:15,608 --> 00:11:21,759
A questo punto, il nostro file index.html è nello stato corrente,

136
00:11:21,759 --> 00:11:26,530
quindi puoi notare che ha un h1 e due p.

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

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

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

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

141
00:11:44,040 --> 00:11:47,709
Quindi, se non ci piace il file corrente che abbiamo nella nostra cartella,

142
00:11:47,709 --> 00:11:50,907
e vogliamo tornare a una versione precedente del file.

143
00:11:50,907 --> 00:11:54,782
Possiamo sempre estrarre il file da un commit precedente o

144
00:11:54,782 --> 00:12:00,230
dal commit corrente, e quindi continuare a lavorare con quel file.

145
00:12:00,230 --> 00:12:07,190
Quindi facciamo uso di questo e vediamo alcune ulteriori modifiche al nostro repository Git.

146
00:12:09,350 --> 00:12:14,705
Tornando alla nostra riga di comando, ricordiamo che,

147
00:12:14,705 --> 00:12:20,235
tra il secondo e il terzo commit, ho apportato modifiche al mio file index.html.

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

149
00:12:25,477 --> 00:12:31,244
Quindi posso semplicemente dire, git checkout 900cfcf,

150
00:12:31,244 --> 00:12:35,045
quindi questo è l'identificatore di commit,

151
00:12:35,045 --> 00:12:40,980
il numero che identifichi quel particolare commit.

152
00:12:40,980 --> 00:12:46,117
E poi posso dire index.html, e quello che noteresti

153
00:12:46,117 --> 00:12:53,190
è che tutto il file verrà ora estratto nella mia directory di lavoro corrente.

154
00:12:55,721 --> 00:12:57,901
Andando al mio codice di Visual Studio,

155
00:12:57,901 --> 00:13:03,340
ora noti che il mio file index.html è tornato alla versione precedente.

156
00:13:03,340 --> 00:13:07,928
Quindi la modifica che ho fatto prima del terzo commit è ora sparita.

157
00:13:07,928 --> 00:13:16,482
Quindi il mio file index.html è stato ripristinato al suo stato alla fine del secondo commit.

158
00:13:18,607 --> 00:13:26,711
Ora alla riga di comando, se

159
00:13:26,711 --> 00:13:33,520
digito git status, noti che questo file index.html, che è tornato a quello che era alla fine del secondo commit.

160
00:13:33,520 --> 00:13:37,710
Ora è già stato messo in scena, quindi usando questo checkout git

161
00:13:38,720 --> 00:13:43,670
estrarrà una versione precedente del file e quindi sostituirà ciò che è nella

162
00:13:43,670 --> 00:13:48,400
directory corrente e poi lo controllerà anche nell'area di staging.

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

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

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

166
00:14:02,249 --> 00:14:05,200
ma supponiamo che non mi piaccia.

167
00:14:05,200 --> 00:14:10,553
Voglio tornare al file index.html alla

168
00:14:10,553 --> 00:14:17,704
fine del terzo commit, quindi tutto ciò che posso fare è dire git reset,

169
00:14:20,178 --> 00:14:24,866
HEAD e index.html.

170
00:14:28,084 --> 00:14:32,404
Quindi, a questo punto, quello che succede è che index.html,

171
00:14:32,404 --> 00:14:37,264
la versione modificata che ho estratto è ancora lì, ma

172
00:14:37,264 --> 00:14:41,137
questo file è stato dismesso dall'area di staging.

173
00:14:43,376 --> 00:14:48,440
Se torni indietro e guardi index.html nel tuo,

174
00:14:50,991 --> 00:14:56,094
Editor, mostrerà comunque lo stato alla fine del secondo commit

175
00:14:56,094 --> 00:15:01,255
perché avevamo estratto quel file usando il checkout per quello.

176
00:15:01,255 --> 00:15:06,900
Ora, se vogliamo tornare a quello che era alla fine del terzo commit,

177
00:15:06,900 --> 00:15:09,470
allora facciamo un altro checkout dal terzo commit.

178
00:15:10,540 --> 00:15:16,431
Andando alla nostra finestra di comando, digita git status, e

179
00:15:16,431 --> 00:15:23,558
noterai che index.html è contrassegnato come modificato.

180
00:15:23,558 --> 00:15:29,661
Ma mostra anche questa particolare affermazione qui, dice git checkout -,

181
00:15:29,661 --> 00:15:35,029
e il nome del file, per scartare le modifiche nella directory di lavoro.

182
00:15:35,029 --> 00:15:38,334
Quindi questo è un modo in cui puoi scartare

183
00:15:38,334 --> 00:15:43,095
le modifiche apportate a un particolare file corrispondente al commit precedente.

184
00:15:43,095 --> 00:15:46,565
Quindi fammi ripristinare questo index.html a quello che era

185
00:15:46,565 --> 00:15:47,653
alla fine del terzo commit.

186
00:15:47,653 --> 00:15:54,315
Quindi, per farlo, dirò semplicemente git checkout -

187
00:15:54,315 --> 00:15:58,712
index.html, e poi se lo faccio,

188
00:16:01,503 --> 00:16:05,815
lo stato Git, mostra che la mia directory è pulita, e fondamentalmente

189
00:16:05,815 --> 00:16:10,520
la mia directory è stata ripristinata allo stato della fine del terzo commento.

190
00:16:12,370 --> 00:16:16,909
Andando al file nel mio codice di Visual Studio, vedo che il file è stato

191
00:16:16,909 --> 00:16:20,767
ripristinato a quello che era alla fine del terzo commit.

192
00:16:20,767 --> 00:16:25,251
Quindi, se hai apportato modifiche a un file dopo un commit e vuoi semplicemente

193
00:16:25,251 --> 00:16:30,632
scartare quelle modifiche, puoi semplicemente estrarre il file dall'ultimo commit.

194
00:16:30,632 --> 00:16:35,338
E poi tutte le modifiche che hai fatto dopo l'ultimo commit verranno scartate in

195
00:16:35,338 --> 00:16:36,144
questa parte..

196
00:16:36,144 --> 00:16:40,304
Quindi questi sono alcuni comandi di base che sono molto utili per

197
00:16:40,304 --> 00:16:42,958
te mentre passi attraverso i corsi e

198
00:16:42,958 --> 00:16:48,821
la specializzazione perché potresti voler impegnarti alla fine di ogni esercizio.

199
00:16:48,821 --> 00:16:51,617
E mentre si procede in avanti,

200
00:16:51,617 --> 00:16:56,744
si avrà ancora una versione di commit

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

202
00:17:01,790 --> 00:17:06,249
In questo modo se stai eseguendo un nuovo esercizio e scopri di aver

203
00:17:06,249 --> 00:17:10,032
commesso degli errori e vuoi tornare al commit precedente.

204
00:17:10,032 --> 00:17:14,832
Avrai sempre un modo per farlo usando i comandi

205
00:17:14,832 --> 00:17:18,010
che abbiamo appena imparato.

206
00:17:18,010 --> 00:17:24,430
Quindi, con questa comprensione di base di questi pochi comandi Git,

207
00:17:24,430 --> 00:17:29,427
saremmo in grado di procedere con la comprensione e

208
00:17:29,427 --> 00:17:33,570
l'uso di Git nei corsi di questa specializzazione.

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

210
00:17:41,434 --> 00:17:47,970
Se digiti semplicemente get reset, ti ripristinerà all'ultimo commit.

211
00:17:47,970 --> 00:17:51,360
Quindi ripristinerà l'area di staging all'ultimo commit

212
00:17:51,360 --> 00:17:55,270
senza disturbare le modifiche che hai fatto alla tua directory di lavoro.

213
00:17:55,270 --> 00:17:59,270
Quindi, una volta ripristinato, puoi estrarre la

214
00:17:59,270 --> 00:18:02,140
versione precedente del file che hai commesso nel commit precedente.

215
00:18:02,140 --> 00:18:05,940
Quindi in questo modo puoi ripristinare la tua cartella dove eri

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

217
00:18:10,450 --> 00:18:16,037
Quindi, a volte, quando stai attraversando un esercizio e ti rendi conto

218
00:18:16,037 --> 00:18:20,082
che hai fatto un errore, hai sempre un modo per tornare a una versione precedente.

219
00:18:20,082 --> 00:18:25,081
Quindi con questi comandi penso che tu sia pronto per andare avanti ad usare

220
00:18:25,081 --> 00:18:28,651
Git nei corsi di questa specializzazione.

221
00:18:30,865 --> 00:18:33,694
Quindi, alla fine di questo esercizio, l'hai Git?

222
00:18:33,694 --> 00:18:37,459
[ MUSIC]