Cómo comprobar si un archivo es binario en Git

GitGitBeginner
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, aprenderás cómo determinar si un archivo es considerado binario por Git. Exploraremos dos métodos: utilizar el comando git diff --numstat para observar cómo Git resume los cambios, y utilizar el comando estándar de Linux file para identificar el tipo de archivo. Al final de este laboratorio, entenderás cómo Git distingue entre archivos de texto y binarios y cómo comprobar esta distinción por ti mismo.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git/BasicOperationsGroup -.-> git/add("Stage Files") git/BasicOperationsGroup -.-> git/status("Check Status") git/BasicOperationsGroup -.-> git/diff("Compare Changes") subgraph Lab Skills git/add -.-> lab-560025{{"Cómo comprobar si un archivo es binario en Git"}} git/status -.-> lab-560025{{"Cómo comprobar si un archivo es binario en Git"}} git/diff -.-> lab-560025{{"Cómo comprobar si un archivo es binario en Git"}} end

Utilizar git diff --numstat para comprobar

En este paso, exploraremos cómo utilizar git diff --numstat para entender los cambios entre diferentes versiones de tus archivos. Este comando proporciona un resumen de los cambios, mostrando el número de líneas agregadas y eliminadas para cada archivo.

Primero, asegúrate de estar en el directorio de tu proyecto. Abre tu terminal y navega hasta el directorio my-time-machine:

cd ~/project/my-time-machine

Ahora, hagamos un cambio en nuestro archivo message.txt. Agregaremos una nueva línea a él:

echo "Hello, Past Me" >> message.txt

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

Comprobemos el estado de nuestro repositorio nuevamente:

git status

Deberías ver que message.txt ha sido modificado:

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)

Ahora, usemos git diff --numstat para ver el resumen de los cambios que hicimos:

git diff --numstat

La salida debería verse algo así:

1       0       message.txt

Esta salida nos dice que en message.txt, se agregó 1 línea y se eliminó 0 líneas. Esta es una forma concisa de ver el impacto general de tus cambios en múltiples archivos.

Comprender git diff --numstat es útil cuando quieres una visión general rápida de cuánto ha cambiado un archivo sin ver el contenido exacto de los cambios. Es especialmente útil cuando revisas cambios realizados por otros o cuando quieres ver la escala de las modificaciones en tu propio trabajo.

Ejecutar el comando file en un archivo

En este paso, aprenderemos sobre el comando file, una herramienta útil en Linux que te indica el tipo de un archivo. Esto es importante porque Git maneja archivos de texto y archivos binarios de manera diferente.

Primero, asegúrate de estar en el directorio de tu proyecto:

cd ~/project/my-time-machine

Ahora, usemos el comando file en nuestro archivo message.txt:

file message.txt

Deberías ver una salida similar a esta:

message.txt: ASCII text

Esto nos dice que message.txt es un archivo de texto. Git está diseñado para funcionar muy bien con archivos de texto porque puede rastrear fácilmente los cambios línea por línea.

¿Qué pasa con otros tipos de archivos? Vamos a crear un archivo binario simple. Podemos usar el comando head para tomar los primeros bytes de un archivo del sistema y redirigirlos a un nuevo archivo en nuestro proyecto. Por ejemplo, creemos un pequeño archivo "binario" a partir del ejecutable /bin/ls:

head -c 1024 /bin/ls > binary_file

Este comando toma los primeros 1024 bytes del archivo /bin/ls y los guarda como binary_file en tu directorio actual.

Ahora, usemos el comando file en este nuevo archivo:

file binary_file

La salida será diferente, lo que indica que es un archivo binario. Puede verse algo así:

binary_file: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=..., for GNU/Linux 3.2.0, BuildID[sha1]=..., stripped

Esta salida confirma que binary_file no es un simple archivo de texto. Git trata los archivos binarios de manera diferente porque no puede determinar fácilmente los cambios línea por línea. En lugar de eso, normalmente almacena todo el archivo binario para cada versión.

Comprender la diferencia entre archivos de texto y archivos binarios es crucial cuando se trabaja con Git, especialmente cuando se manejan archivos como imágenes, programas compilados o archivos comprimidos. Las poderosas capacidades de comparación y combinación de Git están diseñadas principalmente para archivos de texto.

Probar archivos de texto vs archivos binarios

En este paso, veremos cómo Git maneja los cambios en archivos de texto en comparación con archivos binarios. Esto resaltará por qué las capacidades de comparación de Git están diseñadas principalmente para texto.

Primero, asegúrate de estar en el directorio de tu proyecto:

cd ~/project/my-time-machine

Ya tenemos nuestro archivo message.txt (archivo de texto) y binary_file. Hagamos otro cambio en message.txt:

echo "Another line for the future" >> message.txt

Ahora, agreguemos ambos archivos al área de preparación (staging area) y los confirmemos (hagamos commit). Primero, agreguemos los archivos:

git add message.txt binary_file

Comprobemos el estado para confirmar que ambos archivos están en el área de preparación:

git status

Deberías ver ambos archivos listados bajo "Changes to be committed" (Cambios para confirmar):

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

Ahora, confirmemos estos cambios:

git commit -m "Add binary file and update message"

Verás una salida que confirma la confirmación, incluyendo cambios en ambos archivos:

[master ...] Add binary file and update message
 2 files changed, 2 insertions(+)
 create mode 100644 binary_file

Ahora, hagamos un pequeño cambio en el archivo binary_file. Podemos agregar un solo byte a él:

echo -n "a" >> binary_file

La bandera -n evita que echo agregue un carácter de nueva línea.

Comprobemos el estado nuevamente:

git status

Git mostrará que binary_file ha sido modificado:

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:   binary_file

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

Ahora, intentemos ver la diferencia usando git diff:

git diff

En lugar de mostrar cambios línea por línea, Git probablemente te dirá que el archivo binario es diferente:

warning: LF will be replaced by CRLF in binary_file.
The file has no newline at the end of the file.
diff --git a/binary_file b/binary_file
index ... ...
Binary files a/binary_file and b/binary_file differ

Esta salida muestra claramente que Git no intenta mostrar los cambios detallados dentro del archivo binario. Simplemente indica que los archivos son diferentes. Esta es una diferencia clave en cómo Git maneja archivos de texto en comparación con archivos binarios. Para archivos de texto, Git puede mostrar exactamente qué líneas se agregaron, eliminaron o modificaron. Para archivos binarios, solo puede decir que se produjo un cambio.

Este paso demuestra por qué las poderosas herramientas de comparación y combinación de Git son más efectivas con contenido basado en texto, que es común en código fuente y archivos de configuración.

Resumen

En este laboratorio (lab), aprendimos cómo determinar si un archivo es binario en Git. Exploramos dos métodos principales. Primero, usamos el comando git diff --numstat para examinar los cambios entre versiones de archivos, observando cómo resume las adiciones y eliminaciones, lo cual puede indicar indirectamente la naturaleza del archivo en función de la escala de los cambios.

En segundo lugar, aprendimos sobre el comando file, una utilidad estándar de Linux, y cómo usarlo para identificar directamente el tipo de un archivo, distinguiendo entre formatos de texto y binarios. Este enfoque directo es crucial porque la forma en que Git maneja los archivos binarios difiere significativamente de la forma en que maneja los archivos de texto.