Cursos Empresas Blog Live Conf Precios

¿Qué es el staging?

Clase 10 de 43 • Curso Profesional de Git y GitHub

Contenido del curso

Introducción a Git

Comandos básicos en Git

Flujo de trabajo básico en Git

Trabajando con repositorios remotos en GitHub

Flujos de trabajo profesionales

Multiples entornos de trabajo en Git

Comandos de Git para casos de emergencia

Bonus sobre Git y Github

Resumen

El staging es el lugar donde se guardan temporalmente los cambios, para luego ser llevados definitivamente al repositorio. El repositorio es el lugar donde se guardan todos los registros de los cambios realizados a los archivos.

Para iniciar un repositorio, o sea, activar el sistema de control de versiones de Git en tu proyecto, solo debes ejecutar el comando git init.

¿Qué es el área de staging?

El área de staging se puede ver como un limbo donde nuestros archivos están por ser enviados al repositorio o ser regresados a la carpeta del proyecto.

¿Qué es git init?

git inites el comando que activa git en nuestro proyecto creando un espacio en memoria RAM llamado staging y una carpeta .git.

Este comando se encargará de dos cosas: primero, crear una carpeta .git, donde se guardará toda la base de datos con cambios atómicos de nuestro proyecto; segundo, crear un área que conocemos como staging, que guardará temporalmente nuestros archivos (cuando ejecutemos un comando especial para eso) y nos permitirá, más adelante, guardar estos cambios en el repositorio (también con un comando especial).

Cómo funciona el staging y el repositorio: ciclo básico de trabajo en git:

El flujo de trabajo básico en git es algo así:

Modificas una serie de archivos en tu directorio de trabajo.
Preparas los archivos, añadiéndolos a tu área de preparación (staging).
Confirmas los cambios (commit), lo que toma los archivos tal y como están en el área de preparación y almacena esa copia instantánea de manera permanente en tu directorio de git.

Veamos a detalle las 3 secciones principales que tiene un proyecto en git.

Working directory

El working directory es una copia de una versión del proyecto. Estos archivos se sacan de la base de datos comprimida en el directorio de git y se colocan en el disco para que los puedas usar o modificar.

Staging area

Es un área que almacena información acerca de lo que va a ir en tu próxima confirmación. A veces se le denomina índice (index).

.git directory (repository)

En el repository se almacenan los metadatos y la base de datos de los objetos para tu proyecto. Es la parte más importante de git (carpeta .git) y es lo que se copia cuando clonas un repositorio desde otra computadora.

Ciclo de vida o estados de los archivos en git

Cuando trabajamos con git, nuestros archivos pueden vivir y moverse entre 4 diferentes estados (cuando trabajamos con repositorios remotos pueden ser más estados, pero lo estudiaremos más adelante):

Archivos tracked

Son los archivos que viven dentro de git, no tienen cambios pendientes y sus últimas actualizaciones han sido guardadas en el repositorio gracias a los comandos git add y git commit.

Archivos staged

Son archivos en staging. Viven dentro de git y hay registro de ellos porque han sido afectados por el comando git add, aunque no sus últimos cambios. Git ya sabe de la existencia de estos últimos cambios, pero todavía no han sido guardados definitivamente en el repositorio porque falta ejecutar el comando git commit.

Git stash: guarda cambios temporalmente

Archivos unstaged

Entiéndelos como archivos “tracked pero unstaged”. Son archivos que viven dentro de git pero no han sido afectados por el comando git add ni mucho menos por git commit. Git tiene un registro de estos archivos, pero está desactualizado, sus últimas versiones solo están guardadas en el disco duro.

Archivos untracked

Son archivos que NO viven dentro de git, solo en el disco duro. Nunca han sido afectados por git add, así que git no tiene registros de su existencia.

Recuerda que hay un caso muy raro donde los archivos tienen dos estados al mismo tiempo: staged y untracked. Esto pasa cuando guardas los cambios de un archivo en el área de staging (con el comando git add), pero antes de hacer commit para guardar los cambios en el repositorio haces nuevos cambios que todavía no han sido guardados en el área de staging.

Comandos para mover archivos entre los estados de Git

Estos son los comandos más importantes que debes conocer:

Git status

git status nos permite ver el estado de todos nuestros archivos y carpetas.

Git add

git add nos ayuda a mover archivos del untracked o unstaged al estado staged. Podemos usar git nombre-del-archivo-o-carpeta para añadir archivos y carpetas individuales o git add -A para mover todos los archivos de nuestro proyecto (tanto untrackeds como unstageds).

Git reset HEAD

Nos ayuda a sacar archivos del estado staged para devolverlos a su estado anterior. Si los archivos venían de unstaged, vuelven allí. Y lo mismo se venían de untracked.

Git commit

Nos ayuda a mover archivos de unstaged a tracked. Esta es una ocasión especial, los archivos han sido guardados o actualizados en el repositorio. Git nos pedirá que dejemos un mensaje para recordar los cambios que hicimos y podemos usar el argumento m para escribirlo (git commit -m "mensaje").

Git rm

Este comando necesita alguno de los siguientes argumentos para poder ejecutarse correctamente:

git rm --cached: mueve los archivos que le indiquemos al estado untracked.
git rm --force: elimina los archivos de git y del disco duro. Git guarda el registro de la existencia de los archivos, por lo que podremos recuperarlos si es necesario (pero debemos usar comandos más avanzados).

Contribución creada con los aportes de: Diego Camacho, Jesús Sarabia y Angelo Yenque.

Vengo del futuro (del final de las clases) aca dejo los apuntes para el que le interee, igual concentrate en practicarlos todos a medida que vayas viendo las clases, porfavor no te agobies por la cantidad, es mas facil de lo que parece, igual que todo, poco a poco te vas a ir puliendo..

git init ( sirve para indicar la carpeta "previamente selecccionada" en la que se creara un repositorio en el disco duro o staggng)

git add "e.g. Archivo.txt" (sirve para agregar un archivo especifico al area de stagging)

git add . (sirve para agregar todos los archivos al area de stagging)

git commit -m "mensaje" (sirve para enviar todos los archivos del area de stagging al area del repositorio o "master")

git show ( me muestra los cambios que han sido realizados a traves de las versiones)

git log ( me muestra las versiones que han sido guardadas en "Master")

git checkout ( me permite devolver en el tiempo un archivo a una version anterior sin borrar la actual o simplemente toda la carpeta para que me muestre la version anterior en un archivo en especifico debo indicar al final el nombre del archivo)

git diff (indicandole las versions que queremos, nos muestra las diferencias entre ellas)

git reset xxxxxxxxxxxxxxxxxxxxxx --hard (este devuelve en el tiempo el projecto y elimina todo lo realizado posteriormente a la version a la que estamos volviendo)

git reset xxxxxxxxxxxxxxxxxxxxxx -- soft (este elimina los archivos del commit pero mantiene los archivos del area de stagging)

git reset xxxxxxxxxxxxxxxxxxxxxx head ( sirve para pasar los archivos de staging a unstaged en caso de que queramos editar algun archivo o lanzar en otra actualizacion algun cambio que no era para este commit sino para un commit futuro)

git rm --cached: (Elimina los archivos del área de Staging y del próximo commit pero los mantiene en nuestro disco duro.)

git rm --force: (Elimina los archivos de Git y del disco duro. Git siempre guarda todo, por lo que podemos acceder al registro de la existencia de los archivos, de modo que podremos recuperarlos si es necesario (pero debemos usar comandos más avanzados).)

git clone url (sirve para clonar el proyecto de un repositorio ubicado en un servidor a mi repositorio y directorio de trabajo)

git push (sirve para enviar todos los datos actualizados en mi repositorio al repositorio del servidor.)

git fetch (importa un archivo que alguien mas cambio recientemente y no tienes en tu repositorio local, puedes usar git merge para combinar tus archivos, en el directorio de trabajo con tu repositorio local para que quede unidos los cambios )

git merge (combina dos versiones)

git pull (a diferencia de fetch y merge al mismo tiempo, esta lo que hace es tomar los archivos, actualizados del repositorio remoto y copiarlos tanto en mi repositorio local como en mi directorio de trabajo, para asi tener una version actualizada del repositorio remoto.)

git commit -a (sirve para agregar directamente a master sin pasar por el staging)

git branch (sirve para ver las ramas creadas o sirve para crear una rama dependiendo de su uso, si usas el comando tal cual lo leiste, solo te mostrara las ramas existentes, pero si lo usas de este modo e.g. (git branch "inserte aca nombre que le quiera proporcionar a la rama" obviamente sin las comillas, crearas una rama nueva con el nombre que quieras.)

git commit -am (sirve para agregar al repositorio local los archivos que estas trackeando con un mensaje)

git remote add "origin" ( sirve para enviar el projecto en el que estamos trabajando a la base de datos o repositorio remoto)

git remote ( nos mostrara el repositorio remoto dispobible o existente)

git remote -v (nos indicara la direccion web del repositorio remoto)

git push "origin" "master"

git pull "origin" "master"

git pull "origin" "master" --allow-unrelated-histories ( sirve para forzar a combinar los archivos del repositoerio remoto con el repositorio local)

git config -l ( nos muestra las configuraciones de git)

gir config global --user.email "jdbshfjbhfdsbjfh@gmail.com"

git log --all

git log --all --graph --decorate --oneline" ( me muestra todos los commits realizados en el proyecto de manera que se pueden observar los mensajes y los merges)

alias arbolito="git log --all --graph --decorate --oneline" (crear un alias, ese es el ejemplo, un alias ya sabes para que funciona)

git tag (me muestra las versionas realizadas es decir los tags

git tag -a v0.1 -m "Resultado de las primeras clases del curso" 5d10f9c (ejempplo de como se hacen los tag)

git show-ref --tags ( me muestra los tags con las versiones y a que commit estan relacionados.)

git push origin --tags ( enviar los tags)

git tag -d "NombreDeTag" (me permite eliminar un tag que le indique)

git push origin :refs/tags/dormido ( codigo para eliminar el tag de github)

git show-branch (nos muestra todas las ramas, y si le agregamos --all nos muestra mas datos)

gitk (abre en un software la historia del proyecto, de una manera ultravisual)

git remote add "upstream" (nos crea otrwa fuente nueva de donde podemos traer datos a nuestras rama amster)

git remote -v

git clone "link" (nos permite clonar un projecto publico)

cuando queremos que git ignore algun archivo, debemos crear un new file en el editor y guardarlo en el directorio como ".gitignore" luego en el editos utilizaremos "*" para indicarle la extension de los archivos que queramos que ignore

git rebase ( sirve para el momento de realizar un hotfix y que no se vea en el log de ramas el error)

git branch -D "rama Name" (elimina una rama)

git stash (me devuelve el proyecto al estado anterior antes de ralizar algun cambio, manteniendo el cambio guardado temporalmente, es como presionar cntrl+z en Vs code)

git stash pop ( me devuelve al proyecto luego de hacer los cambios antes de aplicar el stash)

git stash list ( me muestra una lista de los stash)

git stash branch "branch name" (lo que hace es que si existe un stash, esto lo mueve a esa nueva rama, realizas un commit y queda gurdado el trabajo alli)

git stash drop ( sirve para borrar los stash realizados)

git clean (sirve para borrar archivos no deseados, o que no utilizas realmente en tu repositorio, agregando "--dry-run" muestra todo lo que va a borrar el comando pero si agregamos -f borra todo el listado que te muestra el comando anterior sin preguntar

git cherry-pick (sirve para traer un commit de otro rama a la que te encuentres(ES MALA PRACTICA))

git reflog (aun habiendo eliminado los errores con un git reset --hard, este muestra el log de los errores cometidos, aquellos que no se ven en un "git log")

git grep (busca en el proyecto las palabras usadas, el nombre de un archivo o lo que sea que le mandes a buscar, y si agregas "-n" te dice inclusive en que lineas se utiliza.. si utilizamos "-c" nos indica las veces que utilizamos esas palabras)

git log -S "palabra a buscar" (busca la palabra que estas buscando en el historial o commits)

git blame "nombre del archivo" (sirve para ver los commits realizados por las diferentes personas en orden con todos los datos si agregamos "-c" se ve un poco mejor)

si utilizamos

git blame "nombre del archivo" "-L35,53" (nos muestra los cambios realizados por las personas en entre las lineas especificadas.)

comandos y recursos colaborativos en git y github

git shortlog ( me muestra el nombre de las personas colaborando y los commits realizados por cada una de ellas.)

git shortlog -sn (me muestra los nombres y la cantidad en numeros de los commits que hicieron)

git shortlog -sn --all (muestra inclusive los commits borrados)

git shortlog -sn -all --no-merges (lo mismo que el anterior pero omite contar los merges)

git congfig --global alias.(nombre del comando) "git shortlog -sn -all --no-merges"

git branch -r (te permite ver las ramas remotas en tu servidor)

git branch - a (te muestra las ramas locales y las remotas)

agrego el amend aca porque es un proceso por pasos:

para que sirve: cuaqndo realizas un commit pero en el commit olvidaste realizar una parte del trabajo o arreglar un detalle.

1ro. debes hacer tu cambio y verificar que colocaste el codigo bien y todo lo demas en tu editor de codigo como normalmente lo haces.

2do. vas a realizar un git add "aqui vas a indicar el archivo que tiene los cambios que no colocaste".

3ro. luego de agregar los archivos a staging vas a realizar un git commit --amend (esto agrega el archivo al que le hiciste los cambios al commi anterior.)

y listo, problema resuelto :D

Keygen ssh creaton proceedements

code:

ssh-keygen -t rsa -b 4096 -C "parapapapaaaaaaa@gmail.com" (para crear el security shell debes introducir el codigo ssh-keygen donde "-t" nos indicara la complejidad del algoritmo que vamos a utilizar en este caso "rsa" y -b nos indicara la complejidad de la llave en este caso usaremos "4096" y por ultimo -C es donde indicaremos el correo a usar "correo@gmail.com"

eval $(ssh-agent -s) (sirve para verificar si el cifrador de llaves esta funcionando en el sistema operativo, es igual en linux y en windows.)

para efectos de un mejor entendimiento se explicaran los siguientes signos a explicar en cada comando;

"": la utilizacion de comillas indicara que luego del comando debe ir un nombre que indicara la creacion o el cambio de un archivo hacia otro, de una rama hacia otra del envio del projecto al repositorio remoto.

Md= mark down para que el repositorio se vea como pagina principal hay que escribir por eejempllo en mi caso

;Espancake.github.io

el git rebase solo debe hacerse en repositorios locales, no debe hacerce e repositorios remotos, es muy mala practica.

agregar --help al comando nos abre el manual del mismo.

Notas destacadas del curso:

windows y mac tienenn un standard de tildes distinto es un problema de unicode o de utf -8

se puede solucionar mediante el siguiente meta charset ;

<head> <metacharset="UTF-8" /> ... </head>

Conceptos básicos Directorio: Es la carpeta del proyecto que está en tu disco duro Staging: Es donde se guardan las modificaciones del archivo antes de enviar la versión final al repositorio (staging es como tener la milanesa empanizada pero no freída). Repositorio: Es la carpeta donde se guardan las versiones finales de los archivos, todos los que trabajen en el mismo proyecto tienen acceso a esta carpeta y pueden ver qué se ha modificado de un archivo y quién lo realizó.

Estados de un archivo Untracked: Son todos aquellos archivos que están en el disco duro que no conoce Git. Staged: Son los archivos que se encuentran en Staging. Tracked: Son archivos que están en el repositorio o en staging. Unstaged: Son archivos tracked que han sido modificados, pero no han sido guardados los cambios en staging.

Comandos necesarios

$git mkdir: Crea un directorio. $git touch: Crea un archivo. $git init: Define la carpeta del proyecto, crea el staging y el repositorio. $git add: Guarda la versión del archivo en staging. $git commit -m””: Guarda el archivo en el repositorio, cada vez que se ejecuta este comando se crea una nueva versión del archivo en el repositorio (en la comillas de -m”” se escribe un comentario sobre las modificaciones para hacer que tus compañeros y tu comprendan posteriormente cuáles fueron los cambios). $git rm --cached: Cambia el estado de los archivos a untracked. $git rm --force: Elimina los archivos tanto en el disco duro como en el flujo de Git, aunque queda registro de ese archivo por si se necesita recuperarlo $checkout: En caso de tener una versión desactualizada de un archivo que está en el repositorio, este comando trae los cambios necesarios al disco duro.

Flujo básico de Git

Con el comando $git mkdir se crea un directorio y los archivos necesarios, los cuales están en estado untracked.
Con el comando $git init se determina el directorio del proyecto, se crea el repositorio y staging.
Con el comando $git touch se crean los archivos necesarios. 4)Conforme se modifican los archivos, se crean versiones de estos con el comando $git add. 5)Al terminar de trabajar en los archivos se guardan en el repositorio con el comando $git commit -m””.