Améliorer votre flux de travail Git : outils en ligne de commande et interfaces graphiques essentiels

Git, en tant que système de contrôle de révision distribué, rapide et évolutif, constitue l'épine dorsale des flux de travail modernes de développement logiciel. Bien que son interface en ligne de commande de base offre un contrôle robuste sur le versionnement, comprendre et exploiter son vaste ensemble de commandes, ainsi que des outils spécialisés en ligne de commande et des interfaces graphiques (GUI), peut considérablement améliorer la productivité et simplifier les tâches complexes. Ce guide se concentre sur les outils qui résolvent de réels problèmes de flux de travail : préparer des commits propres, lire l'historique, réviser les diffs et gérer les branches sans perdre la trace de ce qui a changé.

Vous n'avez pas besoin de tous les outils présentés ici. Choisissez le plus petit ensemble qui rend votre travail quotidien plus clair.

Flux de travail Git de base : opérations essentielles en ligne de commande

Git offre un riche ensemble de commandes, classées en commandes "porcelaine" de haut niveau pour les utilisateurs finaux et en commandes "plomberie" de bas niveau pour les scripts et la gestion interne des objets. Ici, nous nous concentrerons sur les commandes porcelaine essentielles pour les tâches quotidiennes.

Démarrer avec un dépôt

Pour commencer un nouveau projet ou rejoindre un projet existant, ces commandes sont votre point de départ :

Initialiser un nouveau dépôt Git :
```
git init
```
Cloner un dépôt existant à partir d'une URL :
```
git clone <url>
```

Gérer les modifications (indexation et validation)

Avant de valider, Git utilise une "zone d'index" (également appelée index) pour préparer les modifications. Cela vous donne un contrôle précis sur ce qui entre dans chaque commit.

Ajouter des fichiers spécifiques à la zone d'index :
```
git add <fichier>
```
Ajouter tous les fichiers non suivis et modifiés à la zone d'index :
```
git add .
```
Indexer de manière interactive des parties d'un fichier (morceaux) :
```
git add -p
```
Déplacer ou renommer un fichier :
```
git mv <ancien> <nouveau>
```
Supprimer un fichier du répertoire de travail et de la zone d'index :
```
git rm <fichier>
```
Supprimer un fichier du suivi Git sans le supprimer du système de fichiers :
```
git rm --cached <fichier>
```
Désindexer un fichier spécifique :
```
git reset <fichier>
```
Désindexer toutes les modifications :
```
git reset
```
Vérifier l'état de votre répertoire de travail et de la zone d'index :
```
git status
```

Une fois les modifications indexées, vous pouvez les valider :

Valider les modifications indexées (ouvre un éditeur pour le message) :
```
git commit
```
Valider les modifications indexées avec un message :
```
git commit -m 'Votre message de commit'
```
Valider directement toutes les modifications suivies non indexées (contourne git add pour les modifications) :
```
git commit -am 'Votre message de commit'
```

Branches et fusions

Les branches sont fondamentales pour la nature distribuée de Git, permettant le développement parallèle. La fusion et le rebasage sont des moyens d'intégrer les modifications.

Basculer vers une branche existante :

git switch <nom>
# OU (ancienne syntaxe)
git checkout <nom>

Créer et basculer vers une nouvelle branche :

git switch -c <nom>
# OU (ancienne syntaxe)
git checkout -b <nom>

Lister toutes les branches locales :
```
git branch
```
Lister les branches par ordre de commit le plus récent :
```
git branch --sort=-committerdate
```
Supprimer une branche locale (uniquement si fusionnée) :
```
git branch -d <nom>
```
Forcer la suppression d'une branche locale (même si non fusionnée) :
```
git branch -D <nom>
```
Fusionner une branche dans votre branche actuelle :
```
git merge <branche-à-fusionner>
```
Fusionner une branche dans votre branche actuelle en un seul commit (fusion écrasée) :
```
git merge --squash <branche-à-fusionner>
git commit -m 'Message de commit écrasé'
```
Rebaser votre branche actuelle sur une autre (réécrit l'historique) :
```
git rebase <branche-de-base>
```

Collaboration avec les dépôts distants

Git excelle dans les environnements collaboratifs, en poussant et en tirant les modifications depuis des dépôts distants.

Ajouter un nouveau dépôt distant :
```
git remote add <nom> <url>
```
Pousser votre branche actuelle vers sa branche de suivi distante :
```
git push
```
Pousser une nouvelle branche pour la première fois, en définissant la branche amont :
```
git push -u origin <nom>
```
Forcer le push (à utiliser avec une extrême prudence, écrase l'historique distant) :
```
git push --force-with-lease
```
Récupérer les modifications depuis un dépôt distant (ne les intègre pas dans vos branches locales) :
```
git fetch origin main
```
Récupérer les modifications puis les fusionner dans votre branche actuelle :
```
git pull origin main
# OU (si la branche de suivi est définie)
git pull
```
Récupérer les modifications puis rebaser votre branche actuelle :
```
git pull --rebase
```

Inspecter l'historique et les diffs

Comprendre ce qui a changé et qui a fait ces modifications est crucial pour le débogage et la révision.

Afficher un résumé de toutes les modifications indexées et non indexées :
```
git diff HEAD
```
Afficher le diff des seules modifications indexées :
```
git diff --staged
```
Afficher le diff des seules modifications non indexées :
```
git diff
```
Afficher les journaux de commits (diverses options) :
```
git log # Journal complet
git log --graph # Arbre ASCII de l'historique
git log --oneline # Une ligne concise par commit
git log <fichier> # Historique d'un fichier spécifique
git log --follow <fichier> # Historique incluant les renommages
git log -G <motif>
```
git log -G <motif> trouve les commits où le nombre de lignes correspondantes a changé. Par exemple, git log -G "timeout" -- app/ est utile lorsque vous avez besoin de savoir quand la gestion du délai d'attente a changé dans un répertoire de service.

Outils en ligne de commande qui facilitent Git

L'interface en ligne de commande Git de base doit rester votre référence. Les outils supplémentaires sont meilleurs lorsqu'ils rendent l'état plus facile à voir, pas lorsqu'ils cachent ce que Git fait.

lazygit vous offre une interface utilisateur terminal interactive pour indexer des morceaux, parcourir les commits, résoudre des conflits simples et pousser des branches. Il est utile lorsque vous voulez un aperçu visuel mais que vous travaillez toujours dans le terminal.

tig est une interface utilisateur textuelle rapide pour parcourir l'historique. Il est particulièrement adapté sur les serveurs ou les machines de développement distantes où une interface graphique complète n'est pas disponible.

delta améliore les diffs Git avec une coloration syntaxique et un affichage plus clair des lignes déplacées. Après l'avoir installé, une configuration courante est :

git config --global core.pager delta
git config --global interactive.diffFilter "delta --color-only"

Consultez la documentation de delta pour les options qui correspondent aux couleurs de votre terminal. Gardez la configuration petite au début afin que la sortie Git simple soit toujours facile à récupérer.

Pour le nettoyage de dépôt ou la suppression d'historique sensible, git-filter-repo est généralement préféré à l'ancien git filter-branch. Traitez toute réécriture d'historique comme une opération d'équipe. Cela modifie les ID de commit et oblige tous ceux qui utilisent le dépôt à se resynchroniser soigneusement.

Quand une interface graphique est le meilleur outil

Une interface graphique peut être le bon choix pour réviser des modifications importantes, comparer des branches ou enseigner les concepts Git à quelqu'un qui pense visuellement. Des outils tels que GitHub Desktop, GitKraken, Sourcetree, Fork et les intégrations IDE peuvent faciliter l'indexation et l'inspection de l'historique.

Utilisez une interface graphique lorsqu'elle vous aide à répondre à des questions concrètes :

Quels fichiers ont changé dans cette branche ?
Quels commits sont uniques à cette branche ?
Qu'est-ce que ce renommage ou cette refactorisation a réellement touché ?
Quel côté d'un conflit dois-je conserver ?

N'utilisez pas une interface graphique comme substitut à la compréhension des commandes de base. Lorsqu'un push échoue, qu'un rebase entre en conflit ou que CI vérifie un commit détaché, les messages d'erreur et les étapes de récupération sont toujours des concepts Git.

Une configuration pratique pour le travail quotidien

Un flux de travail équilibré pourrait ressembler à ceci :

git status
git add -p
git diff --staged
git commit -m "Ajouter un point de terminaison de vérification de santé"
git pull --rebase
git push -u origin feature/health-check

Utilisez ensuite git log --oneline --graph --decorate --all ou une interface graphique pour inspecter comment la branche s'intègre dans l'historique plus large.

Si vous ajoutez des alias, gardez-les évidents :

git config --global alias.st status
git config --global alias.lg "log --oneline --graph --decorate --all"
git config --global alias.unstage "restore --staged"

Les alias doivent raccourcir les commandes que vous comprenez déjà. Évitez les alias qui effectuent des actions destructrices à moins que le nom ne soit sans équivoque.

Dernier point à retenir

Utilisez la CLI Git pour les opérations que vous devez comprendre sous pression : status, diff, add, commit, branch, fetch, pull, push, merge et rebase. Ajoutez des outils terminaux ou des interfaces graphiques là où ils améliorent la visibilité. Le meilleur flux de travail n'est pas celui qui a le plus d'outils ; c'est celui qui vous permet de voir clairement vos modifications avant de les partager.