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

2
00:00:04,402 --> 00:00:08,751
Exploremos ahora algunos comandos
básicos de Git que son muy útiles

3
00:00:08,751 --> 00:00:10,660
para nosotros
en la especialización.

4
00:00:11,670 --> 00:00:15,299
Hay mucho más que aprender sobre
Git de lo que veremos en este ejercicio.

5
00:00:18,380 --> 00:00:23,779
Para comenzar, ve a una ubicación
que te venga bien en tu computadora

6
00:00:23,779 --> 00:00:27,029
y crea una carpeta
llamada git-test.

7
00:00:30,340 --> 00:00:35,090
Abre esta carpeta
en tu editor favorito.

8
00:00:37,935 --> 00:00:42,875
Esta es la carpeta git-test,
que acabo de crear, abierta

9
00:00:42,875 --> 00:00:45,390
en Visual Studio Code.

10
00:00:45,390 --> 00:00:51,399
Añado un archivo a la
carpeta llamado index.html,

11
00:00:51,399 --> 00:00:55,869
ahora puedes ver
que he añadido

12
00:00:55,869 --> 00:01:00,504
algo de código
en index.html.

13
00:01:00,504 --> 00:01:02,580
Guardaré
los cambios.

14
00:01:02,580 --> 00:01:05,240
Ahora me dirijo a la
línea de comandos.

15
00:01:06,740 --> 00:01:11,320
en la consola, dirígete
a la carpeta git-test,

16
00:01:11,320 --> 00:01:15,860
luego, crea un repositorio de git en la carpeta

17
00:01:15,860 --> 00:01:19,800
Para hacerlo en la línea de
comando escribe git init.

18
00:01:21,620 --> 00:01:26,020
La carpeta está configurada
ahora como un repositorio git.

19
00:01:27,120 --> 00:01:32,650
git init es el primer comando
que hemos aprendido.

20
00:01:32,650 --> 00:01:36,320
Este comando inicializa la carpeta
actual como un repositorio de git

21
00:01:36,320 --> 00:01:42,380
y una vez inicializada, la
carpeta se marca como master.

22
00:01:42,380 --> 00:01:45,690
Esta será la rama
principal de mi git.

23
00:01:45,690 --> 00:01:48,210
Por ahora no nos
preocuparemos de las ramas.

24
00:01:48,210 --> 00:01:50,665
no trabajaremos con
las ramas en este curso.

25
00:01:50,665 --> 00:01:56,240
Solo trabajaremos con la
master branch, en este curso.

26
00:01:56,240 --> 00:01:58,500
La carpeta fue
marcada como master.

27
00:01:58,500 --> 00:02:02,060
Este es el punto
inicial del repositorio.

28
00:02:03,770 --> 00:02:08,410
El siguiente comando
que utilizaremos es git status.

29
00:02:08,410 --> 00:02:10,510
Si escribes git status
en la línea de comandos,

30
00:02:10,510 --> 00:02:13,740
te dirá el estado
actual de la carpeta.

31
00:02:13,740 --> 00:02:17,460
Hagámoslo en la línea de
comandos y veamos qué muestra.

32
00:02:19,470 --> 00:02:23,395
En la línea de comandos,
escribe git status

33
00:02:23,395 --> 00:02:28,945
y lee la información que
aparece en la ventana de comandos.

34
00:02:28,945 --> 00:02:34,390
Dice on branch master, esa es la
rama maestra que añadimos.

35
00:02:34,390 --> 00:02:40,690
Dice, untracked files, y muestra
index.html marcado en rojo.

36
00:02:40,690 --> 00:02:43,790
En tu computadora específica,
puede usar colores diferentes

37
00:02:43,790 --> 00:02:49,040
o representar esto de manera diferente
o esto es lo que muestra en mi Mac.

38
00:02:49,040 --> 00:02:54,040
Este archivo index.html que
acabamos de crear en esta carpeta

39
00:02:54,040 --> 00:02:58,100
no está añadido a
nuestro repositorio git.

40
00:02:58,100 --> 00:03:01,680
Añadimos ese fichero
al repositorio git.

41
00:03:01,680 --> 00:03:07,510
Para hacerlo, decimos, git add,
y simplemente puedes poner punto,

42
00:03:07,510 --> 00:03:12,350
lo que significa que se agregarán
todos los archivos del directorio actual

43
00:03:12,350 --> 00:03:17,680
a lo que se llama la staging
area de mi repositorio git.

44
00:03:17,680 --> 00:03:21,740
Si vuelvo a escribir git status,

45
00:03:21,740 --> 00:03:27,780
verás que index.html ahora
está en marcado en verde.

46
00:03:27,780 --> 00:03:34,202
Y dice, changes to be committed y
luego muestra el nombre del archivo

47
00:03:34,202 --> 00:03:40,161
que significa que este archivo está
listo para commit en mi repositorio git.

48
00:03:41,647 --> 00:03:46,100
El siguiente comando
que veremos es git add.

49
00:03:46,100 --> 00:03:51,190
Con git add podemos agregar
archivos o carpetas a la staging area.

50
00:03:51,190 --> 00:03:57,250
Una vez que se agrega a la staging area,
haces commit de los últimos cambios

51
00:03:57,250 --> 00:04:03,100
del estado de nuestra carpeta
a nuestro repositorio git.

52
00:04:03,100 --> 00:04:06,460
Eso significa que cuando
haces git commit,

53
00:04:08,130 --> 00:04:12,610
lo que este comando hará
es confirmar el actual

54
00:04:12,610 --> 00:04:17,250
estado de nuestras carpetas en
nuestros repositorios git.

55
00:04:17,250 --> 00:04:20,380
Todos los archivos que
existen en este momento,

56
00:04:20,380 --> 00:04:24,720
una vez que están en la staging
area usando git add se hará commit

57
00:04:24,720 --> 00:04:29,510
al repositorio git cuando
ejecutemos git commit.

58
00:04:29,510 --> 00:04:34,650
En este punto cuando ejecutamos
git commit, entonces nuestro estado

59
00:04:34,650 --> 00:04:40,750
inicial cambiará a primer
commit en el repositorio git.

60
00:04:40,750 --> 00:04:42,650
Sigamos y hagámoslo.

61
00:04:45,470 --> 00:04:51,950
De vuelta en el símbolo del
sistema, escribe git commit.

62
00:04:51,950 --> 00:04:54,888
Y entonces podemos incluso
añadir un mensaje al commit.

63
00:04:54,888 --> 00:05:00,010
Voy a decir git
commit -m "first

64
00:05:00,010 --> 00:05:04,160
commit" porque este es el
commit al repositorio git.

65
00:05:04,160 --> 00:05:10,630
Cuando lo hago, dice, se ha agregado
1 archivo al repositorio git

66
00:05:10,630 --> 00:05:15,300
y alguna otra información se
escribirá en la ventana de comandos.

67
00:05:15,300 --> 00:05:20,790
Chequeemos nuevamente,
git status

68
00:05:20,790 --> 00:05:26,220
y ahora ves que dice nothing to commit,
el directorio de trabajo está limpio.

69
00:05:26,220 --> 00:05:31,230
Significa que el estado actual
de mi directorio de trabajo

70
00:05:31,230 --> 00:05:36,390
o carpeta de trabajo se ha hecho
commit al repositorio git,

71
00:05:36,390 --> 00:05:39,330
se ha hecho commit
al repositorio git.

72
00:05:39,330 --> 00:05:47,200
Puedo escribir el siguiente
comando llamado git log --oneline,

73
00:05:47,200 --> 00:05:53,020
y ver que muestra un número,
un número de ocho dígitos,

74
00:05:53,020 --> 00:05:57,850
y también muestra el mensaje que pusimos
en el commit diciendo "first commit".

75
00:05:57,850 --> 00:06:03,340
Ese es el registro de todas los commits
que se han puesto en el repositorio git.

76
00:06:05,120 --> 00:06:08,900
Volviendo a nuestro
próximo comando git,

77
00:06:08,900 --> 00:06:14,094
vimos que git log --oneline

78
00:06:14,094 --> 00:06:18,540
nos mostrará un breve registro
de todos los commits.

79
00:06:18,540 --> 00:06:20,080
Si simplemente escribes git log

80
00:06:21,200 --> 00:06:26,220
muestra información mucho más
detallada de todos los commits.

81
00:06:26,220 --> 00:06:31,344
Pero esto es suficiente para tener
la información que necesitamos.

82
00:06:33,350 --> 00:06:40,248
Ahora regresemos a nuestro
editor, Visual Studio Code,

83
00:06:40,248 --> 00:06:46,141
voy a agregar más cambios
al archivo index.html.

84
00:06:54,501 --> 00:06:57,790
He cambiado el
archivo index.html.

85
00:06:57,790 --> 00:07:02,450
Déjame agregar otra carpeta
debajo de la carpeta git test,

86
00:07:02,450 --> 00:07:07,990
crearé una subcarpeta
llamada templates, y dentro

87
00:07:07,990 --> 00:07:13,450
de la carpeta templates, voy a crear
otro nombre de archivo, test.html.

88
00:07:13,450 --> 00:07:16,230
Esto es solo para
mostrarte cómo git

89
00:07:16,230 --> 00:07:21,120
puede hacer commit en toda la
jerarquía de carpetas en el repositorio.

90
00:07:21,120 --> 00:07:26,002
Con test.html
ahora allí, solo voy

91
00:07:26,002 --> 00:07:31,173
a copiar todo
mi index.html

92
00:07:31,173 --> 00:07:36,499
en mi test.html y
guardo los cambios.

93
00:07:39,447 --> 00:07:41,484
Volviendo a la
línea de comandos,

94
00:07:41,484 --> 00:07:46,480
Chequeamos el estado del
repositorio git y esta carpeta.

95
00:07:46,480 --> 00:07:51,740
Escribe git status,
muestra que

96
00:07:51,740 --> 00:07:56,020
el archivo index.html, que ya hemos
enviado antes al repositorio,

97
00:07:56,020 --> 00:08:00,570
se ha modificado, hay una versión
más reciente del archivo index.html.

98
00:08:00,570 --> 00:08:03,220
Muestra que hay
algunos archivos

99
00:08:03,220 --> 00:08:05,530
desatendidos en esta
carpeta llamada templates.

100
00:08:06,620 --> 00:08:11,794
Agreguemos todos estos
cambios a la staging area

101
00:08:11,794 --> 00:08:16,114
y de nuevo,
escribe git add.

102
00:08:16,114 --> 00:08:21,620
Todos estos archivos
se agregan a la staging area.

103
00:08:21,620 --> 00:08:23,940
Nuevamente,
verificamos el estado.

104
00:08:23,940 --> 00:08:29,490
Verás que los cambios se
han agregado a la staging area.

105
00:08:29,490 --> 00:08:32,850
Todos los archivos se han
añadido a la staging area.

106
00:08:32,850 --> 00:08:36,850
Hagamos un
commit más,

107
00:08:36,850 --> 00:08:42,930
diría git commit -m "second commit"

108
00:08:42,930 --> 00:08:47,096
y echamos un
vistazo al registro.

109
00:08:50,874 --> 00:08:55,246
Si revisas el registro,
verás que hay dos commits

110
00:08:55,246 --> 00:08:58,930
en mi repositorio git,
el primer y el segundo commit.

111
00:08:58,930 --> 00:09:03,040
Y note que cada uno de ellos
tiene un número diferente.

112
00:09:03,040 --> 00:09:07,130
Si deseas ver los detalles
completos del registro,

113
00:09:07,130 --> 00:09:12,510
puedes escribir solo, git log
y recibirás más detalles.

114
00:09:12,510 --> 00:09:15,132
Que te podrían interesar.

115
00:09:15,132 --> 00:09:20,114
Observa que --oneline
solo da los primeros

116
00:09:20,114 --> 00:09:24,405
caracteres del
número de commit.

117
00:09:24,405 --> 00:09:27,028
Eso es suficiente
para trabajar con ellos.

118
00:09:29,245 --> 00:09:34,721
Permíteme volver a Visual
Studio y agregar una más.

119
00:09:43,885 --> 00:09:47,140
Una línea más al
archivo index.html.

120
00:09:47,140 --> 00:09:49,800
El archivo index.html
ha sido modificado.

121
00:09:51,660 --> 00:09:53,170
Y guardamos los cambios.

122
00:09:55,310 --> 00:09:58,530
Volviendo a la línea de
comandos, hago git status

123
00:09:59,870 --> 00:10:04,490
que muestra que el archivo
index.html ha sido modificado.

124
00:10:04,490 --> 00:10:10,650
Lo agregamos a la staging area,
y luego hacemos un tercer commit.

125
00:10:10,650 --> 00:10:15,716
Entonces, digamos, git add,

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

127
00:10:18,720 --> 00:10:22,700
ves que se ha agregado la
versión modificada de index.html.

128
00:10:22,700 --> 00:10:27,722
Podemos decir
git commit.

129
00:10:31,231 --> 00:10:36,825
"third commit"
y git log --oneline,

130
00:10:36,825 --> 00:10:43,810
y ves que hay tres
commits en el repositorio.

131
00:10:43,810 --> 00:10:48,220
El repositorio contiene
instantáneas de tres puntos diferentes,

132
00:10:48,220 --> 00:10:51,370
al final del primer commit,
al final del segundo commit,

133
00:10:51,370 --> 00:10:53,250
y al final del tercer commit.

134
00:10:53,250 --> 00:10:56,930
También podemos
revertir los cambios,

135
00:10:56,930 --> 00:11:01,590
podemos revertir el repositorio
a una versión anterior.

136
00:11:01,590 --> 00:11:04,780
Podemos extraer un archivo
de un commit anterior,

137
00:11:04,780 --> 00:11:09,180
y luego reemplazar el directorio
existente con el antiguo commit.

138
00:11:09,180 --> 00:11:12,370
Vamos a ver cómo podemos
trabajar con estas cosas

139
00:11:12,370 --> 00:11:14,120
aprendiendo un par
de comandos más.

140
00:11:15,820 --> 00:11:21,450
En esta etapa, el archivo index.html
está en su estado actual.

141
00:11:21,450 --> 00:11:24,795
Puedes notar que
tiene un h1 y dos ps.

142
00:11:26,530 --> 00:11:29,365
Veamos ahora el
siguiente comando git.

143
00:11:30,815 --> 00:11:36,185
El siguiente comando git que
vamos a aprender es git checkout.

144
00:11:36,185 --> 00:11:40,300
Este comando ckeckout
nos permite chequear un archivo

145
00:11:40,300 --> 00:11:44,040
de un commit anterior
en nuestro repositorio git.

146
00:11:44,040 --> 00:11:48,050
Si no nos gusta el archivo actual
que tenemos en nuestra carpeta

147
00:11:48,050 --> 00:11:51,160
queremos volver a una
versión anterior del archivo,

148
00:11:51,160 --> 00:11:55,090
siempre podemos reemplazar el
archivo de un commit anterior

149
00:11:55,090 --> 00:12:00,230
con el commit actual y luego
continuar trabajando con ese archivo.

150
00:12:00,230 --> 00:12:07,431
Hagamos uso de esto y veamos algunos
cambios más en nuestro repositorio git.

151
00:12:09,228 --> 00:12:15,366
Volviendo a nuestra línea de comandos,
recordamos que, entre el segundo

152
00:12:15,366 --> 00:12:20,235
y tercer commit, realicé
cambios al archivo index.html.

153
00:12:20,235 --> 00:12:25,735
Supongamos que quiero volver al archivo
index.html de mi segundo commit.

154
00:12:25,735 --> 00:12:29,885
Simplemente puedo decir,

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

156
00:12:34,039 --> 00:12:41,035
El número del commit
identifica al commit concreto,

157
00:12:41,035 --> 00:12:46,971
y luego puedo poner
index.html, y notarás que,

158
00:12:46,971 --> 00:12:53,662
ese archivo anterior ahora está reemplazado
en mi directorio de trabajo actual.

159
00:12:55,845 --> 00:12:58,018
Yendo a mi código
en Visual Studio,

160
00:12:58,018 --> 00:13:03,811
notarás que mi archivo index.html
ha vuelto al funcionamiento anterior,

161
00:13:03,811 --> 00:13:08,580
el cambio que hice antes del
tercer commit ha desaparecido.

162
00:13:08,580 --> 00:13:16,690
Mi archivo index.html ha sido restaurado
a su estado al final del segundo commit.

163
00:13:18,920 --> 00:13:23,042
En la línea de comandos,
si intento git status,

164
00:13:23,042 --> 00:13:28,403
notarás que este archivo
index.html que fue revertido

165
00:13:28,403 --> 00:13:35,470
a lo que era al final del segundo commit,
ahora ya se ha llevado a la staging area.

166
00:13:35,470 --> 00:13:40,930
Usando git checkout, sacaremos
una versión anterior del archivo,

167
00:13:40,930 --> 00:13:44,390
y luego reemplazamos lo que
está en el directorio actual,

168
00:13:44,390 --> 00:13:47,670
y también lo llevará
a la staging area.

169
00:13:48,970 --> 00:13:53,400
Si lo hago y me doy cuenta
de que esto es lo que quiero,

170
00:13:53,400 --> 00:13:56,450
puedo hacer otro
commit en este punto.

171
00:13:56,450 --> 00:14:02,445
Y ese archivo puede ser
confirmado como el cuarto commit.

172
00:14:02,445 --> 00:14:07,812
Pero supongamos que no
me gusta, quiero volver

173
00:14:07,812 --> 00:14:12,641
al archivo index.html
al final del

174
00:14:12,641 --> 00:14:18,291
tercer commit entonces lo que
puedo hacer es poner git reset,

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

176
00:14:28,236 --> 00:14:33,356
En este punto, lo que
sucede es que index.html,

177
00:14:33,356 --> 00:14:38,796
la versión modificada que tenía
con git checkout aún está allí, pero

178
00:14:38,796 --> 00:14:43,397
este archivo está fuera
de la staging area.

179
00:14:43,397 --> 00:14:49,803
Si regresas y miras el
index.html en tu editor,

180
00:14:49,803 --> 00:14:56,680
aún mostrará el estado
al final del segundo commit.

181
00:14:56,680 --> 00:15:01,250
Porque habíamos recuperado
el archivo usando checkout.

182
00:15:01,250 --> 00:15:06,900
Si deseas revertirlo a lo que
era al final del tercer commit,

183
00:15:06,900 --> 00:15:11,956
hacemos un checkout más desde
el tercer commit yendo

184
00:15:11,956 --> 00:15:18,900
a la ventana de comandos,
escribe git status

185
00:15:18,900 --> 00:15:23,920
y verás que index.html
está marcado como modificado.

186
00:15:23,920 --> 00:15:28,870
Pero también muestra
esta instrucción particular.

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

188
00:15:32,270 --> 00:15:35,310
y el nombre del archivo, para descartar
los cambios en el directorio de trabajo.

189
00:15:35,310 --> 00:15:39,270
Esa es una forma de descartar los
cambios que has realizado en un archivo

190
00:15:39,270 --> 00:15:43,095
determinado correspondiente
al commit anterior.

191
00:15:43,095 --> 00:15:46,875
Permíteme restaurar index.html
de nuevo a lo que era al final

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

193
00:15:48,205 --> 00:15:52,455
Para hacerlo, simplemente
podrías decir git checkout

194
00:15:52,455 --> 00:15:58,540
-- index.html y luego,

195
00:15:58,540 --> 00:16:05,480
si hago git status, muestra
que mi directorio está limpio.

196
00:16:05,480 --> 00:16:08,130
Y básicamente mi directorio
ha sido restaurado

197
00:16:08,130 --> 00:16:10,520
al estado del final
del tercer commit.

198
00:16:12,370 --> 00:16:17,580
Al ir al archivo en Virtual
Studio Code, veo que

199
00:16:17,580 --> 00:16:21,060
su archivo ha sido restaurado a
cómo estaba al final del tercer commit.

200
00:16:21,060 --> 00:16:24,740
Esta es una forma que puedes,
si has realizado cambios en tu

201
00:16:24,740 --> 00:16:27,740
archivo después del commit y
deseas descartar esos cambios,

202
00:16:27,740 --> 00:16:31,810
simplemente puedes recuperar el
archivo del último commit, y todos

203
00:16:31,810 --> 00:16:36,220
los cambios que hayas realizado después
del último commit se descartarán en el acto.

204
00:16:36,220 --> 00:16:40,960
Estos son algunos comandos
básicos que son muy útiles

205
00:16:40,960 --> 00:16:44,510
para ti a medida que avanzas en
los cursos de esta especialización

206
00:16:44,510 --> 00:16:49,160
porque es posible que desees hacer
commit al final de cada ejercicio.

207
00:16:49,160 --> 00:16:56,220
Y a medida que avances,
tendrás una visión

208
00:16:56,220 --> 00:17:01,790
del estado de tu carpeta
al final del ejercicio anterior.

209
00:17:01,790 --> 00:17:06,180
De esa manera, si realizas un
nuevo ejercicio y descubres que has

210
00:17:06,180 --> 00:17:10,320
cometido errores y deseas
volver al commit anterior,

211
00:17:10,320 --> 00:17:18,000
siempre tienes una manera de hacerlo
usando los comandos que acabamos de ver.

212
00:17:18,000 --> 00:17:24,430
Con esta comprensión básica
de estos pocos comandos git,

213
00:17:24,430 --> 00:17:29,260
podrás avanzar
en la comprensión

214
00:17:29,260 --> 00:17:33,570
y el uso de git en los cursos
de esta especialización.

215
00:17:35,560 --> 00:17:41,685
Hemos revisado git reset para un
archivo específico o git reset en general.

216
00:17:41,685 --> 00:17:47,970
Si escribes git reset, lo restaurará
de nuevo al último commit.

217
00:17:47,970 --> 00:17:50,680
Restablecerá la staging
area al último commit,

218
00:17:50,680 --> 00:17:55,270
sin perturbar los cambios que has
realizado en tu directorio de trabajo.

219
00:17:55,270 --> 00:17:58,390
Una vez que hagas reset,
puedes recuperar

220
00:17:58,390 --> 00:18:02,140
la versión anterior del archivo que
has confirmado en el commit anterior.

221
00:18:02,140 --> 00:18:07,380
Esta semana, puedes restaurar
tu carpeta donde estaba

222
00:18:07,380 --> 00:18:10,450
en el punto de partida
del commit anterior.

223
00:18:10,450 --> 00:18:15,300
A veces, cuando haces un ejercicio y te
das cuenta de que has fallado en algo.

224
00:18:15,300 --> 00:18:20,174
Siempre tienes una forma
de volver a una versión anterior.

225
00:18:20,174 --> 00:18:25,027
Con estos comandos, creo que
ya está todo listo para continuar

226
00:18:25,027 --> 00:18:28,849
y usar git en los cursos
de esta especialización.

227
00:18:31,070 --> 00:18:34,395
Al final de este ejercicio,
¿Did you Git it?

228
00:18:34,395 --> 00:18:37,459
[MÚSICA] Tres meses más tarde, los viajes
de Lomax lo llevan a Marshall, Texas.