Transcripciones
1. Introducción: Get es una herramienta que se utiliza en casi todos los trabajos de ingeniería de software. Si quieres conseguir un trabajo vas a necesitar saber conseguir, y por eso lo estamos aprendiendo. Entonces vamos a empezar con este tutorial de inmediato con la pregunta más importante, ¿qué es bueno? Entonces si alguna vez has usado Google Docs o Microsoft Word, tienen una característica realmente útil llamada el historial de versiones. Por lo que de vez en cuando, Google Docs guardará una copia de tu documento en ese momento. Y luego podrás encontrar todas las copias de tu documento en un historial de versiones como este. Y esto hace que sea fácil para usted volver
a versiones anteriores de su documento o restaurar su documento de nuevo a una versión anterior en caso de que lo estropee. Get es básicamente lo mismo. Es un historial de versiones para nuestro código. Por lo que nos permite guardar versiones
pasadas de cada caída sobre código. Y luego siempre que lo necesitemos, podemos ver el código que teníamos en el pasado o
podemos restaurar todo lo recodificado de nuevo a él tiene división. Básicamente es una red de seguridad cuando estamos desarrollando software. Pero esa es sólo la punta del iceberg. Muy historias es una pequeña parte de lo que puede hacer. Y más adelante vamos a aprender habilidades
adicionales como GitHub y ramificación. Eso te va a llevar a ese nivel profesional. Pero por ahora vamos a empezar
aprendiendo a usar Git para recrear la función Google Docs at Version History para nuestro código. Para seguir junto con este tutorial, solo
necesitas haber escrito algún código para. No necesitas ninguna experiencia previa. Voy a explicar cada paso que hacemos con eso dicho, empecemos con el tutorial.
2. Instalación Git: En primer lugar, aprendamos a instalar Git. El proceso de instalación es bastante sencillo. Solo tienes que ir a este sitio web, git dash Sem.com descargas de slash. Para Windows, el aislamiento es bastante simple. Solo tenemos que ir a esta sección de Windows y el instalador se descargará automáticamente. Si no lo hace, también puedes hacer clic en este enlace. Después de que el instalador termine de descargar, lo
vamos a abrir. Y entonces sólo vamos a ejecutar el instalador. Para que podamos mantener todas las opciones predeterminadas, solo hacer clic en Siguiente hasta que hayas terminado de instalar. Para usuarios de macOS. Vamos a entrar en esta sección y ya ves tenemos varias opciones aquí. Por lo que la opción recomendada para instalar Git es instalar Xcode. Por lo que hay dos maneras de hacer eso. El primer modo es hacer clic en este icono, que abrirá Spotlight. Y luego vamos a buscar terminal. Y vamos a abrir terminal. Vamos a teclear git. Y luego vamos a presionar Enter. Adelante y pulsa Instalar, y eso instalará Git por ti. Si eso no funcionó para ti. También puedes abrir la tienda de aplicaciones y buscar Xcode para luego instalar Xcode.
3. Configuración de proyectos: Ahora que hemos instalado Git, estamos listos para aprender a usarlo para construir este historial de versiones para nuestro código. Entonces voy a estar haciendo este tutorial en un Mac. Pero los pasos son los mismos, ya sea que estés usando un Mac o un equipo Windows. Entonces el primer paso que tenemos que hacer es tener algún código con el que practicar. Entonces si tienes tu propio código o tu propio proyecto que quieres
usar para tu lectura es que de lo contrario, vamos a crear algún código rápidamente en este momento. Entonces voy a ir a mi escritorio y crear una nueva carpeta que va a contener todo nuestro código. Voy a llamarlo get tutorial. Y luego voy a abrir esta carpeta en mi editor de códigos. ¿ De acuerdo? Entonces solo voy a escribir algún código de ejemplo con el que podamos practicar. Si quieres copiar este código, siéntete libre de pausar el video si es necesario. De acuerdo, Entonces este es nuestro código de ejemplo y solo
tenemos una declaración de registro de consola con el nombre de archivo. Y luego un registro de consola con la versión 1, solo para que podamos rastrear en qué versión estamos ya que estamos construyendo un historial de versiones, es bastante sencillo. Sólo necesitamos algo con lo que practicar.
4. Configuración de Git: Por lo que Git se usa principalmente desde la línea de comandos, que es terminal en Mac o PowerShell en Windows. Para abrir la línea de comandos en un Mac, vamos a hacer clic en este icono, que abrirá Spotlight. Y luego vamos a buscar terminal. Y luego vamos a abrir terminal. Para abrir la línea de comandos en Windows. Vamos a buscar en el menú Inicio el programador PowerShell. Y luego vamos a abrir Windows PowerShell. Entonces sigamos adelante y abramos eso. Por lo que no necesitas saber mucho sobre la línea de comandos para usar Git, pero sí necesitas entender un concepto. En la línea de comandos es donde podemos dar comandos o instrucciones para que la computadora siga. Entonces por ejemplo, puedo dar este comando ls, y cuando presiono Enter, el equipo seguirá este comando y enumerará los archivos y carpetas que se encuentran en la carpeta actual. Por lo que note que dije carpeta actual. Entonces porque aún tengo que entender es que todos
los comandos se ejecutan dentro de una carpeta específica. Entonces, cuando abrimos por primera vez la línea de comandos, los comandos se están ejecutando dentro una carpeta especial llamada la carpeta Inicio. Entonces para poder usar Git, necesitamos cambiar la carpeta que se están ejecutando
los comandos dentro de esta carpeta, que contiene todo nuestro código. Entonces para ello, podemos dar este CD de comando, que significa directorio de cambio. Directorio es lo mismo que una carpeta. Y vamos a cambiar directorio a Tilda slash escritorio slash buen tutorial. Y vamos a verificar que estaban en el lugar correcto dando
nuevamente el comando ls para enumerar los archivos y carpetas que se encuentran en la carpeta actual. Entonces como puedes ver, tenemos config dot js y source aquí, que coincide con lo que tenemos en nuestro editor de código. Entonces sabemos que estamos en el lugar correcto. Entonces una última cosa que tenías que saber sobre la línea de comandos es que si alguna vez cierras la línea de comandos y luego la
reinicias, vas a volver a empezar dentro de la carpeta de inicio. Así que asegúrate de que el primer paso que haces es hacer cambiar directorio de nuevo a esta carpeta la cual contiene todo nuestro código. Y eso es todo. Ahora estamos listos para aprender algo bueno.
5. Crear una versión o compromiso: Ahora vamos a crear la primera versión de nuestro código en el historial de versiones. Entonces lo primero que tenemos que hacer es configurar Git dentro de esta carpeta que contiene nuestro código. Y para hacer eso, vamos a dar este comando git en él. Y para ejecutar el comando vamos a presionar Enter. Entonces lo que esto hace es que configura entrar en esta carpeta y get ahora está rastreando todos
los archivos de esta carpeta para ver cambios. Entonces el siguiente paso que vamos a hacer es que vamos a ejecutar otro comando llamado git status. Y lo que esto hace es que nos
dice qué cambios se han hecho desde nuestra versión anterior y como no tenemos versión en este momento, sólo
vamos a ver que tenemos algunos archivos nuevos. Entonces sigamos adelante y ejecutemos este comando. Entonces hay muchos textos que salen. Aquí está la parte más importante. Tan bueno, esto nos está diciendo que hay un nuevo archivo llamado config dot JS y una nueva carpeta llamada source que no
están siendo rastreados en nuestro historial de versiones. Y eso es correcto porque en realidad no tenemos una palabra en la historia. Por lo que nuestro siguiente paso es crear nuestra primera versión. Y tuvimos que hacer dos cosas para que esto sucediera. El primero que teníamos que hacer es escoger qué cambios queremos en nuestra próxima versión. Y para hacer eso, vamos a usar este comando, git. Agregar. Git en realidad nos permite escoger qué cambios queremos en nuestra próxima versión. Por lo que en realidad no tenemos que tener ambos en la próxima versión. En realidad solo escogemos ab.js agregándolo así. Damos este comando. Git solo pondrá esto en la próxima versión y esta carpeta fuente quedará fuera. Por otro lado, si doy una carpeta para obtener anuncio, se va a agregar todos los archivos
dentro de la carpeta, incluyendo cualquier subcarpeta. Para nuestro primer ejemplo, solo
agreguemos ambos en la próxima versión. Y un atajo para hacer esto es git add dot. Por lo que el punto en línea de comandos representa la carpeta actual que la línea de comandos la está ejecutando. Y si recuerdas
al principio cuando iniciamos la línea de comandos, cambiamos la carpeta. Esa línea de comandos se está ejecutando en esta carpeta, que es esta carpeta que contiene todo nuestro código. Entonces si digo punto aquí, vamos a agregar todo aquí, incluyendo cualquier subcarpeta. Entonces ese es un buen atajo que puedes usar si quieres agregar todo a la siguiente versión. Y vamos a presionar Enter para ejecutar este comando. Y ahora vamos a
volver a ejecutar git status para verificar que funcionó. Por lo que ahora puedes ver tenemos dos nuevos archivos que están listos para ser puestos en nuestro historial de versiones. Entonces recuerda que git add
en realidad no crea una nueva versión. Simplemente nos deja escoger qué cambios queremos en la próxima versión. Entonces para crear una nueva versión, vamos a usar otro comando GET, que es git, commit, dash m Así que una versión en Git se conoce como commit. medida que avanza este tutorial, voy a estar usando las palabras commit and commit history en lugar del historial de versiones y versiones, solo para ayudarte a familiarizarte con la terminología de Git. Pero por ahora voy a usar la versión sólo porque estamos comparando con la función de historial de versiones de Google Docs. Dash m aquí significa que estamos adjuntando un mensaje a este compromiso. Por lo que siempre quieres adjuntar un mensaje a un commit solo para describir lo
que cambiaste para que cuando estés mirando este commit en el camino, sepas exactamente lo que pasó. Entonces como solo estamos practicando, voy a dar un mensaje de
commit muy sencillo , versión uno. Y para ejecutar este comando, vamos a presionar Enter. Dependiendo de tu computadora, realidad
es posible que recibas un mensaje de error que se ve así, fatal. Entonces esto significa que obtengo está requiriendo que configure un correo electrónico y un nombre para obtener que se
adjuntará a su commit junto con su mensaje de commit. Entonces vamos a explicar justo después de lo que esto significa. Pero para obtener el error de pases, sólo había que ejecutar estos dos comandos. Entonces vas a ejecutar git, config, dash, dash global, user.email. Y luego vas a dar tu e-mail. Y también vamos a configurar nuestro nombre. Entonces Git, config dash, dash global, user.name. Y voy a poner mi nombre y tú puedes poner tu nombre. Y ahora vamos a ejecutar git commit de nuevo. Y eso debería funcionar con éxito. Por lo que se puede ver esto fue una gran cantidad de salida de texto aquí. Vamos a atravesarlo uno por uno. Entonces en esta sección donde
básicamente dices que dos archivos o modificados y había cuatro líneas de código agregadas. Y si nos
fijamos en nuestro código, en realidad sí tenemos cuatro líneas de código. Entonces eso es lo que describe esta sección. Y en esta sección, get es básicamente solo advertirnos que no
hemos configurado un nombre de usuario o un correo electrónico para obtener. Por lo que además tu mensaje que adjuntas a cada commit, también
deseas adjuntar tu nombre y tu correo electrónico. De esa manera en caso de que uno de tus cambios rompa el sitio web, tus compañeros saben a quién culpar. Entonces eso es lo que vamos a hacer a continuación. Y todo lo que teníamos que hacer es en realidad sólo seguir estos comandos. Así Git config dash, dash global, user.name. Entonces voy a poner mi nombre, puedes poner tu nombre. Y Git config dash, dash global, user.email assignment, ese super simple, dot-dot-dot. Entonces ahora que hemos configurado Git, echemos un vistazo a nuestro historial de versiones. Entonces podemos hacer eso usando este comando git log. Entonces esta es nuestra historia de versiones. Se puede ver que sólo tenemos una versión aquí en este momento, que es la que acabamos de crear. Y aquí está nuestro mensaje de compromiso. Aquí está el nombre y el correo electrónico del autor. Por lo que note que configuramos el nombre y el correo electrónico después de crear el commit. Por eso tenemos un nombre predeterminado
y un correo electrónico basado en mi computadora. Y eso es todo. Acabamos de aprender a agregar una nueva versión historia demasiado divergente. Más adelante aprenderemos a ir
y venir entre versiones anteriores de tu código. Pero por ahora, sí quiero mostrarles otra cosa. Entonces digamos que mientras estás creando este commit, cometes un error. Entonces, por ejemplo, escribes mal el mensaje de commit o olvidaste agregar un cambio. Entonces, ¿cómo nos enfrentamos a eso? Entonces vamos a configurar esto y vamos a sumar otro cambio aquí. Cambio. Sí. Y digamos que en realidad queríamos que
este expediente estuviera en nuestro compromiso previo. ¿ Qué hacemos? Entonces de una manera de arreglar esto es solo crear nuestra nueva versión como normal. Entonces vamos a hacer git add de nuevo y git commit dash m versión uno. Por lo que aquí puedes arreglar tu ortografía si cometiste un error ortográfico. Y en lugar de solo darte esto, también
vamos a dar guión, guión. Dash, dash modified significa es que en lugar de crear un nuevo commit, estos cambios sólo van a ir en el commit anterior. Entonces, vamos a presionar Enter para ejecutar este comando. Y ahora vamos a volver a ejecutar git log. Como puedes ver, todavía sólo tenemos una versión en nuestro historial de versiones. Y el archivo extra que creamos se
ha agregado a esa versión. Entonces así es como puedes editar un commit en caso de que lo estropees.
6. Visualización de conceptos de Git y Git: Ahora quiero mostrarte cómo puedes visualizar los cambios que nos hacen rastrear dentro de tu editor de código. Por lo que muchos editores tienen integración de Git es en estos días que te permiten
ver lo que obtienen los cambios está rastreando dentro de tu editor en lugar de solo en la línea de comandos. Entonces te mostraré cómo funciona eso. Por lo que el editor que estoy usando se llama Visual Studio Code. Por lo que podría estar usando un editor de código diferente. Por lo que tienes que comprobar si tu editor soporta la integración de Git. Entonces en el código VS, realidad
podemos visualizar qué cambios
hemos realizado desde la versión anterior. Entonces sigamos adelante y hagamos algunos cambios aquí. Simplemente voy a cambiar esto a la versión dos. Y aquí también, lo voy a cambiar a la versión dos. Entonces ahora si entro en esta sección, este es el apartado que
tenemos nuestros cambios que hicimos para llegar aquí. Entonces esto es lo mismo que ejecutar el status de
git en la línea de comandos, excepto que realmente podemos visualizarlo en nuestro código. Entonces si selecciono uno de estos cambios, realidad
podemos ver qué código hemos cambiado en este archivo y también para este archivo. Por lo que puedes ver que puede ser realmente útil si estás trabajando en una gran característica. Y en lugar de dos archivos aquí tienes como 20 archivos diferentes y puedes ver exactamente qué código cambiaste. Por lo que este editor también nos permite ejecutar algunos comandos de Git para nosotros. Entonces, por ejemplo, si quiero git agregar este archivo, realidad
puedo presionar este botón Plus en lugar de ir
a la línea de comandos y ejecutar git add yo mismo. Si quiero agregar este archivo, solo
tengo que hacer clic aquí en el botón Plus. Y si quiero hacer git add dot, entonces el equivalente es solo hacer clic en este botón aquí. Por lo que hace un poco más fácil ejecutar comandos
git solo desde tu editor de código. Por lo que podría haber notado que cuando ejecutamos git add dot u changes replace en esta área llamada los cambios de etapa. Por lo que a esto se le conoce como área de puesta en escena. Aquí es básicamente donde bueno pone todos los cambios que hemos recogido usando git add que queremos entrar a la siguiente versión, lo contrario podríamos olvidar. Y luego bajo el área de puesta en escena están
todos los cambios en los que estamos trabajando actualmente, pero aún no hemos usado git add. Por lo que a esta área se le llama el área de trabajo. Por lo que todos tus cambios comienzan en el área de trabajo. Entonces hagamos un simple cambio ahora solo para visualizarlo. Por lo que ahora se puede ver que ese cambio inicia cualquier área de trabajo. Y luego cuando ejecute git add, lo va a agregar al área de puesta en escena. Entonces otra cosa que quiero mostrarles sobre el área de puesta en escena es que digamos que seguimos
adelante y modificamos de nuevo este archivo. Así que vamos a entrar en config y vamos a tener otra simple modificación. Guárdalo, volverá. Por lo que notarás que el convicto ab.js ahora está tanto en el área de trabajo como en el área de puesta en escena. Entonces, ¿cómo funciona eso? Entonces la forma en que funciona es que en realidad
rastrean los cambios, no los archivos. A pesar de que nos agregan el archivo config js al área de puesta en escena. El segundo cambio
aún no se ha agregado porque obtiene rastrea fundamentalmente los cambios. Entonces por eso puede aparecer en ambos lugares. Entonces sigamos adelante y sumamos estos dos archivos al área de puesta en escena. Y notarás que en realidad fusiona los dos cambios juntos. Entonces eso es solo algún conocimiento fundacional sobre cómo funciona Git. Vas a estar usando mucho el área de puesta en escena. Por lo que es bastante útil conocer algunos de estos hechos sobre el área de puesta en escena así como el área de trabajo. Entonces lo último que quiero mostrarles sobre estas características es cómo
sacar cambios de nuestra zona de puesta en escena y cómo restablecer nuestra zona de trabajo. Entonces, empecemos primero con la puesta en escena. Por lo que para sacar los cambios del área de puesta en escena, nuestro editor de código podría proporcionar un botón conveniente en su integración de Git. Y mi editor de códigos tiene uno justo aquí. Entonces todo lo que tengo que hacer es hacer clic en este botón y sacará el cambio del área de puesta en escena. Entonces ahora aprendamos también el comando get para hacer esto. El comando para hacer esto es git reset. Reset funciona de la misma manera que ADH. Si le damos un nombre de archivo como reset, config dot js,
solo sacará a ArcJS convicto del área de puesta en escena. Si le damos una carpeta, tomará todos los archivos de la carpeta, incluyendo cualquier subcarpeta, y sacará todo eso del área de puesta en escena. Entonces recuerda, un atajo que podemos usar es git reset dot. Por lo que dot aquí representa nuestra carpeta actual, que es esta carpeta que contiene todo nuestro código. Entonces si sí conseguimos reset dot, sacará todos los cambios del área de puesta en escena. Entonces sigamos adelante y ejecutemos este comando. Por lo que ahora todos nuestros cambios están en el área de trabajo. Y también podemos restablecer los cambios en nuestra zona de trabajo usando otro comando GET. Y ese comando es git, checkout dash, dash. Y esto funciona de la misma manera que git add y git reset. Podemos darle un nombre de archivo, que deshará todos
los cambios a este archivo en el área de trabajo. O podemos darle punto, lo que eliminará todos estos cambios. Entonces, para esta vez, volvamos a nuestro editor de código y usemos la integración de Git para hacer esto. Entonces si hago clic en este botón, esto es lo mismo que hacer. Entonces restablecemos, cambiamos eso. Sí, esto es lo mismo que hacer git, checkout dash, dash, change ab.js. Y si hago clic en el botón aquí arriba, esto es lo mismo que hacer git checkout, dash, dash, dot. Para que puedas ver cómo una integración de Git en tu editor de código realmente puede hacerte la vida más fácil cuando estás trabajando con el bien. Entonces ahora que aprendimos los fundamentos del bien y cómo crear versiones de la historia aborigen. Vamos a seguir adelante y crear las otras características que encontramos en el historial de versiones de Google Docs.
7. Completa nuestro historial de versiones: Ahora vamos a crear
versiones tumorales y añadirlas a nuestro historial de versiones para que más adelante podamos
aprender a volver a una versión anterior de nuestro código. Entonces si quieres algo de práctica, en realidad
puedes pausar el video ahora mismo e intentar crear dos versiones por tu cuenta. Entonces es lo mismo que hicimos cuando creamos nuestra primera versión. Está bien, Así que lo haré ahora mismo por mi código. Entonces lo primero que vamos a hacer es sólo hacer algunos cambios. Y luego escogeremos los cambios que
queremos en nuestra próxima versión. Entonces git add dot. Y luego vamos a crear el commit con un mensaje. Yo sólo voy a llamar a esta versión también, sólo porque estamos practicando. Ahora voy a crear otro commit u otra versión. Al modificar primero el código. Voy a añadir los cambios que hice. Y voy a recoger estos cambios para ponerlo en el próximo compromiso. Entonces solo crea otro commit con git commit. Y ahora si ejecuto git log, verás que ahora tenemos tres versiones en nuestro historial de versiones, y ahora estamos listos para aprender a cambiar entre diferentes versiones. Por lo que podría haber notado que una gran diferencia entre Google Docs y get es que Google Docs crea
automáticamente versiones de su documento para usted. Por lo que de vez en cuando guardará una versión y podrás volver a ella más tarde. Pero olvida sin embargo tenemos que crear nuestras versiones manualmente. Por lo que podría estar preguntándose, ¿por qué
seguimos creando nuestras versiones manualmente? ¿ Por qué no podemos automatizar esto? Entonces el problema con el código es que hasta que
termines tu código, probablemente no funcione. Por lo que realmente no queremos estar creando
automáticamente versiones de nuestro código que no funcionen para Google Docs. Realmente no importa que la cosa esté terminada o no. Es sólo un montón de palabras y oraciones, así que no vas a obtener errores de un documento medio terminado que
no es lo mismo con el código medio terminado. Por eso siempre
creamos versiones manualmente con Git. Quieres asegurarte de que nuestro código sea bueno para ir antes de ponerlo en nuestro historial de versiones.
8. Ver verlas anteriores de nuestro código: en nuestro código, en la de versiones anteriores: Entonces ahora que en realidad tenemos un historial de versiones, vamos a aprender a volver atrás y ver una versión anterior de nuestro código. Entonces el comando get para hacer eso es git checkout. Y ahora tenemos que decirle a Git a
qué versión queremos volver. Entonces digamos que queremos volver
a esta versión, versión dos. Entonces para ayudar a conseguir eso, queremos volver a esta versión. Tenemos que darle esta gran cuerda larga. Por lo que esto se conoce como el hash commit. Es básicamente el ID de este commit o esta versión. Entonces lo que haremos es que vamos a copiar este hash commit y vamos a pegar eso a git checkout. Y eso es todo. Ahora si ejecutamos este comando, volvemos a la versión dos. Entonces si miramos nuestro código, se
puede ver que estamos de vuelta a la versión 2 de nuestro código, y eso es lo más sencillo que se pone. Apenas tuvimos que ejecutar git checkout y
volveremos a una versión anterior de nuestro código. Por lo que los cambios que hicimos son realmente simples. Pero puedes imaginar que si tuviéramos una gran característica donde cambiamos 20 o 30 archivos diferentes, esto es realmente poderoso para cambiar todos esos archivos
de vuelta a su versión anterior. Ahora volvamos a nuestra
línea de comandos y vamos a ejecutar git log para comprobar el estado de la historia original. Entonces como pueden ver, sólo
tenemos dos commits aquí en este momento. Y la razón de eso es que git log solo muestra el commit actual, así
como todos los commits detrás del commit actual, pero no ningún commit delante de él. Entonces para mostrar todos
los commits en nuestro historial de versiones, vamos a hacer git log, dash, dash
o.Y eso te mostrará las tres versiones diferentes que teníamos antes. Por lo que podrías notar que esta palabra cabeza está ahora al lado de la versión dos. Nos desplazamos hasta nuestro historial de versiones anteriores. Vemos que la cabeza solía estar al lado de la versión 3. Entonces esta palabra cabeza aquí, esto nos está diciendo qué versión estamos viendo actualmente. Por lo que en Google Docs, cuando estés viendo una versión anterior, desvío normalmente solo se resaltará. Pero en la línea de comando realmente no podemos resaltar cosas. Entonces por eso usamos esta palabra cabeza para indicar qué versión estamos viendo actualmente. Entonces ahora pongamos un poco más de práctica. Vamos a cambiar a la primera versión que tuvimos en nuestro historial de versiones. Entonces pausa el video si lo quieres hacer tú mismo primero, pero ahora lo voy a hacer juntos. Entonces el comando que necesitamos es git checkout. Y recuerda que necesitamos decirle a git el hash commit al que queremos ir. Entonces vamos a copiar esto y pegarlo aquí. Y luego vamos a ejecutar este comando. Entonces ahora estamos en la versión uno y revisamos nuestro código. Podemos ver que efectivamente nuestro código está de vuelta a la versión uno. Y podemos revisar el otro expediente. Ambos archivos están de vuelta a la versión uno. Y si volvemos atrás y ejecutamos git log dash, dash,
todos, vemos que la cabeza está ahora al lado de nuestra primera versión. Entonces así es como regresas y
ves versiones anteriores de tu código.
9. Restaurar una versión anterior de nuestro código: el código, en nuestro código:: La última característica que vamos a recrear a partir
del historial de versiones de Google Docs es el botón restaurar esta versión que restaurará el documento que vuelve a una versión anterior. Vamos a aprender a hacer esa característica excepto usar kid. Entonces una cosa que podríamos estar tentados a probar es que miraremos nuestro código y nos daremos cuenta de que ya nos
han restaurado de nuevo a lo que era en la Versión 1. Entonces pensamos, Oh, teníamos que hacer es empezar a
modificarlo y crear nuevas versiones como de costumbre. Entonces vamos a probar eso y ver qué pasa. Entonces voy a hacer una sencilla actualización aquí. Y luego voy a hacer el habitual git add y luego crear un nuevo commit encima de la versión uno commit, va a llamar a esta virgen actualizada. Y ahora si ejecutamos git log dash, dash all, vemos que todo parece estar funcionando bien. Tenemos nuestra antigua versión 3 commit aquí, y ahora tenemos esta nueva versión uno actualizada en la parte superior. Y éste fue construido a partir de éste. Entonces restauramos nuestro código de vuelta a la versión uno y luego reiniciamos desde la versión uno. Desafortunadamente, esto no es exactamente lo que queremos. Entonces la forma en que funciona es que si vuelves a una versión anterior, comienzas a agregar nuevas versiones encima de esa versión anterior, notarás que las buenas historias van a empezar a ramificarse de esa versión anterior. Y esta es otra forma en que funciona en la historia de versiones de Google Docs. Google Docs básicamente toma lo que fuera tu documento en ese momento y solo
lo copia al documento actual. Entonces esto no es exactamente lo que queremos. Ahora sí quiero mostrarte cómo puedes ver el efecto de ramificación en tu línea de comandos y lo haces con otro comando. Entonces lo primero que notas es que ya no estamos en la línea de comandos porque el git log es demasiado largo. Y así si intentas escribir un comando aquí, no funcionará. Entonces la salida fuera de esta vista, vamos a presionar Q para dejar de fumar. Y ahora vamos a conseguir run git log de nuevo. Excepto en esta ocasión vamos a añadir guión, guión gráfico. Entonces si agregas un guión, el gráfico de guión va a empezar a
mostrarte el efecto de ramificación en tu historial de versiones. Entonces vamos a ejecutar este comando. Y ahora puedes ver tenemos dos ramas de commits. Entonces está aquí la primera sucursal, que es lo que teníamos antes. Y ahora tenemos la segunda rama, que se construye a partir de nuestra primera versión. Entonces esto es lo que sucede cuando simplemente regresas a la versión anterior y luego
comienzas a construir fuera de esa versión. Pero por ahora mismo, ya que estamos tratando recrear la historia escrita de Google Docs, esto no es exactamente lo que queremos. Entonces dejemos de lado esta vista presionando Q. Y vamos a aprender el comando real por hacer exactamente lo mismo que hace Google Docs. Lo primero que vamos a hacer es
volver a la rama anterior o commits, que está aquí. Por lo que notarás que este commit también tiene una palabra al lado, menos llamada Maestro, dependiendo de la versión de Git que tengas, también podría llamarse main. Por lo que a esto se le conoce como nombre de sucursal. Y el nombre de la marca nos ayuda de dos maneras. El primer camino es que hace que sea realmente fácil cambiar a otro commit. Entonces en lugar de hacer git checkout y copiar pegar este hash de
compromiso largo e intentar recordarlo, solo
podemos hacer git checkout master. Y lo segundo con lo que nos
ayuda un nombre de sucursal es que siempre apunta al último commit en la sucursal. Entonces si agrego otro comprometido, esta rama aquí arriba, Maestro apuntará a ese compromiso. Por lo que esta es una manera fácil de cambiar
al último commit en cualquier rama dada. Por lo que aprenderemos más sobre las sucursales más adelante como dije. Pero por ahora, solo debes saber que puedes git checkout a un nombre de sucursal en lugar de solo git checkout el hash commit. Entonces ejecutemos esto y volvamos a nuestra rama anterior. Y ahora si ejecutamos git log dash, dash, dash, dash graph, se puede ver que ahora estamos vuelta a nuestra rama principal de commits que teníamos antes. Ahora sigamos recreando esa función de
la versión de restauración de Google Docs. Entonces, en realidad hay un buen mando para hacer esto. Y ese comando es git checkout. Y tenemos que hablar conseguir dos cosas. El primero que tuvimos que decirle a los niños es de
qué versión queremos restaurar. Entonces digamos que queremos restaurar a partir de la versión 1. Vamos a tomar este hash commit, copiarlo, y pegarlo aquí. Y lo segundo que vamos a ayudar a conseguir es qué archivos queremos restaurar. Por lo que esto funciona de la misma manera que git add y git reset. Podemos dar un archivo individual como este, config dot js. Y restaurará el contenido de
config.xml de nuevo a lo que era en la versión uno. Sin hacer ningún tipo de ramificación o mover la cabeza de nuevo a la Versión 1. Entonces así funciona. Entonces recuerda, olvídate de anuncio. También puedes darle un nombre de carpeta. También podemos hacer lo mismo aquí. Entonces si hacemos git checkout hash y luego source, restaurará todos los archivos de la carpeta fuente, incluyendo cualquier subcarpeta, nuevo a su contenido en esta versión. Entonces recuerda que también podemos hacer punto y esto restaurará todo el código de esta carpeta. Entonces hagámoslo. Vamos a presionar Enter para ejecutar este comando. Y ahora ves que config dot js está de vuelta a lo que era en la versión 1 y index.js está de vuelta a lo que era en la versión uno. Y si ejecutamos git log graph para ver el historial de versiones de IR, notarás que head no se ha movido de nuevo a la Versión 1. Entonces si agregamos otro compromiso a esto, no
va a empezar a ramificar nuestro historial de versiones como teníamos antes. Entonces así es como funciona la función de la versión de
restauración de Google Docs . Simplemente estamos tomando el contenido de la versión anterior y luego poniéndolo y pegándolo en la versión actual. Y este es el comando GET equivalente por hacer eso. Ahora completemos este ejercicio agregando estos cambios a nuestro historial de versiones. Entonces primero, vamos a ejecutar el estado despejado. Y notan que cuando hacemos git checkout para restaurar el contenido del archivo a la versión anterior. En realidad
lo agrega automáticamente en el área de puesta en escena para nosotros. Entonces todo lo que teníamos que hacer es git commit, dash m y dar nuestro mensaje de commit como siempre. Entonces voy a llamarlo versión uno restaurada. Y ahora vamos a hacer git log graph solo para asegurarnos de que no tengamos ninguna ramificación sucediendo. Y ahí tienes. Es así como recreamos la función restore virgin a partir de la historia de Google Docs.
10. Características extra Git: Entonces solo quiero decir felicitaciones porque acabamos de recrear la función de historial de versiones de Google Docs y Microsoft Word usando Git. Y ahora que hemos terminado de comparar consigue con historial de versiones de
Google Docs para el resto de este tutorial, voy a estar usando las palabras commit and commit history solo para ayudarte a
familiarizarte con el Git terminología. Por lo que terminamos el proyecto principal de recrear la historia de versiones de Google Docs usando el bien. Entonces ahora te voy a mostrar algunas características misceláneas son buenas que te resultarán útiles. Entonces la primera característica que
te voy a mostrar es como atajos. Entonces, en lugar de escribir el status de git, en su lugar puedo escribir git como un, TI hará lo mismo. Entonces esto se llama alias y configuras un alias. Aquí está el comando get, git, config, dash, dash, global, alias dot. Y luego vas a dar el tipo de atajo y quieres usar, así que voy a usar el atajo S. Y luego voy a usar el comando completo aquí para decirle a git qué debe representar. Por lo que S se va a presentar por estatus. Así que la próxima vez cuando escriba Git, git realmente va a ejecutar el status de git. Entonces esa es solo una forma de ahorrarte algo de mecanografía y de
hacer que las cosas vayan más rápido cuando estés trabajando con el bien. Por lo que compartiré con ustedes algunos de los alias y uso. Uno de ellos es Git, config
dash, dash global, alias dot cm. Y uso esto para representar commit dash m. y otro es útil es Git config dash,
dash global, alias adagio, y uso eso para aguantar el checkout. Entonces ahora en lugar de hacer git commit dash m, solo
puedo hacer conseguir cm. Entonces si alguna vez necesitas usar los alias que uso o crear los tuyos propios. Entonces la segunda característica extra que quiero
mostrarte es cómo ignorar ciertos archivos de ser agregados a tu historial de versiones. Por lo que esto suele suceder si tienes un archivo como secret dot EXE. Y dentro de este archivo hay un montón de información
sensible y tal vez algunas contraseñas. Y realmente no quieres poner esto en tu historial de versiones porque se salvará para siempre. Entonces lo que puedes hacer es realmente puedes agregar un nuevo archivo llamado dot git ignore. Y esto le va a decir a Git qué archivos
quieres ignorar y no agregar al historial de versiones. Entonces vamos a poner secretos dot TXT en este archivo. Y luego cuando ejecutamos un status git, se
puede ver que porque tenemos un punto gitignore y dentro especificamos queremos ignorar este archivo. Get no está rastreando este archivo en busca de cambios. No lo va a agregar a nuestro historial de versiones. Por lo que este archivo de ignorar punto es en realidad un archivo que debes agregarlo a tu historial de versiones. Entonces lo vamos a agregar ahora mismo. Git, add git, commit, dash m, add git, ignore. Y eso es todo. Es así como evitas que Git rastree
ciertos archivos y se agreguen a tu historial de versiones. Por lo que la tercera y última característica extra que
te voy a mostrar es cómo eliminar por completo obtener de tu producto. Entonces, en primer lugar, vamos a crear una copia de nuestro proyecto porque lo necesitaremos más adelante. Y no queremos quitar get ahora mismo. Entonces vamos a pegar eso. Y yo sólo estoy un poco llamado a este buen tutorial dash dos. Y ahora vamos a abrir una nueva línea de comandos y asegurarnos de
que cambies directorio a esta carpeta que contiene una copia de todo su código. Goryeo dos. Y volvamos a ejecutar git log solo para
asegurarnos de que obtengo sigue en la copia de nuestra carpeta. Eso es bueno. Entonces para salir de esto, vamos a presionar Q para dejar de fumar. Y ahora para quitar get de este proyecto, todo lo que tenemos que hacer es dar este comando RM dash R, F dot. Por lo que todos los datos en aún incluyendo todos nuestros comandos son cambios en nuestro historial de versiones se guarda en una carpeta llamada dot get. Y si solo eliminamos esta carpeta, entonces eliminaremos get de nuestro proyecto. Y este comando RM RF básicamente elimina esta carpeta y todo lo que hay dentro de esta carpeta. Entonces sigamos adelante y ejecutemos este comando. Y ahora sigamos adelante y volvamos a ejecutar git log. Y ves que esto ya no es un repositorio de Git. Por lo que un repositorio solo significa una carpeta que está siendo rastreada por Git. Y así es como eliminaste aún por completo de tu proyecto. Gracias por ver. Reclutamos con éxito buena función de historial de versiones oxy para nuestro código usando Git.