Git es la herramienta de control de versiones más usada en el mundo del desarrollo de software. Si trabajas solo o en equipo, conocer Git a fondo marca la diferencia entre un desarrollador junior y uno que realmente sabe lo que hace. Esta guía te lleva de cero a dominarlo.

¿Qué es Git y por qué es indispensable?

Git es un sistema de control de versiones distribuido creado por Linus Torvalds en 2005. Te permite registrar cambios en tu código, volver a versiones anteriores, trabajar en paralelo con otras personas y mucho más. GitHub, GitLab y Bitbucket son plataformas que alojan repositorios Git en la nube.

Instalación y configuración inicial

Antes de empezar, necesitas instalar Git y configurar tu identidad. Esta información aparecerá en cada commit que hagas.

# Instalar Git en Ubuntu/Debian
sudo apt install git

# Instalar en macOS con Homebrew
brew install git

# Verificar instalación
git --version

# Configurar tu identidad
git config --global user.name "Tu Nombre"
git config --global user.email "tu@email.com"

# Configurar el editor por defecto
git config --global core.editor "code --wait"  # VS Code

# Ver toda la configuración
git config --list

Los tres estados de Git

Para entender Git, debes conocer sus tres áreas principales. El Working Directory es donde tienes tus archivos y haces cambios. El Staging Area (o índice) es una zona intermedia donde preparas los cambios que quieres guardar. El Repository es donde Git almacena definitivamente los snapshots de tu proyecto.

Comandos esenciales de Git

# Inicializar un repositorio nuevo
git init

# Clonar un repositorio existente
git clone https://github.com/usuario/repositorio.git

# Ver el estado actual
git status

# Añadir archivos al staging area
git add archivo.js          # Un archivo específico
git add .                   # Todos los archivos modificados
git add -p                  # Interactivo: elegir partes de archivos

# Crear un commit
git commit -m "feat: añadir funcionalidad de login"

# Ver el historial de commits
git log
git log --oneline --graph   # Versión compacta y visual

# Ver diferencias
git diff                    # Cambios sin añadir al staging
git diff --staged           # Cambios en staging vs último commit

Ramas: la característica más poderosa de Git

Las ramas te permiten trabajar en nuevas funcionalidades de forma aislada sin afectar el código principal. Son una de las características más importantes de Git y la base del trabajo colaborativo.

# Crear una rama nueva
git branch feature/login

# Cambiar a una rama
git checkout feature/login

# Crear y cambiar en un solo comando (forma moderna)
git switch -c feature/login

# Ver todas las ramas
git branch -a

# Fusionar una rama en la actual
git merge feature/login

# Eliminar una rama (ya fusionada)
git branch -d feature/login

# Eliminar una rama remota
git push origin --delete feature/login

Trabajar con repositorios remotos (GitHub)

GitHub es la plataforma más popular para alojar repositorios Git. Aquí tienes los comandos fundamentales para sincronizar tu trabajo local con el remoto.

# Conectar tu repo local con GitHub
git remote add origin https://github.com/tu-usuario/mi-proyecto.git

# Subir cambios al remoto
git push origin main

# Descargar cambios del remoto
git pull origin main

# Descargar cambios sin fusionar
git fetch origin

# Ver los remotos configurados
git remote -v

Git Flow: estrategia de ramas para proyectos reales

En proyectos profesionales, no puedes trabajar sin orden. Git Flow es una de las estrategias más populares. Define ramas específicas para cada tipo de trabajo: main para producción, develop para integración, feature/* para nuevas funcionalidades, hotfix/* para correcciones urgentes y release/* para preparar versiones.

Reescribir la historia: rebase y amend

A veces necesitas limpiar tus commits antes de compartirlos. Git te da herramientas para ello, aunque debes usarlas con cuidado en ramas compartidas.

# Modificar el último commit (mensaje o archivos)
git commit --amend -m "Nuevo mensaje de commit"

# Rebase interactivo: limpiar los últimos 3 commits
git rebase -i HEAD~3

# Rebase de una rama sobre otra
git checkout feature/login
git rebase main

# Stash: guardar cambios temporalmente
git stash
git stash pop          # Recuperar el último stash
git stash list         # Ver todos los stashes

Commits semánticos: escribe mensajes que aporten valor

El estándar Conventional Commits hace que el historial de tu proyecto sea legible por humanos y máquinas. El formato es: tipo(alcance): descripción. Los tipos más comunes son feat (nueva funcionalidad), fix (corrección de bug), docs (documentación), refactor, test y chore (tareas de mantenimiento).

Comandos de emergencia: cuando algo sale mal

# Deshacer el último commit (mantiene los cambios)
git reset --soft HEAD~1

# Deshacer y tirar los cambios (¡cuidado!)
git reset --hard HEAD~1

# Revertir un commit ya publicado (crea un commit nuevo)
git revert abc1234

# Recuperar un archivo borrado
git checkout HEAD -- archivo.js

# Ver qué cambió en un commit específico
git show abc1234

# Buscar en qué commit se introdujo un bug
git bisect start
git bisect bad          # El commit actual tiene el bug
git bisect good v1.0    # Este commit estaba bien

Git puede parecer intimidante al principio, pero con práctica diaria se convierte en una herramienta natural. Lo más importante es entender el modelo mental: snapshots, ramas y la diferencia entre tu área de trabajo, el staging y el repositorio.