¿Cuáles son algunos comandos y técnicas avanzadas de Git?

Question

Accepted Answer

Más allá de los comandos cotidianos, Git ofrece herramientas poderosas para situaciones específicas — **bisect** (encontrar bugs), **blame** (rastrear cambios), **worktree** (múltiples directorios de trabajo), **submodules**, **filter-repo** (reescribir historial), y más. Saber que existen y qué hacen es valioso para manejar escenarios avanzados.

## git bisect — encontrar qué commit introdujo un bug

```bash
git bisect start
git bisect bad                 # the current commit has the bug
git bisect good v1.0           # this older commit was fine
# → Git BINARY-SEARCHES the commits between them, checking out each;
#   you mark each good/bad → it pinpoints the exact commit that introduced the bug
git bisect good   # or: git bisect bad   (at each step)
git bisect reset               # when done
```

`git bisect` realiza una **búsqueda binaria** a través del historial para encontrar eficientemente el commit que introdujo un bug — invaluable para depurar regresiones en historiales grandes.

## git blame — quién cambió cada línea y cuándo

```bash
git blame <file>               # show, per line, the commit/author/date that last changed it
# → trace WHEN and WHY a line was introduced (then git show that commit for context)
```

## Otras herramientas poderosas

```text
git worktree    → multiple working directories from one repo (work on branches
  simultaneously without stashing/switching) — e.g. fix a bug while a build runs
git submodule   → embed another Git repo inside yours (shared dependencies/libraries)
git filter-repo → rewrite history at scale (remove a file/secret from ALL history,
  split/clean repos) — the modern replacement for filter-branch
git rerere      → REuse REcorded REsolution — remembers conflict resolutions to reapply
git hooks       → scripts triggered on events (pre-commit, pre-push) — automation/checks
git revert/reset, reflog → undo/recovery (covered separately)
```

## Por qué es importante

Comprender comandos y técnicas avanzadas de Git es conocimiento valioso de nivel senior para **manejar situaciones complejas de manera efectiva**, así que saber que existen y qué hacen expande tu kit de herramientas de resolución de problemas.

Mientras que los comandos cotidianos son suficientes para el trabajo rutinario, las herramientas avanzadas resuelven problemas específicos, a veces críticos, elegantemente. **`git bisect`** es particularmente valioso — realiza una **búsqueda binaria a través del historial para identificar el commit exacto que introdujo un bug**, convirtiendo la tarea desalentadora de encontrar una regresión en un historial grande en un proceso eficiente y sistemático (una poderosa técnica de depuración que muchos desconocen). **`git blame`** (mostrando qué commit y autor cambió cada línea por última vez) es invaluable para **comprender el historial del código** — rastreando cuándo y por qué se introdujo una línea, útil para depuración y comprensión.

Otras herramientas manejan necesidades reales: **`git worktree`** (múltiples directorios de trabajo de un repositorio, permitiendo trabajo simultáneo en diferentes ramas sin stashing — conveniente para cambios de contexto), **`git submodule`** (incrustando repositorios para dependencias compartidas), **`git filter-repo`** (reescribiendo historial a escala, crucialmente para **eliminar secretos o archivos accidentalmente comprometidos de todo el historial** — una remediación de seguridad importante), **`git rerere`** (recordando resoluciones de conflictos), y **`git hooks`** (automatizando verificaciones en eventos como pre-commit).

Saber que estas herramientas existen y qué hacen significa que cuando surge una situación compleja (encontrar una regresión, comprender el historial, eliminar un secreto filtrado, gestionar dependencias), conoces la herramienta correcta en lugar de luchar con enfoques manuales.

Ya que situaciones complejas de Git surgen (depurar regresiones, rastrear historial, limpiar secretos del historial, gestionar configuraciones complejas) y los comandos avanzados las resuelven poderosamente, comprender comandos y técnicas avanzadas de Git — especialmente bisect para encontrar bugs y blame para rastrear historial, más conciencia de worktree, submodules, filter-repo y hooks — es conocimiento valioso de nivel senior que expande tu capacidad para manejar escenarios sofisticados de Git, reflejando la profundidad y rango de resolución de problemas esperado para roles senior.