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

2
00:00:04,408 --> 00:00:08,754
Vamos a explorar ahora algunos comandos básicos de Git que son muy útiles para

3
00:00:08,754 --> 00:00:10,660
nosotros en esta especialización.

4
00:00:11,670 --> 00:00:15,760
Hay mucho más que conseguir de lo que cubrimos en este ejercicio.

5
00:00:18,167 --> 00:00:23,407
Para empezar, vaya a una ubicación conveniente en su computadora y

6
00:00:23,407 --> 00:00:26,745
luego cree una carpeta llamada git-test.

7
00:00:30,340 --> 00:00:34,600
A continuación, abra esta carpeta en su editor favorito.

8
00:00:38,190 --> 00:00:43,170
Aquí, tengo la carpeta git-test que acabamos de crear abierta

9
00:00:43,170 --> 00:00:45,390
en mi código de Visual Studio.

10
00:00:45,390 --> 00:00:49,257
Permítanme agregar un archivo a esta carpeta

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

12
00:00:54,148 --> 00:00:59,990
Ahora puedes ver que he agregado un código HTML en este índice hacia HTML5.

13
00:00:59,990 --> 00:01:02,580
Guardemos los cambios.

14
00:01:02,580 --> 00:01:05,240
Ahora cambiemos a nuestra línea de comando.

15
00:01:06,740 --> 00:01:11,320
En la línea de comandos, vaya a la carpeta git-test y

16
00:01:11,320 --> 00:01:15,860
inicialicemos esta carpeta para que sea un repositorio git.

17
00:01:15,860 --> 00:01:19,800
Entonces, para hacer eso, en la línea de comando, escriba git init.

18
00:01:21,620 --> 00:01:26,020
Ahora esta carpeta se ha inicializado para ser un repositorio git.

19
00:01:27,170 --> 00:01:32,650
Este es nuestro primer comando git que hemos aprendido, git init.

20
00:01:32,650 --> 00:01:36,320
Esto inicializa la carpeta actual como un repositorio git y

21
00:01:36,320 --> 00:01:42,380
cuando inicializa la carpeta, marcará esa carpeta como un maestro.

22
00:01:42,380 --> 00:01:45,690
Esta es la rama maestra para mi git.

23
00:01:45,690 --> 00:01:48,210
Ahora no nos preocupemos por las ramas y así sucesivamente.

24
00:01:48,210 --> 00:01:51,000
No vamos a tratar con eso en este curso.

25
00:01:51,000 --> 00:01:56,240
Sólo trabajaremos con la rama principal en esta especialización particular.

26
00:01:56,240 --> 00:01:58,500
Así que esto estaría marcado como un maestro.

27
00:01:58,500 --> 00:02:02,060
Ahora este es el punto inicial de nuestro repositorio.

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

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

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

31
00:02:13,740 --> 00:02:17,460
Así que hagamos eso en la línea de comandos y veamos lo que muestra.

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

33
00:02:23,395 --> 00:02:28,945
lea la información que se registra en la ventana de comandos.

34
00:02:28,945 --> 00:02:31,235
Usted ve que dice en el maestro de la rama.

35
00:02:31,235 --> 00:02:35,200
Entonces, esa es la rama principal en la que estamos y dice,

36
00:02:35,200 --> 00:02:40,690
archivos sin seguimiento, y luego muestra index.html en rojo.

37
00:02:40,690 --> 00:02:43,790
En su computadora específica, puede estar usando diferentes colores o

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

39
00:02:49,040 --> 00:02:53,775
Así que ahora, este archivo index.html que acabamos de crear en esta carpeta

40
00:02:53,775 --> 00:02:58,100
ahora no se ha agregado a nuestro repositorio git.

41
00:02:58,100 --> 00:03:01,680
Así que sigamos adelante y agregemos ese archivo al repositorio git.

42
00:03:01,680 --> 00:03:06,740
Así que para hacer eso decimos git add y simplemente puedes decir

43
00:03:06,740 --> 00:03:12,350
dot, lo que significa que todos los archivos en el directorio actual se agregarán a

44
00:03:12,350 --> 00:03:17,680
lo que se llama el área de puesta en escena de mi repositorio git.

45
00:03:17,680 --> 00:03:21,740
Así que ahora si vuelvo a escribir git status,

46
00:03:21,740 --> 00:03:27,780
verá que el archivo index.html está marcado en verde.

47
00:03:27,780 --> 00:03:35,130
Y dice que los cambios se deben comprometer allí, y luego muestra el nombre de archivo.

48
00:03:35,130 --> 00:03:39,000
Y luego, eso significa que este archivo está listo para ser comprometido en mi repositorio

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

50
00:03:41,700 --> 00:03:46,100
Así que el siguiente comando que vimos fue git add,

51
00:03:46,100 --> 00:03:51,190
usando git add, puedes agregar archivos o carpetas a esa área de ensayo.

52
00:03:51,190 --> 00:03:57,250
Así que una vez que lo agregue al área de puesta en escena, puede comprometer esa instantánea

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

54
00:04:03,100 --> 00:04:06,460
Entonces eso significa que cuando haces ese git commit.

55
00:04:08,130 --> 00:04:12,610
Lo que este comando hará es comprometer el estado

56
00:04:12,610 --> 00:04:17,200
actual de nuestras carpetas en nuestro repositorio git.

57
00:04:17,200 --> 00:04:20,380
Así que todos los archivos, tal como existen en este momento,

58
00:04:20,380 --> 00:04:24,570
una vez que hayan sido etapas usando git add, entonces se comprometerán a

59
00:04:24,570 --> 00:04:29,510
nuestro repositorio git cuando ejecutemos la carpeta de comandos git.

60
00:04:29,510 --> 00:04:34,650
Entonces, en este punto, cuando ejecutamos el comando git, entonces nuestro estado

61
00:04:34,650 --> 00:04:40,750
inicial ahora se cambiará al primer commit en el repositorio git.

62
00:04:40,750 --> 00:04:42,650
Así que vamos a seguir adelante y hacer eso.

63
00:04:45,470 --> 00:04:49,460
De vuelta en el símbolo del sistema, vamos a escribir,

64
00:04:49,460 --> 00:04:54,880
git commit y luego podemos agregar un mensaje a nuestra confirmación.

65
00:04:54,880 --> 00:05:00,520
Así que voy a decir git commit -m first commit,

66
00:05:00,520 --> 00:05:04,160
porque este es nuestro primer commit en nuestro repositorio git.

67
00:05:04,160 --> 00:05:10,630
Entonces, cuando hago eso, dice, está bien, se ha agregado un archivo al repositorio git y

68
00:05:10,630 --> 00:05:15,300
se escribirá otra información en esa ventana de comando.

69
00:05:15,300 --> 00:05:20,440
Así que ahora vamos a comprobar de nuevo, el estado de git.

70
00:05:20,440 --> 00:05:26,220
Y ahora ves que no dice nada para comprometer, el directorio de trabajo está limpio.

71
00:05:26,220 --> 00:05:31,230
Entonces, lo que eso significa es que el estado actual de mi directorio de trabajo, o carpeta de trabajo

72
00:05:31,230 --> 00:05:35,860
, se ha comprometido al repositorio git.

73
00:05:35,860 --> 00:05:39,330
Entonces, se ha comprometido una instantánea en mi repositorio git.

74
00:05:39,330 --> 00:05:46,851
Ahora puedo escribir el siguiente comando llamado git log —oneline.

75
00:05:46,851 --> 00:05:53,020
Y ver que muestra un número allí, un número de ocho dígitos allí.

76
00:05:53,020 --> 00:05:57,850
Y luego también muestra el mensaje que ponemos en nuestro compromiso, diciendo primero compromiso.

77
00:05:57,850 --> 00:06:03,340
Entonces ese es el registro de todas las confirmaciones que se han puesto en mi repositorio de datos.

78
00:06:05,120 --> 00:06:13,832
Así que volviendo a nuestro siguiente comando git vimos que git log —oneline veremos y

79
00:06:13,832 --> 00:06:18,540
nos muestra un breve registro de todos los commits.

80
00:06:18,540 --> 00:06:23,920
Si simplemente escribe git log, muestra mucha más información detallada sobre

81
00:06:23,920 --> 00:06:26,220
todas las confirmaciones.

82
00:06:26,220 --> 00:06:30,850
Pero esto es suficiente para obtener la información que necesitamos.

83
00:06:33,350 --> 00:06:40,820
Volvamos ahora a nuestro editor aquí en código de Visual Studio.

84
00:06:40,820 --> 00:06:44,940
Así que voy a agregar más cambios a mi archivo index.html.

85
00:06:44,940 --> 00:06:45,945
Así que voy a añadir.

86
00:06:54,298 --> 00:06:57,790
Así que he cambiado mi archivo index.html.

87
00:06:57,790 --> 00:07:01,750
Ahora permítanme agregar otra carpeta debajo de la carpeta GIT-TEST.

88
00:07:01,750 --> 00:07:07,220
Así que voy a crear una subcarpeta aquí llamada plantillas, y

89
00:07:07,220 --> 00:07:13,450
dentro de esta carpeta de plantillas, voy a crear otro archivo llamado test.html.

90
00:07:13,450 --> 00:07:17,180
Esto es solo para mostrarle cómo git puede comprometer

91
00:07:17,180 --> 00:07:21,120
toda la jerarquía de carpetas en su repositorio.

92
00:07:21,120 --> 00:07:24,754
Así que con test.html ahora allí,

93
00:07:24,754 --> 00:07:31,185
solo voy a copiar todo desde mi index.html

94
00:07:31,185 --> 00:07:36,374
en mi test.html, y guardar los cambios.

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

96
00:07:41,484 --> 00:07:45,943
vamos a echar un vistazo al estado de nuestro repositorio git y esta carpeta.

97
00:07:45,943 --> 00:07:52,880
Así que escribiendo el estado de git muestra que el archivo index.html

98
00:07:52,880 --> 00:07:57,370
que ya hemos agregado anteriormente al repositorio ha sido modificado.

99
00:07:57,370 --> 00:08:00,207
Entonces, si hay una nueva versión del archivo index.html index.html.

100
00:08:00,207 --> 00:08:04,011
También muestra que hay algunos archivos sin seguimiento en

101
00:08:04,011 --> 00:08:06,408
esta carpeta llamada plantillas.

102
00:08:06,408 --> 00:08:11,530
Añadamos todos estos cambios a nuestro repositorio, al área de puesta en escena.

103
00:08:11,530 --> 00:08:16,640
Así que de nuevo escriba git add dot y luego todos estos archivos

104
00:08:16,640 --> 00:08:21,620
se agregarán al área de ensayo.

105
00:08:21,620 --> 00:08:23,940
Una vez más, comprobando el estado,

106
00:08:23,940 --> 00:08:29,490
ahora ves que los cambios que he sido añadido a la zona de ensayo.

107
00:08:29,490 --> 00:08:32,850
Así que todos estos archivos se han agregado al área de ensayo.

108
00:08:32,850 --> 00:08:34,560
Hagamos una confirmación más.

109
00:08:34,560 --> 00:08:38,381
Así que diría git commit -m.

110
00:08:40,218 --> 00:08:47,234
Segunda confirmación y luego echemos un vistazo al registro.

111
00:08:50,828 --> 00:08:57,480
Si revisa el registro, ahora ve que hay dos confirmaciones en mi repositorio git.

112
00:08:57,480 --> 00:08:59,130
La primera y la segunda confirmación y

113
00:08:59,130 --> 00:09:03,040
notan que cada uno de ellos recibe un número diferente allí.

114
00:09:03,040 --> 00:09:09,830
Si desea ver los detalles completos del registro, puede escribir simplemente git log y

115
00:09:09,830 --> 00:09:15,095
luego verá más detalles allí entonces lo que le interesaría.

116
00:09:15,095 --> 00:09:19,115
Así que note que la confirmación de oneline

117
00:09:19,115 --> 00:09:24,405
solo da los primeros caracteres de mi número de confirmación allí.

118
00:09:24,405 --> 00:09:26,395
Eso es suficiente para que operemos con.

119
00:09:29,245 --> 00:09:35,502
Permítanme volver ahora a mi Visual Studio y agregar uno más.

120
00:09:44,019 --> 00:09:45,890
Una línea más a mi archivo index.html.

121
00:09:47,140 --> 00:09:49,800
Así que ahora mi archivo index.html ha sido modificado.

122
00:09:51,660 --> 00:09:53,123
Y guardemos los cambios.

123
00:09:55,099 --> 00:09:57,871
Volviendo a la línea de comandos,

124
00:09:57,871 --> 00:10:04,304
ir en estado git muestra que el archivo index.html ha sido modificado.

125
00:10:04,304 --> 00:10:10,650
Así que agregemos esto al área de puesta en escena y luego hagamos una tercera confirmación.

126
00:10:10,650 --> 00:10:18,720
Así que digamos git add dot git status.

127
00:10:18,720 --> 00:10:22,487
Ahora ves que el index.html, la versión modificada ha sido agregada.

128
00:10:22,487 --> 00:10:26,240
Ahora podemos decir git commit.

129
00:10:31,176 --> 00:10:37,084
Tercera confirmación.

130
00:10:37,084 --> 00:10:43,810
Y git log oneline, y verás que hay tres commits en nuestro repositorio.

131
00:10:43,810 --> 00:10:48,220
Así que ahora nuestro repositorio contiene instantáneas de tres tipos diferentes.

132
00:10:48,220 --> 00:10:51,468
Al final de la primera confirmación, al final de la segunda confirmación, y

133
00:10:51,468 --> 00:10:52,985
al final de la tercera confirmación.

134
00:10:52,985 --> 00:10:56,842
Ahora también podemos revertir los cambios.

135
00:10:56,842 --> 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 una confirmación anterior y

137
00:11:04,780 --> 00:11:09,180
luego ondular este archivo existente en nuestro directamente desde la confirmación anterior.

138
00:11:09,180 --> 00:11:14,120
Así que vamos a ver cómo podemos operar con estas cosas aprendiendo un par de comandos más.

139
00:11:15,820 --> 00:11:21,450
En esta etapa, nuestro archivo Index.html se encuentra en el estado actual.

140
00:11:21,450 --> 00:11:24,795
Así que puedes notar que tiene un h1 y dos p.

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

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

143
00:11:36,185 --> 00:11:40,300
Así que este comando de checkout nos permite extraer un archivo

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

145
00:11:44,040 --> 00:11:48,050
Así que si no nos gusta el archivo actual que tenemos en nuestra carpeta y

146
00:11:48,050 --> 00:11:51,160
vamos a querer volver a una versión anterior del archivo,

147
00:11:51,160 --> 00:11:55,090
siempre podemos revisar el archivo de una confirmación anterior, o

148
00:11:55,090 --> 00:12:00,230
de la confirmación actual y luego continuar trabajando con ese archivo.

149
00:12:00,230 --> 00:12:07,136
Así que hagamos uso de esto y veamos algunos cambios de carpeta en nuestro repositorio git.

150
00:12:09,137 --> 00:12:15,346
Volviendo a nuestra línea de comandos, recordamos que entre la segunda y

151
00:12:15,346 --> 00:12:20,235
la tercera confirmación hice cambios en mi archivo index.html.

152
00:12:20,235 --> 00:12:25,526
Supongamos que quiero volver al archivo index.html desde mi segunda confirmación.

153
00:12:25,526 --> 00:12:33,951
Entonces puedo simplemente decir git checkout 900cfcf.

154
00:12:33,951 --> 00:12:40,980
Entonces ese es el identificador de confirmación, el número que identifica ese comentario en particular.

155
00:12:40,980 --> 00:12:46,170
Y entonces puedo decir, index.html y lo que notarías

156
00:12:46,170 --> 00:12:53,430
es que el archivo posterior anterior ahora será revisado en mi directorio de trabajo actual.

157
00:12:55,919 --> 00:12:58,043
Al ir a mi código de Visual Studio,

158
00:12:58,043 --> 00:13:03,340
ahora nota que mi archivo index.html ha revertido a la versión anterior.

159
00:13:03,340 --> 00:13:07,936
Así que el cambio que hizo antes de la tercera confirmación ya se ha ido.

160
00:13:07,936 --> 00:13:13,123
Así que mi archivo index.html se ha restaurado a

161
00:13:13,123 --> 00:13:18,750
es un estado al final del segundo comentario.

162
00:13:18,750 --> 00:13:24,863
Ahora en la línea de comando si escribo git status.

163
00:13:24,863 --> 00:13:29,140
Notarás como este archivo index.html.

164
00:13:29,140 --> 00:13:33,520
Que ha vuelto a lo que era al final de la segunda confirmación.

165
00:13:33,520 --> 00:13:37,710
Ahora ya se ha organizado por lo que usando git checkout

166
00:13:38,720 --> 00:13:42,930
sacaremos una versión anterior del archivo y luego reemplazaremos lo que

167
00:13:42,930 --> 00:13:47,670
está en el directorio actual y luego lo verificaremos en el área de puesta en escena.

168
00:13:48,970 --> 00:13:53,960
Así que ahora si hago eso y luego me doy cuenta de que esto es lo que quiero, simplemente puedo

169
00:13:53,960 --> 00:13:56,450
hacer otro compromiso en este punto.

170
00:13:56,450 --> 00:14:01,090
Y luego ese archivo se puede comentar como el cuarto commit.

171
00:14:02,710 --> 00:14:08,035
Pero supongamos que no me gusta esto, quiero volver a ese archivo

172
00:14:08,035 --> 00:14:13,700
index.html al final de la tercera confirmación.

173
00:14:13,700 --> 00:14:21,788
Entonces todo lo que puedo hacer es decir git reset HEAD y

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

175
00:14:27,404 --> 00:14:31,821
Así que en este punto lo que sucede es que el index.html,

176
00:14:31,821 --> 00:14:36,780
la versión modificada que reviso sigue ahí.

177
00:14:36,780 --> 00:14:41,275
Pero este archivo no ha sido escenificado desde el área de ensayo.

178
00:14:43,650 --> 00:14:49,269
Si retrocede y mira el index.html en su editor,

179
00:14:49,269 --> 00:14:54,887
aún mostrará el escenario al final de la segunda confirmación

180
00:14:54,887 --> 00:15:01,250
porque habíamos derribado ese archivo usando check-out para eso.

181
00:15:01,250 --> 00:15:06,072
Ahora, si desea revertirlo de nuevo a lo que era al final de la tercera confirmación

182
00:15:06,072 --> 00:15:09,490
, entonces hacemos una comprobación más de la tercera confirmación.

183
00:15:10,540 --> 00:15:18,900
Al ir a nuestra ventana de comandos tipo git status y

184
00:15:18,900 --> 00:15:24,580
notarías que index.html está marcado como modificado, pero

185
00:15:24,580 --> 00:15:31,040
también muestra esta declaración en particular aquí, dice git checkout —

186
00:15:31,040 --> 00:15:35,270
y el enlace del archivo para descartar los cambios en el directorio de trabajo.

187
00:15:35,270 --> 00:15:38,150
Así que esa es una forma de descartar los cambios que

188
00:15:38,150 --> 00:15:43,095
no necesita en un archivo en particular correspondiente a la confirmación anterior.

189
00:15:43,095 --> 00:15:45,595
Así que permítanme restaurar este index.html de nuevo

190
00:15:45,595 --> 00:15:48,205
a lo que era al final de la tercera confirmación.

191
00:15:48,205 --> 00:15:53,104
Así que para hacer eso, simplemente diré git

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

193
00:15:57,647 --> 00:16:04,278
Y luego, si hago el estado git, muestra que mi directorio está limpio y, básicamente,

194
00:16:04,278 --> 00:16:10,520
, mi directorio se había restaurado al estado del final de la tercera confirmación.

195
00:16:12,370 --> 00:16:17,580
Al ir al archivo en mi código de Visual Studio veo que

196
00:16:17,580 --> 00:16:21,060
el archivo se ha restaurado a lo que era al final de la tercera confirmación.

197
00:16:21,060 --> 00:16:25,840
Así que esta es una forma de que puede, si ha realizado cambios en un archivo después de la confirmación y

198
00:16:25,840 --> 00:16:28,700
desea descartar esos cambios, simplemente puede

199
00:16:28,700 --> 00:16:30,880
revisar el archivo de la última confirmación.

200
00:16:30,880 --> 00:16:34,530
Y entonces todos los cambios que hayas hecho después de la última confirmación

201
00:16:34,530 --> 00:16:36,220
serán descartados en el acto.

202
00:16:36,220 --> 00:16:40,960
Así que estos son algunos comandos básicos que son muy útiles para

203
00:16:40,960 --> 00:16:44,510
a medida que vas a los cursos de esta especialización,

204
00:16:44,510 --> 00:16:49,160
porque es posible que quieras comprometerte al final de cada ejercicio.

205
00:16:49,160 --> 00:16:56,220
Y a medida que avanza, todavía tendría una versión comprometida de

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

207
00:17:01,790 --> 00:17:06,920
Así que si estás sacando un nuevo ejercicio y descubriste que

208
00:17:06,920 --> 00:17:11,803
has cometido errores y quieres volver al compromiso anterior,

209
00:17:11,803 --> 00:17:18,010
siempre tienes una forma de hacerlo usando los comandos que acabamos de aprender.

210
00:17:18,010 --> 00:17:24,430
Así que con esta comprensión básica de estos pocos comandos git,

211
00:17:24,430 --> 00:17:29,260
podremos continuar con la comprensión y

212
00:17:29,260 --> 00:17:33,570
usando git en los cursos de esta especialización.

213
00:17:35,560 --> 00:17:41,260
Así que ahora, hemos revisado el restablecimiento de git para un archivo específico o git reset

214
00:17:41,260 --> 00:17:47,970
en general, si simplemente escribe git reset, lo restaurará de nuevo a la última confirmación.

215
00:17:47,970 --> 00:17:51,360
Por lo tanto, restablecería el área de ensayo a la última confirmación

216
00:17:51,360 --> 00:17:55,270
sin alterar los cambios que ha realizado en su directorio de trabajo.

217
00:17:55,270 --> 00:17:58,390
Así que una vez que restablezca, puede revisar

218
00:17:58,390 --> 00:18:02,140
la versión anterior del archivo que ha confirmado en la confirmación anterior.

219
00:18:02,140 --> 00:18:07,380
Así que de esta manera puede restaurar su carpeta de nuevo a donde estaba en

220
00:18:07,380 --> 00:18:10,450
el punto de inicio de la confirmación anterior.

221
00:18:10,450 --> 00:18:15,010
Así que a veces cuando estás haciendo un ejercicio y te das cuenta de que cometiste un error

222
00:18:15,010 --> 00:18:20,360
siempre tienes una forma de volver a una versión anterior.

223
00:18:20,360 --> 00:18:25,665
Así que con estos comandos, creo que estás listo para usar git en

224
00:18:25,665 --> 00:18:31,111
los cursos de esta especialización Así que

225
00:18:31,111 --> 00:18:34,276
al final de este ejercicio, ¿lo hiciste?

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