Después de esta lección, podrás:
- Crea un repositorio Git en tu computadora.
- Verificar el estado de tus repositorios para ver qué ha cambiado.
- Agreguar tus archivos modificados al área de ensayo con
git add. - Crear un checkpoint de los cambios que ha realizado con
git commit. - Ver confirmaciones anteriores que hayas realizado con
git log.
Hemos discutido en una lección anterior que Git es un VCS para hacer un seguimiento de los cambios que realiza en los archivos y carpetas de sus proyectos. Ahora que tenemos la teoría de Git, analicemos el lado práctico y cómo usar realmente esta teoría.
Comencemos creando un directorio para jugar con Git.
$ mkdir -p ~/code/prework/git-practice
$ cd ~/code/prework/git-practice
$ touch data.txt
$ code .
Agrega texto a data.txt. Usa tus propios datos si quieres:
Name: Ironhacker
Age: 25
Favorite Color: Yellow
Discutimos en la lección anterior cómo se usa Git para realizar un seguimiento de los cambios en los archivos y carpetas en su máquina local, pero ¿cómo se hace realmente?
En su carpeta git-practice, ejecute el siguiente comando:
$ git init
Deberías tener git instalado en tu computadora. Puede verificarlo ejecutando el siguiente comando en la terminal:
$ git --version
La salida debe ser su versión de git, algo así como git versión 2.6.4.
git init es el comando para decirle a Git que esta carpeta de tu proyecto será un repositorio de Git. A partir de ese momento, Git rastreará todos los cambios a los archivos y carpetas dentro de esa carpeta.
Pero, ¿cómo hace un seguimiento de estos cambios?
Vamos a ejecutar el comando ls para mostrar carpetas y archivos ocultos dentro de la carpeta:
$ ls -a
# => . .. .git data.txt
# => retorna un valor. No tienes que escribirlo en tu terminal.
Además de data.txt, tenemos una nueva carpeta llamada .git. No creamos este directorio nosotros mismos, Git lo hizo cuando ejecutamos el comando git init.
$ ls -a .git
$ # => . .. HEAD config description hooks info objects refs
El repositorio .git es donde Git realiza un seguimiento de todos los cambios que realiza, y * mucho * más. No tiene sentido entrar en los detalles específicos de la carpeta ahora, pero la haremos referencia a medida que avanza la lección.
git init en una carpeta que no pretendías hacer un repositorio de git, puedes simplemente eliminar la carpeta .git usando rm -rf:
$ git init
$ ls -a
# => . .. .git data.txt
$ rm -rf .git
Ten cuidado, sin embargo. rm -rf es un comando peligroso que puede borrar todo en su sistema si se usa incorrectamente. Además, cualquier historial que tengas en el repositorio de git desaparecerá.
Puede ser más fácil comenzar esto diciéndote dónde no crear un repositorio, y por qué.
La mayoría de las veces, querrás crear el repositorio de Git en una carpeta de proyecto específica. No deseas crear un repositorio de Git en una carpeta de alto nivel, como Documentos, o tu directorio de origen (~).
¿Por qué? Git realiza un seguimiento de la carpeta y * todas las subcarpetas de esa carpeta *. Esto significa que si creas un repositorio de Git en tu directorio de origen (~), harás un seguimiento de todos los cambios en los archivos y carpetas en la computadora de tu usuario local.
Esto es malo porque:
- Es innecesario.
- Cuando vayas a crear un repositorio de Git más adelante dentro de un proyecto, es posible que tengas problemas.
- Cuando finalmente desees almacenar tus repositorios Git en GitHub más adelante, puedes subir accidentalmente información sensible.
En Ironhack, crearás * muchos * proyectos y carpetas para rastrear con Git. Echa un vistazo al siguiente árbol para tener un ejemplo de dónde deberías estar creando repositorios Git:
├── project-1
│ ├── index.html
│ └── style.css
├── project-2
│ ├── index.html
│ └── style.css
├── project-3
│ ├── index.html
│ └── style.css
├── project-4
│ ├── index.html
│ └── style.css
└── project-5
├── index.html
└── style.css
En esta carpeta, tenemos 5 proyectos, todos con un index.html y style.css. Sugerimos crear tu repositorio de git en cada proyecto, así:
├── project-1
│ ├── .git
│ ├── index.html
│ └── style.css
├── project-2
│ ├── .git
│ ├── index.html
│ └── style.css
├── project-3
│ ├── .git
│ ├── index.html
│ └── style.css
├── project-4
│ ├── .git
│ ├── index.html
│ └── style.css
└── project-5
├── .git
├── index.html
└── style.css
Los siguientes son ejemplos de cómo * no * estructurar la carpeta :
├── .git
├── project-1
│ ├── index.html
│ └── style.css
├── project-2
│ ├── index.html
│ └── style.css
├── project-3
│ ├── index.html
│ └── style.css
├── project-4
│ ├── index.html
│ └── style.css
└── project-5
├── index.html
└── style.css
├── .git
├── ironhack
│ ├── .DS_Store
│ ├── project-1
│ │ ├── index.html
│ │ └── style.css
│ ├── project-2
│ │ ├── index.html
│ │ └── style.css
│ ├── project-3
│ │ ├── index.html
│ │ └── style.css
│ ├── project-4
│ │ ├── index.html
│ │ └── style.css
│ └── project-5
│ ├── index.html
│ └── style.css
└── prework
└── git-practice
├── .git
└── data.txt
Volvamos a nuestra carpeta git-practice. Ya hemos ejecutado git init, y Git realiza un seguimiento de nuestros cambios. Actualmente tenemos un archivo en la carpeta que acabamos de crear.
¿Cómo podemos saber de qué se está dando cuenta Git? La respuesta es un comando que usarás muy seguido al crear proyectos: git status.
El estado de Git nos dice qué archivos y carpetas están siendo rastreados, y cuál es su estado actual según Git.
$ git status
Git nos está diciendo algunas cosas con la salida, pero a la que deberíamos prestar atención en este momento es a la que dice archivos no rastreados. data.txt es * untracked * porque lo hemos creado en nuestro sistema de archivos, pero no le hemos dicho a Git que lo vea todavía.
Volveremos y haremos referencia al estado de Git a medida que continuemos la lección, pero descubramos cómo agregar un archivo para que Git lo rastree.
Actualmente, data.txt está en nuestro sistema de archivos, pero Git no lo rastrea. Los archivos y carpetas en este estado se denominan nuestro directorio de trabajo. Para rastrear estos archivos con Git, debemos * agregar * a nuestra * área de preparación *. El área de preparación es un lugar donde hemos notificado a Git que se hará un seguimiento de algo.
Para agregar un archivo al área de ensayo, usemos el comando git add:
$ git add data.txt
$ git status
Ahora, en lugar de decir "Untracked files", Git nos dice que data.txt está en etapas, y en la sección * "changes to be committed" *.
Discutiremos como hacer "commits" en breve, pero por ahora podemos ver que Git ahora está rastreando nuestro archivo.
A menudo, en los proyectos, queremos crear múltiples archivos al mismo tiempo. Esto se puede hacer de diferentes maneras.
Agreguemos algunos archivos nuevos para jugar con esto:
$ touch file1.txt file2.txt file3.txt file4.txt file5.txt
$ git status
Actualmente data.txt está * en etapas *, pero los otros 5 archivos no.
Pongamos archivo1.txt y archivo2.txt
$ git add file1.txt file2.txt
$ git status
Pensándolo bien, me gustaría organizar todos los archivos en mi proyecto:
$ git add -A # -A stands for "All"
$ git status
Todo está agregado!
Parece que en realidad no queremos agregar file5.txt a nuestra área de preparación. Hemos cometido un error, así que vamos a arreglarlo. Podemos usar el comando git reset para eliminar un archivo del área de ensayo.
$ git reset file5.txt
$ git status
Ahora file5.txt está de vuelta en nuestro directorio de trabajo, ¡y ya no está organizado!
La pregunta que puedes haber estado haciendo antes de este punto es: * ¿guardar para qué? * La respuesta está en las capturas de pantalla. Has notado que los archivos en el área de preparación están etiquetados con "Changes to be commited".
A * commit * en Git es una instantánea del estado de los archivos y carpetas en su proyecto, así como del contenido en ellos.
Sus proyectos evolucionarán y cambiarán con el tiempo. A medida que agrega contenido y lo modifica, su * estado * cambia. A medida que su estado cambia, los commits capturarán ese punto en el tiempo.
SI data.txt contiene:
"Hello"
Y lo modificamos para que diga:
"Goodbye"
Su estado ha cambiado
El uso de commits en Git harán lo siguiente:
- Ayuda a revertir los errores a una versión anterior (El botón de * oh shit *).
- Colabora con diferentes desarrolladores en tus proyectos sin colisionar.
- Mantener un registro de * quién * hizo cambios, y cuándo los hicieron.
Por ejemplo, consulte este ejemplo de commits de la evolución de un proyecto:
Podemos hacer commits usando el comando git commit. Esto tomará todos los archivos en nuestro área de preparación y creará un nuevo commit en nuestro repositorio.
Echemos un vistazo al siguiente diagrama para obtener más información visual:
Ya hemos agregado archivos a nuestro área de preparación desde nuestra carpeta de trabajo, ahora tenemos que moverlos de forma permanente a nuestro repositorio. El estado de nuestro proyecto quedará congelado para siempre en ese momento.
$ git commit -m "Initial commit - Added data, and created needed files"
$ git status
git commit -m
significa que daremos un mensaje con nuestro commit. Esto será útil más adelante, pero por ahora ten en cuenta que debes dejar un mensaje detallado y descriptivo sobre lo que estás haciendo en el commit.
Esto es útil cuando necesitas averiguar qué cambios has realizado en el pasado y por qué se hicieron.
- ¿Qué pasó con nuestros archivos? * Cuando creamos commits, elimina los archivos del área de preparación, porque se han confirmado. El único archivo restante es
file5.txt, que no hemos agregado.
Estupendo. Ahora nuestros archivos están añadidos y almacenados en Git, pero ¿cómo podemos ver los commits que hemos realizado previamente y qué han hecho?
En algún momento en el futuro, es probable que deseemos ver todos los cambios en nuestro proyecto. Además, es posible que desee revertir nuestro proyecto a un punto anterior.
El comando git log se usa para ver los commits y los datos sobre esos. Démosle una oportunidad y veamos qué pasa:
q para salir de esta vista en la terminal
En este diálogo se incluye nuestro commit y algunos datos sobre el mismo. Cada commit tiene lo siguiente:
- Commit SHA (
commit 905616a7252c247f3244bf6ca00faeeba324a26f) - Puedes pensar en esto como un ID único para cada commit. Esto se puede usar en el futuro para revertir a este commit, eliminarlo o combinar varios. - Autor: el atributo de autor es útil cuando se trabaja con equipos para ver quién hizo qué. Si alguien hace un cambio radical, puedes encontrar a quién y regañarlo por eso.
- Fecha - Fecha en que se creó el commit.
- Mensaje - El mensaje que dejamos al hacer el commit. Esto nos da un contexto sobre lo que se hizo en ese punto. Es por eso que es muy importante dejar mensajes detallados y descriptivos.
Hagamos otro commit y veamos cómo cambia el registro:
$ git add file5.txt
$ git commit -m "Add file5 to repo"
$ git log
Apareció nuestro nuevo commit!
git log es extremadamente personalizable en cuanto a cómo se puede formatear la salida. Consulte el articulo de Advanced Git Log para mas detalles
Codeschool tiene un tutorial interactivo para poner en práctica los comandos que acabamos de aprender.
Visita GitHub Lab y completa el Intro a Github
Una vez que haya terminado envíe una captura de pantalla de un desafío completado a su TA o Instructor.
Aquí tienes los comandos más importantes que deberías haber aprendido en esta lección:
Iniciar un repositorio
$ git init
Ver cambios en el repositorio
$ git status
Agregar archivos
$ git add <file-name>
Guardar cambios
$ git commit -m"<commit-message>"
Ver los commits
$ git log
En esta lección, hablamos sobre cómo crear un repositorio de Git y cómo Git realiza un seguimiento de estos cambios en la carpeta .git. Además, también discutimos dónde crear estos repositorios para un flujo de trabajo eficiente.
También discutimos las áreas * working * y * staging *, y cómo mover archivos entre ellas. Además, hablamos sobre cómo mover archivos desde el área de preparación a su repositorio en el área de commits.
Finalmente, discutimos cómo ver estos commits, y los diferentes datos registrados en esos commits.
Estos comandos serán algunos de los comandos más comúnmente utilizados que serán cruciales para tu flujo de trabajo de desarrollador. ¡Familiarízate con su uso y no temas utilizar git status todo el tiempo!