Git — Jonatan Mata

Git es un sistema de control de versiones distribuido donde cada clon es un repositorio completo con historial total. No depende de un servidor central para funcionar — puedes hacer commits, branches y merges completamente offline.

¿Por qué importa?

Git es la infraestructura invisible sobre la que se construye todo el desarrollo de software moderno. Cada desarrollador tiene una copia completa del historial, branching y merging son operaciones de milisegundos, y la integridad criptográfica garantiza que cada commit verifica todo su contenido y ancestros. GitHub, GitLab, Bitbucket y Azure DevOps — todos están construidos sobre Git. Entender su modelo interno (objetos, refs, DAG de commits) es lo que separa a quien usa Git de quien realmente lo domina.

Modelo mental

Working Directory → Staging Area (Index) → Local Repository → Remote Repository
      edit            git add               git commit          git push

Los tres árboles de Git:

Working tree — los archivos que ves en disco
Index (staging area) — lo que irá en el próximo commit
HEAD — el último commit de la rama actual

Comandos esenciales con ejemplos

Configuración inicial

# Identidad (obligatorio antes del primer commit)
git config --global user.name "Tu Nombre"
git config --global user.email "tu@email.com"
 
# Editor por defecto
git config --global core.editor "code --wait"
 
# Ver toda la configuración activa
git config --list --show-origin
 
# Alias útiles
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.lg "log --oneline --graph --all --decorate"

Crear y clonar

# Nuevo repositorio
git init mi-proyecto
cd mi-proyecto
 
# Clonar existente
git clone https://github.com/user/repo.git
 
# Clonar solo la última revisión (rápido para CI)
git clone --depth 1 https://github.com/user/repo.git
 
# Clonar rama específica
git clone -b develop https://github.com/user/repo.git

Staging y commits

# Ver estado actual
git status
git status -s          # formato corto
 
# Agregar archivos al staging
git add archivo.ts                # archivo específico
git add src/                      # directorio completo
git add -A                        # todo (nuevos, modificados, eliminados)
git add -p                        # interactivo: elegir hunks individuales
 
# Quitar del staging (sin perder cambios)
git restore --staged archivo.ts   # Git 2.23+
git reset HEAD archivo.ts         # forma clásica
 
# Commit
git commit -m "feat: add user authentication"
git commit -am "fix: typo in header"   # add + commit (solo tracked files)
git commit --amend                      # modificar último commit
git commit --amend --no-edit            # mismo mensaje, agregar archivos olvidados
git commit --allow-empty -m "trigger CI"  # commit vacío

Branches

# Listar ramas
git branch              # locales
git branch -r           # remotas
git branch -a           # todas
git branch -v           # con último commit
 
# Crear y cambiar
git branch feature/login
git checkout feature/login
git checkout -b feature/login          # crear + cambiar en un paso
git switch -c feature/login            # Git 2.23+ (preferido)
 
# Renombrar
git branch -m viejo-nombre nuevo-nombre
git branch -m nuevo-nombre             # renombrar la rama actual
 
# Eliminar
git branch -d feature/login            # solo si ya fue mergeada
git branch -D feature/login            # forzar eliminación
git push origin --delete feature/login # eliminar rama remota

Merge y rebase

# Merge: incorporar cambios de otra rama
git checkout main
git merge feature/login                # merge commit (no fast-forward si divergen)
git merge --no-ff feature/login        # forzar merge commit (útil para historial)
git merge --squash feature/login       # aplastar todos los commits en uno
git merge --abort                      # cancelar merge con conflictos
 
# Rebase: reescribir historial sobre otra rama
git checkout feature/login
git rebase main                        # mover commits encima de main
git rebase -i HEAD~3                   # rebase interactivo (últimos 3 commits)
git rebase --abort                     # cancelar rebase
git rebase --continue                  # después de resolver conflictos
 
# Rebase interactivo — opciones por commit:
# pick   = usar commit tal cual
# reword = cambiar mensaje
# edit   = pausar para modificar
# squash = combinar con el anterior
# fixup  = combinar sin mensaje
# drop   = eliminar commit

Inspección del historial

# Log básico
git log
git log --oneline                      # una línea por commit
git log --oneline --graph --all        # grafo visual de todas las ramas
git log --since="2 weeks ago"
git log --author="nombre"
git log -- archivo.ts                  # historial de un archivo
git log -p -- archivo.ts              # con diffs
 
# Buscar en el historial
git log --grep="fix"                   # commits cuyo mensaje contiene "fix"
git log -S "functionName"              # commits que agregaron/eliminaron ese texto
git log -G "regex"                     # búsqueda por regex en diffs
 
# Diferencias
git diff                               # working tree vs staging
git diff --staged                      # staging vs último commit
git diff main..feature/login           # entre dos ramas
git diff HEAD~3..HEAD                  # últimos 3 commits
git diff --stat                        # resumen de archivos cambiados
git diff --name-only                   # solo nombres de archivos
 
# Quién escribió cada línea
git blame archivo.ts
git blame -L 10,20 archivo.ts         # solo líneas 10-20
 
# Mostrar un commit específico
git show abc1234
git show HEAD~2:archivo.ts            # archivo en un commit anterior

Stash

# Guardar cambios temporalmente
git stash                              # stash con mensaje automático
git stash push -m "work in progress"   # con mensaje descriptivo
git stash push -p                      # stash interactivo (elegir hunks)
git stash --include-untracked          # incluir archivos nuevos
 
# Recuperar
git stash pop                          # aplicar y eliminar del stash
git stash apply                        # aplicar sin eliminar
git stash apply stash@{2}             # aplicar un stash específico
 
# Gestionar
git stash list                         # ver todos los stashes
git stash show -p stash@{0}           # ver contenido de un stash
git stash drop stash@{0}              # eliminar un stash
git stash clear                        # eliminar todos

Remotos

# Ver remotos configurados
git remote -v
 
# Agregar remoto
git remote add upstream https://github.com/original/repo.git
 
# Traer cambios sin merge
git fetch origin
git fetch --all                        # de todos los remotos
git fetch --prune                      # eliminar refs de ramas remotas borradas
 
# Traer y merge
git pull                               # fetch + merge
git pull --rebase                      # fetch + rebase (historial lineal)
git pull --rebase --autostash          # stash automático antes de rebase
 
# Enviar cambios
git push origin main
git push -u origin feature/login       # push + set upstream
git push --force-with-lease            # force push seguro (verifica que nadie más pusheó)
git push origin --tags                 # enviar todos los tags

Deshacer cambios

# Descartar cambios en working tree
git restore archivo.ts                 # Git 2.23+
git checkout -- archivo.ts             # forma clásica
 
# Deshacer último commit (mantener cambios)
git reset --soft HEAD~1                # cambios quedan en staging
git reset --mixed HEAD~1               # cambios quedan en working tree (default)
git reset --hard HEAD~1                # ⚠️ eliminar cambios completamente
 
# Revertir un commit (crea nuevo commit inverso — seguro para ramas compartidas)
git revert abc1234
git revert HEAD                        # revertir último commit
git revert --no-commit HEAD~3..HEAD    # revertir rango sin commits individuales
 
# Recuperar commits «perdidos»
git reflog                             # historial de movimientos de HEAD
git checkout abc1234                   # ir a un commit del reflog
git branch recovery abc1234            # crear rama desde commit recuperado

Cherry-pick y bisect

# Aplicar un commit específico a la rama actual
git cherry-pick abc1234
git cherry-pick abc1234 def5678        # múltiples commits
git cherry-pick --no-commit abc1234    # aplicar sin commit
 
# Encontrar el commit que introdujo un bug (búsqueda binaria)
git bisect start
git bisect bad                         # el commit actual tiene el bug
git bisect good v1.0.0                 # este commit estaba bien
# Git te lleva a commits intermedios — marcas good/bad hasta encontrar el culpable
git bisect reset                       # volver al estado normal
 
# Bisect automático con un script de test
git bisect start HEAD v1.0.0
git bisect run npm test

Limpieza y mantenimiento

# Eliminar archivos no rastreados
git clean -n                           # dry run (ver qué se eliminaría)
git clean -fd                          # eliminar archivos y directorios
git clean -fdx                         # incluir archivos ignorados por .gitignore
 
# Optimizar repositorio
git gc                                 # garbage collection
git gc --aggressive                    # compresión más agresiva
 
# Verificar integridad
git fsck

.gitignore

# Patrones comunes
node_modules/
dist/
.env
.env.local
*.log
.DS_Store
.next/
coverage/

Regla clave: nunca commitear secretos. Si un secreto llega al historial, rotarlo inmediatamente — git filter-branch o BFG Repo-Cleaner pueden eliminarlo del historial, pero asume que ya fue comprometido.

Referencias

Pro Git Book — Scott Chacon & Ben Straub, 2014. El libro definitivo, gratuito y oficial.
Git Reference — Git Project. Documentación oficial de cada comando.
Oh Shit, Git!?! — Katie Sylor-Miller. Guía práctica para salir de situaciones comunes.
Atlassian Git Tutorials — Atlassian, 2024. Tutoriales visuales con explicaciones claras.
Git Flight Rules — Kate Hudson, 2023. Recetas para escenarios específicos estilo «flight rules» de la NASA.