Git es el sistema de control de versiones más usado en el mundo del desarrollo de software. Te permite llevar un historial de cambios, trabajar en equipo sin conflictos y volver a cualquier punto anterior de tu proyecto. En esta guía aprenderás los comandos más importantes con diagramas que te ayudarán a visualizar cada operación.
Cómo funciona Git internamente
Antes de ver los comandos, es fundamental entender las tres áreas principales de Git:
- Working Directory — Los archivos que ves y editas en tu editor
- Staging Area — Los cambios que has marcado para incluir en el próximo commit
- Local Repository — El historial completo de commits en tu máquina
- Remote Repository — La copia en el servidor (GitHub, GitLab, etc.)
Configuración inicial
Antes de empezar, configura tu identidad:
# Configurar nombre y email (obligatorio para commits)
git config --global user.name "Tu Nombre"
git config --global user.email "[email protected]"
# Ver la configuración actual
git config --list
# Configurar el editor por defecto
git config --global core.editor "code --wait"
Crear y clonar repositorios
# Inicializar un repositorio nuevo en el directorio actual
git init
# Clonar un repositorio existente
git clone https://github.com/usuario/proyecto.git
# Clonar en un directorio específico
git clone https://github.com/usuario/proyecto.git mi-proyecto
El ciclo básico: add, commit, push
Este es el flujo que usarás el 90% del tiempo:
git status — Ver el estado actual
# Muestra archivos modificados, en staging y sin rastrear
git status
# Versión compacta
git status -s
La salida te muestra:
- Rojo — Archivos modificados o nuevos que NO están en staging
- Verde — Archivos en staging, listos para commit
git add — Preparar cambios
# Añadir un archivo específico
git add index.html
# Añadir varios archivos
git add index.html style.css app.js
# Añadir todos los archivos modificados
git add .
# Añadir solo archivos con cierta extensión
git add *.js
git commit — Guardar cambios
# Commit con mensaje inline
git commit -m "Añadir página de contacto"
# Commit con mensaje multilínea
git commit -m "Añadir página de contacto
- Crear formulario con validación
- Añadir estilos responsive
- Integrar con API de email"
# Añadir al staging y hacer commit en un paso (solo archivos ya rastreados)
git commit -am "Corregir bug en el formulario"
Buenas prácticas para mensajes de commit:
- Usa imperativo: "Añadir feature" en vez de "Añadida feature"
- Primera línea: máximo 50 caracteres
- Si necesitas más detalle, deja una línea en blanco y añade el cuerpo
git push — Subir cambios al remoto
# Subir la rama actual
git push
# Subir y vincular la rama al remoto
git push -u origin main
# Subir una rama específica
git push origin mi-feature
git pull — Descargar cambios del remoto
# Descargar y fusionar cambios
git pull
# Equivalente a:
git fetch + git merge
# Pull con rebase (historial más limpio)
git pull --rebase
Ramas (branches)
Las ramas son la herramienta más poderosa de Git. Te permiten trabajar en features, fixes o experimentos de forma aislada.
Comandos de ramas
# Ver todas las ramas locales
git branch
# Ver ramas locales y remotas
git branch -a
# Crear una rama nueva
git branch feature/login
# Crear y cambiar a la nueva rama
git checkout -b feature/login
# o con el comando más moderno:
git switch -c feature/login
# Cambiar de rama
git checkout main
# o:
git switch main
# Eliminar una rama (ya mergeada)
git branch -d feature/login
# Eliminar una rama (forzar)
git branch -D feature/experimental
# Renombrar la rama actual
git branch -m nuevo-nombre
Merge — Fusionar ramas
El merge combina los cambios de una rama en otra.
# Primero, cambia a la rama destino
git checkout main
# Fusionar una rama en la actual
git merge feature/login
# Merge sin fast-forward (siempre crea un commit de merge)
git merge --no-ff feature/login
Resolver conflictos de merge
Cuando dos ramas modifican las mismas líneas, Git no puede decidir cuál mantener y marca un conflicto:
<<<<<<< HEAD
const color = "azul";
=======
const color = "rojo";
>>>>>>> feature/tema
Para resolverlo:
- Abre el archivo y elige qué código mantener
- Elimina los marcadores (
<<<<<<<,=======,>>>>>>>) - Haz
git adddel archivo resuelto - Haz
git commitpara completar el merge
Rebase — Reescribir el historial
El rebase mueve tus commits al final de otra rama, creando un historial lineal y más limpio.
# Estando en la rama feature:
git rebase main
# Si hay conflictos, resuélvelos y continúa:
git add .
git rebase --continue
# Cancelar un rebase en progreso:
git rebase --abort
Merge vs Rebase: Usa merge para ramas compartidas (preserva la historia real). Usa rebase para ramas locales de trabajo (historial más limpio). Nunca hagas rebase de ramas que ya están en el remoto y otros usan.
Inspeccionar el historial
# Ver el log de commits
git log
# Log compacto en una línea
git log --oneline
# Log con gráfico de ramas
git log --oneline --graph --all
# Ver los cambios de un commit específico
git show abc1234
# Ver diferencias entre el working directory y el staging
git diff
# Ver diferencias en el staging (lo que va en el próximo commit)
git diff --staged
# Ver diferencias entre dos ramas
git diff main..feature/login
Deshacer cambios
# Descartar cambios en un archivo (volver a la versión del último commit)
git restore archivo.js
# Quitar un archivo del staging (pero mantener los cambios)
git restore --staged archivo.js
# Revertir un commit (crea un nuevo commit que deshace los cambios)
git revert abc1234
# Volver a un commit anterior (mantiene los cambios en working directory)
git reset --soft abc1234
# Volver a un commit anterior (descarta todos los cambios)
git reset --hard abc1234
Cuidado con
git reset --hard: elimina cambios de forma irreversible. Úsalo solo si estás seguro de que no necesitas esos cambios.
Stash — Guardar cambios temporalmente
El stash te permite guardar cambios sin hacer commit, ideal para cuando necesitas cambiar de rama rápidamente.
# Guardar cambios actuales en el stash
git stash
# Guardar con un mensaje descriptivo
git stash save "WIP: formulario de registro"
# Ver la lista de stashes
git stash list
# Recuperar el último stash (y eliminarlo del stash)
git stash pop
# Recuperar un stash específico
git stash apply stash@{2}
# Eliminar un stash
git stash drop stash@{0}
Flujo de trabajo con Git
Un flujo de trabajo típico para trabajar en equipo:
Resumen de comandos
| Comando | Descripción |
|---|---|
git init |
Inicializar un repositorio |
git clone url |
Clonar un repositorio |
git status |
Ver estado de los archivos |
git add archivo |
Añadir al staging |
git commit -m "msg" |
Guardar cambios |
git push |
Subir al remoto |
git pull |
Descargar del remoto |
git branch nombre |
Crear rama |
git checkout -b rama |
Crear y cambiar de rama |
git merge rama |
Fusionar una rama |
git rebase rama |
Rebase sobre otra rama |
git log --oneline |
Ver historial compacto |
git stash |
Guardar cambios temporales |
git diff |
Ver diferencias |
git restore archivo |
Descartar cambios |
git revert hash |
Revertir un commit |
Conclusión
Git puede parecer intimidante al principio, pero con práctica estos comandos se vuelven naturales. Lo más importante es entender el flujo: editar → preparar (add) → guardar (commit) → compartir (push). Una vez que domines este ciclo básico, las ramas, merges y rebases se convertirán en herramientas que usarás sin pensar.
El mejor consejo: no tengas miedo de experimentar. Mientras no hagas push, tus cambios son locales y puedes deshacerlos fácilmente. Crea un repositorio de prueba y practica con todos estos comandos.
¡Happy coding!