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

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

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

4
00:00:11,670 --> 00:00:15,760
C' è molto di più da ottenere di quello che copriamo in questo esercizio.

5
00:00:18,167 --> 00:00:23,407
Per iniziare, vai in una posizione comoda sul tuo computer e

6
00:00:23,407 --> 00:00:26,745
crea una cartella denominata git-test.

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

8
00:00:38,190 --> 00:00:43,170
Qui, ho la cartella git-test che abbiamo appena creato aperta

9
00:00:43,170 --> 00:00:45,390
nel mio codice Visual Studio.

10
00:00:45,390 --> 00:00:49,257
Permettetemi di aggiungere un file a questa

11
00:00:49,257 --> 00:00:54,148
cartella denominata index.html.

12
00:00:54,148 --> 00:00:59,990
Ora puoi vedere che ho aggiunto un codice HTML in questo indice verso HTML5.

13
00:00:59,990 --> 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, digita 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,170 --> 00:01:32,650
Questo è il nostro primo comando git che abbiamo imparato, git init.

20
00:01:32,650 --> 00:01:36,320
Questo intializza 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 master per il mio git.

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

24
00:01:48,210 --> 00:01:51,000
Non ci occuperemo di questo in questo corso.

25
00:01:51,000 --> 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 tracciate nella finestra di comando.

34
00:02:28,945 --> 00:02:31,235
Vedete che dice sul ramo master.

35
00:02:31,235 --> 00:02:35,200
Quindi, questo è il ramo master su cui siamo e dice,

36
00:02:35,200 --> 00:02:40,690
file non tracciati, e quindi mostra index.html in rosso.

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

38
00:02:43,790 --> 00:02:49,040
rappresentarlo in modo diverso, ma questo è ciò che mostra nel mio Mac.

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

40
00:02:53,775 --> 00:02:58,100
non è stato aggiunto al nostro repository git.

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

42
00:03:01,680 --> 00:03:06,740
Quindi per farlo diciamo git add e puoi semplicemente dire

43
00:03:06,740 --> 00:03:12,350
dot, il che significa che tutti i file nella directory corrente verranno aggiunti a quella

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

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

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

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

48
00:03:35,130 --> 00:03:39,000
E poi, questo significa che questo file è pronto per essere impegnato nel mio

49
00:03:39,000 --> 00:03:39,830
repository git.

50
00:03:41,700 --> 00:03:46,100
Quindi il comando successivo che abbiamo visto era git add,

51
00:03:46,100 --> 00:03:51,190
usando git add puoi aggiungere file o cartelle a quell'area di staging.

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

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

54
00:04:03,100 --> 00:04:06,460
Quindi ciò significa che quando fai quel commit git.

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

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

57
00:04:17,200 --> 00:04:20,380
Quindi tutti i file, come esistono al momento,

58
00:04:20,380 --> 00:04:24,570
una volta che sono stati stadi usando git add, allora saranno impegnati nel

59
00:04:24,570 --> 00:04:29,510
nostro repository git quando eseguiamo la cartella dei comandi git.

60
00:04:29,510 --> 00:04:34,650
Quindi su questo punto, quando eseguiamo il comando git, il nostro

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

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

63
00:04:45,470 --> 00:04:49,460
Tornando al prompt dei comandi, scriviamo,

64
00:04:49,460 --> 00:04:54,880
git commit e poi possiamo mai aggiungere un messaggio al nostro commit.

65
00:04:54,880 --> 00:05:00,520
Quindi dirò git commit -m first commit,

66
00:05:00,520 --> 00:05:04,160
perché questo è il nostro primo commit nel nostro repository git.

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

68
00:05:10,630 --> 00:05:15,300
alcune altre informazioni verranno digitate su quella finestra di comando.

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

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

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

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

73
00:05:35,860 --> 00:05:39,330
Quindi un'istantanea è stata impegnata nel mio repository git.

74
00:05:39,330 --> 00:05:46,851
Ora posso digitare il prossimo comando chiamato git log —oneline.

75
00:05:46,851 --> 00:05:53,020
E vedi che mostra un numero lì, un numero di otto cifre lì.

76
00:05:53,020 --> 00:05:57,850
E poi mostra anche il messaggio che abbiamo messo nel nostro commit, dicendo primo commit.

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

78
00:06:05,120 --> 00:06:13,832
Quindi tornando al nostro prossimo comando git abbiamo visto quel git log —oneline che vedremo e

79
00:06:13,832 --> 00:06:18,540
ci mostra un breve log di tutti i commit.

80
00:06:18,540 --> 00:06:23,920
Se digiti semplicemente git log, visualizza molte più informazioni dettagliate su

81
00:06:23,920 --> 00:06:26,220
tutti i commit.

82
00:06:26,220 --> 00:06:30,850
Ma questo è sufficiente per ottenere informazioni di cui abbiamo bisogno.

83
00:06:33,350 --> 00:06:40,820
Torniamo ora al nostro editor qui nel codice di Visual Studio.

84
00:06:40,820 --> 00:06:44,940
Quindi aggiungerò altre modifiche al mio file index.html.

85
00:06:44,940 --> 00:06:45,945
Quindi aggiungo.

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

87
00:06:57,790 --> 00:07:01,750
Ora lasciami aggiungere un'altra cartella sotto la cartella GIT-TEST.

88
00:07:01,750 --> 00:07:07,220
Quindi creerò una sottocartella qui denominata template, e

89
00:07:07,220 --> 00:07:13,450
all'interno di questa cartella template, creerò un altro file chiamato test.html.

90
00:07:13,450 --> 00:07:17,180
Questo è solo per mostrarti come git può impegnare

91
00:07:17,180 --> 00:07:21,120
l'intera gerarchia di cartelle nel suo repository.

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

93
00:07:24,754 --> 00:07:31,185
ho intenzione di copiare tutto dal mio index.html

94
00:07:31,185 --> 00:07:36,374
nel mio test.html e salvare le modifiche.

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

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

97
00:07:45,943 --> 00:07:52,880
Quindi digitando lo stato git mostra che il

98
00:07:52,880 --> 00:07:57,370
file index.html che abbiamo già aggiunto in precedenza al repository è stato modificato.

99
00:07:57,370 --> 00:08:00,207
Quindi se c'è una nuova versione del file di indice index.html.

100
00:08:00,207 --> 00:08:04,011
Inoltre mostra che ci sono alcuni file non tracciati in

101
00:08:04,011 --> 00:08:06,408
questa cartella chiamati template.

102
00:08:06,408 --> 00:08:11,530
Aggiungiamo tutte queste modifiche al nostro repository, all'area di gestione temporanea.

103
00:08:11,530 --> 00:08:16,640
Quindi di nuovo digita git add dot e poi tutti questi

104
00:08:16,640 --> 00:08:21,620
file verranno aggiunti all'area di staging.

105
00:08:21,620 --> 00:08:23,940
Ancora una volta, controllando lo stato,

106
00:08:23,940 --> 00:08:29,490
ora si vede che le modifiche che sono stato aggiunto all'area di gestione temporanea.

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

108
00:08:32,850 --> 00:08:34,560
Facciamo un altro commit.

109
00:08:34,560 --> 00:08:38,381
Quindi direi git commit -m.

110
00:08:40,218 --> 00:08:47,234
Secondo commit e poi controlliamo il registro.

111
00:08:50,828 --> 00:08:57,480
Se controlli il registro ora vedi che ci sono due commit nel mio repository git.

112
00:08:57,480 --> 00:08:59,130
Il primo e il secondo commit e

113
00:08:59,130 --> 00:09:03,040
nota che a ciascuno di essi viene dato un numero diverso lì.

114
00:09:03,040 --> 00:09:09,830
Se vuoi vedere i dettagli completi del log, puoi digitare semplicemente git log e

115
00:09:09,830 --> 00:09:15,095
poi vedrai più dettagli lì dentro quindi a cosa saresti interessato.

116
00:09:15,095 --> 00:09:19,115
Quindi nota che il commit oneline

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

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

119
00:09:29,245 --> 00:09:35,502
Lasciami ora tornare di nuovo al mio Visual Studio e aggiungerne un altro.

120
00:09:44,019 --> 00:09:45,890
Un' altra riga al mio file index.html.

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

122
00:09:51,660 --> 00:09:53,123
E salviamo le modifiche.

123
00:09:55,099 --> 00:09:57,871
Tornando alla riga di comando,

124
00:09:57,871 --> 00:10:04,304
vai in git status mostra che il file index.html è stato modificato.

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

126
00:10:10,650 --> 00:10:18,720
Quindi diciamo git add dot git status.

127
00:10:18,720 --> 00:10:22,487
Ora si vede che il index.html, la versione modificata è stata aggiunta.

128
00:10:22,487 --> 00:10:26,240
Ora possiamo dire git commit.

129
00:10:31,176 --> 00:10:37,084
Terzo commit.

130
00:10:37,084 --> 00:10:43,810
E git log oneline, e vedrai 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 tipi diversi.

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

133
00:10:51,468 --> 00:10:52,985
alla fine del terzo commit.

134
00:10:52,985 --> 00:10:56,842
Ora possiamo anche ripristinare le modifiche.

135
00:10:56,842 --> 00:11:01,590
Siamo in grado di ripristinare il repository a una versione precedente.

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

137
00:11:04,780 --> 00:11:09,180
quindi ripple questo file esistente nel nostro direttamente dal commit precedente.

138
00:11:09,180 --> 00:11:14,120
Quindi vediamo come possiamo operare con queste cose imparando un paio di comandi in più.

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

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

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

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

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

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

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

146
00:11:48,050 --> 00:11:51,160
vorremo tornare a una versione precedente del file,

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

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

149
00:12:00,230 --> 00:12:07,136
Quindi facciamo uso di questo e vediamo alcune modifiche alla cartella nel nostro repository git.

150
00:12:09,137 --> 00:12:15,346
Tornando alla nostra riga di comando, ricordiamo che tra il secondo e

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

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

153
00:12:25,526 --> 00:12:33,951
Quindi posso semplicemente dire git checkout 900cfcf.

154
00:12:33,951 --> 00:12:40,980
Quindi questo è l'identificatore di commit, il numero che identificherà quel particolare commento.

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

156
00:12:46,170 --> 00:12:53,430
è che il file precedente verrà ora controllato nella mia directory di lavoro corrente.

157
00:12:55,919 --> 00:12:58,043
Andando al mio codice di Visual Studio,

158
00:12:58,043 --> 00:13:03,340
ora noti che il mio file index.html è tornato alla versione precedente.

159
00:13:03,340 --> 00:13:07,936
Quindi la modifica che ha fatto prima del terzo commit è ora sparita.

160
00:13:07,936 --> 00:13:13,123
Quindi il mio file index.html è stato ripristinato

161
00:13:13,123 --> 00:13:18,750
allo stato alla fine del secondo commento.

162
00:13:18,750 --> 00:13:24,863
Ora alla riga di comando se digito git status.

163
00:13:24,863 --> 00:13:29,140
Noterai come questo file index.html.

164
00:13:29,140 --> 00:13:33,520
Che è tornato a quello che era alla fine del secondo commit.

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

166
00:13:38,720 --> 00:13:42,930
tireremo fuori una versione precedente del file e poi sostituiremo ciò che

167
00:13:42,930 --> 00:13:47,670
è nella directory corrente e poi lo controllerà anche nell'area di staging.

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

169
00:13:53,960 --> 00:13:56,450
fare un altro commit a questo punto.

170
00:13:56,450 --> 00:14:01,090
E poi quel file può essere commentato come il quarto commit.

171
00:14:02,710 --> 00:14:08,035
Ma supponiamo che non mi piaccia, voglio tornare a quel

172
00:14:08,035 --> 00:14:13,700
file index.html alla fine del terzo commit.

173
00:14:13,700 --> 00:14:21,788
Quindi tutto quello che posso fare è dire git reset HEAD e

174
00:14:21,788 --> 00:14:27,404
index.html.

175
00:14:27,404 --> 00:14:31,821
Quindi a questo punto ciò che accade è che index.html,

176
00:14:31,821 --> 00:14:36,780
la versione modificata che controllo è ancora lì.

177
00:14:36,780 --> 00:14:41,275
Ma questo file non è stato messo in scena dall'area di gestione temporanea.

178
00:14:43,650 --> 00:14:49,269
Se torni indietro e guardi index.html nel tuo editor,

179
00:14:49,269 --> 00:14:54,887
mostrerà comunque lo stage alla fine del secondo commit

180
00:14:54,887 --> 00:15:01,250
perché avevamo tirato giù quel file usando il check out per quello.

181
00:15:01,250 --> 00:15:06,072
Ora, se vuoi ripristinarlo a quello che era alla fine del terzo commit

182
00:15:06,072 --> 00:15:09,490
, facciamo un altro check out dal terzo commit.

183
00:15:10,540 --> 00:15:18,900
Andando alla nostra finestra di comando digita git status e

184
00:15:18,900 --> 00:15:24,580
noteresti che index.html è contrassegnato come modificato,

185
00:15:24,580 --> 00:15:31,040
ma mostra anche questa particolare istruzione qui, dice git checkout -

186
00:15:31,040 --> 00:15:35,270
e il link del file per scartare le modifiche nella directory di lavoro.

187
00:15:35,270 --> 00:15:38,150
Quindi questo è un modo in cui puoi scartare le modifiche che

188
00:15:38,150 --> 00:15:43,095
non hai bisogno di un particolare file corrispondente al commit precedente.

189
00:15:43,095 --> 00:15:45,595
Quindi fammi ripristinare questo index.html

190
00:15:45,595 --> 00:15:48,205
a quello che era alla fine del terzo commit.

191
00:15:48,205 --> 00:15:53,104
Quindi per farlo dirò semplicemente git

192
00:15:53,104 --> 00:15:57,647
checkout - index.html.

193
00:15:57,647 --> 00:16:04,278
E poi, se faccio lo stato git, mostra che la mia directory è pulita e, fondamentalmente

194
00:16:04,278 --> 00:16:10,520
la mia directory era stata ripristinata allo stato della fine del terzo commit.

195
00:16:12,370 --> 00:16:17,580
Andando al file nel mio codice di Visual Studio vedo che

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

197
00:16:21,060 --> 00:16:25,840
Quindi questo è un modo in cui puoi, se hai apportato modifiche a un file dopo il commit e

198
00:16:25,840 --> 00:16:28,700
vuoi semplicemente scartare quelle modifiche puoi semplicemente

199
00:16:28,700 --> 00:16:30,880
estrarre il file dall'ultimo commit.

200
00:16:30,880 --> 00:16:34,530
E poi tutte le modifiche che hai fatto dopo l'ultimo commit

201
00:16:34,530 --> 00:16:36,220
verranno scartate sul posto.

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

203
00:16:40,960 --> 00:16:44,510
te mentre vai ai corsi in questa specializzazione,

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

205
00:16:49,160 --> 00:16:56,220
E mentre procedi in avanti, avrai ancora una versione di commit

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

207
00:17:01,790 --> 00:17:06,920
In questo modo, se stai uscendo un nuovo esercizio e hai scoperto di

208
00:17:06,920 --> 00:17:11,803
aver commesso degli errori e vuoi tornare al commit precedente,

209
00:17:11,803 --> 00:17:18,010
hai sempre un modo per farlo usando i comandi che abbiamo appena imparato.

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

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

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

213
00:17:35,560 --> 00:17:41,260
Quindi ora, abbiamo esaminato il git reset per file specifici o git reset

214
00:17:41,260 --> 00:17:47,970
in generale se si digita semplicemente git reset, ti ripristinerà all'ultimo commit.

215
00:17:47,970 --> 00:17:51,360
Quindi reimposterebbe l'area di staging all'ultimo commit

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

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

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

219
00:18:02,140 --> 00:18:07,380
Quindi in questo modo puoi ripristinare la tua cartella dove eri

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

221
00:18:10,450 --> 00:18:15,010
Quindi, a volte, quando si sta andando un esercizio e ti

222
00:18:15,010 --> 00:18:20,360
rendi conto che hai fatto un errore hai sempre un modo per tornare a una versione precedente.

223
00:18:20,360 --> 00:18:25,665
Quindi con questi comandi, penso che tu sia tutto pronto per usare git

224
00:18:25,665 --> 00:18:31,111
nei corsi di questa specializzazione Quindi

225
00:18:31,111 --> 00:18:34,276
alla fine di questo esercizio, l'hai Git?

226
00:18:34,276 --> 00:18:37,459
[ MUSIC]