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

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

3
00:00:08,754 --> 00:00:10,660
nós nesta especialização.

4
00:00:11,670 --> 00:00:15,760
Há muito mais para obter do que o que cobrimos neste exercício.

5
00:00:18,167 --> 00:00:23,407
Para começar, vá para um local conveniente no seu computador e

6
00:00:23,407 --> 00:00:26,745
, em seguida, crie uma pasta chamada git-test.

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

8
00:00:38,190 --> 00:00:43,170
Aqui, eu tenho a pasta git-test que acabamos de criar open

9
00:00:43,170 --> 00:00:45,390
no meu código Visual Studio.

10
00:00:45,390 --> 00:00:49,257
Deixe-me adicionar um arquivo a esta pasta

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

12
00:00:54,148 --> 00:00:59,990
Agora você pode ver que eu adicionei em algum código HTML neste índice para HTML5.

13
00:00:59,990 --> 00:01:02,580
Vamos salvar as alterações.

14
00:01:02,580 --> 00:01:05,240
Agora vamos mudar para a nossa linha de comando.

15
00:01:06,740 --> 00:01:11,320
Na linha de comando, vá para a pasta git-test e

16
00:01:11,320 --> 00:01:15,860
vamos inicializar esta pasta para ser um repositório git.

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

18
00:01:21,620 --> 00:01:26,020
Agora esta pasta foi inicializada para ser um repositório git.

19
00:01:27,170 --> 00:01:32,650
Este é o nosso primeiro comando git que aprendemos, git init.

20
00:01:32,650 --> 00:01:36,320
Isso intializa a pasta atual como um repositório git e

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

22
00:01:42,380 --> 00:01:45,690
Este é o ramo mestre do meu git.

23
00:01:45,690 --> 00:01:48,210
Agora não vamos nos preocupar com ramos e assim por diante.

24
00:01:48,210 --> 00:01:51,000
Não vamos lidar com isso neste curso.

25
00:01:51,000 --> 00:01:56,240
Só trabalharemos com o ramo mestre nesta especialização específica.

26
00:01:56,240 --> 00:01:58,500
Então isso seria marcado como um mestre.

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

28
00:02:03,770 --> 00:02:08,410
O próximo comando que vamos ver é o status do git.

29
00:02:08,410 --> 00:02:10,510
Se você digitar git status na linha de comando,

30
00:02:10,510 --> 00:02:13,740
ele informará o status atual da pasta.

31
00:02:13,740 --> 00:02:17,460
Então vamos fazer isso na linha de comando e ver o que ela mostra.

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

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

34
00:02:28,945 --> 00:02:31,235
Você vê que ele diz no mestre ramo.

35
00:02:31,235 --> 00:02:35,200
Então, esse é o ramo mestre em que estamos e diz,

36
00:02:35,200 --> 00:02:40,690
arquivos não rastreados, e então mostra index.html em vermelho.

37
00:02:40,690 --> 00:02:43,790
Em seu computador específico, ele pode estar usando cores diferentes ou

38
00:02:43,790 --> 00:02:49,040
representam isso de forma diferente, mas isso é o que ele mostra no meu Mac.

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

40
00:02:53,775 --> 00:02:58,100
agora não foi adicionado ao nosso repositório git.

41
00:02:58,100 --> 00:03:01,680
Então vamos em frente e adicionar esse arquivo ao repositório git.

42
00:03:01,680 --> 00:03:06,740
Então, para fazer isso, dizemos git add e você pode simplesmente dizer

43
00:03:06,740 --> 00:03:12,350
dot, o que significa que todos os arquivos no diretório atual serão adicionados ao

44
00:03:12,350 --> 00:03:17,680
o que é chamado de área de preparação do meu repositório git.

45
00:03:17,680 --> 00:03:21,740
Então agora se eu digitar novamente status git,

46
00:03:21,740 --> 00:03:27,780
você verá que o arquivo index.html está marcado em verde.

47
00:03:27,780 --> 00:03:35,130
E diz que as mudanças devem ser confirmadas lá, e então mostra o nome do arquivo.

48
00:03:35,130 --> 00:03:39,000
E então, isso significa que este arquivo está pronto para ser confirmado no meu repositório

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

50
00:03:41,700 --> 00:03:46,100
Então, o próximo comando que vimos foi git add,

51
00:03:46,100 --> 00:03:51,190
usando git add você pode adicionar arquivo ou pastas a essa área de teste.

52
00:03:51,190 --> 00:03:57,250
Assim, uma vez que você adicioná-lo à área de preparação, então você pode enviar esse snapshot

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

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

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

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

57
00:04:17,200 --> 00:04:20,380
Então todos os arquivos, como eles existem no momento,

58
00:04:20,380 --> 00:04:24,570
uma vez que eles foram estágios usando o git add, então eles serão enviados para

59
00:04:24,570 --> 00:04:29,510
nosso repositório git quando executarmos a pasta de comando git.

60
00:04:29,510 --> 00:04:34,650
Então, neste ponto, quando executarmos o comando git, então nosso estado

61
00:04:34,650 --> 00:04:40,750
inicial agora será alterado para o primeiro commit no repositório git.

62
00:04:40,750 --> 00:04:42,650
Então vamos em frente e fazer isso.

63
00:04:45,470 --> 00:04:49,460
De volta ao prompt de comando, vamos digitar,

64
00:04:49,460 --> 00:04:54,880
git commit e, em seguida, podemos adicionar uma mensagem ao nosso commit.

65
00:04:54,880 --> 00:05:00,520
Então eu vou dizer git commit -m primeiro commit,

66
00:05:00,520 --> 00:05:04,160
porque este é o nosso primeiro commit no nosso repositório git.

67
00:05:04,160 --> 00:05:10,630
Então, quando eu fizer isso, ele diz, ok um arquivo foi adicionado ao repositório git e

68
00:05:10,630 --> 00:05:15,300
algumas outras informações serão digitadas nessa janela de comando.

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

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

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

72
00:05:31,230 --> 00:05:35,860
, foi confirmado no repositório git.

73
00:05:35,860 --> 00:05:39,330
Então, um instantâneo foi confirmado no meu repositório git.

74
00:05:39,330 --> 00:05:46,851
Agora eu posso digitar o próximo comando chamado git log —oneline.

75
00:05:46,851 --> 00:05:53,020
E veja que ele mostra um número lá, um número de oito dígitos lá.

76
00:05:53,020 --> 00:05:57,850
E então também mostra a mensagem que colocamos em nosso commit, dizendo primeiro commit.

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

78
00:06:05,120 --> 00:06:13,832
Então, voltando ao nosso próximo comando git vimos que git log —oneline veremos e

79
00:06:13,832 --> 00:06:18,540
ele nos mostra um breve log de todos os commits.

80
00:06:18,540 --> 00:06:23,920
Se você simplesmente digitar git log ele exibir muito mais informações detalhadas sobre

81
00:06:23,920 --> 00:06:26,220
todos os commits.

82
00:06:26,220 --> 00:06:30,850
Mas isso é suficiente para obter informações que precisamos.

83
00:06:33,350 --> 00:06:40,820
Vamos agora voltar para o nosso editor aqui no código do Visual Studio.

84
00:06:40,820 --> 00:06:44,940
Então eu vou adicionar mais alterações ao meu arquivo index.html.

85
00:06:44,940 --> 00:06:45,945
Então vou adicionar.

86
00:06:54,298 --> 00:06:57,790
Então eu alterei meu arquivo index.html.

87
00:06:57,790 --> 00:07:01,750
Agora deixe-me adicionar outra pasta sob a pasta GIT-TEST.

88
00:07:01,750 --> 00:07:07,220
Então eu vou criar uma subpasta aqui chamado templates, e

89
00:07:07,220 --> 00:07:13,450
dentro desta pasta templates, Eu vou criar outro arquivo chamado test.html.

90
00:07:13,450 --> 00:07:17,180
Isto é apenas para mostrar como o git pode submeter

91
00:07:17,180 --> 00:07:21,120
hierarquia de pastas inteiras em seu repositório.

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

93
00:07:24,754 --> 00:07:31,185
Eu só vou copiar tudo do meu index.html

94
00:07:31,185 --> 00:07:36,374
para o meu test.html, e salvar as alterações.

95
00:07:39,447 --> 00:07:41,484
Voltando para a linha de comando,

96
00:07:41,484 --> 00:07:45,943
vamos agora verificar o status do nosso repositório git e desta pasta.

97
00:07:45,943 --> 00:07:52,880
Portanto, digitar o status do git mostra que o arquivo index.html

98
00:07:52,880 --> 00:07:57,370
que já adicionamos anteriormente ao repositório foi modificado.

99
00:07:57,370 --> 00:08:00,207
Então, se houver uma nova versão do arquivo index.html índice.

100
00:08:00,207 --> 00:08:04,011
Também mostra que existem alguns arquivos não rastreados em

101
00:08:04,011 --> 00:08:06,408
esta pasta chamada templates.

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

103
00:08:11,530 --> 00:08:16,640
Então, novamente digite git add dot e, em seguida, todos esses arquivos

104
00:08:16,640 --> 00:08:21,620
serão adicionados à área de preparação.

105
00:08:21,620 --> 00:08:23,940
Novamente, verificando o status,

106
00:08:23,940 --> 00:08:29,490
você agora vê que as alterações que eu fui adicionado à área de preparação.

107
00:08:29,490 --> 00:08:32,850
Então todos esses arquivos foram adicionados à área de preparação.

108
00:08:32,850 --> 00:08:34,560
Vamos fazer mais um commit.

109
00:08:34,560 --> 00:08:38,381
Então eu diria git commit -m.

110
00:08:40,218 --> 00:08:47,234
Segundo commit e, em seguida, vamos verificar o log.

111
00:08:50,828 --> 00:08:57,480
Se você verificar o log, você verá que há dois commits no meu repositório git.

112
00:08:57,480 --> 00:08:59,130
O primeiro e o segundo commit e

113
00:08:59,130 --> 00:09:03,040
observam que cada um deles recebe um número diferente lá.

114
00:09:03,040 --> 00:09:09,830
Se você quiser ver os detalhes completos do log, você pode digitar simplesmente git log e

115
00:09:09,830 --> 00:09:15,095
então você verá mais detalhes lá, em seguida, o que você estaria interessado em.

116
00:09:15,095 --> 00:09:19,115
Então note que o oneline commit

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

118
00:09:24,405 --> 00:09:26,395
Isso é suficiente para operarmos.

119
00:09:29,245 --> 00:09:35,502
Deixe-me agora voltar novamente para o meu Visual Studio e adicionar mais um.

120
00:09:44,019 --> 00:09:45,890
Mais uma linha para meu arquivo index.html.

121
00:09:47,140 --> 00:09:49,800
Então agora meu arquivo index.html foi modificado.

122
00:09:51,660 --> 00:09:53,123
E vamos salvar as alterações.

123
00:09:55,099 --> 00:09:57,871
Voltando para a linha de comando,

124
00:09:57,871 --> 00:10:04,304
go in git status mostra que o arquivo index.html foi modificado.

125
00:10:04,304 --> 00:10:10,650
Então vamos adicionar isso à área de preparação e, em seguida, fazer um terceiro commit.

126
00:10:10,650 --> 00:10:18,720
Então digamos que git add dot git status.

127
00:10:18,720 --> 00:10:22,487
Agora você vê que o index.html, a versão modificada foi adicionada.

128
00:10:22,487 --> 00:10:26,240
Agora podemos dizer git commit.

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

130
00:10:37,084 --> 00:10:43,810
E git log oneline, e você verá que existem três commits em nosso repositório.

131
00:10:43,810 --> 00:10:48,220
Então, agora nosso repositório contém snapshots de três tipos diferentes.

132
00:10:48,220 --> 00:10:51,468
No final do primeiro commit, no final do segundo commit, e

133
00:10:51,468 --> 00:10:52,985
no final do terceiro commit.

134
00:10:52,985 --> 00:10:56,842
Agora também podemos reverter as alterações.

135
00:10:56,842 --> 00:11:01,590
Podemos reverter o repositório para uma versão anterior.

136
00:11:01,590 --> 00:11:04,780
Podemos retirar um arquivo de um commit mais antigo e

137
00:11:04,780 --> 00:11:09,180
, em seguida, ondular este arquivo existente em nosso diretamente do commit mais antigo.

138
00:11:09,180 --> 00:11:14,120
Então vamos ver como podemos operar com essas coisas aprendendo mais alguns comandos.

139
00:11:15,820 --> 00:11:21,450
Nesta fase, nosso arquivo Index.html está no estado atual.

140
00:11:21,450 --> 00:11:24,795
Então você pode notar que ele tem um h1 e dois p's.

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

142
00:11:30,815 --> 00:11:36,185
O próximo comando git que vamos aprender é o checkout do git.

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

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

145
00:11:44,040 --> 00:11:48,050
Então, se não gostarmos do arquivo atual que temos em nossa pasta e

146
00:11:48,050 --> 00:11:51,160
vamos querer voltar para uma versão anterior do arquivo,

147
00:11:51,160 --> 00:11:55,090
podemos sempre verificar o arquivo de um commit anterior, ou

148
00:11:55,090 --> 00:12:00,230
do commit atual e depois continuar a trabalhar com esse arquivo.

149
00:12:00,230 --> 00:12:07,136
Então vamos fazer uso disso e ver algumas alterações de pasta em nosso repositório git.

150
00:12:09,137 --> 00:12:15,346
Voltando à nossa linha de comando, lembramos que entre o segundo e

151
00:12:15,346 --> 00:12:20,235
o terceiro commit fiz alterações no meu arquivo index.html.

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

153
00:12:25,526 --> 00:12:33,951
Então eu posso simplesmente dizer git checkout 900cfcf.

154
00:12:33,951 --> 00:12:40,980
Então, que é o identificador de confirmação, o número que identifica esse comentário específico.

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

156
00:12:46,170 --> 00:12:53,430
é o arquivo de volta mais antigo agora será verificado em meu diretório de trabalho atual.

157
00:12:55,919 --> 00:12:58,043
Indo para o meu código do Visual Studio,

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

159
00:13:03,340 --> 00:13:07,936
Então, a alteração que fez antes do terceiro commit agora desapareceu.

160
00:13:07,936 --> 00:13:13,123
Então meu arquivo index.html foi restaurado para

161
00:13:13,123 --> 00:13:18,750
é um estado no final do segundo comentário.

162
00:13:18,750 --> 00:13:24,863
Agora na linha de comando se eu digitar git status.

163
00:13:24,863 --> 00:13:29,140
Você notará como este arquivo index.html.

164
00:13:29,140 --> 00:13:33,520
Que reverteu para o que era no final do segundo commit.

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

166
00:13:38,720 --> 00:13:42,930
nós vamos retirar uma versão mais antiga do arquivo e, em seguida, substituir o que

167
00:13:42,930 --> 00:13:47,670
está no diretório atual e, em seguida, ele também irá verificá-lo na área de preparação.

168
00:13:48,970 --> 00:13:53,960
Então agora se eu fizer isso e então eu perceber que isso é o que eu quero eu posso simplesmente

169
00:13:53,960 --> 00:13:56,450
fazer outro commit neste momento.

170
00:13:56,450 --> 00:14:01,090
E então esse arquivo pode ser comentado como o quarto commit.

171
00:14:02,710 --> 00:14:08,035
Mas suponha que eu não goste disso, eu quero reverter para aquele arquivo

172
00:14:08,035 --> 00:14:13,700
index.html no final do terceiro commit.

173
00:14:13,700 --> 00:14:21,788
Então tudo o que posso fazer é dizer git reset HEAD e

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

175
00:14:27,404 --> 00:14:31,821
Então, neste ponto, o que acontece é que o index.html,

176
00:14:31,821 --> 00:14:36,780
a versão modificada que eu check-out ainda está lá.

177
00:14:36,780 --> 00:14:41,275
Mas este arquivo foi despreparado da área de preparação.

178
00:14:43,650 --> 00:14:49,269
Se você voltar e olhar para o index.html em seu editor,

179
00:14:49,269 --> 00:14:54,887
ele ainda vai mostrar o palco no final do segundo commit

180
00:14:54,887 --> 00:15:01,250
porque tivemos puxar para baixo esse arquivo usando check-out para isso.

181
00:15:01,250 --> 00:15:06,072
Agora, se você quiser revertê-lo para o que era no final do terceiro commit

182
00:15:06,072 --> 00:15:09,490
, então fazemos mais um check-out do terceiro commit.

183
00:15:10,540 --> 00:15:18,900
Indo para a nossa janela de comando tipo git status e

184
00:15:18,900 --> 00:15:24,580
você notaria que o index.html está marcado como modificado, mas

185
00:15:24,580 --> 00:15:31,040
também mostra esta declaração em particular aqui, ele diz git checkout —

186
00:15:31,040 --> 00:15:35,270
e o link do arquivo para descartar as alterações no diretório de trabalho.

187
00:15:35,270 --> 00:15:38,150
Então essa é uma maneira que você pode descartar as alterações que você

188
00:15:38,150 --> 00:15:43,095
não precisa para um arquivo específico correspondente ao commit anterior.

189
00:15:43,095 --> 00:15:45,595
Então deixe-me restaurar este index.html volta

190
00:15:45,595 --> 00:15:48,205
para o que era no final do terceiro commit.

191
00:15:48,205 --> 00:15:53,104
Então, para fazer isso, vou simplesmente dizer git

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

193
00:15:57,647 --> 00:16:04,278
E então, se eu fizer o status do git, ele mostra que meu diretório está limpo e, basicamente

194
00:16:04,278 --> 00:16:10,520
meu diretório foi restaurado para o estado do fim do terceiro commit.

195
00:16:12,370 --> 00:16:17,580
Indo para o arquivo no meu código do Visual Studio vejo que

196
00:16:17,580 --> 00:16:21,060
o arquivo foi restaurado de volta ao que era no final do terceiro commit.

197
00:16:21,060 --> 00:16:25,840
Então esta é uma maneira que você pode, se você fez alterações em um arquivo após o commit e

198
00:16:25,840 --> 00:16:28,700
você quer apenas descartar essas alterações você pode simplesmente

199
00:16:28,700 --> 00:16:30,880
verificar o arquivo do último commit.

200
00:16:30,880 --> 00:16:34,530
E então todas as suas alterações que você fez após o último commit

201
00:16:34,530 --> 00:16:36,220
serão descartadas no local.

202
00:16:36,220 --> 00:16:40,960
Então, estes são alguns comandos básicos que são muito úteis para

203
00:16:40,960 --> 00:16:44,510
você como você vai para os cursos nesta especialização,

204
00:16:44,510 --> 00:16:49,160
porque você pode querer cometer no final de cada exercício.

205
00:16:49,160 --> 00:16:56,220
E à medida que você avança, você ainda teria uma versão confirmada de

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

207
00:17:01,790 --> 00:17:06,920
Assim, se você está saindo de um novo exercício e você descobriu que você

208
00:17:06,920 --> 00:17:11,803
tinha cometido erros e você quer voltar para o commit anterior você

209
00:17:11,803 --> 00:17:18,010
sempre tem uma maneira de fazer isso usando os comandos que acabamos de aprender.

210
00:17:18,010 --> 00:17:24,430
Assim, com esta compreensão básica desses poucos comandos git,

211
00:17:24,430 --> 00:17:29,260
poderemos prosseguir com a compreensão e

212
00:17:29,260 --> 00:17:33,570
usando git nos cursos desta especialização.

213
00:17:35,560 --> 00:17:41,260
Então agora, nós temos rever o git reset para arquivo específico ou git reset

214
00:17:41,260 --> 00:17:47,970
em geral se você simplesmente digitar git reset ele irá restaurá-lo de volta para o último commit.

215
00:17:47,970 --> 00:17:51,360
Assim, ele iria redefinir a área de preparação para o último commit

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

217
00:17:55,270 --> 00:17:58,390
Assim, uma vez que você redefinir, então você pode conferir

218
00:17:58,390 --> 00:18:02,140
a versão anterior do arquivo que você cometeu no commit anterior.

219
00:18:02,140 --> 00:18:07,380
Assim, você pode restaurar sua pasta de volta para onde você estava em

220
00:18:07,380 --> 00:18:10,450
o ponto inicial do commit anterior.

221
00:18:10,450 --> 00:18:15,010
Então, às vezes, quando você está fazendo um exercício e você percebe que cometeu erro

222
00:18:15,010 --> 00:18:20,360
você sempre tem uma maneira de reverter para uma versão anterior.

223
00:18:20,360 --> 00:18:25,665
Então, com esses comandos, eu acho que você está tudo pronto para usar git em

224
00:18:25,665 --> 00:18:31,111
os cursos desta especialização Então

225
00:18:31,111 --> 00:18:34,276
no final deste exercício, você Git it it?

226
00:18:34,276 --> 00:18:37,459
[MÚSICA]