Boostez votre productivité : créez des alias Git personnalisés pour les commandes courantes

Travailler avec Git en ligne de commande implique souvent de répéter les mêmes longues commandes. Les alias Git personnalisés vous permettent de transformer ces commandes en sous-commandes courtes et mémorables telles que git st, git lg ou git fp.

Ce guide montre comment créer des alias en toute sécurité, y compris des raccourcis simples, des formats de journal, des aides pour le stash et des alias basés sur des commandes shell pour les workflows en plusieurs étapes.

Que sont les alias Git ?

Les alias Git sont essentiellement des raccourcis personnalisés ou des surnoms que vous pouvez attribuer aux commandes Git. Au lieu de taper la commande complète, vous pouvez taper un alias plus court, et Git exécutera la commande longue correspondante. Cela est réalisé via le système de configuration de Git.

Par exemple, au lieu de taper git checkout -b feature/nouvelle-branche, vous pourriez définir un alias git cob pour effectuer la même action.

Pourquoi utiliser les alias Git ?

Il y a plusieurs raisons impérieuses d'adopter les alias Git :

Gain de temps : Des commandes plus courtes signifient moins de frappe, ce qui s'accumule considérablement au fil du temps.
Réduction des fautes de frappe : Les commandes complexes sont sujettes aux erreurs. Les alias simplifient la saisie, minimisant les risques d'erreurs.
Lisibilité améliorée : Les alias personnalisés peuvent rendre votre historique de commandes plus facile à comprendre d'un coup d'œil.
Rationalisation du workflow : Les commandes fréquemment utilisées en plusieurs parties peuvent être condensées en raccourcis uniques et faciles à retenir.
Personnalisation : Adaptez Git à vos besoins et préférences spécifiques.

Comment créer des alias Git

Les alias Git sont définis dans vos fichiers de configuration Git. Il existe trois niveaux de configuration : système, global et local (spécifique au dépôt). Pour les alias que vous souhaitez utiliser dans tous vos projets Git, la configuration globale est l'endroit le plus courant pour les définir.

Vous pouvez gérer les alias à l'aide de la commande git config ou en modifiant directement le fichier de configuration.

Utilisation de `git config` (Recommandé)

La commande git config est la méthode préférée pour gérer les configurations Git, y compris les alias. Pour créer un alias global, vous utilisez l'option --global.

La syntaxe générale est :

git config --global alias.<nom-alias> '<commande-git>'

Détaillons cela :

git config : La commande pour interagir avec la configuration de Git.
--global : Spécifie que cette configuration doit s'appliquer à tous vos dépôts Git.
alias.<nom-alias> : C'est la clé où vous définissez l'alias. <nom-alias> est le raccourci que vous souhaitez créer.
'<commande-git>' : C'est la commande Git réelle (ou la séquence de commandes) que votre alias représentera. Il est crucial de mettre la commande entre guillemets simples pour gérer correctement les espaces et les caractères spéciaux.

Modification directe du fichier de configuration

Alternativement, vous pouvez modifier manuellement votre fichier de configuration Git global, qui se trouve généralement à ~/.gitconfig sur Linux/macOS ou C:\Utilisateurs\VotreNom\.gitconfig sur Windows.

Sous la section [alias], vous pouvez ajouter vos alias personnalisés :

[alias]
    st = status
    co = checkout
    ci = commit
    br = branch

Si la section [alias] n'existe pas, vous pouvez la créer.

Exemples pratiques d'alias Git utiles

Voici quelques exemples pratiques d'alias Git qui peuvent considérablement améliorer votre utilisation quotidienne de Git. Nous couvrirons des scénarios courants et fournirons les commandes git config pour les configurer.

1. Raccourcis courants

Ces alias remplacent des commandes fréquemment utilisées, mais légèrement plus longues, par des versions beaucoup plus courtes.

Statut : Vérifier le statut de votre dépôt.
- Commande : git status
- Alias : st
- Configuration : git config --global alias.st status
Checkout : Changer de branche ou restaurer les fichiers de l'arbre de travail.
- Commande : git checkout
- Alias : co
- Configuration : git config --global alias.co checkout
Commit : Enregistrer les modifications dans le dépôt.
- Commande : git commit
- Alias : ci
- Configuration : git config --global alias.ci commit
Branche : Lister, créer ou supprimer des branches.
- Commande : git branch
- Alias : br
- Configuration : git config --global alias.br branch

2. Améliorations de la gestion des branches et des fusions

Rationalisez vos workflows de gestion des branches et de fusion.

Créer et basculer vers une nouvelle branche : Une séquence courante.
- Commande : git checkout -b <nom-branche>
- Alias : cob (checkout branch)
- Configuration : git config --global alias.cob 'checkout -b'
- Utilisation : git cob feature/ma-nouvelle-fonctionnalite
Basculer vers la branche précédente : Revenir rapidement là où vous étiez.
- Commande : git checkout -
- Alias : cprev (checkout previous)
- Configuration : git config --global alias.cprev 'checkout -'
Fetch et Prune : Récupérer tous les changements distants et supprimer les branches de suivi distant qui n'existent plus sur le dépôt distant.
- Commande : git fetch --prune
- Alias : fp
- Configuration : git config --global alias.fp 'fetch --prune'
Pull avec Rebase : Récupérer depuis et intégrer avec un autre dépôt ou une branche locale, en utilisant rebase au lieu de merge.
- Commande : git pull --rebase
- Alias : pr (pull rebase)
- Configuration : git config --global alias.pr 'pull --rebase'

3. Utilitaires de commit et de journal

Rendre la visualisation et la gestion des commits plus efficaces.

Journal de commit sur une ligne : Voir les commits dans un format compact sur une seule ligne.
- Commande : git log --oneline
- Alias : lo
- Configuration : git config --global alias.lo 'log --oneline'
Journal de commit graphique : Voir l'historique des commits visuellement (si Git est configuré avec un outil graphique).
- Commande : git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --date=relative
- Alias : lg (log graph)
- Configuration : git config --global alias.lg "log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --date=relative"
- Remarque : Pour les commandes complexes contenant des guillemets simples à l'intérieur de la commande elle-même, vous devrez peut-être utiliser des guillemets doubles pour la définition de l'alias et échapper les guillemets doubles internes avec une barre oblique inverse, ou utiliser un alias !commande-shell.
Afficher le dernier commit : Afficher le dernier commit avec tous les détails.
- Commande : git show
- Alias : show (peut aussi être sh, mais show est plus clair)
- Configuration : git config --global alias.show show

4. Stash et nettoyage

Gérez vos modifications stashées et nettoyez votre répertoire de travail.

Stasher toutes les modifications : Stasher tous les fichiers modifiés suivis et les modifications stagées.
- Commande : git stash push
- Alias : stash
- Configuration : git config --global alias.stash 'stash push'
Appliquer et supprimer le dernier stash : Appliquer le stash le plus récent, puis le supprimer de la liste des stashs.
- Commande : git stash pop
- Alias : sp (stash pop)
- Configuration : git config --global alias.sp 'stash pop'
Nettoyer les fichiers non suivis : Supprimer les fichiers non suivis du répertoire de travail.
- Commande : git clean -fd ( -f pour forcer, -d pour les répertoires)
- Alias : clean
- Configuration : git config --global alias.clean 'clean -fd'
- Avertissement : Soyez extrêmement prudent avec git clean. Il supprime définitivement des fichiers et des répertoires. Vérifiez toujours avant d'exécuter.

5. Commandes shell dans les alias

Les alias Git peuvent également exécuter des commandes shell arbitraires en préfixant la commande avec un point d'exclamation (!). Ceci est utile pour des opérations plus complexes qui peuvent impliquer d'autres outils en ligne de commande.

Lister toutes les branches (locales et distantes) : Une tâche courante qui nécessite un peu plus qu'une simple commande Git.
- Commande : git branch -a
- Alias : bla (branch list all)
- Configuration : git config --global alias.bla '!git branch -a'
Voir les modifications non commitées (Diff) : Voir les différences entre votre répertoire de travail et le dernier commit.
- Commande : git diff
- Alias : d (diff)
- Configuration : git config --global alias.d diff
Voir les modifications stagées (Diff) : Voir les différences entre votre zone de staging et le dernier commit.
- Commande : git diff --staged
- Alias : ds (diff staged)
- Configuration : git config --global alias.ds 'diff --staged'

Alias avancés : Enchaînement de commandes

Les alias Git peuvent également être utilisés pour enchaîner plusieurs commandes Git ensemble. Ceci est particulièrement puissant pour les workflows complexes.

Par exemple, pour créer une nouvelle branche, stagifier toutes les modifications et commiter avec un message :

Alias : acm (add, commit, message)
Configuration : git config --global alias.acm '!f() { git add -A && git commit -m "$1"; }; f'
Utilisation : git acm "Votre message de commit ici"

Cet alias avancé définit une fonction shell f() qui ajoute d'abord toutes les modifications (git add -A) puis les commite avec le message fourni comme premier argument ($1). Le f() à la fin exécute la fonction.

Conseils pour gérer vos alias

Commencez simplement : Débutez avec des remplacements de commandes simples et courants. Au fur et à mesure que vous vous sentez à l'aise, vous pouvez créer des alias plus complexes.
Utilisez des noms significatifs : Choisissez des noms d'alias intuitifs et faciles à retenir.
Documentez vos alias : Si vous créez de nombreux alias, envisagez de conserver une liste dans un fichier de notes personnel ou même dans votre README.md pour les grands projets.
Révisez votre .gitconfig : Périodiquement, révisez votre fichier ~/.gitconfig pour voir tous vos alias définis et supprimez ceux qui ne sont plus utiles.
Soyez prudent avec l'écrasement : Évitez de créer des alias qui masquent les commandes Git intégrées, sauf si vous comprenez parfaitement les implications.

À retenir

Les alias Git fonctionnent mieux lorsqu'ils encodent des commandes que vous maîtrisez déjà. Commencez par des alias inoffensifs en lecture seule comme st, lo et lg, puis ajoutez des alias d'écriture comme fp, pr ou sp une fois que les noms vous semblent naturels. Soyez particulièrement prudent avec les alias pour clean, reset ou les commandes shell, car un nom court peut rendre une commande destructive plus facile à exécuter par erreur.