Curso sacado de: https://www.youtube.com/watch?

v=VdGzPZ31ts8

Git es un sistema de control de versiones, es la herramienta que nos permite a nosotros poder
tener un historial completo de todo el código que hemos desarrollado sobre nuestra
aplicación. supongamos que tenemos un código que se encuentra escrito en html este código
es nuestro código inicial no le hemos realizado absolutamente ningún cambio y vamos a decir
que este es la versión 1,0 luego decidimos realizar un cambio creamos una nueva
funcionalidad por ende esta ya no es la versión 1,0 sino que es la versión 1,1.

Git trabaja de manera descentralizada lo que significa que cada uno de estos desarrolladores
tiene una copia completa del código que se está trabajando(en su pc) y los desarrolladores
tienen la opción de que los cambios que ellos realizan sobre estos archivos luego poder
subirlos a un servidor central y de esta manera sincronizar los cambios entre absolutamente
todos los desarrolladores. Git nos va a entregar un historial de todo el trabajo que hemos
realizado sobre nuestro código y también el historial que otros desarrolladores han realizado
sobre un código en particular. No va a ser necesario que nosotros tengamos que empezar a
compartir los distintos cambios que le estamos haciendo los distintos archivos git se va a
encargar de solucionar ese problema por nosotros y también algo muy importante que se
menciona muy poco de git, y que es algo sumamente útil es que nos permite a nosotros saber
cuándo se introdujo un error en una aplicación, cuando encontramos un error en producción
nosotros podemos empezar a volver atrás dentro de nuestro historial para ver qué commit fue
el que introdujo cierto error, y de esta manera así nosotros podemos reducir la cantidad de
código que nosotros debemos revisar para poder dar con dicho error.

Los comandos de git en este momento como pueden ver el limpiado mi terminal para que ésta
se encuentra completamente en blanco y aquí nosotros vamos a empezar a trabajar con
nuestros primeros comandos el primer comando que nosotros vamos a ejecutar es el de:

ls nosotros lo vamos a utilizar para poder listar todos nuestros archivos directorios y carpetas

pwd de lo vamos a utilizar para saber dónde nos encontramos.

cd para poder ingresar a directorios

cd .. para poder salir de un directorio.

Directorio= carpeta

Para crear una carpeta nueva vamos a escribir lo siguiente mkdir nombredelanuecacarpeta
(todo con minusculas)

Iniciar un proyecto que vamos a gestionar tenemos que escribir git init y aquí nos va a indicar
que inicializado un repositorio en git completamente vacío. El .git es para indicar que ese
directorio se encuentra oculto para verlo tenemos que escribir ls -a mostrara absolutamente
todo incluido los directorios y archivos que se encuentren ocultos aunque en este caso lo único
que se encuentra oculto es el directorio de git . Ejecutaando nuevamente el comando de ls -a
podemos ver aparecen todos los archivos que se utilizan en git para poder gestionar nuestros
proyectos esto es un detalle de implementación aquí es donde se van a almacenar las distintas
versiones de nuestro código las distintas ramas los comités absolutamente todo. Ejemplo:
Vamos a ver el flujo de trabajo que nosotros debemos seguir cuando nos encontremos

Git push
Git add Git commit

trabajando con git: lo

primero que nosotros vamos a ver es que cuando nos encontremos trabajando en el
computador aquí nosotros vamos a poder empezar a agregar y también modificar todos los
archivos que nosotros queramos pero por el simple hecho de modificar agregar o eliminar
archivos en nuestro computador eso no quiere decir que estos se vayan a agregar
inmediatamente a un repositorio para ello nosotros vamos a tener que ejecutar un comando el
cual se llama git pero eso lo vamos a ver más adelante cuando nosotros ejecutamos este
comando de git lo que haremos será seleccionar los archivos que nosotros queramos pasar a
una etapa que se llama stage cuando nosotros todos estos archivos que queremos a pasar a
esta etapa de stage lo que estamos haciendo es poder verificar todos los cambios que nosotros
queremos eventualmente pasar a nuestro repositorio cuando nos encontramos en la etapa de
stage no necesariamente quiere decir que esto se va a ver reflejado en el repositorio esto es
solamente una etapa intermedia para que nosotros podamos indicar cuáles son los cambios
que nosotros efectuamos para que éstos pasen al repositorio esto es importante no pasan
todos solamente los cambios que nosotros seleccionemos una vez de que nosotros hayamos
revisado nuestra etapa de stage van a existir momentos donde nosotros quizás no vamos a
querer pasar estos cambios a nuestro repositorio por lo que nosotros vamos a poder sacar
estos elementos de esta etapa de stage pero supongamos que nosotros ya tenemos
absolutamente todos todos todos los archivos y todos los cambios que nosotros queremos
comprometer y eventualmente pasar a nuestro repositorio en ese caso nosotros vamos a
poder ejecutar otro comando el cual es el de git commit lo mismo vamos a verlo más adelante
lo importante es entender primero este proceso luego cuando nosotros efectuamos git
commit vamos a pasar estos archivos y los vamos a dejar aquí en esta nueva etapa la cual se
llama los archivos de cómic y ahora nosotros podemos eliminar esto que se encuentra aquí
dentro de stage una vez que nosotros ya hemos realizado esto donde pasamos nuestros
cambios seleccionamos los cambios que nosotros queríamos comprometer luego
comprometemos nuestros cambios con commit viene una última etapa la cual es opcional
pero opcional entre comillas porque siempre cuando ustedes estén trabajando con git van a
terminar en este paso y es los cambios que nosotros hayamos comprometido vamos a poder
pasarlos a un servidor que se encuentra en la nube por lo general va a ser dentro de git jap
puede ser también dentro de bit baquet o incluso también dentro de otros servicios que
permitan almacenar estos códigos y esto finalmente vendría siendo el flujo de trabajo que se
sigue con guita ahora podría ocurrir que nosotros por alguna razón vayamos a eliminar un
archivo en el caso que nosotros eliminemos un archivo debemos ejecutar el mismo comando
contra ese archivo el cual es el de git de esta manera a esta etapa de stage vamos a agregar un
archivo que nosotros hemos eliminado esto puede sonar un poco extraño pero esto es
importante para mantener el registro de todo el trabajo que nosotros estamos realizando
luego de que nosotros agregamos este cambio finalmente también lo podemos comprometer
y luego pasar finalmente al servidor donde este archivo va a ser eliminado del repositorio aquí
nos encontramos nuevamente de regreso en nuestra terminal y lo que haremos será abrir
nuestro editor de texto para poder empezar a realizar modificaciones a nuestro proyecto y así
empezar a trabajar con git para eso nosotros vamos a escribir code espacio punto el punto
quiere decir quiero que abras la carpeta en la cual yo me encuentro y aquí como pueden ver
aparece el nombre de la carpeta el cual es mi web lo primero que vamos a hacer es agregar un
nuevo archivo el cual se va a llamar archivo 1 punto y aquí podemos darle la extensión que
nosotros queramos puede ser un archivo de javascript puede ser un archivo css puede ser un
archivo html todo lo que ustedes quieran puede ser seguido por git pero en este caso yo
sencillamente voy a indicar que es un archivo de texto y una vez acá dentro de este archivo de
texto voy e indicarle el mensaje de mi primer programa que no es el mundo puesto que
pensaba que era ahora mundo no es chanchito feliz ahora vamos a guardar y podemos
devolvernos aquí a nuestra terminal y una vez aquí en de regreso en nuestra terminal vamos a
escribir git status get status lo que hace es mostrarnos el estado actual de nuestro repositorio
como pueden ver aquí nos está indicando que todavía no existe absolutamente ningún comité
y que también se encuentran ántrax files ántrax files quiere decir que son archivos los cuales
git no está siguiendo por defecto git nos sigue todos los archivos que nosotros coloquemos
dentro de nuestro proyecto nosotros tenemos que ir a seleccionarlos y para seleccionarlos
nosotros lo vamos a hacer con el comando de git así es que vamos a escribir kit up espacio y
aquí el último argumento que recibe esta función son de varias formas podemos colocar
primero el nombre del archivo el cual va a ser archivo uno punto txt podemos colocar también
alguna expresión regular como por ejemplo asterisco punto de xtb eso lo que hará será
agregar absolutamente todos los archivos que tengan una extensión txt o también podemos
utilizar el punto el punto lo que hará será agregar absolutamente los archivos que aparezcan
dentro de este listado o que cuando nosotros escribamos kits status aparezcan marcados en
rojo esto es una mala práctica y la razón por la cual es considerado una mala práctica es
porque a nosotros se nos podría haber olvidado que estuvimos quizás modificando otros
archivos que nosotros no queremos incluir o podría ser también que se encuentren archivos
binarios muy grandes como imágenes o ejecutables o cualquier tipo de cosa que no queramos
subir al repositorio porque van a hacer que nuestro repositorio sea cada vez más grande de
manera completamente innecesaria por eso nosotros el punto no lo vamos a utilizar
solamente contadas ocasiones donde la cantidad de código que hayamos escrito estemos
100% seguro que es código útil que nosotros queramos comprometer pero acá nosotros
vamos a utilizar git az y los nombres de los archivos que queramos agregar a nuestra etapa de
stage aquí vamos a presionar enter y vamos a describir nuevamente git status para ver el
estado de nuestra aplicación aquí como podemos ver nos está indicando que seguimos en la
rama mein ya vamos a llegar a ese punto que no tenemos absolutamente ningún comité y
también que se encuentran cambios ya listos para ser comprometidos todo esto que se
encuentre acá en texto verde son archivos que se encuentran en una etapa de stage o sea
estos están listos para ser comprometidos pero nosotros aún no lo vamos a comprometer lo
que haremos será crear otro archivo el cual se va a llamar archivo 2 para eso nos vamos a
devolver a nuestro editor y aquí vamos a agregar un nuevo archivo que se va a llamar archivo 2
punto de x t y aquí nosotros en lugar de colocar a chanchito félix vamos a colocar a chanchito
triste nos vamos a devolver aquí a nuestra terminal vamos a limpiarla y vamos a escribir
nuevamente git status esto lo que hace es que nos muestran nuevamente el archivo 1 el cual
se encuentra en nuestra etapa de stage pero sin embargo el archivo 2 todavía no está siendo
seguido porque así es que lo que haremos será agregarlo para eso vamos a escribir archivo 2
punto de x d en el caso que nosotros quisiéramos agregar más de un archivo a nuestra etapa
de stage lo que podemos hacer es escribir git de espacio y aquí los nombres de los archivos
separados por un espacio o sea si yo quisiera agregar archivo 1 y también archivo 2 tengo que
escribir archivo 1 punto txt espacio archivo 2 punto de x d vamos a escribir nuevamente git
status para ver qué es lo que nos está mostrando ahora podemos ver que se encuentran dos
archivos agregados a nuestra etapa de stage pero quiero que veamos algo en particular qué es
lo que ocurre si nosotros realizamos una modificación en archivo 2 por ejemplo así que me voy
a devolver aquí a visual studio code y aquí en archivo 2 en lugar de colocar a chanchito triste
luego voy a cambiar por chanchito feliz porque no me gusta tener 32 tristes solamente me
gusta tener tránsitos felices ahora de que guarde me voy a devolver nuevamente aquí a mi
terminal y vamos a escribir nuevamente git status y aquí está pasando algo sumamente
interesante como pueden verse en cuenta archivo 1 y archivo dos agregados a nuestra etapa
de stage pero también nos está indicando de que existen cambios los cuales no se encuentran
en una etapa de stage y estos cambios se refieren a los de archivo 2 que estaba ocurriendo los
cambios que se encuentran dentro de esta etapa de stage con respecto a archivo 2 son los
cambios cuando archivo 2 contenía el texto de chanchito triste si nosotros comprometemos
esto se va a comprometer que archivo dos tiene el texto de chanchito triste si nosotros
queremos reemplazar ese cambio tenemos que necesariamente volver a agregar archivo 2 y
eso es lo que nosotros vamos a hacer ahora vamos a hacer get up archivo 2 y aquí nosotros
podemos autocompletar el nombre del archivo utilizando la tecla de tab presionamos enter
volvemos a escribir git status y aquí podemos ver el estado completo de nuestra etapa de
stage de esta manera nosotros podemos tomar archivos a los cuales les hemos realizado
cambios y pasarlos a una etapa de stage pero ojo con esto lo que estamos pasando a la etapa
de stage no son los archivos mismos sino que son las modificaciones que hemos realizado
sobre estos archivos ahora da la coincidencia de que hemos creado un nuevo archivo con
cambios pero una vez que nosotros comprometamos esto vamos a ver que después cuando
volvamos a realizar un cambio sobre por ejemplo archivo 1 vamos a poder seguir agregando
cambios a esta etapa de stage pero no el archivo sino que los cambios en este momento
nosotros ya estamos preparados para poder comprometer nuestro trabajo estoy diciendo
comprometer de la palabra en inglés commit para que nosotros podamos comprometer
nuestro trabajo existen principalmente dos formas la primera y la reforma recomendada que
nosotros vamos a seguir en el transcurso de este curso es utilizando el comando de git commit
espacio - m espacio colocamos dos comillas dobles y acá adentro nosotros tenemos que
colocar un mensaje que tenga sentido de nada sirve que nosotros coloquemos un punto que
coloquemos lala o arregle un back nosotros tenemos que decir algo que haga sentido en este
caso es un comité inicial y esto es solamente por propósito del curso voy a colocar commit
inicial ya que nosotros vamos a presionar enter en este caso nuestros cambios han sido
comprometidos o sean cómic creado aunque esa palabra no existe pero ahora vamos a escribir
git status para ver qué es lo que ocurrió ahora podemos ver que seguimos en nuestra rama de
main pero que ya no se encuentra absolutamente nada disponible para poder hacer un comité
lo que nosotros haremos ahora será volver a nuestro editor de texto vamos a realizar un
cambio y ahora vamos a hacer un comité pero de la forma alternativa volvemos aquí a nuestro
editor de texto y aquí en nuestro archivo 2 vamos a presionar enter y vamos a colocar otro
chanchito feliz de esta manera vamos a tener 2 chanchitos felices en este archivo nos
devolvemos y ahora vamos a escribir nuevamente git status vemos que nuestro archivo 2 ha
sido modificado así que nosotros vamos a proceder ahora a agregar lo luego de eso volvemos a
escribir status para ver que este se encuentra en la tapa de stage y ahora podemos volver a
realizar un comité vamos a escribir git commit pero ahora nosotros en lugar de escribir menos
m y el comentario vamos a presionar enter inmediatamente y fíjense en qué es lo que va a
ocurrir en este momento nos ha abierto nuestro editor de texto que teníamos configurado que
en este caso es bs code y abrió de ese code porque ese es el editor de texto que nosotros
configuramos en la sección de configurar git aquí nosotros podemos ver que nos está
indicando cuál es el archivo que ha sido modificado y al comienzo nosotros podemos indicar
cuál va a ser el mensaje que nosotros queremos agregar en este comité para eso nosotros
tenemos que escribir agregando un chanchito feliz y esta parte es sumamente importante acá
nosotros tenemos guardar y luego ahora debemos cerrar esto ahora si nos podemos devolver
a nuestra terminal y vamos a ver que ahora se agregó el texto de agregando un chanchito feliz
nos indica one file change y una inserción volvemos a escribir git status y podemos ver ahora
que ya no se encuentra absolutamente nada disponible para hacerle committee vamos a
continuar ahora eliminando archivos dentro de nuestro repositorio para eso nosotros vamos a
hacer un listado de los elementos que se encuentran dentro de nuestra carpeta con el
comando de ls y vamos a ver qué tenemos archivo 1 y archivo 2 aquí en este momento
nosotros vamos a eliminar archivo 2 para eso vamos a escribir rm espacio archivo 2 y
rellenamos con la tecla de tab y vamos a presionar enter luego de esto vamos a escribir git
status y vamos a ver que ahora nos ha aparecido en el texto rojo archivo 2 punto te quisiste y
esto significa que son cambios que nosotros hemos realizado que no se encuentran en la etapa
de stage así que lo que haremos será agregar este cambio a la etapa de stage para eso
tenemos que escribir archivo 2 de x de aquí nosotros vamos a presionar enter y vamos a
escribir nuevamente git status para ver qué es lo que estaba ocurriendo ahora nos está
mostrando que tenemos la acción de eliminar el archivo dos puntos de xp y que éste se
encuentra dentro de nuestra etapa de stage ahora lo que haremos será realizar un comité de
este cambio así que escribiremos git commit - m y dentro de las comillas dobles colocaré
eliminando archivo 2 presionamos enter y ahora vemos que el cambio ha sido comprometido
voy a escribir beats status nuevamente y vemos ahora que este archivo ya no se encuentra
listado ya sea en la tabla de staying o que no se haya agregado a nuestra etapa de stage vamos
a escribir nuevamente ls y vemos que efectivamente este archivo ha sido eliminado con éxito
este paso que nosotros estamos realizando de eliminar el archivo y luego agregarlo staging es
algo la verdad es que un poco repetitivo afortunadamente git tiene un comando que nos
permite ahorrarnos un paso y ese es git espacio rm espacio en el nombre del archivo que en
este caso va a ser archivo 1 ahora con estos 5 segundos la verdad es que no sé qué es lo que
vas a hacer con los que estás ahorrando con solamente escribir un comando pero supongamos
que vas a hacer algo productivo con ese tiempo aquí podemos ver de que el archivo 2 se
encuentra inmediatamente disponible y listo para ser comido o comprometido si nosotros por
alguna razón quisiéramos sacar algún cambio que nosotros hayamos pasado a la etapa de
stage para eso nosotros podemos utilizar este comando que nos está indicando acá el cual es
el de git restore - - stage ya que nosotros escribimos archivo 1 punto txt voy a presionar enter
y vamos a describir bits status nuevamente y vemos ahora de que este archivo ya no se
encuentra dentro de nuestra etapa de stage ahora qué es lo que pasaría si yo quisiera
descartar los cambios ya que si que yo escribo ahora ls voy a ver que el archivo 10 fue
eliminado pero a mí me gustaría poder recuperar ese archivo para eso nosotros podemos
utilizar este comando que aparece acá así que ese es el comando que nosotros vamos a utilizar
ahora git restore espacio archivo 1 punto txt vamos a nuevamente git status vemos que
nuestros cambios se encuentran completamente limpios voy a escribir ls lo voy a ejecutar y
vemos ahora que nuestro archivo uno se encuentra acá eliminamos un archivo pero luego
utilizando git pudimos recuperar ese archivo que habíamos eliminado incluso desde una etapa
antes de hacer commit ahora vamos a ver cómo podemos mover un archivo o cambiar el
nombre vamos a escribir ls nuevamente y vemos que todavía aquí tenemos nuestro archivo 1
punto txt este archivo la verdad es que es un único archivo así que vamos a cambiar su nombre
por archivo punto txt así que para eso vamos a escribir mb mbs el comando para poder mover
archivos y le tenemos que indicar cuál es el origen en este caso va a ser archivo 1 punto txt el
siguiente argumento que recibe esta función de mb vendría siendo el destino o sea cuál va a
ser el nombre final que va a tener este archivo y yo voy a escribir archivo punto presionó enter
y ahora voy a escribir ls para ver que esto se ha cambiado con éxito como podemos ver ahora
solamente sale archivo punto txt vamos a escribir ahora git status y vemos ahora que tenemos
dos cambios el primero fue el de eliminar archivo uno punto txt y el segundo es que se ha
creado un nuevo archivo que en este caso se llama archivo punto txt el cual git no lo está
siguiendo así es que lo que tenemos que hacer en este caso es agregar archivo uno y también
tenemos que agregar archivo para eso vamos a escribir git archivo uno espacio archivo punto
txt y ahora vamos a presionar enter escribimos nuevamente quit status y vemos ahora que nos
aparece ahora esta acción de reading lo que quiere decir es que el archivo 1 ha cambiado de
nombre a archivo punto txt ahora si podemos comprometer nuestros cambios con git commit -
m comillas dobles renombrando archivo y le damos a enter de esta manera nosotros podemos
renombrar nuestros archivos enguita por supuesto que git viene con una herramienta para
que nosotros podamos renombrar y también agregar inmediatamente a este gene nuestros
cambios en este caso el comando es el de git mb y aquí tenemos que indicar el nombre del
archivo el cual es archivo punto txt y lo vamos a volver a llamar archivo 1 punto txt
presionamos enter escribimos quit status y vemos ahora que este cambio ya se encuentra
agregado inmediatamente stage así que ahora podemos escribir git commit - m devolviendo el
nombre del archivo vamos a ver ahora cómo podemos ignorar archivos para que estos no sean
incluidos nunca en nuestros repositorios de git esto se hace más que nada porque a veces
vamos a querer tener archivos de configuración que sean específicos solamente para nuestra
máquina como por ejemplo podrían ser variables de entorno supongamos que nosotros
estamos trabajando con una base de datos y esa base de datos nosotros la vamos a tener
instalada en local y esto para que nosotros podamos estar trabajando con un ambiente de
desarrollo en ese caso los usuarios contraseñas y cualquier otro tipo de acceso va a ser
completamente diferente al de producción en este caso nosotros queremos tener ese archivo
almacenado dentro de nuestra máquina pero que éste no se suba por algún error al
repositorio ya que no queremos que otras personas conozcan nuestra contraseña y además
más importante queremos que esto sea configurable de manera que cuando la aplicación se
despliegue a producción solamente una persona tenga acceso a esas variables de entorno las
cuales servirán para configurar la aplicación y que ésta se conecte finalmente con la base de
datos de producción volvamos a la parte nuestra supongamos que nosotros queremos colocar
algunas variables de configuración en este caso lo que voy a hacer ahora yo es sencillamente
abrir nuevamente de ese code voy a cerrar esto porque ya no tenemos ese archivo y voy a
cerrar también esta pestaña y voy a crear un nuevo archivo el cual se va a llamar punto n vea
que este es un nombre bastante estándar para variables de entorno aquí lo que yo voy a hacer
es escribir por ejemplo password y esto va a ser igual a 1 2 3 4 5 6 voy a querer también
agregar un looser y en este caso el usuario va a hacer nicolás y voy a suponer que mi aplicación
se va a conectar a una base de datos mysql utilizando ambas variables ahora si es que yo me
devuelvo a la terminal y escribo status voy a ver que aparece este archivo de punto mb y yo no
quiero por algún error llegar a comprometer este archivo o llegar a comité arlo para eso yo me
voy a devolver nuevamente aquí a visual studio code y lo que desea crear un nuevo archivo el
cual se va a llamar punto hit ignore y le voy a dar enter aquí es donde yo tengo que especificar
cuáles son los archivos o también cuáles son las rutas que yo quiero ignorar y que éstas no
vayan a mi repositorio en este caso yo le voy a indicar que quiero ignorar el archivo en b pero
nosotros también podemos indicarle carpetas por ejemplo si nosotros estuviésemos
trabajando con no podemos indicar acá la carpeta de naut modules y en este caso también se
va a ignorar esa carpeta además del archivo punto nb ahora podemos devolvernos aquí a
nuestra terminal y vamos a escribir nuevamente git estatus como pueden ver el archivo de
punto n ya no aparece pero si aparece nuestro archivo de git ignore en este caso lo que
haremos ahora será agregar nuestro archivo de git ignore y lo vamos a comprometer
inmediatamente archivo git ignore voy a aprovechar este mismo momento para poder
mostrarles un tip bastante útil al momento de ver el estado en git nosotros hasta ahora hemos
estado viendo el comando de git status pero este la verdad es que es bastante verboso y nos
muestra mucha más información de la que nosotros necesitamos por lo que ahora yo les voy a
mostrar una alternativa que es bastante más elegante y bastante más fácil de seguir una vez
que ya te acostumbraste a trabajar con git para eso nos vamos a devolver a nuestro editor de
texto y vamos a empezar a realizar modificaciones vamos a realizar una modificación aquí en
nuestro git ignore vamos a eliminar nou de módulos porque no lo necesitamos y vamos a venir
aquí a archivo 1 y vamos a agregar otro chanchito feliz además de eso vamos a volver a crear
un archivo que se va a llamar archivo dos punto t xd y este va a tener también otro chanchito
feliz guardamos y ahora nos vamos a devolver acá voy a limpiar mi terminal y voy a escribir
nuevamente git status como pueden ver aquí nos está entregando mucha información nos
está entregando en qué rama nos encontramos los cambios que no se encuentran todavía en
stage algunos cambios a los cuales todavía no se han agregado para que git les pueda hacer
seguimiento y también unos comandos de ejemplo que nosotros podemos ejecutar en el caso
que queramos hacer alguna determinada acción en este caso vamos a suponer que nosotros
ya sabemos absolutamente todo así que lo que vamos a hacer es escribir git status espacio
menos ese y fíjense en cómo aparece todo esto fíjese que el primer archivo el de ignorar
contiene una m esto quiere decir que este es un archivo que ha sido modificado así que yo
escribo git y agregó mi archivo de git y ignore cuando vuelva a ejecutar status vamos a ver
ahora que este ha cambiado de rojo a verde lo que quiere decir que este se ha agregado a la
etapa de stage también tenemos lo mismo con archivo 1 y con archivo dos nosotros vemos
que contiene de interrogación esos símbolos de interrogación quieren decir que este archivo 2
todavía no ha sido agregado para que le pueda hacer seguimiento vamos a agregar archivo 2 y
vamos a volver a ejecutar status s pero antes voy a limpiar la terminal y aquí podemos ver
ahora que nos aparece una a al lado de archivo 2 esto quiere decir que nosotros estamos
agregando este archivo vamos a aprovechar también de agregar archivo 1 y vamos a volver a
ejecutar status cc y ahora podemos ver de que estos tres archivos se encuentran marcados con
sus respectivas acciones pero que estos también contienen el color verde lo cual nos indica
que esto ya se encuentra listo para comprometer así que vamos a escribir el commit - m
mostrando estatus corto ahora veremos cómo podemos ver los cambios que hemos realizado
pero de una manera un poco más visual para eso nosotros nos vamos a ir a nuestro editor de
texto nuevamente y aquí donde nosotros tenemos archivo 2 vamos a agregar chanchito triste
y vamos a agregar también a felipe vamos a guardar y ahora nos vamos a devolver aquí a
nuestra terminal vamos a escribir git status vemos que se encuentra nuestro archivo 2 listo
para ser agregado a nuestra tapa de stage pero en lugar de eso nosotros lo que haremos será
escribir git aquí nosotros podemos ver todo el texto de lo que representaría los cambios que
nosotros estamos dispuestos a agregar aquí podemos ver que estamos viendo la diferencia de
archivo dos puntos de xc y lo que esto nos está queriendo decir es que se eliminó la línea de
chanchito félix y se agregó una nueva de chanchito feliz chanchito triste y también de felipe
ahora porque he estado ocurriendo esto ya que nosotros ya teníamos la línea de chanchito
feliz porque nos está indicando que la eliminó y luego la volvió a agregar la razón por la que
estaba ocurriendo esto es que antes nosotros teníamos solamente la línea de chanchito feliz y
no habíamos presionado enter no existía un salto de línea entonces cuando nosotros
agregamos el salto de línea ese salto de línea se agrega sobre la misma línea que en este caso
sería chanchito félix entonces lo que tiene que hacer es eliminar esta línea y luego agregar
nuevamente chanchito félix pero con un carácter de salto de línea después de eso nos está
indicando que está agregando chanchito triste y también que está agregando felipe fíjense
también aquí en lo que aparece acá arriba nos está indicando que esto está comenzando
desde la línea esto es con la versión anterior de nuestro archivo y después de esto nosotros
tendríamos la siguiente versión que vendrían siendo los cambios que nosotros realizamos
también comenzando desde la línea 1 y que ha extraído tres líneas las cuales vendrían siendo
nuestros cambios o sea chanchito feliz tantito triste y también felipe para que nosotros
podamos salir de esta pantalla tenemos que presionar la letra q y ahora sí nosotros podemos
proceder a agregar estos cambios así que vamos a escribir archivo dos puntos de xc y vamos a
volver a escribir git dif como pueden ver ahora nos está indicando que no tenemos
absolutamente ningún cambio pero vamos a volver a probar una versión de git dif pero le
vamos a agregar la opción de stage y aquí nosotros podemos ver cuáles son los cambios que se
encuentran en nuestra etapa de stage por ende la primera versión del comando cuando es
solamente git dif nos va a mostrar todos los cambios que nosotros hemos escrito pero que
todavía no hemos pasado a la etapa de stage pero sin embargo si nosotros agregamos menos
menos stage justamente al final de git dif nos va a mostrar todos los cambios que se
encuentren en nuestra etapa de stage como está apareciendo acá esto muy útil ya que
solamente si queremos ver cambios vamos a querer ver los cambios que nosotros queremos
comprometer y no vamos a querer ver absolutamente todo ahora vamos a ver cómo podemos
revisar el historial de todo nuestro repositorio existe un comando que se llama git lo que sí es
que ustedes lo ejecutan se van a dar cuenta que van a ver mucha información van a ver el
nombre de la persona que realizó cierto commit el correo electrónico también de la persona el
cual fue el que nosotros configuramos y también un mensaje de commit si es que ustedes
quieren seguir navegando dentro de esa misma pantalla pueden hacerlo con la barra de
espacio pero a mí esta pantalla la verdad es que en lo personal me desagrada mucho y yo les
voy a mostrar otra que a mí me gusta bastante más y esta es utilizar el mismo comando de git
log pero seguido de la opción one line esto lo que hará será mostrarnos el historial con un
pequeño hash el cual sirve como identificador de ese comité eso piensen que vendría siendo
un número único con el cual se va a identificar ese comité dentro de nuestro registro que
tenemos en git además de eso nos va a mostrar el mensaje que nosotros colocamos dentro de
nuestros comités por esto es sumamente importante que los nombres que nosotros
coloquemos como mensaje dentro de nuestros comités sea algo que tenga sentido no
solamente para nosotros sino que también para otros desarrolladores ya que cuando otro
desarrollador venga y lea estos comités él va a tener que entender de qué es lo que se trata y
así él quizás podría llegar hasta incluso encontrar un potencial error ahora para que nosotros
podamos salir de esta pantalla vamos a hacerlo presionando la letra q hasta ahora nosotros
hemos estado trabajando de una manera completamente lineal esto quiere decir cada vez que
nosotros realizamos un cambio este se va a colocar por encima en nuestro historial esto quiere
decir así que nosotros comenzamos a desarrollar en esta parte y luego nosotros realizamos un
cambio esto se va a ver de la siguiente manera siempre nosotros vamos a estar colocando
cambios con respecto a algo que se encuentra en el pasado por ende nosotros podemos seguir
constantemente agregando cambios pero qué es lo que ocurriría si es que existe más de un
desarrollador trabajando sobre un mismo proyecto en este caso nosotros lo que queremos
hacer es tomar una pequeña bifurcación o salirnos de esta parte del historial de manera de
que nosotros podamos estar trabajando en nuestro propio código y una vez de que nosotros
hayamos terminado nuestra funcionalidad o de corregir el error o de lo que tengamos que
hacer recién ahí intentar devolvernos a la rama principal esto se conoce como branch en git o
directamente la traducción sería ramas donde nosotros vamos a literalmente una rama a la
cual nosotros vamos a seguir agregándole cómics pero esta es completamente independiente
de la rama principal y finalmente una vez que nosotros hayamos terminado de desarrollar esta
funcionalidad nosotros después podemos solicitar realizar un merge a la rama de main que
vendría siendo esta rama principal y luego nosotros podemos continuar con el desarrollo de
nuestra aplicación vamos a ver cómo podemos hacer esto mismo lo primero que haré será
ejecutar git status y luego voy a restaurar este archivo voy a ejecutar nuevamente git status y
voy a descartar estos cambios ahora voy a limpiar mi terminal me voy a asegurar de que estoy
en una zona de trabajo limpia antes de nosotros crear una rama lo primero que haremos será
verificar en qué rama nosotros nos encontramos para eso vamos a escribir git branch aquí
nosotros podemos ver que nos está indicando el texto de main y eso quiere decir que la rama
en la cual nosotros estamos trabajando es la rama main que por cierto main es la rama
principal en la cual nosotros vamos a estar trabajando no solamente en este proyecto sino que
en cualquier otro proyecto que nosotros creemos por defecto estos casi siempre van a tener
una rama de main ahora para que nosotros podamos crear una rama tenemos que escribir el
comando git check-out espacio menos ve seguido del nombre de la rama aquí hay algunas
empresas que prefieren utilizar la nomenclatura de features hacia adelante y el nombre de la
funcionalidad pero también hay otras empresas que lo que prefieren hacer sencillamente
colocar el número del ticket que ellos quieren arreglar y los tickets pueden tener una
nomenclatura de algo así como ese ese guión 45 15 por decir algo nosotros sencillamente
vamos a colocar la rama b vamos a presionar enter y aquí nosotros vemos que nos está
indicando que nos hemos cambiado a una rama que se llama rama b vamos a escribir git
branch y vemos ahora que existe la rama main pero también existe la rama que se llama rama
b ahora nosotros podemos empezar a realizar cambios sobre nuestros archivos me voy a
devolver aquí a mi editor de texto y voy aquí en archivo 2 presionar enter y agregar otro
chanchito félix vamos a guardar pero voy a aprovechar de agregar otra vez espacio y ahora si
podemos volver a escribir status vemos que se encuentra archivo 2 vamos a agregar lo y
vamos a inmediatamente hacer un comité una vez que ya hemos realizado eso podemos ahora
empezar a ver el historial en el cual nosotros nos encontramos trabajando para eso nosotros
vamos a escribir nuevamente git log seguido de menos menos one line vamos a presionar
enter y aquí nosotros podemos ver que yo me encuentro en la cabeza de rama vez esto quiere
decir que yo me encuentro al final con justamente la última parte de rama ve el último código
que se ha escrito pero que también se encuentra aquí una rama que se llama main y en este
caso la cabeza de main está diciendo que es el del comité mostrando estatus corto para salir
de esta pantalla volvemos a presionar q y vamos a aprovechar de ejecutar el siguiente
comando catch archivo 2 de x de esto lo que hará será mostrarnos el contenido de nuestro
archivo voy a limpiar la terminal y voy a presionar enter como podemos ver aquí tenemos
chanchito feliz chanchito feliz pero fíjense en qué es lo que ocurre si yo me cambio de rama a
la rama main para eso escribo mi checkout main y aquí volvemos a ejecutar el comando de
catch archivo 2 y como podemos ver lo que contiene es el texto de chanchito feliz de esta
manera nosotros podemos tener varias versiones de código que están siendo trabajadas
nosotros tenemos rama b donde ya habíamos agregado una nueva línea y también chanchito
félix pero en la rama main nosotros hemos reflejado que aún no están los cambios lo que
haremos ahora será tratar de traernos los cambios desde rama ve a la rama de main à y para
poder nosotros traernos los cambios de la rama ve a la rama de main tenemos que la rama
main eso es muy importante no tenemos que estar en rama b tenemos que estar en rama
main aquí nosotros debemos escribir git merge seguido del nombre de la rama a la cual
queremos traer en este caso es rama b aquí nosotros vemos como se trajo el archivo 2 punto
de x t con sus cambios incluidos y si ahora nosotros volvemos a realizar un cat de archivo 2
vamos a ver que ahora tenemos chanchito feliz y también chanchito feliz en una nueva línea
de esta manera nosotros podemos realizar varios trabajos y no estar todos trabajando
derechamente en la rama main sino que cada persona o cada desarrollador se crea su rama
implementa la funcionalidad y luego la mezcla o hace un merge con la rama main ahora
nosotros veremos cómo podemos tomar todo el código con el cual nosotros hemos trabajado
y subirlo a la nube vamos a ver cómo podemos hacer esto utilizando github lo primero que
debemos hacer es ingresar al sitio web de git hub puntocom y crearnos una cuenta es un
proceso de la verdad es que bastante sencillo así que ustedes vayan ingresen sus datos y luego
presionan en enviar luego les va a mostrar una pantalla similar a esta o nos va a llevar a
crearse ustedes un repositorio inmediatamente yo lo que voy a hacer es pinchar aquí donde
dice new es el botón que vamos a utilizar para poder crear un nuevo repositorio y finalmente
vamos a terminar con algo muy similar a esto aquí yo le voy a indicar que mi repositorio se va a
llamar mi web la descripción no le voy a colocar absolutamente nada porque es opcional voy a
decir que es un repositorio público y no le voy a agregar un ritmo hyung ignore ni tampoco voy
a elegir una licencia voy a dejar todo esto completamente sin chequear luego de eso voy a
pinchar acá donde dice wright repository y aquí nos va a dar unas cuantas opciones de que
podemos hacer nosotros para poder tomar todo el código de nuestro repositorio y subirlo acá
a la nube para eso nosotros vamos a copiar esta línea que aparece acá la de wii remote a origin
y la vamos a pegar en nuestra terminal y promote nos sirve para que nosotros podamos indicar
si es que vamos a tener un servidor remoto en el cual nosotros podemos subir nuestros
cambios y en este caso cuando le estamos diciendo a origin es que necesitamos indicando de
donde nosotros tenemos que ir a obtener nuestro código y también a donde tenemos que
subir los cambios que nosotros realicemos seguido de eso le indicamos la url de donde se
encuentra almacenado nuestro código ya que nosotros vamos a presionar enter ahora nos
vamos a devolver nuevamente al explorador y vamos a ver que aquí nos está indicando git
push - o origin main vamos a copiar también esa línea y la vamos a pegar acá en nuestra
terminal git puig es el comando para que nosotros podamos subir nuestros cambios los cuales
van a ser con respecto a la rama con la cual nosotros estemos trabajando pero sin embargo la
rama de main no se encuentra creada en nuestro repositorio en github por lo que nosotros
tenemos que indicarle que queremos crearla para hacer eso lo hacemos con la opción de
menos y seguido de eso le indicamos en origen que queremos que la rama mein col - sub
creamos la rama con origin le indicamos donde queremos que esta sea creada y finalmente el
nombre de la rama acá nosotros vamos a presionar enter y nos va a indicar que tenemos que
indicar nuestro nombre de usuario para kitkat aquí yo voy a indicar mi nombre de usuario y
luego nos va a pedir que nosotros ingresemos una contraseña sin embargo esta no es la
contraseña con la cual nosotros nos registramos anguita aquí nosotros tenemos que obtener
un aquí y yo les voy a indicar cómo podemos obtener está aquí nos vamos a devolver aquí el
explorador vamos a pinchar acá donde aparece su foto y vamos a abrir una pestaña nueva
donde dice settings voy a venir para acá y voy a bajar casi al final a donde dice aquí de belo
pero settings voy a pinchar esto y me voy a ir acá donde dice personal access tokens pincho
acá y luego de eso voy a pinchar aquí donde dice generate new token pincho en él y aquí yo le
tengo que indicar cómo se va a llamar este token el token yo voy a decir que se va a llamar
imac porque vendría siendo el nombre de mi computador y voy a indicar que yo quiero que
expire en 30 días seguido de eso yo le tengo que indicar cuál es el alcance que quiero que
tenga este toque así que le voy a indicar absolutamente todas las opciones del repositorio voy
a bajar hasta el final y voy a pinchar aquí donde dice generate token ya que nosotros podemos
ver el token ya generado luego como pueden ver nos aparecen esos dos pequeños cuadrados
voy a pinchar en estos y lo que harán serán copiar esta llave dentro de mi clipboard ahora me
voy a devolver aquí a la terminal y voy a pegar luego de pegar presiono enter y ahora podemos
ver como todo nuestro código se subió en este caso aquí para que nosotros podamos revisar
eso nos vamos a devolver acá pinchamos aquí donde dice esta pestaña donde supuestamente
está nuestro repositorio y vamos a refrescar y aquí nosotros podemos ver ya que tenemos
nuestro archivo de kit ignore archivo 1 y archivo 2 y ahora cada vez que queramos seguir
agregando más código sencillamente lo vamos modificando con nuestro editor de texto
favorito luego nos vamos a la terminal escribimos git y agregamos los archivos luego de eso
realizamos un cómic y finalmente escribimos la instrucción de git puig y con eso vamos a tomar
todos nuestros cambios y los vamos a subir en el caso que ustedes estén creando una nueva
rama y aún no le quieran hacer un merge con master pero sin embargo si quieren que ésta se
encuentra en el repositorio ustedes lo que tienen que hacer es se cambian de rama con git
checkout - b y vamos a colocar que esto se va a llamar rama c y aquí nosotros escribimos git
puig - y origin rama ce y esto lo que hará será crear esta rama en el repositorio y este fue el
vídeo de esta semana si te gustó recuerda golpear mucho al maldito del botón de me gusta si
te encantó considera suscribirte a este canal déjame un comentario acá abajo sobre qué otro
tipo de vídeo te gustaría que hiciera y si deseas profundizar en alguna materia acá abajo vas a
encontrar links con acceso a todos mis cursos hasta la próxima.

Comandos GIT mas usados:

Configuración Básica
Configurar Nombre que salen en los commits

git config --global user.name "dasdo"

Configurar Email

git config --global user.email dasdo1@gmail.com

Marco de colores para los comando

git config --global color.ui true

Iniciando repositorio
Iniciamos GIT en la carpeta donde esta el proyecto
 git init
Clonamos el repositorio de github o bitbucket

git clone <url>

Añadimos todos los archivos para el commit

git add .
Hacemos el primer commit

git commit -m "Texto que identifique por que se hizo el commit"

subimos al repositorio

git push origin master

GIT CLONE
Clonamos el repositorio de github o bitbucket

git clone <url>

Clonamos el repositorio de github o bitbucket ?????

git clone <url> git-demo

GIT ADD
Añadimos todos los archivos para el commit

git add .
Añadimos el archivo para el commit

git add <archivo>

Añadimos todos los archivos para el commit omitiendo los nuevos

git add --all

Añadimos todos los archivos con la extensión especificada

git add *.txt

Añadimos todos los archivos dentro de un directorio y de una extensión
especifica

git add docs/*.txt

Añadimos todos los archivos dentro de un directorios

git add docs/

GIT COMMIT
Cargar en el HEAD los cambios realizados
 git commit -m "Texto que identifique por que se hizo el commit"
Agregar y Cargar en el HEAD los cambios realizados

git commit -a -m "Texto que identifique por que se hizo el commit"

De haber conflictos los muestra

git commit -a
Agregar al ultimo commit, este no se muestra como un nuevo commit en los
logs. Se puede especificar un nuevo mensaje

git commit --amend -m "Texto que identifique por que se hizo el

commit"

GIT PUSH
Subimos al repositorio

git push <origien> <branch>

Subimos un tag

git push --tags

GIT LOG
Muestra los logs de los commits

git log
Muestras los cambios en los commits

git log --oneline --stat

Muestra graficos de los commits

git log --oneline --graph

GIT DIFF
Muestra los cambios realizados a un archivo

git diff
git diff --staged

GIT HEAD
Saca un archivo del commit

git reset HEAD <archivo>

Devuelve el ultimo commit que se hizo y pone los cambios en staging
 git reset --soft HEAD^
Devuelve el ultimo commit y todos los cambios

git reset --hard HEAD^

Devuelve los 2 ultimo commit y todos los cambios

git reset --hard HEAD^^

Rollback merge/commit

git log
git reset --hard <commit_sha>

GIT REMOTE
Agregar repositorio remoto

git remote add origin <url>

Cambiar de remote

git remote set-url origin <url>

Remover repositorio

git remote rm <name/origin>

Muestra lista repositorios

git remote -v
Muestra los branches remotos

git remote show origin

Limpiar todos los branches eliminados

git remote prune origin

GIT BRANCH
Crea un branch

git branch <nameBranch>

Lista los branches

git branch
Comando -d elimina el branch y lo une al master

git branch -d <nameBranch>

Elimina sin preguntar

git branch -D <nameBranch>

GIT TAG
Muestra una lista de todos los tags

git tag
Crea un nuevo tags

git tag -a <verison> - m "esta es la versión x"

GIT REBASE
Los rebase se usan cuando trabajamos con branches esto hace que los branches
se pongan al día con el master sin afectar al mismo

Une el branch actual con el mastar, esto no se puede ver como un merge

git rebase
Cuando se produce un conflicto no das las siguientes opciones:

cuando resolvemos los conflictos --continue continua la secuencia del rebase

donde se pauso

git rebase --continue

Omite el conflicto y sigue su camino

git rebase --skip

Devuelve todo al principio del rebase

git reabse --abort

Para hacer un rebase a un branch en especifico

git rebase <nameBranch>

OTROS COMANDOS
Lista un estado actual del repositorio con lista de archivos modificados o
agregados

git status
Quita del HEAD un archivo y le pone el estado de no trabajado

git checkout -- <file>

Crea un branch en base a uno online

git checkout -b newlocalbranchname origin/branch-name

Busca los cambios nuevos y actualiza el repositorio

git pull origin <nameBranch>

Cambiar de branch

git checkout <nameBranch/tagname>

Une el branch actual con el especificado

git merge <nameBranch>

Verifica cambios en el repositorio online con el local

git fetch
Borrar un archivo del repositorio

git rm <archivo>

Fork
Descargar remote de un fork

git remote add upstream <url>

Merge con master de un fork

git fetch upstream

git merge upstream/master