Fundamentos de Git

Módulo 2: Fundamentos de Git

En este módulo aprenderás los conceptos y comandos fundamentales de Git. Dominar estos fundamentos es esencial para trabajar eficientemente con control de versiones.

Crear un repositorio local (git init)

Un repositorio Git es un directorio que contiene tu proyecto y todo su historial de versiones. Puedes crear uno desde cero o clonar uno existente.

Inicializar un nuevo repositorio

Crear repositorio nuevo

# Crear directorio para el proyecto
mkdir mi-primer-proyecto
cd mi-primer-proyecto

# Inicializar repositorio Git
git init

# Verificar que se creó el repositorio
ls -la
# Verás una carpeta .git (contiene toda la información de Git)

Note

La carpeta .git contiene toda la base de datos de Git. ¡Nunca la elimines manualmente! Si la eliminas, perderás todo el historial del proyecto.

Estructura de un repositorio Git

Estructura .git

.git/
├── HEAD                # Apunta a la rama actual
├── config              # Configuración del repositorio
├── description         # Descripción del repositorio
├── hooks/              # Scripts de automatización
├── info/               # Información adicional
├── objects/            # Base de datos de objetos
├── refs/               # Referencias (ramas, tags)
└── logs/               # Logs de referencias

Verificar repositorio

# Verificar estado del repositorio
  git status

  # Ver configuración del repositorio
  git config --list --local

  # Ver información de la rama actual
  git branch

  # Ver si hay commits
  git log

Configurar repositorio específico

Configuración local

# Configurar nombre y email solo para este repositorio
git config user.name "Nombre Específico"
git config user.email "email.especifico@ejemplo.com"

# Ver configuración actual
git config --list --local

# Configurar rama por defecto
git config init.defaultBranch main

Estados de un archivo: working, staging, committed

Entender los tres estados de los archivos en Git es fundamental para trabajar eficientemente.

Los tres estados explicados

Diagrama visual

WORKING DIRECTORY    STAGING AREA         REPOSITORY
(Directorio de       (Índice)             (Commits)
 trabajo)

archivo.txt     →    git add archivo.txt    →    git commit
[Modified]           [Staged]                    [Committed]
     ↑                                               ↓
     └─────────── git checkout archivo.txt ←────────┘

Estados posibles:
• Untracked: Archivo nuevo, Git no lo conoce
• Modified: Archivo conocido pero con cambios
• Staged: Archivo preparado para commit
• Committed: Archivo guardado en el historial

Comandos por estado

# Ver estado actual de todos los archivos
  git status

  # Ver estado resumido
  git status -s

  # Ver diferencias en working directory
  git diff

  # Ver diferencias en staging area
  git diff --staged

  # Ver diferencias entre commits
  git diff HEAD~1 HEAD

Ejemplo práctico de estados

1. Crear archivo nuevo (Untracked)

   echo "Hola mundo" > saludo.txt
   git status
   # Output: Untracked files: saludo.txt

2. Agregar al staging area (Staged)

   git add saludo.txt
   git status
   # Output: Changes to be committed: new file: saludo.txt

3. Modificar archivo ya staged (Modified + Staged)

   echo "Adiós mundo" >> saludo.txt
   git status
   # Output:
   # Changes to be committed: new file: saludo.txt
   # Changes not staged: modified: saludo.txt

4. Confirmar cambios (Committed)

   git add saludo.txt  # Agregar modificaciones
   git commit -m "Agregar archivo de saludo"
   git status
   # Output: nothing to commit, working tree clean

Agregar y confirmar cambios (git add, git commit)

Los comandos git add y git commit son los más utilizados en Git. Aprende todas sus variaciones.

git add - Agregar archivos al staging area

Comandos básicos

# Agregar archivo específico
git add archivo.txt

# Agregar múltiples archivos
git add archivo1.txt archivo2.txt

# Agregar todos los archivos modificados
git add .

# Agregar todos los archivos (incluso eliminados)
git add -A

# Agregar solo archivos ya rastreados
git add -u

Comandos avanzados

# Agregar interactivamente (elegir qué cambios)
git add -p archivo.txt

# Agregar por extensión
git add *.js

# Agregar por directorio
git add src/

# Ver qué se agregará sin agregarlo
git add --dry-run .

# Deshacer git add (quitar del staging)
git reset HEAD archivo.txt

git commit - Confirmar cambios

Variaciones de git commit

# Commit básico con mensaje
git commit -m "Mensaje descriptivo del cambio"

# Commit con mensaje multilínea
git commit -m "Título del commit" -m "Descripción detallada del cambio"

# Commit abriendo editor para mensaje largo
git commit

# Commit agregando automáticamente archivos modificados
git commit -am "Mensaje del commit"

# Modificar el último commit (antes de push)
git commit --amend -m "Nuevo mensaje"

# Commit vacío (útil para triggers)
git commit --allow-empty -m "Trigger deployment"

Mejores prácticas para commits

Convenciones de commits

Convenciones de commit

# Formato recomendado:
# tipo(alcance): descripción

# Tipos comunes:
feat: nueva funcionalidad
fix: corrección de bug
docs: cambios en documentación
style: cambios de formato (espacios, comas, etc.)
refactor: refactorización de código
test: agregar o modificar tests
chore: tareas de mantenimiento

# Ejemplos:
git commit -m "feat(auth): agregar sistema de login con JWT"
git commit -m "fix(api): corregir error 500 en endpoint de usuarios"
git commit -m "docs(readme): actualizar instrucciones de instalación"
git commit -m "refactor(utils): simplificar función de validación"

Tip

Un buen mensaje de commit debe completar la frase: “Si se aplica, este commit…”

Consultar historial de commits (git log)

El historial de commits es fundamental para entender la evolución de tu proyecto.

Comandos básicos de git log

Variaciones de git log

# Ver historial completo
git log

# Ver historial resumido (una línea por commit)
git log --oneline

# Ver últimos N commits
git log -5

# Ver commits con estadísticas de archivos
git log --stat

# Ver commits con diferencias
git log -p

# Ver historial gráfico
git log --graph --oneline --all

Filtrar historial

Por autor y fecha

# Commits de un autor específico
git log --author="Juan Pérez"

# Commits desde una fecha
git log --since="2024-01-01"

# Commits hasta una fecha
git log --until="2024-12-31"

# Commits en un rango de fechas
git log --since="2024-01-01" --until="2024-01-31"

# Commits de la última semana
git log --since="1 week ago"

Por archivos y contenido

# Commits que modificaron un archivo específico
git log -- archivo.txt

# Commits que modificaron archivos en un directorio
git log -- src/

# Buscar en mensajes de commit
git log --grep="fix"

# Buscar cambios en el código
git log -S "función_específica"

# Commits que agregaron o eliminaron una línea
git log -G "patrón_regex"

Formatos personalizados

Personalizar formato de log

# Formato personalizado
git log --pretty=format:"%h - %an, %ar : %s"

# Formato con colores
git log --pretty=format:"%C(yellow)%h%C(reset) - %C(blue)%an%C(reset), %C(green)%ar%C(reset) : %s"

# Crear alias para formato personalizado
git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"

# Usar el alias
git lg

Navegar por el historial

Navegar historial

# Ver commit específico
git show abc1234

# Ver archivos en un commit específico
git show abc1234 --name-only

# Ver diferencias entre commits
git diff abc1234 def5678

# Ver diferencias entre commit y working directory
git diff abc1234

# Volver a un commit específico (temporal)
git checkout abc1234

# Volver a la rama principal
git checkout main

Ignorar archivos con .gitignore

No todos los archivos deben ser versionados. El archivo .gitignore te permite especificar qué ignorar.

Crear archivo .gitignore

Crear .gitignore

# Crear .gitignore en la raíz del proyecto
touch .gitignore

# Agregar patrones de archivos a ignorar
echo "node_modules/" >> .gitignore
echo "*.log" >> .gitignore
echo ".env" >> .gitignore

# Confirmar el .gitignore
git add .gitignore
git commit -m "Agregar .gitignore"

Patrones comunes en .gitignore

Desarrollo web

# Dependencias
node_modules/
npm-debug.log*
yarn-debug.log*
yarn-error.log*

# Archivos de producción
/build
/dist

# Variables de entorno
.env
.env.local
.env.development.local
.env.test.local
.env.production.local

# Logs
logs
*.log

# Cache
.cache/
.parcel-cache/

# IDEs
.vscode/
.idea/
*.swp
*.swo

Python

# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class

# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg

# Virtual environments
venv/
env/
ENV/

# IDE
.vscode/
.idea/
*.swp

# OS
.DS_Store
Thumbs.db

Java

# Compiled class files
*.class

# Log files
*.log

# Package Files
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar

# Maven
target/
pom.xml.tag
pom.xml.releaseBackup
pom.xml.versionsBackup
pom.xml.next
release.properties
dependency-reduced-pom.xml
buildNumber.properties
.mvn/timing.properties

# Gradle
.gradle
build/

# IDEs
.idea/
.vscode/
*.swp
*.swo
*~

# OS
.DS_Store
Thumbs.db

Reglas de .gitignore

Sintaxis de .gitignore

# Ignorar archivo específico
archivo.txt

# Ignorar todos los archivos con extensión
*.log
*.tmp

# Ignorar directorio completo
directorio/

# Ignorar archivos en directorio específico
directorio/*.txt

# Ignorar recursivamente
directorio/**/*.log

# Excepción (NO ignorar)
!importante.log

# Ignorar solo en raíz del proyecto
/archivo-raiz.txt

# Comentarios
# Este es un comentario
# Los archivos de configuración local no deben versionarse

Comandos útiles para .gitignore

Comandos para archivos ignorados

# Ver qué archivos están siendo ignorados
git status --ignored

# Verificar por qué un archivo está siendo ignorado
git check-ignore -v archivo.txt

# Forzar agregar archivo ignorado
git add -f archivo-ignorado.txt

# Dejar de rastrear archivo ya versionado
git rm --cached archivo.txt
echo "archivo.txt" >> .gitignore
git commit -m "Dejar de rastrear archivo.txt"

# Limpiar archivos ignorados del working directory
git clean -fdX

Caution

Si un archivo ya está siendo rastreado por Git, agregarlo a .gitignore no lo eliminará del repositorio. Debes usar git rm --cached primero.

Ejemplo práctico completo

Vamos a crear un proyecto completo aplicando todos los conceptos aprendidos:

1. Crear proyecto y repositorio

   mkdir mi-aplicacion-web
   cd mi-aplicacion-web
   git init
   git config user.name "Tu Nombre"
   git config user.email "tu@email.com"

2. Crear estructura inicial

   mkdir src css js
   touch index.html src/app.js css/styles.css
   echo "# Mi Aplicación Web" > README.md

3. Crear .gitignore

   cat > .gitignore << EOF
   # Logs
   *.log
   logs/
   
   # Dependencias
   node_modules/
   
   # Archivos temporales
   *.tmp
   *.swp
   
   # Variables de entorno
   .env
   
   # OS
   .DS_Store
   Thumbs.db
   EOF

4. Agregar contenido inicial

   cat > index.html << EOF
   <!DOCTYPE html>
   <html>
   <head>
     <title>Mi Aplicación</title>
     <link rel="stylesheet" href="css/styles.css">
   </head>
   <body>
     <h1>Hola Mundo</h1>
     <script src="src/app.js"></script>
   </body>
   </html>
   EOF
   
   echo "console.log('Aplicación iniciada');" > src/app.js
   echo "body { font-family: Arial, sans-serif; }" > css/styles.css

5. Primer commit

   git add .
   git status
   git commit -m "feat: estructura inicial del proyecto
   
   - Agregar HTML básico
   - Agregar CSS y JavaScript
   - Configurar .gitignore
   - Agregar README"

6. Hacer más cambios

   echo "<p>Párrafo agregado</p>" >> index.html
   echo "/* Nuevo estilo */" >> css/styles.css
   
   git status
   git add index.html
   git status
   git diff --staged
   git commit -m "feat: agregar párrafo en página principal"

7. Ver historial

   git log --oneline
   git log --stat
   git show HEAD

Comandos de ayuda y solución de problemas

Comandos útiles

Comandos de ayuda

# Ver ayuda de cualquier comando
git help add
git add --help

# Ver estado detallado
git status -v

# Ver qué cambios se perderían
git diff HEAD

# Deshacer cambios en working directory
git checkout -- archivo.txt
git checkout .  # Todos los archivos

# Deshacer git add (quitar del staging)
git reset HEAD archivo.txt
git reset HEAD .  # Todos los archivos

# Ver configuración actual
git config --list

# Ver repositorios remotos
git remote -v

# Verificar integridad del repositorio
git fsck

Resumen

En este módulo has aprendido:

Fundamentos de Git

• ✅ git init: Crear repositorios locales
• ✅ Estados de archivos: Working, Staging, Committed
• ✅ git add: Agregar cambios al staging area
• ✅ git commit: Confirmar cambios en el historial
• ✅ git log: Consultar historial de commits
• ✅ .gitignore: Ignorar archivos innecesarios
• ✅ Flujo básico: Modificar → Agregar → Confirmar
• ✅ Buenas prácticas: Commits descriptivos, estructura organizada

Flujo de Trabajo Práctico

• ✅ Primer setup: git init → git add . → git commit → git remote add → git push -u
• ✅ Flujo diario: git status → git add → git commit → git push
• ✅ Nueva máquina: git clone → trabajar → git add → git commit → git push
• ✅ Sincronización: git pull antes de trabajar, git push al terminar
• ✅ Comandos esenciales: Los que usarás todos los días
• ✅ Problemas comunes: Soluciones a errores típicos

Tip

💡 Recuerda la regla de oro: git pull → trabajar → git add → git commit → git push

En el próximo módulo aprenderemos a trabajar con repositorios remotos en GitHub, incluyendo cómo clonar, conectar repositorios locales con remotos, y sincronizar cambios.