Quels sont les commandes Git avancées et les techniques ?

Question

IT Interview Practice · Accepted Answer

Au-delà des commandes quotidiennes, Git offre des outils puissants pour des situations spécifiques — **bisect** (trouver les bugs), **blame** (tracer les modifications), **worktree** (plusieurs répertoires de travail), **submodules**, **filter-repo** (réécrire l'historique), et bien d'autres. Savoir qu'ils existent et ce qu'ils font est précieux pour gérer les scénarios avancés.

## git bisect — trouver quel commit a introduit 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` effectue une **recherche binaire** dans l'historique pour trouver efficacement le commit qui a introduit un bug — inestimable pour déboguer les régressions dans les grands historiques.

## git blame — qui a changé chaque ligne et quand

```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)
```

## Autres outils puissants

```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)
```

## Pourquoi c'est important

Comprendre les commandes Git avancées et les techniques est une connaissance de haut niveau précieuse pour **gérer efficacement les situations complexes**, donc savoir qu'elles existent et ce qu'elles font élargit votre boîte à outils de résolution de problèmes.

Bien que les commandes quotidiennes suffisent pour le travail routinier, les outils avancés résolvent des problèmes spécifiques, parfois critiques, avec élégance. **`git bisect`** est particulièrement précieux — il **recherche en binaire dans l'historique pour identifier le commit exact qui a introduit un bug**, transformant la tâche décourageante de trouver une régression dans un grand historique en un processus efficace et systématique (une puissante technique de débogage que beaucoup ne connaissent pas). **`git blame`** (affichant quel commit et quel auteur ont modifié chaque ligne en dernier) est inestimable pour **comprendre l'historique du code** — tracer quand et pourquoi une ligne a été introduite, utile pour déboguer et comprendre.

D'autres outils répondent à des besoins réels : **`git worktree`** (plusieurs répertoires de travail à partir d'un seul dépôt, permettant un travail simultané sur différentes branches sans stashing — pratique pour les changements de contexte), **`git submodule`** (intégrer des dépôts pour les dépendances partagées), **`git filter-repo`** (réécrire l'historique à grande échelle, crucial pour **supprimer les secrets ou fichiers accidentellement commités de tout l'historique** — une remédiation de sécurité importante), **`git rerere`** (mémoriser les résolutions de conflits), et **`git hooks`** (automatiser les vérifications sur les événements comme pre-commit).

Savoir que ces outils existent et ce qu'ils font signifie que lorsqu'une situation complexe survient (trouver une régression, comprendre l'historique, supprimer un secret divulgué, gérer les dépendances), vous connaissez le bon outil plutôt que de lutter avec des approches manuelles.

Puisque les situations Git complexes surviennent (déboguer les régressions, tracer l'historique, nettoyer les secrets de l'historique, gérer les configurations complexes) et que les commandes avancées les résolvent puissamment, comprendre les commandes Git avancées et les techniques — en particulier bisect pour trouver les bugs et blame pour tracer l'historique, plus la sensibilisation à worktree, submodules, filter-repo, et hooks — est une connaissance de haut niveau précieuse qui élargit votre capacité à gérer les scénarios Git sophistiqués, reflétant la profondeur et la portée de résolution de problèmes attendues pour les rôles seniors.

git bisect — trouver quel commit a introduit un bug

git blame — qui a changé chaque ligne et quand

Autres outils puissants

Pourquoi c'est important

Questions connexes