Hoja de Referencia de Git: Comandos Esenciales para Cada Desarrollador

31 de marzo de 2026 · 12 min de lectura

Git es el sistema de control de versiones más utilizado en el mundo, impulsando millones de proyectos desde proyectos personales hasta aplicaciones empresariales. Ya seas un desarrollador individual o parte de un equipo grande, conocer los comandos esenciales de Git ahorra tiempo y previene errores.

Esta hoja de referencia completa cubre cada comando que necesitarás para el trabajo de desarrollo diario, desde operaciones básicas hasta flujos de trabajo avanzados. Lo hemos organizado por tipo de tarea para que puedas encontrar rápidamente lo que necesitas cuando lo necesitas.

Guarda esta página como tu referencia rápida. Para formatear tu documentación de Git y archivos README, prueba nuestro Editor de Markdown.

Configuración Inicial

Antes de tu primer commit, necesitas configurar tu identidad. Estas configuraciones se almacenan globalmente y se adjuntan a cada commit que hagas, para que otros desarrolladores sepan quién hizo qué cambios.

Configuración Inicial

git config --global user.name "Tu Nombre"
git config --global user.email "[email protected]"
git config --global init.defaultBranch main
git config --global core.editor "code --wait"

La bandera --global aplica estas configuraciones a todos los repositorios en tu máquina. Si necesitas configuraciones diferentes para un proyecto específico, ejecuta los mismos comandos sin --global dentro de ese repositorio.

Opciones de Configuración Útiles

git config --global color.ui auto              # Habilitar salida con colores
git config --global core.autocrlf true         # Manejar finales de línea (Windows)
git config --global core.autocrlf input        # Manejar finales de línea (Mac/Linux)
git config --global pull.rebase false          # Usar estrategia de fusión para pulls
git config --global alias.st status            # Crear atajo: git st
git config --global alias.co checkout          # Crear atajo: git co
git config --global alias.br branch            # Crear atajo: git br
git config --global alias.ci commit            # Crear atajo: git ci

Ver y Editar Configuración

git config --list                              # Ver todas las configuraciones
git config --list --show-origin                # Mostrar dónde está definida cada configuración
git config user.name                           # Ver configuración específica
git config --global --edit                     # Editar configuración global en el editor

Creación de Repositorios

Hay dos formas de comenzar a trabajar con Git: inicializar un nuevo repositorio o clonar uno existente desde un servidor remoto.

Inicializar un Nuevo Repositorio

git init                                       # Inicializar repo en el directorio actual
git init mi-proyecto                           # Crear nuevo directorio con repo
git init --bare repositorio-compartido.git     # Crear repo bare (para servidores)

Cuando ejecutas git init, Git crea un directorio oculto .git que almacena toda la información de control de versiones. Este directorio contiene todo el historial de tu proyecto, configuración y metadatos.

Clonar un Repositorio Existente

git clone https://github.com/usuario/repo.git  # Clonar vía HTTPS
git clone [email protected]:usuario/repo.git      # Clonar vía SSH
git clone <url> mi-carpeta                     # Clonar en directorio específico
git clone --depth 1 <url>                      # Clonación superficial (solo último commit)
git clone --branch develop <url>               # Clonar rama específica

Las clonaciones superficiales son útiles para pipelines de CI/CD o cuando solo necesitas el código más reciente sin el historial completo. Son significativamente más rápidas y usan menos espacio en disco.

Comandos de Flujo de Trabajo Básico

El flujo de trabajo central de Git gira en torno a tres áreas: el directorio de trabajo (tus archivos), el área de preparación (cambios listos para commit), y el repositorio (historial confirmado). Entender este flujo es crucial para usar Git efectivamente.

Verificar Estado

git status                                     # Verificar estado del árbol de trabajo
git status -s                                  # Formato de salida corto
git status -sb                                 # Formato corto con información de rama

Ejecuta git status frecuentemente. Muestra qué archivos están modificados, preparados o sin seguimiento, y te ayuda a entender el estado actual de tu repositorio.

Preparar Cambios

git add archivo.txt                            # Preparar un archivo específico
git add *.js                                   # Preparar todos los archivos JavaScript
git add .                                      # Preparar todos los cambios
git add -A                                     # Preparar todos los cambios (incluyendo eliminaciones)
git add -p                                     # Preparar cambios interactivamente (modo parche)
git add -u                                     # Preparar solo archivos modificados y eliminados

El área de preparación (también llamada índice) te permite crear commits precisos. Puedes preparar solo los cambios que quieres incluir, incluso si has modificado múltiples archivos.

Confirmar Cambios

git commit -m "Agregar autenticación de usuario"  # Commit con mensaje
git commit -am "Corregir error de inicio de sesión" # Preparar archivos rastreados + commit
git commit --amend                             # Modificar el último commit
git commit --amend --no-edit                   # Modificar sin cambiar el mensaje
git commit -v                                  # Mostrar diff en el editor de mensajes de commit

Escribe mensajes de commit claros y descriptivos. Un buen formato es: un resumen corto (50 caracteres o menos), seguido de una línea en blanco, luego una explicación detallada si es necesario.

Ver Cambios

git diff                                       # Mostrar cambios no preparados
git diff --staged                              # Mostrar cambios preparados
git diff HEAD                                  # Mostrar todos los cambios desde el último commit
git diff rama1..rama2                          # Comparar dos ramas
git diff --stat                                # Mostrar estadísticas de cambios
git diff --word-diff                           # Mostrar diferencias a nivel de palabra

Ramificación y Fusión

Las ramas son una de las características más poderosas de Git. Te permiten trabajar en funcionalidades, correcciones o experimentos de forma aislada sin afectar el código base principal.

Gestión de Ramas

git branch                                     # Listar ramas locales
git branch -a                                  # Listar todas las ramas (locales + remotas)
git branch feature-login                       # Crear nueva rama
git branch -d feature-login                    # Eliminar rama (seguro)
git branch -D feature-login                    # Forzar eliminación de rama
git branch -m nombre-viejo nombre-nuevo        # Renombrar rama
git branch -vv                                 # Mostrar ramas con información de seguimiento

Cambiar de Rama

git checkout feature-login                     # Cambiar a rama
git checkout -b feature-signup                 # Crear y cambiar a nueva rama
git checkout -                                 # Cambiar a rama anterior
git switch feature-login                       # Forma moderna de cambiar ramas
git switch -c feature-signup                   # Crear y cambiar (sintaxis moderna)

El comando git switch fue introducido en Git 2.23 como una alternativa más clara a git checkout, que tiene múltiples propósitos. Ambos funcionan idénticamente para cambiar ramas.

Fusionar Ramas

git merge feature-login                        # Fusionar rama en la rama actual
git merge --no-ff feature-login                # Forzar commit de fusión (sin fast-forward)
git merge --squash feature-login               # Comprimir commits en uno
git merge --abort                              # Cancelar fusión en progreso

Cuando fusionas, Git combina los cambios de dos ramas. Si ambas ramas modificaron las mismas líneas, obtendrás un conflicto de fusión que necesita resolución manual.

Resolver Conflictos de Fusión

Cuando ocurren conflictos, Git marca las secciones en conflicto en tus archivos:

<<<<<<< HEAD
Tus cambios actuales
=======
Cambios entrantes de la rama que se está fusionando
>>>>>>> rama-caracteristica

Para resolver conflictos:

1. Abre los archivos en conflicto y edítalos para resolver los conflictos
2. Elimina los marcadores de conflicto (<<<<<<<, =======, >>>>>>>)
3. Prepara los archivos resueltos con git add
4. Completa la fusión con git commit

git status                                     # Ver qué archivos tienen conflictos
git add archivo-resuelto.js                    # Marcar conflicto como resuelto
git merge --continue                           # Continuar fusión después de resolver
git merge --abort                              # Rendirse y empezar de nuevo

Rebase

git rebase main                                # Rebasar rama actual sobre main
git rebase -i HEAD~3                           # Rebase interactivo de los últimos 3 commits
git rebase --continue                          # Continuar después de resolver conflictos
git rebase --abort                             # Cancelar rebase en progreso
git rebase --skip                              # Saltar commit actual durante rebase

El rebase reescribe el historial moviendo tus commits a una nueva base. Crea un historial más limpio y lineal pero nunca debe hacerse en ramas públicas que otros estén usando.

Operaciones Remotas

Los repositorios remotos son versiones de tu proyecto alojadas en internet o en una red. Permiten la colaboración y el respaldo.

Gestionar Remotos

git remote                                     # Listar conexiones remotas
git remote -v                                  # Listar remotos con URLs
git remote add origin <url>                    # Agregar nuevo remoto
git remote remove origin                       # Eliminar remoto
git remote rename origin upstream              # Renombrar remoto
git remote set-url origin <nueva-url>          # Cambiar URL del remoto
git remote show origin                         # Mostrar información detallada del remoto

Obtener y Traer

git fetch                                      # Descargar cambios remotos
git fetch origin                               # Obtener de remoto específico
git fetch --all                                # Obtener de todos los remotos
git fetch --prune                              # Eliminar ramas remotas eliminadas
git pull                                       # Obtener y fusionar cambios remotos
git pull --rebase                              # Obtener y rebasar en lugar de fusionar
git pull origin main                           # Traer rama específica

La diferencia entre fetch y pull: fetch descarga cambios pero no modifica tu directorio de trabajo, mientras que pull obtiene e inmediatamente fusiona los cambios.

Enviar Cambios

git push                                       # Enviar a remoto/rama predeterminado
git push origin main                           # Enviar a remoto/rama específico
git push -u origin feature-login               # Enviar y establecer seguimiento upstream
git push --all                                 # Enviar todas las ramas
git push --tags                                # Enviar todas las etiquetas
git push --force                               # Forzar envío (¡peligroso!)
git push --force-with-lease                    # Envío forzado más seguro