01
Nivel 01 · Básico

Lo que Git guarda

Instala Git, haz tus primeros commits y entiende qué guarda de verdad: fotos completas del proyecto, enlazadas una con otra. Con esa idea, todo lo demás tiene sentido.

Lección 1.1

¿Qué problema resuelve Git?

Si alguna vez tuviste informe_final.docx, informe_final_v2.docx e informe_final_DEFINITIVO.docx, ya conoces el problema: guardar versiones a mano es desordenado, no dice qué cambió entre una y otra, y no sirve cuando dos personas trabajan en lo mismo.

Git es un sistema de control de versiones: guarda la historia de tu proyecto como una serie de fotos, cada una con quién la tomó, cuándo y por qué. Puedes volver a cualquier foto, comparar dos, y trabajar en paralelo con otras personas sin pisarse.

En simple

Git es una máquina del tiempo para una carpeta. Cada vez que guardas un punto (un commit), puedes volver a él cuando quieras, y ver exactamente qué cambió desde el anterior.

Git no es GitHub

Git es un programa que corre en tu computador y funciona sin internet. GitHub, GitLab y Bitbucket son servicios donde subes una copia de tu repositorio para compartirla, revisar cambios con tu equipo y automatizar pruebas. Puedes usar Git toda la vida sin GitHub; al revés, no.

DistribuidoCada copia del repositorio tiene la historia completa. Si el servidor desaparece, cualquier clon sirve para recuperarlo.
RápidoCasi todo ocurre en tu disco: ver el historial, cambiar de rama o comparar versiones tarda milisegundos.
SeguroCada versión se identifica por un hash de su contenido: si algo se corrompe o se altera, Git lo nota.
Lección 1.2

Instalar y configurar Git

Comprueba primero si ya lo tienes: abre una terminal y escribe git --version. Si responde algo como git version 2.56.0, sáltate la instalación.

SistemaCómo instalarlo
macOSxcode-select --install (viene con las herramientas de Apple) o brew install git para tener la última versión
WindowsGit for Windows desde git-scm.com o winget install --id Git.Git -e. Incluye Git Bash, una terminal donde funcionan todos los comandos de esta guía
Linuxsudo apt install git (Debian, Ubuntu) o sudo dnf install git (Fedora)

Antes del primer commit, Git necesita saber quién eres: tu nombre y correo quedan grabados en cada commit. Arma tu configuración aquí y cópiala a la terminal.

Tu configuración inicial
bash

La opción --global guarda la configuración en ~/.gitconfig y vale para todos tus repositorios. Sin --global se guarda en el repo actual (.git/config) y gana sobre la global: útil para usar el correo del trabajo solo en los proyectos del trabajo.

bash
git config --list --show-origin     # toda tu configuración y de qué archivo viene
git config user.email               # el valor que usará este repo
Dos detalles que ahorran problemasUsa en user.email el mismo correo de tu cuenta de GitHub o GitLab, para que tus commits aparezcan a tu nombre. Y con init.defaultBranch main tus repos nuevos empiezan en main, que es lo que esperan GitHub y la mayoría de los equipos (y lo que Git 3.0 hará por defecto).
Lección 1.3

Tu primer repositorio

Hay dos formas de tener un repositorio: crearlo en una carpeta que ya tienes, o clonar uno que existe en un servidor.

bash
cd ~/proyectos/tienda
git init                       # crea la carpeta oculta .git: ya es un repositorio

# o bien, traer uno que ya existe (con toda su historia):
git clone https://github.com/ana/tienda.git

git init no toca tus archivos. Solo crea una carpeta oculta, .git, donde Git guardará toda la historia. Si borras .git, borras la historia; tus archivos actuales quedan, pero dejan de ser un repositorio.

En simple

Un repositorio es tu carpeta de siempre más una carpeta oculta .git con la historia. En el nivel Experto abrimos esa carpeta y vemos qué hay dentro.

El comando que más vas a usar

git status te dice en qué rama estás y en qué estado está cada archivo. Úsalo antes y después de cada cosa que hagas: es la forma más rápida de no perderte.

salida de git status en un repo nuevo
En la rama main

No hay commits todavía

Archivos sin seguimiento:
  (usa "git add <archivo>..." para incluirlo a lo que será confirmado)
	index.html
	estilos.css

Git en español dice «confirmar» donde casi todo el mundo dice commit. En esta guía usamos los nombres en inglés, que son los que vas a ver en la documentación, en GitHub y en tu equipo. Si prefieres la terminal en inglés: LANG=en_US.UTF-8 git status. Las animaciones de esta guía muestran la salida en inglés, que es la que aparece en casi toda la documentación y en los mensajes de error que vas a buscar en internet.

Lección 1.4

Las tres áreas: trabajo, staging y repositorio

Esta es la idea que más confunde al empezar, y la que más ayuda después. Tus cambios pasan por tres lugares antes de quedar guardados:

Directorio de trabajoTus archivos, tal como los ves en el editor. Aquí cambias cosas.
Staging (índice)Una zona de preparación: lo que pongas aquí es lo que irá en el próximo commit.
RepositorioLa historia guardada en .git: cada commit, para siempre.

¿Para qué el paso intermedio? Porque casi nunca cambias una sola cosa. Arreglas un bug, de paso renombras una variable y dejas un console.log de prueba. El staging te deja elegir qué va en cada commit, para que cada uno cuente una sola historia.

bash
git add index.html app.js      # agrega dos archivos al staging
git add .                      # agrega todo lo cambiado en esta carpeta y sus subcarpetas
git add -p                     # revisa cada trozo cambiado y elige cuáles agregar
git commit -m "agrega el buscador de productos"
git add -p es un superpoderTe muestra cada bloque cambiado y pregunta y (sí), n (no) o s (dividir en partes más chicas). Así un archivo con dos cambios distintos puede ir en dos commits distintos.
Lección 1.5

Qué es un commit

Mucha gente cree que Git guarda las diferencias entre versiones. No: cada commit guarda una foto completa del proyecto. Lo que no cambió no se copia otra vez: el commit nuevo apunta al mismo contenido que ya estaba guardado.

Además de la foto, cada commit guarda:

  • Su padre: el commit anterior. Así se forma la historia, como una cadena que apunta hacia atrás.
  • Autor y fecha: quién escribió el cambio y cuándo.
  • Mensaje: por qué existe este cambio.
  • Un hash: un identificador como 3f9a2c1, calculado a partir de todo lo anterior. Es su nombre único.
En simple

Un commit es una foto completa del proyecto más una nota que dice «vengo de este otro commit». La historia de Git es una cadena de fotos que apuntan hacia atrás.

¿Cada cuánto hacer commit?Cada vez que algo funciona y puedes describirlo en una frase. Commits chicos son más fáciles de revisar, de revertir y de entender meses después. «Arregla el total del carrito» es un buen commit; «cambios del martes», no.
Lección 1.6

Dentro de un commit: blobs, trees y hashes

Git guarda todo con solo tres tipos de objeto. Conocerlos explica por qué Git es tan rápido y por qué nunca pierde datos sin avisar.

ObjetoQué guarda
BlobEl contenido de un archivo. Solo el contenido: ni el nombre ni la carpeta
TreeUna carpeta: la lista de nombres de archivo, sus permisos y el hash de cada blob o subcarpeta
CommitEl tree raíz del proyecto, el padre, autor, fecha y mensaje

Cada objeto se guarda con el nombre de su hash: un número de 40 caracteres calculado con SHA-1 a partir del contenido. Mismo contenido, mismo hash, siempre y en cualquier computador. Por eso dos archivos idénticos ocupan un solo blob, y por eso si cambia una letra de un archivo, cambia el hash de su blob, de su carpeta y del commit.

bash
git cat-file -p HEAD            # el commit actual por dentro
git cat-file -p HEAD^{tree}     # la carpeta raíz de ese commit
git log --oneline               # hashes abreviados: con 7 caracteres basta
SHA-256 y Git 3.0SHA-1 ya tiene ataques conocidos, y Git lo usa con detección de colisiones. Git 3.0 (previsto para 2027) creará los repositorios nuevos con SHA-256, de 64 caracteres. Para tu día a día no cambia nada: seguirás usando hashes abreviados.
Lección 1.7

Ver el historial y los cambios

Dos preguntas que te harás todos los días: «¿qué cambié?» y «¿qué pasó antes?». La primera la responde git diff; la segunda, git log.

ComandoCompara
git diffTu directorio de trabajo con el staging: lo que cambiaste y todavía no agregaste
git diff --stagedEl staging con el último commit: lo que entraría si haces commit ahora
git diff HEADTu directorio de trabajo con el último commit: todo lo que cambió
git diff main featureDos ramas o dos commits cualesquiera

El historial, a tu medida

bash
git log --oneline --graph --all     # todo el grafo, una línea por commit
git log -p -2                       # los dos últimos commits con sus cambios
git log --stat                      # qué archivos tocó cada commit
git log --author="Ana" --since="2 weeks ago"
git log -- src/carrito.js           # solo los commits que tocaron ese archivo
git show 3f9a2c1                    # un commit: mensaje y cambios
Guárdalo como aliasgit config --global alias.lg "log --oneline --graph --all --decorate" y desde ahora git lg te muestra el grafo completo. Es lo más parecido a las animaciones de esta guía que vas a ver en la terminal.

Con q sales del historial, con /texto buscas dentro y con la barra espaciadora avanzas una página.

Lección 1.8

Ignorar archivos con .gitignore

Hay archivos que nunca deben entrar al repositorio: dependencias que se reinstalan (node_modules/), archivos generados (dist/), configuraciones locales y, sobre todo, secretos como .env. Un archivo .gitignore en la raíz le dice a Git que haga como si no existieran.

Probador de .gitignore
PatrónQué ignora
*.logCualquier archivo que termine en .log, en cualquier carpeta
dist/Carpetas llamadas dist (la barra final dice «solo carpetas»)
/borradoresSolo la de la raíz (la barra inicial ancla el patrón)
docs/**/*.pdfPDFs dentro de docs, a cualquier profundidad
!.env.exampleExcepción: este sí se versiona, aunque una regla anterior lo ignore
.gitignore no saca lo que ya está versionadoSi un archivo ya entró en un commit, agregarlo a .gitignore no basta. Primero quítalo del índice sin borrarlo del disco: git rm --cached .env. Y si era un secreto que ya subiste, cámbialo: quedó en la historia.

Para saber qué regla ignora un archivo: git check-ignore -v ruta/al/archivo. GitHub mantiene plantillas por lenguaje en github/gitignore.

Lección 1.9

Deshacer lo básico

Para deshacer algo, primero pregúntate dónde está lo que quieres deshacer: en tu directorio de trabajo, en el staging o en el último commit. Cada lugar tiene su comando.

Quiero…Comando¿Se pierde algo?
Descartar lo que cambié en un archivogit restore app.jsSí: los cambios sin guardar se pierden para siempre
Sacar un archivo del staginggit restore --staged app.jsNo: los cambios siguen en el archivo
Corregir el último commit (mensaje o archivos)git commit --amendNo, pero el commit cambia de hash
Borrar archivos nuevos sin seguimientogit clean -n y luego git clean -fSí: -n muestra qué borraría
amend reemplaza, no edita--amend crea un commit nuevo con otro hash. Si ya subiste el commit original y alguien más trabaja sobre él, corregirlo te obliga a reescribir historia compartida. Regla práctica: amend solo antes del push.

Vas a ver git checkout -- archivo en tutoriales viejos: hace lo mismo que git restore archivo. restore existe desde Git 2.23 y es más claro, porque checkout hace dos trabajos distintos (cambiar de rama y restaurar archivos).

Lección 1.10

Mensajes de commit que sirven

Un mensaje de commit lo va a leer alguien (tú, en seis meses) que intenta entender por qué el código es como es. La convención que usa casi todo el mundo:

  • Asunto de hasta 50 caracteres (72 como máximo), que diga qué hace el commit: «agrega», «corrige», «elimina».
  • Una línea en blanco.
  • Un cuerpo opcional que explique el porqué y lo que no es obvio. El qué ya lo muestra el diff.
Revisor de mensajes
Ejemplos:

    Conventional Commits es un formato opcional que agrega un tipo al comienzo (feat, fix, docs, refactor, test…). Muchos equipos lo usan para generar el changelog y calcular la próxima versión automáticamente. Si tu equipo lo usa, síguelo; si no, un buen asunto en presente basta.

    Escribe el mensaje en el editorCon git commit (sin -m) se abre tu editor y es más fácil escribir asunto y cuerpo. Las líneas que empiezan con # son ayuda de Git y no quedan en el mensaje.
    Quiz final

    Quiz · Nivel Básico

    Responde todas correctamente para aprobar