1
00:00:00,000 --> 00:00:04,425
[MÚSICA]

2
00:00:04,425 --> 00:00:09,324
Vamos agora explorar alguns comandos básicos do Git que são muito úteis para

3
00:00:09,324 --> 00:00:11,474
nós nesta especialização.

4
00:00:11,474 --> 00:00:15,055
Há muito mais no Git do que o que cobrimos neste exercício.

5
00:00:18,130 --> 00:00:23,231
Para começar, vá para o local conveniente no computador

6
00:00:23,231 --> 00:00:26,523
e crie uma pasta chamada git-test.

7
00:00:30,140 --> 00:00:34,408
Em seguida, abra esta pasta no seu editor favorito.

8
00:00:37,895 --> 00:00:42,585
Aqui eu tenho a pasta git-test que acabamos de criar

9
00:00:42,585 --> 00:00:45,390
aberta no meu Visual Studio Code.

10
00:00:45,390 --> 00:00:51,915
Deixe-me adicionar um arquivo a esta pasta chamada index.html.

11
00:00:54,122 --> 00:01:00,430
Agora você pode ver que eu adicionei em algum código HTML neste arquivo index.html.

12
00:01:00,430 --> 00:01:06,507
Vamos salvar as alterações, agora vamos mudar para a nossa linha de comando.

13
00:01:06,507 --> 00:01:10,903
Na linha de comando, vá para a pasta git-test, e

14
00:01:10,903 --> 00:01:15,860
vamos inicializar esta pasta para ser um repositório Git.

15
00:01:15,860 --> 00:01:19,800
Então, para fazer isso, adicione a linha de comando, digite, git init.

16
00:01:21,620 --> 00:01:27,710
Agora esta pasta foi inicializada para ser um repositório Git, então

17
00:01:27,710 --> 00:01:32,650
este é o nosso primeiro comando Git que aprendemos, git init.

18
00:01:32,650 --> 00:01:36,320
Isso inicializa a pasta atual como um repositório Git, e

19
00:01:36,320 --> 00:01:42,380
quando inicializa a pasta, ele marcará essa pasta como um mestre.

20
00:01:42,380 --> 00:01:47,770
Este é o ramo mestre para o meu Git, agora não vamos nos preocupar com ramos e

21
00:01:47,770 --> 00:01:51,000
assim por diante, não vamos lidar com isso neste curso.

22
00:01:51,000 --> 00:01:55,738
Nós só estaremos trabalhando com o ramo mestre nesta especialização particular,

23
00:01:55,738 --> 00:01:58,500
então isso seria marcado como o mestre.

24
00:01:58,500 --> 00:02:02,060
Agora, este é o ponto inicial do nosso repositório,

25
00:02:03,770 --> 00:02:08,410
o próximo comando que vamos olhar é git status.

26
00:02:08,410 --> 00:02:12,600
Se você digitar git status na linha de comando, ele informará o status atual

27
00:02:12,600 --> 00:02:17,460
da pasta, então vamos fazer isso na linha de comando e ver o que ela mostra.

28
00:02:19,470 --> 00:02:23,395
Na linha de comando, digite git status e

29
00:02:23,395 --> 00:02:28,945
leia as informações digitadas na janela de comando.

30
00:02:28,945 --> 00:02:33,943
Você vê que ele diz, No ramo mestre, de modo que é o ramo mestre em que estamos,

31
00:02:33,943 --> 00:02:40,690
e ele diz, arquivos não rastreados, e, em seguida, mostra index.html em vermelho.

32
00:02:40,690 --> 00:02:44,458
Em seu computador específico, ele pode estar usando cores diferentes ou

33
00:02:44,458 --> 00:02:49,040
representando isso de forma diferente, mas isso é o que ele mostra no meu Mac.

34
00:02:49,040 --> 00:02:54,040
Então agora este arquivo index.html que acabamos de criar nesta pasta

35
00:02:54,040 --> 00:02:58,140
não foi adicionado ao nosso repositório Git.

36
00:02:58,140 --> 00:03:01,335
Então vamos em frente e adicionar esse arquivo ao repositório Git.

37
00:03:01,335 --> 00:03:07,510
Então, para fazer isso, nós dizemos, git add, e você pode simplesmente dizer dot,

38
00:03:07,510 --> 00:03:12,350
o que significa que todos os arquivos no diretório atual serão adicionados ao

39
00:03:12,350 --> 00:03:17,680
que é chamado como a área de teste do meu repositório Git.

40
00:03:17,680 --> 00:03:22,880
Então, agora, se eu digitar novamente, status git, você verá

41
00:03:22,880 --> 00:03:27,910
que o arquivo index.html está marcado em verde, e

42
00:03:27,910 --> 00:03:35,130
ele diz que as alterações a serem confirmadas lá, e então mostra o nome do arquivo.

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

44
00:03:35,672 --> 00:03:39,601
então, isso significa que este arquivo agora está pronto para ser submetido ao meu repositório Git.

45
00:03:41,438 --> 00:03:46,856
Então, o próximo comando que vimos foi git add, usando git add,

46
00:03:46,856 --> 00:03:51,190
você pode adicionar arquivos ou pastas para a área de teste.

47
00:03:51,190 --> 00:03:57,250
Então, uma vez que você adicioná-lo à área de teste, então você pode enviar esse instantâneo

48
00:03:57,250 --> 00:04:03,100
do status da nossa pasta para o nosso repositório Git.

49
00:04:03,100 --> 00:04:06,460
Então isso significa que quando você faz o git commit,

50
00:04:08,130 --> 00:04:12,610
o que este comando fará é submeter o

51
00:04:12,610 --> 00:04:17,200
estado atual de nossas pastas em nosso repositório Git.

52
00:04:17,200 --> 00:04:21,780
Então todos os arquivos, como eles existem no momento, uma vez que eles foram encenados

53
00:04:21,780 --> 00:04:25,560
usando o git add, então eles serão submetidos através de um repositório Git,

54
00:04:25,560 --> 00:04:29,510
então nós executamos a pasta de comando git.

55
00:04:29,510 --> 00:04:33,580
Então, neste ponto, quando executamos o comando git,

56
00:04:33,580 --> 00:04:38,373
então nosso estado inicial agora será alterado para o primeiro commit para

57
00:04:38,373 --> 00:04:42,369
o repositório Git, então vamos em frente e fazer isso.

58
00:04:45,208 --> 00:04:50,261
De volta ao prompt de comando, vamos digitar git commit,

59
00:04:50,261 --> 00:04:54,880
e então podemos até adicionar uma mensagem ao nosso commit.

60
00:04:54,880 --> 00:04:59,275
Então eu vou dizer git commit -m “first commit”,

61
00:04:59,275 --> 00:05:03,879
porque este é o nosso primeiro commit para o nosso repositório Git.

62
00:05:03,879 --> 00:05:10,106
Então, quando eu faço isso, ele diz, ok, um arquivo foi adicionado ao repositório Git e

63
00:05:10,106 --> 00:05:15,300
algumas outras informações serão digitadas na janela de comando.

64
00:05:15,300 --> 00:05:20,440
Então vamos agora verificar, novamente, status do git,

65
00:05:20,440 --> 00:05:26,220
e agora você vê que ele diz, nada para confirmar, diretório de trabalho é limpo.

66
00:05:26,220 --> 00:05:31,230
Então o que isso significa é que o estado atual do meu diretório de

67
00:05:31,230 --> 00:05:35,860
trabalho ou pasta de trabalho foi submetido ao repositório do Git.

68
00:05:35,860 --> 00:05:41,050
Assim, um instantâneo foi submetido ao meu repositório Git, agora eu posso digitar o próximo

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

70
00:05:47,200 --> 00:05:52,156
E veja que ele mostra um número lá, um número de oito dígitos lá, e

71
00:05:52,156 --> 00:05:57,545
também mostra a mensagem que colocamos em nosso commit dizendo “primeiro commit”.

72
00:05:57,545 --> 00:06:03,340
Então esse é o log de todos os commits que foram colocados no meu repositório Git.

73
00:06:05,120 --> 00:06:08,900
Então, voltando ao nosso próximo comando git,

74
00:06:08,900 --> 00:06:14,094
vimos que o git log —oneline

75
00:06:14,094 --> 00:06:18,540
nos mostrará um breve log de todos os commits.

76
00:06:18,540 --> 00:06:20,442
Se você simplesmente digitar git log,

77
00:06:20,442 --> 00:06:25,658
ele exibirá informações muito mais detalhadas sobre todos os commits, mas

78
00:06:25,658 --> 00:06:30,652
isso é suficiente para obter informações que precisamos.

79
00:06:33,013 --> 00:06:40,820
Vamos agora voltar ao nosso editor aqui no Visual Studio Code.

80
00:06:40,820 --> 00:06:45,379
Então eu vou adicionar mais alterações ao meu arquivo index.html, então eu vou adicionar,

81
00:06:54,307 --> 00:06:57,790
Então eu mudei meu arquivo index.html.

82
00:06:57,790 --> 00:07:02,453
Agora deixe-me adicionar outra pasta sob a pasta git-test, então

83
00:07:02,453 --> 00:07:06,890
eu vou criar uma subpasta aqui chamada templates.

84
00:07:06,890 --> 00:07:09,344
E dentro desta pasta templates,

85
00:07:09,344 --> 00:07:13,039
vou criar outro arquivo chamado test.html.

86
00:07:13,039 --> 00:07:17,798
Isto é apenas para mostrar como o Git pode submeter toda a

87
00:07:17,798 --> 00:07:21,120
hierarquia de pastas em seu repositório.

88
00:07:21,120 --> 00:07:24,734
Então, com test.html agora lá,

89
00:07:24,734 --> 00:07:29,321
eu vou apenas copiar tudo do

90
00:07:29,321 --> 00:07:34,047
meu index.html para o meu test.html, e

91
00:07:34,047 --> 00:07:41,422
salvar as alterações Voltando para a linha de comando,

92
00:07:41,422 --> 00:07:46,187
vamos agora verificar o status do nosso repositório Git e desta pasta.

93
00:07:46,187 --> 00:07:51,079
Então, digitando o status do git mostra que o arquivo index.html que

94
00:07:51,079 --> 00:07:55,971
já adicionamos anteriormente ao repositório foi modificado,

95
00:07:55,971 --> 00:08:00,570
então há uma versão mais recente do arquivo index.html.

96
00:08:00,570 --> 00:08:03,220
Além disso, ele mostra que existem alguns

97
00:08:03,220 --> 00:08:05,530
arquivos não rastreados nesta pasta chamados templates.

98
00:08:06,620 --> 00:08:11,720
Vamos adicionar todas essas alterações ao nosso repositório, à área de preparação.

99
00:08:11,720 --> 00:08:16,350
Então, novamente, digite git add., e

100
00:08:16,350 --> 00:08:21,620
então todos esses arquivos serão adicionados à área de teste.

101
00:08:21,620 --> 00:08:27,820
Novamente, verificando o status, agora você verá que as alterações que foram

102
00:08:27,820 --> 00:08:32,850
adicionadas à área de teste, então todos esses arquivos foram adicionados à área de teste.

103
00:08:32,850 --> 00:08:37,735
Vamos fazer mais um commit, então eu diria git commit -m,

104
00:08:41,526 --> 00:08:46,595
“Segundo commit”, e então, vamos verificar o log.

105
00:08:50,794 --> 00:08:54,179
Se você verificar o log, você verá agora que

106
00:08:54,179 --> 00:08:58,930
existem dois commits no meu repositório Git, o primeiro e o segundo commit.

107
00:08:58,930 --> 00:09:02,826
E note que cada um deles recebe um número diferente lá.

108
00:09:02,826 --> 00:09:09,700
Se você quiser ver os detalhes completos do log, você pode digitar simplesmente, git log.

109
00:09:09,700 --> 00:09:12,510
E então você verá mais detalhes lá

110
00:09:12,510 --> 00:09:15,095
do que o que você estaria interessado.

111
00:09:15,095 --> 00:09:19,115
Portanto, note que a confirmação de uma linha

112
00:09:19,115 --> 00:09:24,405
só dá os primeiros caracteres do meu número de commit lá.

113
00:09:24,405 --> 00:09:26,674
Isso é suficiente para nós operarmos.

114
00:09:29,000 --> 00:09:34,006
Deixe-me agora voltar novamente ao meu Visual Studio e adicionar mais uma,

115
00:09:43,821 --> 00:09:45,890
Mais uma linha ao meu arquivo index.html.

116
00:09:47,140 --> 00:09:52,666
Então, agora meu arquivo index.html foi modificado e vamos salvar as alterações.

117
00:09:55,066 --> 00:09:57,813
Voltando à linha de comando,

118
00:09:57,813 --> 00:10:04,490
fazendo o status do git mostra que o arquivo index.html foi modificado.

119
00:10:04,490 --> 00:10:08,640
Então vamos adicionar isso à área de teste e,

120
00:10:08,640 --> 00:10:14,382
em seguida, fazer um terceiro commit, então vamos dizer git add. ,

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

122
00:10:18,720 --> 00:10:22,700
Agora você verá que o index.html, a versão modificada, foi adicionado.

123
00:10:22,700 --> 00:10:27,305
Agora, podemos dizer git commit,

124
00:10:31,164 --> 00:10:37,144
“Terceiro commit”, E fazer git log —oneline,

125
00:10:37,144 --> 00:10:43,818
e você verá que há três commits em nosso repositório.

126
00:10:43,818 --> 00:10:47,625
Então agora nosso repositório contém instantâneos de três pontos diferentes,

127
00:10:47,625 --> 00:10:51,234
no final do primeiro commit, no final do segundo commit, e

128
00:10:51,234 --> 00:10:52,929
no final do terceiro commit.

129
00:10:52,929 --> 00:10:56,297
Agora também podemos reverter as alterações,

130
00:10:56,297 --> 00:11:01,417
podemos reverter o repositório para uma versão anterior.

131
00:11:01,417 --> 00:11:04,366
Podemos retirar um arquivo de um commit mais antigo e

132
00:11:04,366 --> 00:11:09,180
, em seguida, substituir o arquivo existente em nosso diretório do commit mais antigo.

133
00:11:09,180 --> 00:11:13,604
Então vamos ver como podemos operar com essas coisas aprendendo

134
00:11:13,604 --> 00:11:15,608
mais alguns comandos.

135
00:11:15,608 --> 00:11:21,759
Nesta fase, nosso arquivo index.html está no estado atual,

136
00:11:21,759 --> 00:11:26,530
então você pode notar que ele tem um h1 e dois p.

137
00:11:26,530 --> 00:11:29,365
Vamos agora olhar para o próximo comando Git.

138
00:11:30,815 --> 00:11:36,185
O próximo comando Git que vamos aprender sobre é git checkout.

139
00:11:36,185 --> 00:11:40,300
Então este comando checkout nos permite fazer check-out de um arquivo

140
00:11:40,300 --> 00:11:44,040
de um commit anterior em nosso repositório Git.

141
00:11:44,040 --> 00:11:47,709
Então, se não gostarmos do arquivo atual que temos em nossa pasta,

142
00:11:47,709 --> 00:11:50,907
e queremos voltar para uma versão anterior do arquivo.

143
00:11:50,907 --> 00:11:54,782
Podemos sempre verificar o arquivo de um commit anterior ou

144
00:11:54,782 --> 00:12:00,230
do commit atual e, em seguida, continuar a trabalhar com esse arquivo.

145
00:12:00,230 --> 00:12:07,190
Então vamos fazer uso disso e ver algumas alterações adicionais em nosso repositório Git.

146
00:12:09,350 --> 00:12:14,705
Voltando à nossa linha de comando, lembramos que,

147
00:12:14,705 --> 00:12:20,235
entre o segundo e o terceiro commit, fiz alterações no meu arquivo index.html.

148
00:12:20,235 --> 00:12:25,477
Suponha que eu queira reverter para o arquivo index.html do meu segundo commit.

149
00:12:25,477 --> 00:12:31,244
Então eu posso simplesmente dizer, git checkout 900cfcf, de

150
00:12:31,244 --> 00:12:35,045
modo que é o identificador de commit,

151
00:12:35,045 --> 00:12:40,980
o número que identifica esse commit em particular.

152
00:12:40,980 --> 00:12:46,117
E então eu posso dizer index.html, e o que você notaria

153
00:12:46,117 --> 00:12:53,190
é que todo o arquivo agora será verificado no meu diretório de trabalho atual.

154
00:12:55,721 --> 00:12:57,901
Indo para o meu Visual Studio Code,

155
00:12:57,901 --> 00:13:03,340
agora você percebe que meu arquivo index.html foi revertido para a versão anterior.

156
00:13:03,340 --> 00:13:07,928
Então a mudança que eu fiz antes do terceiro commit agora se foi.

157
00:13:07,928 --> 00:13:16,482
Então, meu arquivo index.html foi restaurado ao seu estado no final do segundo commit.

158
00:13:18,607 --> 00:13:22,936
Agora, na linha de comando, se eu digitar git status,

159
00:13:22,936 --> 00:13:26,711
você percebe que este arquivo index.html,

160
00:13:26,711 --> 00:13:33,520
que reverteu para o que era no final do segundo commit.

161
00:13:33,520 --> 00:13:37,710
Ele já foi encenado, então usando este checkout git

162
00:13:38,720 --> 00:13:43,670
irá retirar uma versão mais antiga do arquivo e, em seguida, substituir o que está no

163
00:13:43,670 --> 00:13:48,400
diretório atual e, em seguida, ele também irá verificá-lo na área de teste.

164
00:13:48,400 --> 00:13:53,400
Então, agora, se eu fizer isso e então eu percebo que isso é o que

165
00:13:53,400 --> 00:13:56,450
eu quero, eu posso simplesmente fazer outro compromisso neste momento.

166
00:13:56,450 --> 00:14:02,249
E então esse arquivo pode ser confirmado como o quarto commit,

167
00:14:02,249 --> 00:14:05,200
mas suponha que eu não goste disso.

168
00:14:05,200 --> 00:14:10,553
Eu quero reverter para o arquivo index.html no

169
00:14:10,553 --> 00:14:17,704
final do terceiro commit, então tudo o que posso fazer é dizer git reset,

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

171
00:14:28,084 --> 00:14:32,404
Então, neste ponto, o que acontece é que

172
00:14:32,404 --> 00:14:37,264
o index.html, a versão modificada que eu verifiquei ainda está lá, mas

173
00:14:37,264 --> 00:14:41,137
este arquivo não foi preparado da área de teste.

174
00:14:43,376 --> 00:14:48,440
Se você voltar e olhar para o index.html em seu,

175
00:14:50,991 --> 00:14:56,094
Editor, ele ainda mostrará o estado no final do segundo commit

176
00:14:56,094 --> 00:15:01,255
porque nós tínhamos puxado para fora esse arquivo usando checkout para isso.

177
00:15:01,255 --> 00:15:06,900
Agora, se quisermos revertê-lo de volta para o que era no final do terceiro commit,

178
00:15:06,900 --> 00:15:09,470
então faremos mais um checkout do terceiro commit.

179
00:15:10,540 --> 00:15:16,431
Indo para nossa janela de comando, digite git status, e

180
00:15:16,431 --> 00:15:23,558
você notaria que o index.html está marcado como modificado.

181
00:15:23,558 --> 00:15:29,661
Mas também mostra esta declaração em particular aqui, ele diz git checkout —,

182
00:15:29,661 --> 00:15:35,029
e o nome do arquivo, para descartar as alterações no diretório de trabalho.

183
00:15:35,029 --> 00:15:38,334
Portanto, essa é uma maneira de descartar as alterações

184
00:15:38,334 --> 00:15:43,095
feitas em um arquivo específico correspondente ao commit anterior.

185
00:15:43,095 --> 00:15:46,565
Então deixe-me restaurar este index.html de volta ao que era

186
00:15:46,565 --> 00:15:47,653
no final do terceiro commit.

187
00:15:47,653 --> 00:15:54,315
Então, para fazer isso, eu vou simplesmente dizer git checkout —

188
00:15:54,315 --> 00:15:58,712
index.html, e então se eu fizer,

189
00:16:01,503 --> 00:16:05,815
Git status, ele mostra que meu diretório está limpo, e basicamente meu

190
00:16:05,815 --> 00:16:10,520
diretório foi restaurado para o estado do final do terceiro comentário.

191
00:16:12,370 --> 00:16:16,909
Indo para o arquivo no meu Visual Studio Code, vejo que o arquivo foi

192
00:16:16,909 --> 00:16:20,767
restaurado de volta ao que estava no final da terceira confirmação.

193
00:16:20,767 --> 00:16:25,251
Então, se você fez alterações em um arquivo após um commit e você quer simplesmente

194
00:16:25,251 --> 00:16:30,632
descartar essas alterações, você pode simplesmente fazer o check-out do arquivo do último commit.

195
00:16:30,632 --> 00:16:35,338
E então todas as suas alterações que você fez após o último commit serão descartadas

196
00:16:35,338 --> 00:16:36,144
nesta parte..

197
00:16:36,144 --> 00:16:40,304
Então estes são alguns comandos básicos que são muito úteis para

198
00:16:40,304 --> 00:16:42,958
você enquanto você percorre os cursos e

199
00:16:42,958 --> 00:16:48,821
a especialização porque você pode querer se comprometer no final de cada exercício.

200
00:16:48,821 --> 00:16:51,617
E à medida que

201
00:16:51,617 --> 00:16:56,744
você avança, você ainda teria uma versão confirmada

202
00:16:56,744 --> 00:17:01,790
do estado da sua pasta no final do exercício anterior.

203
00:17:01,790 --> 00:17:06,249
Assim, se você estiver realizando um novo exercício e descobrir que

204
00:17:06,249 --> 00:17:10,032
cometeu erros e quer reverter para o commit anterior.

205
00:17:10,032 --> 00:17:14,832
Você sempre terá uma maneira de fazer isso usando os comandos

206
00:17:14,832 --> 00:17:18,010
que acabamos de aprender.

207
00:17:18,010 --> 00:17:24,430
Assim, com esta compreensão básica destes poucos comandos Git,

208
00:17:24,430 --> 00:17:29,427
nós seríamos capazes de prosseguir com a compreensão e

209
00:17:29,427 --> 00:17:33,570
usando o Git nos cursos desta especialização.

210
00:17:35,560 --> 00:17:41,434
Então, agora, nós revisamos o git reset para um arquivo específico ou git reset em geral.

211
00:17:41,434 --> 00:17:47,970
Se você simplesmente digitar get reset, ele irá restaurá-lo de volta para a última confirmação.

212
00:17:47,970 --> 00:17:51,360
Assim, ele irá redefinir a área de teste para o último commit

213
00:17:51,360 --> 00:17:55,270
sem perturbar as alterações que você fez em seu diretório de trabalho.

214
00:17:55,270 --> 00:17:59,270
Então, uma vez que você redefinir, então você pode fazer check-out

215
00:17:59,270 --> 00:18:02,140
da versão anterior do arquivo que você confirmou no commit anterior.

216
00:18:02,140 --> 00:18:05,940
Dessa forma, você pode restaurar sua pasta de volta para onde você estava

217
00:18:07,440 --> 00:18:10,450
no ponto inicial do commit anterior.

218
00:18:10,450 --> 00:18:16,037
Então, às vezes, quando você está passando por um exercício e você percebe que cometeu um erro,

219
00:18:16,037 --> 00:18:20,082
você sempre tem uma maneira de reverter para uma versão anterior.

220
00:18:20,082 --> 00:18:25,081
Então, com esses comandos eu acho que você está pronto para ir em frente para usar

221
00:18:25,081 --> 00:18:28,651
o Git nos cursos desta especialização.

222
00:18:30,865 --> 00:18:33,694
Então, no final deste exercício, você fez isso?

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