Git Básico: Conceptos Fundamentales para Desarrolladores

por

Introducción: Más Allá de los Comandos

Si eres como muchos desarrolladores, probablemente usas Git todos los días con comandos como git add, git commit, git push. Pero ¿realmente entiendes qué está sucediendo debajo del capó?

Entender los conceptos fundamentales de Git no solo te hará más productivo, sino que te preparará para dominar workflows complejos como Git Flow y GitHub Flow. Este artículo es tu base sólida.

¿Qué es Git Realmente?

Git no es solo un sistema de control de versiones. Es un sistema de control de versiones distribuido que funciona creando snapshots de tu proyecto en cada commit, usando internamente delta compression para optimizar el almacenamiento.

La Analogía del Caja de Seguridad

Imagina que Git es como una caja de seguridad mágica:

  • Cada commit es una foto instantánea completa de tu proyecto
  • Las ramas son como diferentes líneas de tiempo
  • El merge es combinar líneas de tiempo
  • El rebase es reorganizar tu línea de tiempo

Los Tres Estados de Git

Para entender Git, debes comprender sus tres estados principales:

1. Working Directory (Directorio de Trabajo)

Es donde ves y editas tus archivos. Es el estado “normal” de tu proyecto.

# Estás en el working directory
ls -la
# archivo.txt (modificado)

2. Staging Area (Área de Preparación)

Es un archivo, generalmente en tu repositorio Git, que almacena información sobre qué irá en tu próximo commit.

# Mover cambios al staging area
git add archivo.txt
# Ahora archivo.txt está "staged"

3. Repository (Repositorio Git)

Es donde Git permanentemente almacena tus commits como snapshots, optimizando internamente con delta compression.

# Crear un commit (snapshot permanente)
git commit -m "Descripción de los cambios"

El Flujo Completo

Working Directory → Staging Area → Repository
     (editas)    →   (add)    →   (commit)

Conceptos Fundamentales

Commits: El Corazón de Git

Un commit en Git es mucho más que “guardar cambios”. Es:

  • Un snapshot completo de tu proyecto en ese momento
  • Un identificador único (hash SHA-1)
  • Metadatos: autor, fecha, mensaje, commit padre
  • Inmutable: Una vez creado, no se modifica

¿Cómo funciona internamente?

Git usa una combinación inteligente:

  1. Snapshots para los objetos: Cada commit apunta a un tree object que representa el estado completo
  2. Delta compression para almacenamiento: Para optimizar espacio, Git comprime las diferencias entre objetos similares
  3. Packfiles para transferencia: Cuando envías/recibes datos, usa deltas para eficiencia

En resumen: Tú trabajas con snapshots completos, Git optimiza con deltas internamente.

# Estructura de un commit
commit a1b2c3d4e5f6...
Author: Tu Nombre <tu@email.com>
Date: Mon Oct 29 10:30:00 2025

    Mensaje descriptivo del commit

diff --git a/archivo.txt b/archivo.txt
index 1234567..abcdefg 100644
--- a/archivo.txt
+++ b/archivo.txt
@@ -1,3 +1,4 @@
 línea original
 línea modificada
+nueva línea

Branches: Punteros Mágicos

Las ramas en Git son simplemente punteros móviles a commits. No son copias de código.

# Crear una nueva rama
git branch feature-nueva

# Esto crea un puntero llamado "feature-nueva"
# que apunta al mismo commit que tu rama actual

Visualización:

A---B---C  (main)
     |
     D---E  (feature-nueva)

HEAD: Dónde Estás Ahora

HEAD es un puntero especial que apunta a la rama en la que estás actualmente.

# HEAD apunta a main
git checkout main
# HEAD → main → commit C

# Cambiar a feature-nueva
git checkout feature-nueva
# HEAD → feature-nueva → commit E

Comandos Esenciales y Qué Hacen Realmente

git add: Preparar Cambios

# Agregar un archivo específico
git add archivo.txt

# Agregar todos los cambios
git add .

# Agregar archivos por patrón
git add *.js

Qué hace: Mueve archivos del Working Directory al Staging Area.

git commit: Crear Snapshot

# Commit con mensaje
git commit -m "Agregar funcionalidad de login"

# Commit interactivo (permite modificar archivos)
git commit -i

# Commit con staged y unstaged changes
git commit -a -m "Mensaje"

Qué hace: Crea un nuevo snapshot con todo lo que está en el Staging Area.

git status: El Estado Actual

git status

Qué muestra:

  • Archivos modificados (unstaged)
  • Archivos en staging area (staged)
  • Archivos no trackeados
  • Rama actual y estado respecto a remote

git log: Historial de Commits

# Log básico
git log

# Log compacto
git log --oneline

# Log con gráfico
git log --oneline --graph --all

# Log de archivo específico
git log --follow archivo.txt

Trabajando con Remotos

Origen y Destino

Git es distribuido, lo que significa que tienes un repositorio local y uno o más remotos.

# Ver remotos configurados
git remote -v

# Agregar un remote
git remote add origin https://github.com/usuario/repo.git

# Enviar cambios al remote
git push origin main

# Traer cambios del remote
git pull origin main

# Traer cambios sin merge
git fetch origin

Flujo de Trabajo Típico

# 1. Traer últimos cambios
git pull origin main

# 2. Hacer tus cambios
# ... editar archivos ...

# 3. Preparar y commitear
git add .
git commit -m "Descripción clara"

# 4. Enviar cambios
git push origin main

Merge vs Rebase: La Diferencia Clave

Merge: Unir Historias

# Estás en main, quieres integrar feature
git merge feature-nueva

Resultado: Crea un “merge commit” que une ambas historias.

A---B---C---M  (main)
     \     /
      D---E  (feature-nueva)

Rebase: Reorganizar Historia

# Estás en feature, quieres reorganizar sobre main
git rebase main

Resultado: Mueve tus commits sobre el último commit de main.

A---B---C  (main)
         \
          D'---E'  (feature-nueva)

Cuándo Usar Cada Uno

Usa Merge cuando:

  • Quieres preservar la historia exacta
  • Es un feature importante o release
  • Trabajas en equipo con muchos desarrolladores

Usa Rebase cuando:

  • Quieres una historia lineal y limpia
  • Es tu feature personal
  • Antes de hacer merge a main

Problemas Comunes y Soluciones

Conflictos de Merge

Los conflictos ocurren cuando Git no puede resolver automáticamente diferencias entre commits.

# Ejemplo de conflicto
<<<<<<< HEAD
tu código aquí
=======
código del otro aquí
>>>>>>> feature-nueva

Cómo resolver:

  1. Editar el archivo manualmente
  2. Eliminar marcadores de conflicto
  3. git add archivo-resuelto
  4. git commit (Git creará el merge commit)

Commits No Deseados

# Eliminar último commit (mantener cambios)
git reset --soft HEAD~1

# Eliminar último commit y cambios
git reset --hard HEAD~1

# Revertir un commit (crear commit inverso)
git revert <hash-del-commit>

Historial Limpio

# Editar últimos commits (interactivo)
git rebase -i HEAD~3

# Modificar mensaje de último commit
git commit --amend

Buenas Prácticas Fundamentales

1. Commits Atómicos

Cada commit debe hacer UNA sola cosa bien definida.

# ❌ Mal: Un commit con todo
git add .
git commit -m "Muchos cambios no relacionados"

# ✅ Bien: Commits específicos
git add login.js
git commit -m "feat: Add user authentication"

git add styles.css
git commit -m "style: Update login form styles"

2. Mensajes de Commit Efectivos

Usa el formato convencional:

<tipo>(<alcance>): <descripción>

[optional cuerpo]

[optional footer]

Tipos comunes:

  • feat: Nueva funcionalidad
  • fix: Corrección de bug
  • docs: Documentación
  • style: Formato, sin cambios lógicos
  • refactor: Refactorización
  • test: Tests
  • chore: Mantenimiento

3. Branching Strategy Básica

# main/master: producción estable
git checkout main

# develop: desarrollo activo
git checkout develop

# feature/*: nuevas funcionalidades
git checkout -b feature/user-auth

# hotfix/*: correcciones urgentes
git checkout -b hotfix/critical-bug

Herramientas Útiles

Git Aliases

# Configurar aliases útiles
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.cm commit
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'
git config --global alias.visual '!gitk'

.gitignore

# Archivos a ignorar
node_modules/
*.log
.env
.DS_Store
dist/
build/

Preparación para Workflows Avanzados

Con estos conceptos fundamentales, ahora estás listo para entender:

  1. Git Flow: Usa branches específicas (develop, release, hotfix)
  2. GitHub Flow: Flujo simple con main + feature branches
  3. GitLab Flow: Combina lo mejor de ambos
  4. Trunk-Based Development: Desarrollo directo en main

Resumen: Lo Que Debes Recordar

  1. Git crea snapshots y usa delta compression internamente
  2. Tres estados: Working → Staging → Repository
  3. Las ramas son punteros, no copias de código
  4. HEAD es donde estás ahora mismo
  5. Merge une historias, rebase reorganiza
  6. Los commits deben ser atómicos y descriptivos

Próximos Pasos

Ahora que tienes los fundamentos:

  1. Practica estos comandos en un proyecto personal
  2. Experimenta con merge y rebase para entender la diferencia
  3. Crea tu propia estrategia de branching simple
  4. Lee sobre Git Flow para ver cómo se aplican estos conceptos

Recursos Adicionales

Este artículo es la base para entender workflows más complejos. Con estos conceptos dominados, estarás listo para Git Flow, GitHub Flow y estrategias avanzadas de colaboración.

Deja un comentario