📘 Módulo 2: Fundamentos de Git

Fundamentos

Módulo 2: Fundamentos de Git — Repositorios, Cambios e Historial

Domina los pilares de Git: crea o clona repositorios, registra cambios con precisión y explora el historial de tu código. Aprenderás el modelo mental de áreas (working directory, staging area e historial), el uso de .gitignore y las mejores prácticas para un flujo de trabajo limpio, seguro y eficiente.

Guía rápida (en 60 segundos)

Inicializa o clona:

# Proyecto nuevo
git init -b main
# Proyecto existente
git clone <URL> mi-proyecto

Registra cambios:

git status
git add archivo.txt
git commit -m "feat: agrega nueva función"

Revisa historial y diferencias:

git log --oneline --graph --decorate
git diff
git diff --staged

Ignora archivos no deseados:

echo "node_modules/" >> .gitignore
echo ".env" >> .gitignore

Consejo: Configura tu identidad antes de tu primer commit.

git config --global user.name "Tu Nombre"
git config --global user.email "tu@correo.com"

Modelo mental de Git: áreas y flujo

Comprender las áreas de Git evita errores y acelera tu trabajo:

Working Directory Tu carpeta de trabajo. Aquí editas, renombrás y borras archivos.
Staging Area (Index) Zona intermedia donde preparas exactamente qué se incluirá en el próximo commit.
Repository (HEAD) Historial confirmado. Cada commit es una “instantánea” inmutable del proyecto.

# Ver estado de cada área
git status
# Diferencias entre trabajo y staging
git diff
# Diferencias entre staging y HEAD
git diff --staged
# Dónde está HEAD (último commit)
git rev-parse --short HEAD

Git almacena objetos en .git/objects y referencias como HEAD en .git. Es rápido, distribuido y diseñado para ramas ligeras.

Crear y clonar repositorios

Crear un repositorio nuevo con git init

Inicializa un repositorio en una carpeta existente. Usa -b para fijar el nombre de la rama inicial.

mkdir mi-app && cd mi-app
git init -b main
echo "# Mi App" > README.md
git add README.md
git commit -m "chore: primer commit"
git branch -M main

Opcional: conecta un remoto y publica.

git remote add origin git@github.com:usuario/mi-app.git
git push -u origin main

Configura el nombre por defecto de la rama: git config --global init.defaultBranch main
Repositorios bare (sin working directory) para servidores: git init --bare

Clonar con git clone

Copias el historial completo o parcial de un repositorio remoto a tu máquina.

# Clonado completo
git clone https://github.com/usuario/proyecto.git
# Solo una rama
git clone --branch main --single-branch <URL>
# Clonado superficial (rápido, menos historia)
git clone --depth 20 <URL>
# Partial clone (optimiza blobs)
git clone --filter=blob:none --no-checkout <URL> proyecto

Autenticación:

HTTPS con PAT (token) o gestor de credenciales
SSH con llaves (ssh-keygen y agrega la clave pública al proveedor)

Problemas comunes:

Permisos denegados (SSH): verifica ssh -T git@github.com
Windows: habilita rutas largas git config --system core.longpaths true
Proxys corporativos: configura git config --global http.proxy

Registrar cambios: git add y git commit

Selecciona qué va al próximo commit

# Añadir un archivo o patrón
git add app.py
git add src/**/*.ts
# Añadir todo (cuidado)
git add -A
# Staging interactivo (ideal para commits atómicos)
git add -p

Evita “commits gigantes”. Prefiere commits pequeños, coherentes y con mensajes descriptivos.

Confirmar con intención

# Commit rápido con mensaje
git commit -m "fix(auth): valida token expirado"
# Editar último commit (sin cambiar historial público)
git commit --amend
# Firmar commits (GPG/YubiKey)
git commit -S -m "docs: agrega guía de instalación"

Buenas prácticas de mensajes:

Usa imperativo y contexto: feat, fix, docs, refactor...
Primera línea ≤ 72 caracteres; cuerpo con “qué y por qué”.
Relaciona issues: “Refs #123” o “Fixes #456”.

Revertir errores rápido

# Quitar de staging sin perder cambios
git restore --staged archivo.txt
# Deshacer cambios en el working directory
git restore archivo.txt
# Volver al último commit (con cuidado)
git reset --hard HEAD

Para cambios temporales, usa git stash. Si ya publicaste un commit, prefiere git revert para mantener un historial claro.

Rastrear el historial y el estado: git log, git status, git diff

Explorar el historial con git log

# Vista compacta con grafo y decoraciones
git log --oneline --graph --decorate --all
# Cambios y estadísticas
git log --stat
git log -p
# Filtrar por autor, archivo o rango
git log --author="Tu Nombre"
git log -- <ruta/archivo>
git log main..feature/login

Trucos: git shortlog -sn para resumen por autor; git blame archivo para ver línea por línea quién cambió qué; git show <commit> para detalles de un commit.

Comparar diferencias con git diff

# Working vs staging
git diff
# Staging vs HEAD
git diff --staged
# Entre commits o ramas
git diff main...feature/login
# Resaltar por palabras y obviar espacios
git diff --word-diff --ignore-all-space

Activa colores: git config --global color.ui auto. Para detección de renombres: git diff --find-renames.

git status es tu “radar”: muestra archivos modificados, en staging y sin seguimiento. Ejecútalo a menudo para prevenir errores.

Ignorar archivos con .gitignore

Patrones útiles y precedencias

# Ignorar dependencias y artefactos
node_modules/
dist/
build/
*.log
# Variables de entorno y credenciales
.env
*.key
*.pem
# SO/IDE
.DS_Store
Thumbs.db
.vscode/

Usa negación para excepciones: !dist/keep.config.json
Ignora por proyecto (.gitignore), por usuario (~/.config/git/ignore) o local (.git/info/exclude)
Si un archivo ya está trackeado, .gitignore no lo “des-trackea”. Usa: git rm -r --cached . && git add .

Mejores prácticas y seguridad

No subas secretos. Usa variables de entorno, bóvedas (Vault, SSM) o Git-crypt/SOPS
Controla finales de línea con .gitattributes (* text=auto) para evitar “diffs de EOL” entre Windows/Linux
Para archivos binarios grandes, usa Git LFS

¿Revelaste un secreto? Rótalo de inmediato. Luego reescribe el historial con git filter-repo o las herramientas del proveedor para purgarlo.

Compatibilidad, rendimiento y escalabilidad

Multiplataforma

Windows: habilita core.autocrlf true para normalizar EOL
macOS/Windows: sistemas de archivos insensibles a mayúsculas; evita renombres solo por case
WSL/Contenedores: mapea tu repo a volúmenes locales para mejor I/O

Rendimiento

Clonado superficial o partial clone para repos grandes
Mantenimiento automático: git config --global maintenance.auto true
Compacta objetos: git gc --aggressive (uso puntual)
Evita binarios en el repo; prefiere LFS o artefactories

Seguridad

Prefiere SSH o HTTPS con tokens; evita contraseñas en texto claro
Firma commits y tags para trazabilidad (git tag -s)
Hooks pre-commit para lint/secret-scan (pre-commit, detect-secrets, gitleaks)

Problemas frecuentes y cómo resolverlos

Conflictos y errores comunes

Conflictos al integrar: edita archivos en conflicto, marca la resolución y confirma.

git status
# Edita y resuelve marcadores <<<<<< ======= >>>>>>
git add <archivo-resuelto>
git commit

Commiteaste al branch equivocado: usa git cherry-pick <hash> hacia la rama correcta
Perdiste cambios locales: revisa git reflog para recuperar referencias recientes

Líneas finales, encoding y rutas

Saltos de línea: configura .gitattributes y core.autocrlf
Encoding: mantén UTF-8 para evitar diffs ruidosos
Rutas largas (Windows): git config --system core.longpaths true

en Programación

ASIMOV Ingeniería S. de R.L. de C.V., Emiliano Nava 10 noviembre, 2025

Nuestros blogs

Iniciar sesión dejar un comentario

Modulo1 GIT Introducción

Introducción