Guía de Comandos Git 2026 - Cheat Sheet Completa

Introducción: Git en 2026

Git sigue siendo el sistema de control de versiones más utilizado en el mundo del desarrollo de software. Ya sea que trabajes en un proyecto personal o en un equipo de cientos de desarrolladores, dominar Git es una habilidad esencial que mejorará tu productividad y tu capacidad para colaborar de manera efectiva.

Esta guía completa cubre desde los comandos más básicos hasta técnicas avanzadas que todo desarrollador debería conocer en 2026. Incluye ejemplos prácticos, consejos profesionales y las mejores prácticas para trabajar con repositorios Git en proyectos reales.

Configuración Inicial

Antes de empezar a trabajar con Git, necesitas configurar tu identidad y algunas preferencias básicas.

Configuración Global

# Configurar nombre de usuario
git config --global user.name "Tu Nombre"

# Configurar email
git config --global user.email "tu@email.com"

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

# Configurar el nombre de la rama principal
git config --global init.defaultBranch main

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

# Configurar alias ú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 -m"
git config --global alias.lg "log --oneline --graph --all"

Configuración por Proyecto

# Configurar usuario solo para un repositorio específico
git config user.name "Nombre para este proyecto"
git config user.email "email-proyecto@empresa.com"

Comandos Básicos: El Día a Día

Crear y Clonar Repositorios

# Inicializar un nuevo repositorio
git init

# Inicializar con un nombre de rama específico
git init -b main

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

# Clonar un repositorio en una carpeta específica
git clone https://github.com/usuario/repo.git mi-carpeta

# Clonar solo una rama específica
git clone -b develop --single-branch https://github.com/usuario/repo.git

# Clonar con profundidad limitada (útil para repos grandes)
git clone --depth 1 https://github.com/usuario/repo.git

Estado y Seguimiento de Cambios

# Ver el estado del repositorio
git status

# Ver estado en formato corto
git status -s

# Ver diferencias en archivos modificados (no staged)
git diff

# Ver diferencias en archivos staged
git diff --staged

# Ver diferencias entre dos ramas
git diff main..develop

# Ver diferencias de un archivo específico
git diff -- archivo.ts

Añadir y Confirmar Cambios

# Añadir un archivo específico al staging area
git add archivo.ts

# Añadir todos los archivos modificados y nuevos
git add .

# Añadir archivos de forma interactiva
git add -p

# Confirmar cambios con mensaje
git commit -m "feat: añadir autenticación con JWT"

# Confirmar con mensaje de múltiples líneas
git commit -m "feat: añadir autenticación con JWT" -m "Implementa login, logout y refresh token"

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

# Añadir archivos olvidados al último commit
git add archivo-olvidado.ts
git commit --amend --no-edit

Trabajo con Ramas

Las ramas son fundamentales para el flujo de trabajo en Git. Te permiten trabajar en funcionalidades de forma aislada sin afectar el código principal.

Gestión de Ramas

# Listar ramas locales
git branch

# Listar todas las ramas (locales y remotas)
git branch -a

# Listar ramas con información detallada
git branch -vv

# Crear una nueva rama
git branch feature/nueva-funcionalidad

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

# Forma moderna (Git 2.23+)
git switch -c feature/nueva-funcionalidad

# Cambiar a una rama existente
git switch main

# Renombrar la rama actual
git branch -m nuevo-nombre

# Renombrar otra rama
git branch -m nombre-viejo nombre-nuevo

# Eliminar una rama local (solo si está fusionada)
git branch -d feature/completada

# Forzar eliminación de una rama local
git branch -D feature/abandonada

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

Fusión de Ramas (Merge)

# Fusionar una rama en la rama actual
git merge feature/nueva-funcionalidad

# Fusionar sin fast-forward (crea un commit de merge)
git merge --no-ff feature/nueva-funcionalidad

# Fusionar con squash (combina todos los commits en uno)
git merge --squash feature/nueva-funcionalidad

# Abortar una fusión con conflictos
git merge --abort

Rebase

# Rebase de la rama actual sobre main
git rebase main

# Rebase interactivo de los últimos 5 commits
git rebase -i HEAD~5

# Continuar rebase después de resolver conflictos
git rebase --continue

# Abortar un rebase en progreso
git rebase --abort

# Rebase con autosquash
git rebase -i --autosquash main

Trabajo con Remotos

Gestión de Remotos

# Ver remotos configurados
git remote -v

# Añadir un remoto
git remote add origin https://github.com/usuario/repo.git

# Añadir un segundo remoto (por ejemplo, upstream)
git remote add upstream https://github.com/original/repo.git

# Cambiar la URL de un remoto
git remote set-url origin https://nueva-url.git

# Eliminar un remoto
git remote remove nombre

Push y Pull

# Enviar cambios al remoto
git push origin main

# Enviar y configurar upstream tracking
git push -u origin feature/nueva-funcionalidad

# Enviar todas las ramas
git push --all

# Enviar tags
git push --tags

# Obtener cambios del remoto sin fusionar
git fetch origin

# Obtener y fusionar cambios
git pull origin main

# Pull con rebase en vez de merge
git pull --rebase origin main

# Forzar push (usar con precaución)
git push --force-with-lease origin feature/mi-rama

Historial y Navegación

Ver el Historial

# Ver el log completo
git log

# Log en una línea por commit
git log --oneline

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

# Log de los últimos 10 commits
git log -10

# Log filtrado por autor
git log --author="nombre"

# Log filtrado por fecha
git log --after="2026-01-01" --before="2026-03-16"

# Log filtrado por mensaje
git log --grep="fix"

# Log de un archivo específico
git log -- archivo.ts

# Log con estadísticas de cambios
git log --stat

# Ver quién modificó cada línea de un archivo
git blame archivo.ts

# Buscar un string en el historial
git log -S "nombreFuncion" --oneline

Navegación y Restauración

# Ver un commit específico
git show abc1234

# Ver un archivo en un commit específico
git show abc1234:src/archivo.ts

# Restaurar un archivo al último commit
git restore archivo.ts

# Restaurar un archivo del staging area
git restore --staged archivo.ts

# Restaurar un archivo a un commit específico
git restore --source=abc1234 archivo.ts

Técnicas Avanzadas

Stash (Almacenamiento Temporal)

# Guardar cambios temporalmente
git stash

# Guardar con un mensaje descriptivo
git stash save "WIP: trabajando en el login"

# Guardar incluyendo archivos no rastreados
git stash -u

# Listar stashes guardados
git stash list

# Aplicar el último stash y eliminarlo de la pila
git stash pop

# Aplicar un stash específico sin eliminarlo
git stash apply stash@{2}

# Eliminar un stash específico
git stash drop stash@{1}

# Eliminar todos los stashes
git stash clear

# Crear una rama desde un stash
git stash branch nueva-rama stash@{0}

Cherry-Pick

# Aplicar un commit específico a la rama actual
git cherry-pick abc1234

# Cherry-pick sin hacer commit automático
git cherry-pick --no-commit abc1234

# Cherry-pick de múltiples commits
git cherry-pick abc1234 def5678

# Cherry-pick de un rango de commits
git cherry-pick abc1234..def5678

Bisect (Búsqueda Binaria de Bugs)

# Iniciar bisect
git bisect start

# Marcar el commit actual como malo
git bisect bad

# Marcar un commit conocido como bueno
git bisect good abc1234

# Git automáticamente navega al commit medio
# Probar y marcar como bueno o malo
git bisect good  # o git bisect bad

# Finalizar bisect
git bisect reset

# Bisect automático con un script de test
git bisect start HEAD abc1234
git bisect run npm test

Worktrees (Árboles de Trabajo Múltiples)

# Crear un worktree adicional
git worktree add ../mi-feature feature/login

# Listar worktrees activos
git worktree list

# Eliminar un worktree
git worktree remove ../mi-feature

# Crear un worktree con nueva rama basada en main
git worktree add -b hotfix/urgente ../hotfix main

Reflog (Registro de Referencias)

# Ver el reflog completo
git reflog

# Recuperar un commit perdido
git checkout abc1234

# Crear una rama desde un commit perdido
git branch recuperar abc1234

# Recuperar después de un reset --hard accidental
git reflog
git reset --hard HEAD@{2}

Resolución de Conflictos

Los conflictos son inevitables al trabajar en equipo. Aquí te mostramos cómo manejarlos eficientemente:

Proceso de Resolución

# 1. Identificar archivos con conflictos
git status

# 2. Abrir los archivos y buscar marcadores de conflicto
# <<<<<<< HEAD
# Tu código
# =======
# Código de la otra rama
# >>>>>>> feature/otra-rama

# 3. Editar y resolver manualmente, luego marcar como resuelto
git add archivo-resuelto.ts

# 4. Completar el merge
git commit

# Usar herramienta visual para resolver conflictos
git mergetool

Estrategias para Prevenir Conflictos

Pull frecuente: Mantén tu rama actualizada con la rama principal
Ramas pequeñas: Trabaja en cambios pequeños y específicos
Comunicación: Coordina con tu equipo sobre qué archivos está modificando cada uno
Commits atómicos: Haz commits pequeños y enfocados

Convenciones de Commits

Seguir convenciones como Conventional Commits mejora la legibilidad del historial:

# Tipos comunes de commits
git commit -m "feat: añadir sistema de notificaciones push"
git commit -m "fix: corregir error de autenticación en mobile"
git commit -m "docs: actualizar documentación de la API"
git commit -m "style: formatear código según ESLint"
git commit -m "refactor: simplificar lógica de validación"
git commit -m "test: añadir tests unitarios para UserService"
git commit -m "chore: actualizar dependencias de desarrollo"
git commit -m "perf: optimizar consultas de base de datos"

Herramientas Complementarias

Para trabajar eficientemente con Git, es fundamental contar con buenas herramientas complementarias. Si necesitas formatear archivos JSON de configuración, utiliza nuestro formateador de JSON. Para verificar expresiones regulares en tus archivos .gitignore o hooks, prueba el probador de regex. Y si trabajas con datos codificados en tus repositorios, la herramienta de codificación Base64 te será muy útil.

Consejos de Productividad

Usa alias: Configura alias para los comandos que más utilizas
Hooks de Git: Automatiza validaciones con pre-commit hooks
Archivos .gitignore: Mantén tu repositorio limpio ignorando archivos innecesarios
Firma tus commits: Usa GPG para verificar la autoría de tus commits
Revisa antes de pushear: Siempre revisa tus cambios con git diff --staged antes de confirmar

Conclusión

Dominar Git requiere práctica constante y curiosidad por explorar funcionalidades avanzadas más allá de los comandos básicos. Esta guía te proporciona las herramientas necesarias para manejar cualquier situación que encuentres en tu flujo de trabajo diario, desde operaciones rutinarias hasta la recuperación de commits perdidos o la resolución de conflictos complejos.

Recuerda que Git es extremadamente potente y, con el conocimiento adecuado, se convierte en tu mejor aliado para mantener un historial limpio, colaborar eficientemente y entregar código de calidad. Practica regularmente, experimenta en repositorios de prueba y consulta esta guía siempre que lo necesites.