🚀 El principio con Git: Fundamentos y Primeros Pasos

El control de versiones es la habilidad base de cualquier desarrollador moderno. Sin él, coordinar código en equipo o volver a un estado funcional anterior es prácticamente imposible.

En esta lección aprenderás:

  1. Qué es Git y por qué es el estándar indiscutido de la industria.
  2. Conceptos fundamentales: repositorios, archivos, commits e historial.
  3. Cómo instalar Git y configurar tu identidad obligatoria con git config.
  4. El ciclo de vida de los tres estados: Working Directory, Staging Area y Repository.
  5. Cómo inspeccionar el historial y crear tus primeras ramas de trabajo.

¿Qué es Git?

Git es un sistema de control de versiones.

👉 En palabras simples:
Git sirve para guardar la historia de los cambios de un proyecto, igual que un “guardar partida” en un videojuego.

Analogía sencilla

Imagina que escribes un trabajo en Word:

  • Versión 1

  • Versión 2

  • Versión final

  • Versión final FINAL 😅

Git hace eso automáticamente, pero:

  • Guarda cada cambio

  • Te permite volver atrás

  • Te deja trabajar en equipo sin pisarse

  • Funciona perfecto con código

🧠 ¿Por qué Git es tan importante?

Aprender Git te permite:

  • No perder tu trabajo

  • Trabajar con otras personas

  • Probar ideas sin romper nada

  • Trabajar como un programador profesional

💡 TODAS las empresas de tecnología usan Git.

🧩 Conceptos fundamentales (muy importante)

Antes de usar comandos, necesitas entender estos conceptos clave:

1️⃣ Repositorio (repo)

Es el proyecto.

📦 Piensa en un repositorio como:

Una carpeta especial que Git controla

Puede contener:

  • Código

  • Imágenes

  • Documentación

  • Cualquier archivo

2️⃣ Archivo

Son los archivos normales:

  • .html

  • .css

  • .js

  • .txt

Git observa estos archivos y detecta cambios.

3️⃣ Versión / Commit

Un commit es una foto del proyecto en un momento del tiempo.

📸 Cada commit:

  • Tiene un mensaje (“qué hice”)

  • Tiene fecha

  • Tiene autor

Ejemplo de mensaje de commit:

Agrego botón de login

4️⃣ Historial

Git guarda todos los commits en orden.

Esto te permite:

  • Ver qué cambió

  • Volver a una versión anterior

  • Saber quién hizo qué

🧰 Instalación de Git

En Windows

Descarga desde:
👉 https://git-scm.com

Instálalo dejando las opciones por defecto.

En macOS

brew install git

En Linux

sudo apt install git

Verifica que está instalado:

git --version

⚙️ Configuración inicial (obligatorio antes de empezar)

Antes de crear tu primer commit, Git necesita saber quién eres. Cada cambio en el historial queda firmado con un nombre y un correo electrónico.

Configurar tu identidad

Ejecuta en tu terminal:

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

💡 Nota importante: user.name y user.email son metadatos para firmar los commits, no credenciales para autenticarte contra GitHub. Puedes usar el mismo correo de tu cuenta de GitHub para que la plataforma vincule tus commits a tu perfil.

Configurar la rama principal por defecto

Históricamente Git llamaba a la rama inicial master. El estándar actual de la industria y de GitHub es main:

git config --global init.defaultBranch main

¿Dónde se guarda esta configuración?

  • --global: Aplica a todos los repositorios en tu computadora (se guarda en el archivo ~/.gitconfig).
  • --local: Aplica únicamente al repositorio actual (útil si manejas una cuenta laboral y otra personal).

Para verificar tu configuración activa en cualquier momento:

git config --list

🚀 Empezando con Git (primeros pasos)

Paso 1: Crear un proyecto

Crea una carpeta y entra en ella:

# Crear la carpeta de nuestro nuevo proyecto
mkdir mi-proyecto

# Entrar al directorio del proyecto
cd mi-proyecto

Paso 2: Inicializar Git

Dentro de la carpeta:

# Inicializar un nuevo repositorio Git local en este directorio
git init

👉 Esto crea un repositorio Git.

💡 Git ahora controla esta carpeta.

📂 El estado de Git (muy importante)

Siempre puedes preguntar:

# Consultar el estado actual del directorio de trabajo y del staging area
git status

Esto te dice:

  • Qué archivos cambiaron

  • Qué está listo para guardar

  • Qué no

📝 Crear tu primer archivo

Crea un archivo llamado:

hola.txt

Contenido:

Hola, este es mi primer proyecto con Git

Revisa el estado:

git status

Verás algo como:

archivo nuevo no rastreado

➕ Agregar archivos (staging)

Git trabaja en 3 zonas fundamentales:

1️⃣ Working Directory

Tus archivos normales en disco, donde programas y editas.

2️⃣ Staging Area

El área de preparación donde seleccionas exactamente qué cambios formarán parte del próximo commit.

3️⃣ Repository (.git)

La base de datos local donde Git guarda el historial definitivo en forma de commits.

Las tres zonas de Git: Working Directory, Staging Area y Repository 1. Working Directory Archivos en disco hola.txt (modificado) Cambios sin preparar 2. Staging Area Preparados para commit hola.txt (en stage) Listo para el snapshot 3. Repository (.git) Historial permanente commit: a1b2c3d Versión registrada git add git commit git restore --staged (deshacer stage)
El ciclo de vida en tres estados de Git: tus modificaciones en el directorio de trabajo se seleccionan con git add hacia el Staging Area y se confirman con git commit en la base de datos local.

Para mover un archivo a staging:

# Agregar un archivo específico al staging area
git add hola.txt

O todos los archivos modificados a la vez:

# Agregar todos los cambios del directorio actual al staging area
git add .

💾 Guardar cambios (commit)

Ahora guarda los cambios:

# Crear un commit que registra los cambios del staging area en el historial
git commit -m "Agrego archivo hola.txt"

🎉 ¡Primer commit hecho!

🔁 Flujo básico de Git (memorízalo)

Este es el flujo más importante de Git:

Editar → git add → git commit

Siempre será así.

🧪 Modificar un archivo

Edita hola.txt:

Hola mundo
Estoy aprendiendo Git

Revisa estado:

# Verificar qué archivos fueron modificados tras la edición
git status

Agrega y guarda:

# Preparar las modificaciones en el staging area
git add .

# Confirmar la nueva versión en el repositorio
git commit -m "Actualizo mensaje de saludo"

⏪ Volver atrás en el tiempo

Ver historial:

# Listar los commits cronológicos con su autor, fecha y hash identificador
git log

Verás una lista de commits. Cada commit tiene un ID único.

Para volver a un commit:

# Inspeccionar el estado del proyecto en un commit específico (modo lectura)
git checkout ID_DEL_COMMIT

⚠️ Esto es modo lectura (no para trabajar directamente).

🌿 Ramas (branches)

¿Qué es una rama?

Una rama es una línea paralela de trabajo.

🌱 Te permite:

  • Probar ideas sin afectar la rama principal
  • Trabajar en equipo en paralelo sin pisarse

La rama principal se llama:

main

Crear una rama

# Crear una nueva rama a partir del commit actual
git branch nueva-funcion

Cambiar a ella:

# Cambiar de rama de trabajo
git checkout nueva-funcion

O en un solo paso (muy recomendado):

# Crear la rama y cambiar a ella inmediatamente
git checkout -b nueva-funcion

Fusionar ramas (merge)

Vuelve a main:

# Regresar a la rama principal
git checkout main

Fusiona:

# Integrar los commits de la rama secundaria en la rama actual (main)
git merge nueva-funcion

🌍 Git vs GitHub (muy importante)

🚫 Git NO es GitHub

GitGitHub
Herramienta localPlataforma online
Controla versionesGuarda repositorios
Funciona sin internetRequiere internet

GitHub usa Git, pero no son lo mismo.

☁️ Subir proyecto a GitHub (básico)

  1. Crear un repositorio vacío en GitHub (sin README ni .gitignore iniciales).
  2. Conectar el repositorio local con el remoto:
# Asociar la URL remota de GitHub bajo el alias 'origin'
git remote add origin https://github.com/tu-usuario/tu-repositorio.git
  1. Subir código y configurar seguimiento:
# Subir la rama local 'main' al remoto 'origin' y configurar seguimiento (-u)
git push -u origin main

📥 Descargar un proyecto

# Clonar un repositorio existente desde GitHub a tu equipo
git clone https://github.com/usuario/repositorio.git

⚠️ Errores comunes

❌ No hacer commits seguido
❌ Mensajes de commit malos
❌ Trabajar sin ramas
❌ No usar git status

🧠 Próximos pasos en este curso

Ahora que conoces las bases y el ciclo local, avanza con las siguientes lecciones del curso:

  1. Lección 2: Bajar y subir cambios: Sincronización remota con GitHub (pull, push, tracking branches).
  2. Lección 3: Fusionar ramas y conflictos: Trabajo colaborativo con ramas (branch, merge) y cómo resolver conflictos de integración.
  3. Lección 4: Rebase y buenas prácticas: Rebase paso a paso, historial lineal, commits atómicos, Conventional Commits y uso correcto de .gitignore.

📌 Resumen final

Git te permite:

  • Guardar versiones
  • Volver atrás
  • Trabajar en equipo
  • Programar profesionalmente

Flujo clave que usarás a diario:

# 1. Comprobar qué archivos cambiaron
git status

# 2. Agregar los cambios al área de preparación
git add .

# 3. Guardar el snapshot con un mensaje claro
git commit -m "feat: agrego mensaje claro"