Cómo verificar si un archivo está preparado (staged) en Git

Introducción

En este laboratorio, aprenderás cómo verificar si un archivo ha sido preparado (staged) en Git. Exploraremos el comando git status para ver el estado de tu repositorio e identificar los archivos preparados. Luego, utilizarás git diff --cached para verificar los cambios específicos que actualmente se encuentran en el área de preparación (staging area), lo que te brindará una visión clara de lo que se incluirá en tu próximo commit. Finalmente, realizarás pruebas con archivos no preparados (unstaged) para consolidar aún más tu comprensión del proceso de preparación.

Skills Graph

Verificar el estado de Git para archivos preparados (staged)

En este paso, verificaremos el estado de nuestro repositorio de Git después de agregar un archivo al área de preparación (staging area). Esto nos ayudará a entender cómo Git rastrea los cambios antes de que se realicen los commits.

Primero, asegúrate de estar en el directorio my-time-machine. Puedes usar el comando cd para navegar hasta allí:

cd ~/project/my-time-machine

Ahora, creemos un nuevo archivo llamado future_plans.txt y agreguemos algo de contenido a él:

echo "Plan 1: Build a bigger time machine" > future_plans.txt

Este comando crea el archivo y escribe el texto "Plan 1: Build a bigger time machine" en él.

A continuación, agregaremos este nuevo archivo al área de preparación usando el comando git add:

git add future_plans.txt

Recuerda, git add prepara (stage) los cambios, los pone listos para el próximo commit. Aún no crea el commit en sí.

Ahora, verifiquemos el estado de nuestro repositorio usando git status:

git status

Deberías ver una salida similar a esta:

On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   future_plans.txt

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        message.txt ## Este archivo ya está en un commit, pero el estado de Git lo muestra de manera diferente después de un commit. No te preocupes por esto por ahora.

Observa la sección "Changes to be committed:" (Cambios para ser confirmados). Esto indica que future_plans.txt ahora está en el área de preparación, listo para ser incluido en el próximo commit. Git lo reconoce como un "nuevo archivo".

Comprender el área de preparación es crucial en Git. Te permite agrupar cambios relacionados antes de hacer un commit. Esto significa que puedes trabajar en múltiples cosas, pero solo confirmar cambios específicos cuando estén listos.

Utilizar git diff --cached para verificar

En este paso, aprenderemos cómo ver los cambios que actualmente se encuentran en el área de preparación (staging area). Aquí es donde el comando git diff resulta muy útil, especialmente con la opción --cached.

Asegúrate de seguir estando en el directorio ~/project/my-time-machine.

Anteriormente agregamos future_plans.txt al área de preparación. Ahora, usemos git diff --cached para ver exactamente qué cambios están preparados:

git diff --cached

Deberías ver una salida similar a esta:

diff --git a/future_plans.txt b/future_plans.txt
new file mode 100644
index 0000000..a1b2c3d
--- /dev/null
+++ b/future_plans.txt
@@ -0,0 +1 @@
+Plan 1: Build a bigger time machine

Desglosemos esta salida:

• diff --git a/future_plans.txt b/future_plans.txt: Esta línea indica que Git está mostrando la diferencia entre dos versiones del archivo future_plans.txt.
• new file mode 100644: Esto muestra que future_plans.txt es un nuevo archivo.
• index 0000000..a1b2c3d: Estos son identificadores internos de Git para el contenido del archivo.
• --- /dev/null y +++ b/future_plans.txt: Estas líneas indican que el archivo se está comparando desde nada (/dev/null) hasta la nueva versión de future_plans.txt.
• @@ -0,0 +1 @@: Este es un "encabezado de hunk" que indica las líneas que han cambiado. -0,0 significa cero líneas del archivo original (inexistente), y +1 significa una línea en el nuevo archivo.
• +Plan 1: Build a bigger time machine: El signo + al principio de la línea indica que esta línea se ha agregado.

El comando git diff --cached muestra la diferencia entre el área de preparación y el último commit. Dado que aún no hemos realizado ningún commit en este repositorio (excepto el inicial en el laboratorio anterior), muestra la diferencia entre el área de preparación y un estado vacío.

Este comando es increíblemente útil para revisar tus cambios preparados antes de confirmarlos. Te ayuda a asegurarte de que solo estás confirmando los cambios que pretendes.

Presiona q para salir de la vista de diferencias y volver a la línea de comandos.

Probar archivos no preparados (unstaged)

En este paso, exploraremos cómo Git maneja los cambios que se han realizado en un archivo rastreado pero que aún no se han agregado al área de preparación (staging area). Estos se llaman cambios "no preparados" (unstaged).

Asegúrate de estar en el directorio ~/project/my-time-machine.

Anteriormente creamos y preparamos (staged) el archivo future_plans.txt. Ahora, agreguemos otra línea a este archivo sin preparar el cambio:

echo "Plan 2: Invent a self-folding laundry machine" >> future_plans.txt

El operador >> agrega el texto al archivo existente, en lugar de sobrescribirlo.

Ahora, verifiquemos el estado de nuestro repositorio nuevamente:

git status

Deberías ver una salida similar a esta:

On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   future_plans.txt

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   future_plans.txt

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        message.txt

Observa la nueva sección: "Changes not staged for commit:" (Cambios no preparados para el commit). Esto nos dice que Git detecta cambios en future_plans.txt que son diferentes de la versión en el área de preparación. El archivo se lista como "modificado".

Este es un concepto clave en Git: el directorio de trabajo (donde realizas los cambios) es separado del área de preparación. Puedes tener cambios en tu directorio de trabajo que aún no estén preparados.

Para ver la diferencia entre el directorio de trabajo y el área de preparación, puedes usar git diff sin ninguna opción:

git diff

Deberías ver una salida similar a esta:

diff --git a/future_plans.txt b/future_plans.txt
index a1b2c3d..e4f5g6h 100644
--- a/future_plans.txt
+++ b/future_plans.txt
@@ -1 +1,2 @@
 Plan 1: Build a bigger time machine
+Plan 2: Invent a self-folding laundry machine

Esta salida muestra la diferencia entre la versión de future_plans.txt en el área de preparación (que solo tiene "Plan 1") y la versión en tu directorio de trabajo (que ahora tiene tanto "Plan 1" como "Plan 2"). El signo + nuevamente indica la línea agregada.

Comprender la diferencia entre cambios preparados y no preparados, y cómo verlos con git status y git diff, es fundamental para usar Git de manera efectiva.

Presiona q para salir de la vista de diferencias.

Resumen

En este laboratorio, aprendimos cómo verificar si un archivo está preparado (staged) en Git. Comenzamos creando un nuevo archivo y agregándolo al área de preparación utilizando git add. Luego, usamos git status para observar que el archivo estaba listado bajo "Changes to be committed" (Cambios para confirmar), lo que confirma que estaba preparado.

También exploramos el uso de git diff --cached para ver los cambios específicos que actualmente se encuentran en el área de preparación, lo que nos brinda una vista detallada de lo que se incluirá en el próximo commit. Finalmente, probamos el comportamiento de git status con archivos no preparados (unstaged) para diferenciar entre cambios preparados y no preparados.