📝 git_apuntes
← Volver

📋 Hoja de Apuntes: Comandos Git

Asignatura: Desarrollo de Software / Control de Versiones
Nivel: Universitario — Intermedio
Herramienta: Git (cualquier versión moderna)

1. Conceptos Fundamentales

El Modelo de las Tres Zonas

┌─────────────────────┐     git add      ┌──────────────────┐    git commit    ┌───────────────┐
│  Working Directory  │ ───────────────► │  Staging Area    │ ───────────────► │  Repository   │
│  (tus archivos)     │                  │  (Index)         │                  │  (.git/)      │
└─────────────────────┘                  └──────────────────┘                  └───────────────┘
         ▲                                                                              │
         └──────────────────────────── git restore / git checkout ────────────────────┘

El Ciclo de Vida de un Archivo

Untracked → Staged → Committed → Modified → Staged → ...

2. Inicialización y Configuración

Configuración Global

git config --global user.name "Tu Nombre"
git config --global user.email "tu@email.com"
git config --global core.editor "code --wait"   # VS Code como editor
git config --list                                # Ver toda la configuración

Iniciar un Repositorio

Comando Función
git init Crear repositorio local en el directorio actual
git clone <url> Clonar repositorio remoto completo
git clone <url> <directorio> Clonar en un directorio con nombre específico

3. Staging y Commits

Regla de oro: Un commit = una idea lógica completa. Los mensajes deben responder a: "Si aplico este commit, el proyecto ____."

Comando Función
git add <archivo> Añadir archivo específico al staging
git add . Añadir todos los cambios al staging
git add -p Añadir cambios de forma interactiva (por bloques)
git commit -m "mensaje" Guardar cambios con mensaje descriptivo
git commit -am "mensaje" Ataajo: add + commit (solo archivos rastreados)
git commit --amend Modificar el último commit (mensaje o archivos)

Inspección del Estado

git status              # Estado del working directory y staging
git status -s           # Vista compacta (short)
git diff                # Diferencias en working directory (sin staging)
git diff --staged       # Diferencias en staging (listo para commit)
git log                 # Historial de commits
git log --oneline       # Historial compacto (una línea por commit)
git log --oneline --graph --all   # Árbol visual de ramas
git show <hash>         # Detalles de un commit específico

4. Ramas (Branches)

Concepto clave: Una rama es simplemente un puntero a un commit. Son ligeras y baratas de crear.

Comando Función
git branch Listar ramas locales
git branch -a Listar ramas locales y remotas
git branch <nombre> Crear nueva rama
git branch -d <nombre> Eliminar rama (seguro, comprueba merge)
git branch -D <nombre> Eliminar rama (forzado)
git checkout <rama> Cambiar a una rama existente
git checkout -b <rama> Crear rama y cambiar a ella en un solo paso
git switch <rama> Cambiar de rama (sintaxis moderna)
git switch -c <rama> Crear y cambiar de rama (sintaxis moderna)
git merge <rama> Fusionar <rama> en la rama actual
git rebase <rama> Reescribir historial sobre la punta de <rama>

merge vs rebase

Característica git merge git rebase
Historial Preserva el historial real Reescribe el historial (más lineal)
Commit extra Crea un "merge commit" No crea commit extra
Seguridad Seguro en ramas compartidas ⚠️ Peligroso en ramas públicas
Uso recomendado Integrar ramas de features completas Limpiar historial local antes de push 
# Flujo típico con merge
git checkout main
git merge feature/nueva-funcionalidad

# Flujo típico con rebase (solo en ramas locales)
git checkout feature/nueva-funcionalidad
git rebase main

5. Repositorios Remotos

Comando Función
git remote -v Ver remotos configurados (con URLs)
git remote add origin <url> Añadir remoto con alias origin
git remote rename <viejo> <nuevo> Renombrar un remoto
git remote remove <nombre> Eliminar un remoto
git push origin <rama> Subir rama al remoto
git push -u origin <rama> Subir y establecer tracking (primera vez)
git push --force-with-lease Push forzado (más seguro que --force)
git pull Descargar cambios remotos y fusionar (fetch+merge)
git pull --rebase Descargar y rebasar en lugar de fusionar
git fetch Descargar cambios sin fusionar
git fetch --prune Limpiar referencias a ramas remotas eliminadas

fetch vs pull

git fetch  →  Trae los cambios al repositorio LOCAL pero NO toca tu código.
git pull   →  fetch + merge automático. Equivale a: git fetch && git merge

6. Deshacer Cambios

⚠️ Precaución: Los comandos con --hard son destructivos e irreversibles.

Comando Alcance Función
git restore <archivo> Working dir Descartar cambios no staged en un archivo
git restore --staged <archivo> Staging Sacar un archivo del staging (sin perder cambios)
git reset --soft HEAD~1 Commits Deshace el último commit, conserva cambios staged
git reset --mixed HEAD~1 Commits+Staging Deshace commit, cambios quedan en working dir
git reset --hard HEAD~1 Todo ⚠️ Borra el último commit Y los cambios
git revert <hash> Historial Crea un nuevo commit que invierte los cambios
git checkout -- <archivo> Working dir (Clásico) Restaurar archivo desde el último commit

¿Cuándo usar reset vs revert?

reset  →  Para correcciones LOCALES. Reescribe historial.
           Úsalo ANTES de hacer push.

revert →  Para correcciones en ramas COMPARTIDAS. Seguro.
           Úsalo DESPUÉS de hacer push (no reescribe historial).

7. Etiquetas (Tags)

Los tags se usan para marcar versiones de release (e.g., v1.0.0, v2.3.1).

Comando Función
git tag Listar todos los tags
git tag v1.0 Crear tag ligero en el commit actual
git tag -a v1.0 -m "Release 1.0" Crear tag anotado (recomendado en releases)
git tag -a v1.0 <hash> Crear tag sobre un commit específico
git push origin v1.0 Subir un tag específico al remoto
git push --tags Subir todos los tags al remoto
git tag -d v1.0 Eliminar tag local

8. Comandos de Utilidad Avanzada

git stash                    # Guardar cambios temporalmente (sin commit)
git stash pop                # Recuperar y eliminar el último stash
git stash list               # Ver lista de stashes guardados

git cherry-pick <hash>       # Aplicar un commit específico en la rama actual

git blame <archivo>          # Ver quién escribió cada línea de un archivo
git bisect start             # Iniciar búsqueda binaria de bugs

git shortlog -sn             # Resumen de commits por autor

El archivo .gitignore

# Archivos de sistema
.DS_Store
Thumbs.db

# Dependencias
node_modules/
vendor/

# Variables de entorno (¡nunca al repositorio!)
.env
.env.local

# Builds
/dist
/build
*.log

9. Flujos de Trabajo (Workflows)

Flujo básico diario

git pull                          # 1. Actualizar desde remoto
git checkout -b feature/mi-tarea  # 2. Crear rama para tu tarea
# ... editar archivos ...
git add .                         # 3. Preparar cambios
git commit -m "feat: añadir X"    # 4. Confirmar cambios
git push -u origin feature/mi-tarea # 5. Subir rama
# 6. Abrir Pull Request en GitHub/GitLab

Convención de mensajes de commit (Conventional Commits)

<tipo>(<alcance>): <descripción corta>

Tipos comunes:
  feat:     Nueva funcionalidad
  fix:      Corrección de bug
  docs:     Cambios en documentación
  style:    Formato (sin cambios lógicos)
  refactor: Refactorización de código
  test:     Añadir o corregir tests
  chore:    Tareas de mantenimiento

10. Tabla Comparativa: Comandos de Deshacer

Situación Comando Recomendado Seguro en Remoto
Descartar cambio en un archivo git restore <archivo> ✅
Quitar archivo del staging git restore --staged <archivo> ✅
Rehacer el último commit git commit --amend ⚠️ Solo si no pusheaste
Deshacer commit, mantener cambios git reset --soft HEAD~1 ❌
Deshacer commit, borrar todo git reset --hard HEAD~1 ❌
Revertir un commit ya publicado git revert <hash> ✅

✅ Resumen en 3 Puntos

  1. Git opera en tres zonas: Working Directory → Staging Area → Repository. Entender el flujo add → commit es la base de todo. El staging existe para darte control granular sobre qué cambios agrupas en cada commit.

  2. Las ramas son punteros ligeros: Crear una rama no duplica el proyecto. merge preserva el historial tal cual; rebase lo reescribe de forma lineal. Usa rebase solo en ramas locales para no romper el trabajo de tu equipo.

  3. Para deshacer, elige según el contexto: Si el error es local (no pusheaste), usa reset. Si el error ya está en el repositorio remoto compartido, usa siempre revert para no reescribir historial público.

❓ Preguntas de Autoevaluación

  1. ¿Cuál es la diferencia entre git fetch y git pull? ¿En qué situación preferirías usar fetch?

  2. Tienes 3 archivos modificados: quieres commitear solo 2 de ellos. ¿Cómo lo harías paso a paso?

  3. Ya hiciste push de un commit con un error. ¿Usarías git reset o git revert? Justifica tu respuesta.

  4. ¿Qué hace exactamente git commit --amend y cuándo es peligroso usarlo?

  5. Explica con tus propias palabras la diferencia entre git merge y git rebase. ¿En qué escenario usarías cada uno?

  6. ¿Qué es el .gitignore y por qué nunca debe subirse el archivo .env a un repositorio?

📌 Documento generado para uso académico. Compatible con Obsidian, Notion, GitHub y cualquier renderizador Markdown estándar.