Git Diff Explicado: Una Guía Completa con Ejemplos

Tutoriales
Git

Git diff es tu ventana a los cambios que ocurren en tu repositorio de código. En su núcleo, es un comando que te muestra las diferencias entre varios estados de tus archivos, ya sea comparando tu trabajo actual con lo que ya has preparado o comparando cambios entre ramas y confirmaciones. Piénsalo como la forma en que Git responde a la pregunta, “¿Qué ha cambiado?” Cuando ejecutas git diff, Git analiza el contenido de los archivos línea por línea, identificando lo que se ha añadido, eliminado o modificado, y presenta esta información en un formato estandarizado que resalta exactamente qué cambió y dónde.

Git diff ayuda a los desarrolladores a garantizar la calidad del código al proporcionar una vista clara de las modificaciones antes de que se confirmen. Aquí cubriremos cómo utilizar este comando esencial de manera efectiva, desde comparaciones básicas hasta técnicas avanzadas que mejorarán tu flujo de trabajo de desarrollo y la colaboración en equipo.

Prerrequisitos

Para seguir este tutorial, debes estar familiarizado con estos conceptos de Git:

  • Flujo básico de Git (init, add, commit)
  • Repositorios de Git y su estructura
  • Ramas y cómo funcionan
  • Commits e historial de commits
  • El área de preparación (index)

Si necesitas repasar estos conceptos, estos recursos te ayudarán:

Vas a necesitar Git instalado en tu sistema para seguir los ejemplos. Todos los comandos se pueden ejecutar en una terminal o símbolo del sistema.

Por qué Git Diff es esencial para los desarrolladores

Cada desarrollador necesita saber qué ha cambiado en su código, ya sea que esté trabajando solo o en un equipo de cientos. Sin git diff, te quedarías adivinando qué líneas has alterado, lo que haría que la solución de problemas y la colaboración fueran casi imposibles.

Git diff es esencial para la gestión de cambios y sirve como la base para construir software de calidad a través de procesos efectivos de revisión. Al examinar cambios, git diff proporciona el contexto necesario para entender no solo qué cambió, sino por qué esos cambios son importantes.

Esta visibilidad directa en la evolución del código ayuda a los equipos a mantener estándares y evitar que los errores lleguen a producción.

A medida que los proyectos crecen en complejidad, git diff se vuelve verdaderamente indispensable por varias razones clave:

  • Verificación de cambios: Confirma exactamente lo que estás a punto de confirmar, evitando la inclusión accidental de código de depuración o cambios no relacionados
  • Transferencia de conocimiento: Comprender lo que han hecho los compañeros de equipo sin tener que leer archivos completos
  • Resolución de conflictos: Identificar exactamente dónde y cómo surgen conflictos durante fusiones
  • Análisis histórico: Rastrear cuándo se introdujeron cambios específicos para buscar errores o entender la evolución de funciones
  • Revisiones de código dirigidas: Enfocar la atención en las partes del código que realmente cambiaron, ahorrando tiempo y mejorando la calidad de la revisión

Para usar eficazmente git diff, es necesario comprender la arquitectura subyacente que permite estas comparaciones: el modelo “Tres-Árboles” de Git.

Arquitectura de Tres Árboles de Git

Para entender git diff, primero necesitas comprender la arquitectura fundamental de “tres árboles” de Git. A pesar del nombre, no se trata de árboles reales en el sistema de archivos, sino de tres estados distintos donde existe tu código.

Considera estos estados como tres versiones diferentes de tu proyecto que Git mantiene simultáneamente: el Directorio de Trabajo (tus archivos actuales), el Área de Preparación (o índice, donde se preparan los cambios para confirmar) y el Repositorio (el historial confirmado de tu proyecto almacenado en el directorio .git).

Fuente: Hashnode

El Directorio de Trabajo contiene los archivos que estás editando activamente, aquí es donde escribes código, haces cambios y pruebas tu trabajo. El Área de Preparación actúa como una zona de preparación donde seleccionas qué cambios deben incluirse en tu próximo commit. Puedes pensar en ella como un muelle de carga donde los paquetes (tus cambios) se organizan antes de enviarlos.

Finalmente, el Repositorio almacena la historia completa de tu proyecto como una serie de commits, instantáneas de tu código en puntos específicos en el tiempo, enlazadas para formar una cadena histórica.

Git diff opera comparando estos tres estados en varias combinaciones. Cuando ejecutas git diff sin argumentos, compara tu Directorio de Trabajo con el Área de Preparación, mostrando los cambios que has hecho pero aún no has preparado.

Usando git diff --staged compara el Área de Preparación con el último commit, mostrando qué se incluirá en tu próximo commit.

Y git diff HEAD compara tu Directorio de Trabajo directamente con el último commit, mostrando todos los cambios no confirmados sin importar el estado de preparación.

Estos puntos de comparación forman la base para todas las operaciones diff en Git:

  • Directorio de Trabajo ↔ Área de Preparación: ¿Qué cambios he realizado pero aún no he preparado? (git diff)
  • Área de preparación ↔ Repositorio: ¿Qué cambios he preparado que se comprometerán a continuación? (git diff --staged)
  • Directorio de trabajo ↔ Repositorio: ¿Cuál es la diferencia total entre mis archivos de trabajo y el último commit? (git diff HEAD)
  • Entre commits: ¿Cómo ha evolucionado el código entre puntos específicos en la historia? (git diff hash-del-commit1 hash-del-commit2)

Comprender esta arquitectura te proporciona el modelo mental necesario para utilizar eficazmente git diff y señalar exactamente qué ha cambiado, dónde y cuándo en tu base de código.

Con esta comprensión arquitectónica en su lugar, ahora podemos explorar cómo utilizar los comandos git diff en la práctica para obtener información sobre la evolución de tu código en estos tres estados.

Uso básico de git diff

Creemos un proyecto de análisis de datos de muestra para demostrar el uso de git diff en acción. Configuraremos un pequeño repositorio con scripts de Python, datos CSV y archivos de texto que podremos modificar a lo largo de este tutorial.

# Crear e inicializar nuestro proyecto
mkdir data-analysis-project
cd data-analysis-project
git init

# Crear archivos iniciales
echo "# Data Analysis Project\nA sample project to demonstrate git diff functionality." > README.md
echo "import pandas as pd\n\ndef load_data(filename):\n return pd.read_csv(filename)\n\ndef analyze_data(data):\n return data.describe()" > analysis.py
echo "id,name,value\n1,alpha,10\n2,beta,20\n3,gamma,30" > data.csv
echo "DEBUG=False\nDATABASE_PATH=./data/" > config.txt
echo "def normalize_data(data):\n return (data - data.min()) / (data.max() - data.min())" > utils.py

# Hacer nuestro primer commit
git add .
git commit -m "Initial commit with basic project structure"

# Verificar la estructura del directorio
> tree

.
├── README.md
├── analysis.py
├── config.txt
├── data.csv
└── utils.py

Nuestro proyecto ahora tiene cinco archivos bajo control de versión, lo que nos proporciona una base para demostrar varios escenarios de diferencias. A medida que avancemos, modificaremos estos archivos para mostrar cómo git diff revela cambios en diferentes contextos.

Entendiendo los resultados de git diff

Cuando ejecutas un comando git diff, el resultado sigue un formato estandarizado diseñado para indicar claramente qué ha cambiado. Modifiquemos nuestro archivo analysis.py para ver una diferencia en acción:

# Actualizar analysis.py con una nueva función
echo "import pandas as pd\n\ndef load_data(filename):\n return pd.read_csv(filename)\n\ndef analyze_data(data):\n return data.describe()\n\ndef visualize_data(data):\n return data.plot(kind='bar')" > analysis.py

Ahora examinemos el git diff resultante:

git diff

Verás una salida similar a esta:

Nota: Para salir de la salida de git diff, presiona “q” en tu terminal.

Desglosemos esta salida:

  1. El encabezado (diff --git a/analysis.py b/analysis.py) muestra qué archivo se está comparando, que es analysis.py
  2. El metadatos del archivo (index db0e049..a7a7ab0 100644) muestra identificadores internos de Git para las versiones antes y después
  3. Los marcadores de archivo (--- a/analysis.py y +++ b/analysis.py) indican los archivos “antes” y “después”
  4. El encabezado de fragmento (@@ -5,3 +5,6 @@) muestra qué líneas fueron afectadas. Esta notación se puede interpretar como:
  • -5,3 significa que a partir de la línea 5 en el archivo original, se muestran 3 líneas en la diferencia
  • +5,6 significa que a partir de la línea 5 en el archivo modificado, se muestran 6 líneas en la diferencia
  • La diferencia entre estos números indica que se agregaron 3 líneas

5. El cambio de contenido con líneas que comienzan con + muestran adiciones

En archivos más grandes, git diff agrupa los cambios en “hunks” – secciones del archivo que contienen cambios. Cada hunk tiene su propio encabezado con números de línea para ayudarte a ubicar los cambios en el archivo.

Comparando el directorio de trabajo y el área de preparación

Ejecutar git diff sin argumentos compara tu Directorio de Trabajo (estado actual de los archivos) con el Área de Preparación (cambios listos para ser confirmados). Esto es útil para revisar lo que has cambiado pero aún no has preparado para tu próximo commit.

¡Modifiquemos varios archivos para demostrarlo!

# Actualizar README.md
echo "# Data Analysis Project\nA sample project to demonstrate git diff functionality.\n\n## Installation\nRun \pip install -r requirements.txt" > README.md

# Actualizar data.csv
echo "id,name,value\n1,alpha,10\n2,beta,20\n3,gamma,30\n4,delta,40" > data.csv

Ahora solo preparemos los cambios en README.md:

git add README.md

Ejecutar git diff ahora mostrará solo los cambios no preparados en data.csv y el archivo analysis.py arriba:

Esto te ayuda a enfocarte en lo que aún no has preparado. Si deseas ver lo que ya has preparado:

git diff --staged # or git diff --cached (they're synonyms)

Esto mostrará los cambios en README.md que están preparados y listos para ser confirmados. Este flujo de trabajo es crucial para construir confirmaciones limpias y lógicas. Puedes preparar porciones de tu trabajo que tengan sentido juntas, revisar la diferencia preparada para verificar que sea una unidad coherente de cambio y luego confirmarla.

Comparando el área de preparación y la última confirmación

El comando git diff --staged compara tu Área de Preparación con tu último commit. Esto te muestra exactamente qué se incluirá en tu próximo commit si ejecutas git commit ahora.

¡Vamos a preparar nuestros cambios en data.csv y examinar lo que está preparado:

git add data.csv
git diff --staged

La salida ahora mostrará cambios tanto en README.md como en data.csv, ya que ambos han sido preparados. Este paso de revisión es crítico antes de confirmar, actúa como tu última línea de defensa contra confirmar cambios no deseados.

Un flujo de trabajo común podría verse así:

  1. Hacer cambios en varios archivos
  2. Ejecutar git diff para revisar todos los cambios
  3. Usa git add <archivo> selectivamente para agregar grupos lógicos de cambios
  4. Ejecuta git diff --staged para verificar lo que está a punto de ser comprometido
  5. Compromete los cambios agregados con git commit -m "Tu mensaje"
  6. Repite para otros grupos lógicos de cambios

Este enfoque metódico ayuda a mantener un historial de confirmaciones limpio y significativo que facilita la comprensión de cómo evolucionó su proyecto y dónde podrían haberse introducido problemas. A medida que gane experiencia, estos comandos de diferencias se convertirán en algo natural, sirviendo como sus compañeros constantes en el proceso de desarrollo.

Hagamos nuestras confirmaciones antes de pasar a la siguiente etapa:

# Se deben confirmar data.csv y README.md
git commit -m "Modify data.csv and README.md files"

# Etapa y confirma analysis.py
git add analysis.py
git diff --staged  # Review the changes one more time
git commit -m "Add a new function to analysis.py"

Técnicas Intermedias de Diferenciación en Git

Ahora que entendemos los conceptos básicos de git diff, exploremos técnicas más poderosas que mejorarán su capacidad para rastrear y analizar cambios en sus proyectos. Continuaremos trabajando en nuestro proyecto de análisis de datos para demostrar estos conceptos intermedios.

Comparación entre diferentes referencias

Git está construido en torno al concepto de referencias, punteros a estados específicos de su código. Estas referencias incluyen ramas, confirmaciones y etiquetas. El comando git diff puede comparar dos de estas referencias para mostrar qué cambió entre ellas.

Creemos una nueva rama para desarrollar una característica y hagamos algunos cambios:

# Crear y cambiar a una nueva rama
git checkout -b feature/advanced-analytics

# Modificar el archivo analysis.py con una nueva función
echo "import pandas as pd
import numpy as np

def load_data(filename):
   return pd.read_csv(filename)

def analyze_data(data):
   return data.describe()

def visualize_data(data):
   return data.plot(kind='bar')

def perform_advanced_analysis(data):
   """Performs advanced statistical analysis on the dataset"""
   results = {}
   results['correlation'] = data.corr()
   results['skew'] = data.skew()
   return results" > analysis.py

# Confirmar los cambios
git add analysis.py
git commit -m "Add advanced analysis function"

Ahora podemos comparar nuestra rama de características con la rama principal:

git diff main feature/advanced-analytics

Este comando muestra todas las diferencias entre las dos ramas, cada archivo que ha sido modificado, añadido o eliminado. Verás los cambios que hicimos en analysis.py, incluyendo nuestras nuevas importaciones y funciones (presiona enter varias veces ya que la diferencia completa se trunca en la terminal).

Para comparar con un commit específico, puedes usar el hash del commit:

git log --oneline  # Find the commit hash you want to compare with

git diff 7b3105e  # Replace 7b3105e with the actual commit hash you want to compare

Esta capacidad de comparación se vuelve invaluable cuando:

  • Preparas revisiones de código al ver todos los cambios en una rama de características
  • Comprobar qué cambios introduciría la rama de un colega antes de fusionar
  • Comprender cómo evolucionó tu base de código entre versiones o lanzamientos

Comparar archivos específicos

Cuando trabajas con repositorios grandes, a menudo quieres enfocarte en los cambios en archivos o directorios específicos en lugar de ver todas las diferencias. Git diff facilita esto al permitirte especificar rutas.

Vamos a hacer cambios en varios archivos:

# Actualizar config.txt
echo "DEBUG=True
DATABASE_PATH=./data/
LOG_LEVEL=INFO" > config.txt

# Actualizar utils.py
echo "def normalize_data(data):
   return (data - data.min()) / (data.max() - data.min())

def clean_data(data):
   return data.dropna()" > utils.py

Para ver los cambios solo en el archivo de configuración:

git diff config.txt

O para comparar un archivo específico entre ramas:

# Comparar el archivo analysis.py entre las ramas main y feature/advanced-analytics
git diff main feature/advanced-analytics -- analysis.py

El -- en el comando anterior ayuda a Git a distinguir entre referencias y rutas de archivos. Esto es particularmente útil cuando:

  • Trabajando en repositorios con muchos archivos pero centrándose en componentes específicos (lo cual suele ser el caso)
  • Comprobando cómo ha cambiado la configuración a lo largo de ramas
  • Revisando solo los archivos más críticos en un conjunto grande de cambios

Opciones de diferencias contextuales

Git diff proporciona varias opciones para ajustar cómo se muestran las diferencias, facilitando centrarse en cambios significativos.

Por ejemplo, al tratar con cambios de formato de código, las diferencias de espaciado pueden ocultar cambios semánticos importantes. Vamos a demostrarlo con un cambio de formato:

# Realizar un cambio de espaciado en analysis.py
sed -i '' 's/    return/  return/g' analysis.py  # Reduce indentation

Ahora, al comparar con el git diff estándar se muestran los cambios de espaciado (nota cómo las declaraciones de retorno están desalineadas):

git diff analysis.py

# OUT:
--- a/analysis.py
+++ b/analysis.py
@@ -2,17 +2,17 @@ import pandas as pd
import numpy as np

def load_data(filename):
-    return pd.read_csv(filename)
+  return pd.read_csv(filename)

def analyze_data(data):
-    return data.describe()
+  return data.describe()

def visualize_data(data):
-    return data.plot(kind='bar')
+  return data.plot(kind='bar')

def perform_advanced_analysis(data):
    Performs advanced statistical analysis on the dataset
    results = {}
    results['correlation'] = data.corr()
    results['skew'] = data.skew()
-    return results
+  return results

Pero podemos ignorar los cambios de espaciado (esto no muestra cambios ya que solo eliminamos espaciado):

git diff -w analysis.py  # or --ignore-all-space

Otra opción útil es controlar las líneas de contexto, las líneas sin cambios que se muestran alrededor de las modificaciones:

git diff -U1 analysis.py  # Show only 1 line of context (default is 3)
git diff -U5 analysis.py  # Show 5 lines of context

Estas opciones contextuales son particularmente valiosas cuando:

  • Se está revisando código que ha pasado por un formateo automatizado
  • Se quiere enfocar en cambios funcionales en lugar de cambios de estilo
  • Se necesita más contexto para entender un cambio en particular
  • Se está trabajando con archivos grandes donde el contexto predeterminado crearía demasiada salida

Al dominar estas técnicas intermedias, tendrás un control mucho más preciso sobre cómo revisas y entiendes los cambios en tu base de código, lo que hará que tu flujo de trabajo de desarrollo sea más eficiente y tus revisiones de código más efectivas.

Vamos a confirmar los últimos cambios antes de pasar a las aplicaciones avanzadas de git diff:

git add .
git commit -m "Modify analysis.py, config.txt, and utils.py"

Aplicaciones Avanzadas de Git Diff

Construyendo sobre nuestro entendimiento de las técnicas intermedias de git diff, exploremos algunas aplicaciones avanzadas que llevarán tus habilidades en Git al siguiente nivel. Estas técnicas avanzadas son particularmente útiles cuando se trabaja en bases de código complejas o se colabora con equipos más grandes.

Usando herramientas de diff externas

Aunque el diff integrado de Git es potente, a veces una herramienta de diff visual proporciona una mejor claridad, especialmente para cambios complejos. Git te permite configurar herramientas externas para mejorar tu experiencia de diff.

Vamos a configurar una herramienta de diff visual popular. Utilizaremos VSCode como ejemplo, pero una configuración similar funciona para herramientas como Beyond Compare, Meld o KDiff3:

# Configurar Git para usar VSCode como herramienta de diff (específico del proyecto)
git config diff.tool vscode
git config difftool.vscode.cmd "code --wait --diff \$LOCAL \$REMOTE"

# Para usar otras herramientas populares, podrías usar:
# Para Beyond Compare (específico del proyecto):
git config diff.tool bc3
git config difftool.bc3.path "/path/to/beyond/compare"

# Comandos de instalación:
# Para Beyond Compare:
# En macOS: brew install --cask beyond-compare
# En Ubuntu: sudo apt-get install beyond-compare
# En Windows: Descargar desde https://www.scootersoftware.com/download.php

# Nota: Para aplicar estas configuraciones de forma global en lugar de solo en el proyecto actual,
# agrega la bandera --global a cada comando, por ejemplo:
# git config --global diff.tool vscode

Ahora, en lugar de usar git diff, puedes usar:

git difftool main feature/advanced-analytics

Esto abrirá tu herramienta de diferenciación visual configurada para mostrar los cambios. Así es como se ve Beyond Compare:

Las herramientas de diferenciación visual ofrecen varias ventajas:

  1. Comparación lado a lado que facilita ver el contexto
  2. Resaltado de sintaxis que se alinea con tus preferencias de editor
  3. Navegación avanzada entre cambios
  4. Capacidad de editar archivos directamente mientras se revisan las diferencias

Cuando se revisan cambios grandes o archivos con estructuras complejas (como JSON o XML anidados), las herramientas de diferenciación visual pueden mejorar drásticamente la comprensión y la eficiencia.

Comandos de diferenciación especializados

Git ofrece comandos de diferenciación especializados que te brindan un control más granular para casos de uso específicos. Vamos a explorar algunos de estos comandos poderosos:

git diff-tree examina las diferencias entre objetos de árbol (directorios):

# Obtener el hash de los dos últimos commits
LAST_COMMIT=$(git rev-parse HEAD)
PREV_COMMIT=$(git rev-parse HEAD~1)

# Mostrar los cambios en el último commit
git diff-tree --patch $PREV_COMMIT $LAST_COMMIT

git diff-index compara el directorio de trabajo con el índice (área de preparación) o un árbol:

# Comparar el directorio de trabajo con el índice
git diff-index --patch HEAD

git diff-index es particularmente útil para scripts y automatización. Te permite verificar de forma programática qué cambios se incluirían en tu próximo commit, lo que lo hace valioso para ganchos pre-commit y scripts de validación.

Por ejemplo, podrías usarlo en un pipeline de CI/CD para verificar que ciertos archivos no hayan sido modificados o para asegurarte de que los cambios de configuración sigan patrones específicos antes de permitir commits.

git diff-files muestra cambios entre archivos en el directorio de trabajo y el índice:

# Verificar diferencias para archivos específicos
git diff-files --patch config.txt

Estos comandos especializados son particularmente útiles para:

  • Crear flujos de trabajo y scripts personalizados de Git
  • Depurar problemas con las partes internas de Git
  • Realizar análisis dirigido del estado del repositorio
  • Construir herramientas de automatización que interactúan con Git

Analizar la historia del código

Una de las aplicaciones más poderosas de git diff es analizar cómo ha evolucionado el código con el tiempo, lo cual puede ser crucial para depurar o entender el desarrollo de funciones.

Vamos a examinar un commit específico utilizando la notación especial ^!:

# Obtener el hash de nuestro commit de análisis avanzado
ANALYTICS_COMMIT=$(git log --oneline | grep "advanced analysis" | cut -d ' ' -f 1)

# Mostrar solo los cambios introducidos en ese commit específico
git diff $ANALYTICS_COMMIT^!

La sintaxis ^! es una forma abreviada de comparar un commit con su padre, mostrando exactamente qué cambió en ese commit.

Para rastrear cómo evolucionó un archivo específico a lo largo del tiempo:

# Analizar cómo cambió analysis.py en los últimos 3 commits
git log -p -3 analysis.py

Cuando busques un error, puedes usar git diff con git bisect:

# Agregar un bug para simular una regresión
echo "import pandas as pd
import numpy as np

def load_data(filename):
   # Bug: devolver accidentalmente None en lugar de los datos
   pd.read_csv(filename)
   return None

def analyze_data(data):
   return data.describe()

def visualize_data(data):
   return data.plot(kind='bar')

def perform_advanced_analysis(data):
   results = {}
   results['correlation'] = data.corr()
   results['skew'] = data.skew()
   return results" > analysis.py

git add analysis.py
git commit -m "Update analysis.py with a hidden bug"

# Ahora usa git bisect para encontrar cuándo se introdujo el bug
git bisect start
git bisect bad  # Mark current commit as containing the bug
git bisect good main  # Mark the main branch as working correctly

# Git verificará los commits para que los pruebes
# Una vez encontrado, puedes examinar el cambio exacto que introdujo el bug
git diff HEAD^!

Git bisect es una poderosa herramienta de depuración que realiza una búsqueda binaria en el historial de tus commits para encontrar qué commit introdujo un bug. Combinado con git diff, crea un flujo de trabajo eficiente:

1. Inicia el proceso de bisect con git bisect start

2. Marca el commit actual como malo (contiene el error) con git bisect bad

3. Marca un commit conocido como bueno (donde el error no existe) con git bisect good <hash-del-commit>

4. Git verifica automáticamente un commit en el medio de tu historial para que lo pruebes.

5. Después de probar el commit actual, dile a git el resultado:

  • Si el error existe en este commit: git bisect bad
  • Si el error no existe en este commit: git bisect good

6. Git continuará revisando diferentes confirmaciones basadas en tus comentarios (después de cada comando git bisect bad/good), estrechando la búsqueda cada vez. Repite el proceso de prueba y marcado hasta que git identifique la primera confirmación mala.

7. Una vez que git encuentre la confirmación problemática, mostrará un mensaje indicando qué confirmación introdujo el error.

8. Examina exactamente lo que cambió en la confirmación identificada con: git diff HEAD^!

9. Este comando te muestra precisamente qué código se modificó en la confirmación que introdujo el error, permitiéndote enfocar tus esfuerzos de depuración en esos cambios específicos.

10. Salga de la búsqueda binaria en cualquier momento con: git bisect reset Esto le devolverá a la rama en la que estaba antes de comenzar el proceso de búsqueda binaria.

11. También puede automatizar el proceso de búsqueda binaria con: git bisect run <script-de-prueba> Donde es un comando que devuelve 0 para confirmar buenos y diferente de cero para confirmar malos.

Este flujo de trabajo reduce drásticamente el tiempo de depuración, especialmente en bases de código grandes con muchos commits entre estados de trabajo y rotos.

Estas técnicas de análisis de historial son invaluables para:

  • Encontrar cuándo y por qué se introdujo un error
  • Comprender la evolución de una función o componente
  • Auditar cambios para revisiones de seguridad
  • Documentar el proceso de toma de decisiones detrás de los cambios de código

Al dominar estas aplicaciones avanzadas de diferencia de git, podrás navegar por la historia de tu proyecto con precisión, depurar problemas de manera más eficiente y obtener una comprensión más profunda de la evolución de tu base de código.

Referencia del comando Git Diff

Git diff ofrece una amplia gama de opciones para personalizar su salida y comportamiento para situaciones específicas. Aquí tienes una referencia completa de los parámetros más comúnmente utilizados para mejorar tu análisis diferencial:

Opciones básicas de comparación

  • git diff – Comparar directorio de trabajo con área de preparación
  • git diff --staged (o --cached) – Comparar área de preparación con último commit
  • git diff HEAD – Comparar directorio de trabajo con último commit
  • git diff <commit> – Comparar directorio de trabajo con commit específico
  • git diff <commit1> <commit2> – Comparar dos commits específicos
  • git diff <branch1> <branch2> – Comparar dos ramas

Limitación de ruta

  • git diff -- <path> – Limitar la comparación a un archivo o directorio específico
  • git diff --stat – Mostrar un resumen de los cambios (archivos modificados, inserciones, eliminaciones), una opción muy útil para diffs grandes
  • git diff --name-only – Mostrar solo los nombres de los archivos modificados
  • git diff --name-status – Mostrar nombres y estado (añadido, modificado, eliminado) de archivos modificados

Mostrar control

  • git diff -w (o –ignore-all-space) – Ignorar cambios de espacios en blanco
  • git diff --ignore-space-change – Ignorar cambios en la cantidad de espacios en blanco
  • git diff --color-words – Mostrar diferencias a nivel de palabras con color
  • git diff --word-diff – Mostrar diferencias a nivel de palabras en un formato diferente
  • git diff -U<n> – Mostrar n líneas de contexto (el valor por defecto es 3)
  • git diff --no-prefix – No mostrar los prefijos a/ y b/ en la salida de diff

Filtrado de contenido

  • git diff --binary – Mostrar cambios en archivos binarios
  • git diff -S<string> – Buscar cambios que agreguen o eliminen la cadena especificada
  • git diff -G<regex> – Buscar cambios que coincidan con el patrón regex especificado
  • git diff --pickaxe-all – Al usar -S o -G, muestra todos los cambios en el archivo, no solo los coincidentes

Opciones de formato

  • git diff --patch-with-stat – Mostrar resumen de parche y estadísticas
  • git diff --compact-summary – Mostrar resumen de estadísticas en un formato compacto
  • git diff --numstat – Mostrar estadísticas en un formato amigable para máquinas
  • git diff --summary – Mostrar resumen de creación/eliminación

Estas opciones se pueden combinar para crear comparaciones poderosas y específicas. Por ejemplo, para ver cambios a nivel de palabra en un archivo específico mientras se ignoran los espacios en blanco:

git diff --color-words -w -- analysis.py

O para encontrar todos los lugares donde una función específica pudo haber sido agregada o eliminada:

git diff -S"def perform_advanced_analysis" main feature/advanced-analytics

Comprender estas opciones te ayuda a filtrar el ruido y enfocarte precisamente en los cambios que importan, haciendo que tus flujos de trabajo de revisión y análisis de código sean más eficientes. Ya sea que estés buscando errores, preparándote para una solicitud de extracción o simplemente tratando de entender qué cambió, la opción correcta de git diff puede facilitar significativamente tu tarea.

Conclusión

A lo largo de este artículo, hemos explorado git diff como un comando versátil para ver los cambios de código. Hemos cubierto la comparación de archivos de trabajo con cambios en etapa, examinando las diferencias entre ramas y confirmaciones, y utilizando comandos especializados para obtener información más profunda. Incorporar git diff en tu flujo de trabajo ayuda a construir confirmaciones más limpias, detectar problemas temprano y facilitar mejores revisiones de código.

Ya sea trabajando solo o en equipo, dominar git diff te eleva de simplemente escribir código a comprender cómo evoluciona tu base de código con el tiempo.

Para seguir construyendo tu experiencia en Git, consulta estos recursos valiosos:

Estos recursos te ayudarán a ampliar lo aprendido sobre git diff y llevar tu dominio del control de versiones al siguiente nivel.

Source:
https://www.datacamp.com/tutorial/git-diff-guide