Cómo comprobar si un archivo ha sido eliminado en Git

Introducción

En este laboratorio, aprenderás cómo comprobar si un archivo ha sido eliminado en un repositorio de Git. Exploraremos diferentes métodos para identificar archivos eliminados, incluyendo el uso de git log para ver el historial de cambios y git status para ver el estado actual de tu directorio de trabajo.

A través de pasos prácticos, crearás, confirmarás (commit) y luego eliminarás un archivo, observando cómo Git registra estos cambios. En particular, utilizarás git log -- <file> para ver el commit en el que se eliminó el archivo y git status para ver los archivos eliminados antes de que se confirmen. Finalmente, probarás estos métodos en archivos existentes para consolidar tu comprensión.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git(("Git")) -.-> git/BranchManagementGroup(["Branch Management"]) git/BasicOperationsGroup -.-> git/add("Stage Files") git/BasicOperationsGroup -.-> git/status("Check Status") git/BasicOperationsGroup -.-> git/commit("Create Commit") git/BasicOperationsGroup -.-> git/rm("Remove Files") git/BranchManagementGroup -.-> git/log("Show Commits") subgraph Lab Skills git/add -.-> lab-560026{{"Cómo comprobar si un archivo ha sido eliminado en Git"}} git/status -.-> lab-560026{{"Cómo comprobar si un archivo ha sido eliminado en Git"}} git/commit -.-> lab-560026{{"Cómo comprobar si un archivo ha sido eliminado en Git"}} git/rm -.-> lab-560026{{"Cómo comprobar si un archivo ha sido eliminado en Git"}} git/log -.-> lab-560026{{"Cómo comprobar si un archivo ha sido eliminado en Git"}} end

Ejecutar git log -- File para comprobar la eliminación

En este paso, exploraremos cómo usar git log para ver el historial de cambios en nuestro repositorio, centrándonos específicamente en cómo muestra las eliminaciones de archivos.

Primero, asegúrate de estar en el directorio de tu proyecto. Abre tu terminal y escribe:

cd ~/project/my-time-machine

Ahora, creemos un nuevo archivo que eliminaremos más adelante. Lo llamaremos to_be_deleted.txt.

echo "This file is temporary." > to_be_deleted.txt

Comprueba que el archivo se haya creado:

cat to_be_deleted.txt

Deberías ver:

This file is temporary.

Ahora, agreguemos este archivo al área de preparación (staging area) y confirmémoslo (commit). Esto registrará su existencia en nuestro historial de Git.

git add to_be_deleted.txt
git commit -m "Add a file to be deleted"

Deberías ver una salida similar a esta, lo que indica que se ha creado un nuevo commit:

[master <commit-id>] Add a file to be deleted
 1 file changed, 1 insertion(+)
 create mode 100644 to_be_deleted.txt

Ahora, eliminemos el archivo usando el comando rm:

rm to_be_deleted.txt

El archivo ya no está en tu sistema de archivos. Pero, ¿qué sabe Git sobre esto? Comprobemos el estado:

git status

Deberías ver algo como esto:

On branch master
Changes not staged for commit:
  (use "git add/rm <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        deleted:    to_be_deleted.txt

no changes added to commit but untracked files present (use "git add" to track)

Git identifica correctamente que el archivo ha sido eliminado. Esto se debe a que Git registra el estado de tus archivos. Cuando se elimina un archivo rastreado, Git detecta el cambio.

Ahora, confirmemos esta eliminación. Volvemos a usar git add para preparar la eliminación y luego git commit.

git add to_be_deleted.txt
git commit -m "Delete the temporary file"

Deberías ver una salida que indique que la eliminación se ha confirmado:

[master <commit-id>] Delete the temporary file
 1 file changed, 1 deletion(-)
 delete mode 100644 to_be_deleted.txt

Finalmente, usemos git log para ver el historial, incluyendo la eliminación.

git log

Verás dos entradas de commit. La más reciente tendrá el mensaje "Delete the temporary file" y mostrará que to_be_deleted.txt ha sido eliminado.

Presiona q para salir de la vista del log.

Esto demuestra cómo Git no solo registra la creación y modificación de archivos, sino también su eliminación, proporcionando un historial completo de la evolución de tu proyecto.

Usar git status para archivos eliminados

En este paso, exploraremos más a fondo cómo git status nos ayuda a gestionar los archivos eliminados antes de confirmar (commit) los cambios.

Asegúrate de que todavía estés en el directorio de tu proyecto:

cd ~/project/my-time-machine

Anteriormente eliminamos to_be_deleted.txt y confirmamos la eliminación. Vamos a crear otro archivo y luego eliminarlo sin confirmar la eliminación de inmediato.

Crea un nuevo archivo llamado another_file.txt:

echo "This is another file." > another_file.txt

Agrega y confirma este nuevo archivo:

git add another_file.txt
git commit -m "Add another file"

Deberías ver una salida que confirme el commit:

[master <commit-id>] Add another file
 1 file changed, 1 insertion(+)
 create mode 100644 another_file.txt

Ahora, eliminemos another_file.txt usando el comando rm:

rm another_file.txt

El archivo ya no está en tu sistema de archivos. Comprobemos el estado de nuestro repositorio:

git status

Esta vez, la salida se verá similar a esta:

On branch master
Changes not staged for commit:
  (use "git add/rm <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        deleted:    another_file.txt

no changes added to commit but untracked files present (use "git add" to track)

Observa que Git reconoce la eliminación y lista another_file.txt bajo "Changes not staged for commit" (Cambios no preparados para el commit). Esto significa que Git sabe que el archivo se ha eliminado, pero este cambio aún no se ha preparado para incluirse en el próximo commit.

Este es un punto crucial: eliminar un archivo de tu sistema de archivos no prepara automáticamente la eliminación en Git. Debes decir explícitamente a Git que quieres registrar esta eliminación en tu historial.

El comando git status es tu ventana al estado actual de tu repositorio. Te dice qué archivos se han modificado, cuáles son nuevos y no rastreados y cuáles se han eliminado. Al comprobar regularmente git status, puedes estar al tanto de los cambios en tu proyecto y decidir qué cambios quieres incluir en tu próximo commit.

En el siguiente paso, veremos cómo Git maneja los archivos existentes que no se eliminan.

Probar archivos existentes

En este paso, veremos cómo Git maneja las modificaciones de archivos que ya están siendo rastreados.

Asegúrate de estar en el directorio de tu proyecto:

cd ~/project/my-time-machine

Tenemos el archivo message.txt que creamos y confirmamos (commit) en el primer laboratorio. Modifiquemos este archivo. Podemos usar el comando echo con >> para agregar texto al archivo existente.

echo "Hello again, Future Me!" >> message.txt

El operador >> agrega el texto al final del archivo, en lugar de sobrescribirlo (lo que haría >).

Veamos el contenido del archivo para confirmar el cambio:

cat message.txt

Deberías ver ambas líneas:

Hello, Future Me
Hello again, Future Me!

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

git status

La salida mostrará algo como esto:

On branch master
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:   message.txt

no changes added to commit but untracked files present (use "git add" to track)

Git identifica correctamente que message.txt ha sido "modificado". Lo sabe porque compara la versión actual del archivo en tu directorio de trabajo con la versión almacenada en el último commit.

Al igual que con los archivos eliminados, Git te dice que los cambios están "no preparados para el commit". Esto significa que has modificado el archivo, pero aún no has dicho a Git que quieres incluir estas modificaciones específicas en tu próximo punto de guardado.

Este es el flujo de trabajo estándar en Git: haces cambios en los archivos, luego usas git status para ver lo que has cambiado, luego usas git add para preparar los cambios que quieres confirmar y, finalmente, usas git commit para guardar esos cambios preparados como una nueva versión en el historial de tu proyecto.

Comprender la salida de git status es clave para trabajar de manera efectiva con Git. Proporciona una visión clara del estado de tu proyecto y te guía en los siguientes pasos que debes dar para registrar tus cambios.

Resumen

En este laboratorio, aprendimos cómo comprobar si un archivo ha sido eliminado en Git. Comenzamos creando y confirmando (commit) un archivo para establecer su presencia en el historial del repositorio. Luego, eliminamos el archivo usando el comando rm y observamos cómo git status informó con precisión la eliminación como un cambio. Finalmente, confirmamos la eliminación, registrando este evento en el historial de Git.

A través de estos pasos, comprendimos que Git rastrea las eliminaciones de archivos y proporciona herramientas como git status para identificar estos cambios antes de que se confirmen. Este proceso demuestra cómo Git mantiene un registro de los eventos del ciclo de vida de los archivos, incluyendo la creación y la eliminación.