Les commandes git à connaître absolument pour les développeurs

Vous voulez apprendre les commandes de base de git ? Vous connaissez git push git pull et git clone et voulez apprendre plus du commandes ? Vous perdez du temps car vous ne maîtrisez pas git ?

Alors ce top des commandes git les plus utiles est fait pour vous !

Git est un logiciel de contrôle de version (version control) qui permet d’avoir un historique les modifications apportées a son code ou a celui des autres. Ce projet open-source gratuit est un standard de l’industrie que tout développeur se doit de connaître sur le bout des doigts !

Apres avoir lu cet article vous serez capables de :

• Manipuler des branches
• Pousser du code avec git sur github ou un autre serveur git (push)
• Télécharger du code de github (clone)
• Écrire proprement vos messages commit
• Maîtriser votre flow localement

Commençons sans plus tarder a explorer les commandes git les plus utiles !

git config

Pour configurer votre username et l’adresse email à utiliser pour vos commits. Le flag -global rend ces changements persistants sur votre machine plutôt qu’uniquement pour le projet.

git config username

git config –global user.name <votre_nom_d'utilisateur>

git config email

git config –global user.email <votre_adresse_email>

Si vous travaillez depuis plusieurs machines et que vos commit semblent afficher différents emails ou pseudo, c’est parce que vous n’avez pas la meme configuration !

git init

Pour initialiser un nouveau repo, utilisez la commande :

git init <le_nom_de_votre_repo_git>

git init bare

Un repo initialisé avec le flag bare n’aura pas de working tree. Ce qui veut dire qu’on ne pourra pas simplement git add des fichiers pour ensuite les commit et les push. D’ailleurs si vous git init --bare un dossier et puis tapez ls -la vous verrez que git n’a pas généré de .git mais plutôt ce qui se trouve habituellement dans un dossier cache .git, directement a la racine de votre dossier.

git init --bare <nom_de_depot>

Mais alors a quoi sert git init — bare ?

On initialise un repo avec bare quand on veut par exemple, trigger des git hooks quand une certaine action se produit. On peut ainsi mettre en production des projets a chaque nouveau commit.

git init --bare est aussi utile quand on travaille en équipe et qu’on veut un remote repository commun, pour ne pas polluer le repo et n’avoir que les commit, on met a jour le repo sur github ou sur un autre serveur git uniquement avec des git push, sans modifier le code directement (comme il n’y a pas de working tree).

Par convention, quand on initialise un repo avec git init --bare, on ajoute .git en fin de nom de dossier. Ainsi, monprojet devient monprojet.git

git clone

Pour cloner un dépôt à partir d’une URL existante (github, gitlab, serveur git prive, …).

git clone <url_du_depot_git>

git add

Pour ajouter un fichier en staging. On peut add un ou plusieurs fichiers et certains flags sont comme le flag --patch sont particulièrement utiles.

git add <nom_du_ou_des_fichier(s)>

git add *

git add --patch *

Le flag —patch lance un programme interactif qui vous permet d’ajouter en staging ou pas certains bouts de code. Vous aurez plusieurs options comme split pour diviser encore plus le code en morceaux. --patch est parfait si vous avec fait plusieurs modifications dans un fichier mais que vous ne voulez commit qu’une modification dans ce meme fichier.

git commit

La commande git commit permet d’enregistrer les changements effectués sur votre code dans l’historique git.

Qu’est ce qu’un commit dans git ?

Un commit est une “capture” de l’état actuel de votre code à un moment précis.

Pour qu’un commit soit le plus leger possible, git compresse la différence (delta) entre la version antérieure de votre code et les modifications apportées par le nouveau commit.

Avec ce système de commit, git garde un historique de tous les changements apportés au fil du temps et vous permet de revenir facilement à un état précédent de votre code (quand ça fonctionnait).

Pour “commiter” du code, on utilise la commande git commit.

Comment faire un commit sur git ?

Après avoir ajouté vos changements avec une commande comme git add ..., il faut ajouter ces modifications à git avec la commande git commit. En plus de la date et le lien vers la version antérieure de votre code base, il est de pratique standard d’ajouter un message de commit aussi explicite que possible.

Avoir un message de commit clair permet à vos collaborateurs (ou votre “vous” du futur) de s’y retrouver facilement.

Idéalement, vous avez configuré Vim, Emacs, Nano ou un autre éditeur de texte pour qu’il soit votre éditeur de texte Git par défaut.

Pour écrire votre message de commit proprement et éviter les symboles qui cassent vos commit, utilisez :

git commit

Votre éditeur de texte se lance et vous pouvez formater votre message proprement avec les conventions que vous utilisez.

Quelle est la commande git qui permet d’écrire un message de commit ?

Comme nous l’avons vu juste au dessus, en plus de garder un historique de vos changements, lier un message à un commit permet de s’y retrouver plus facilement quand vous naviguez entre les versions de votre code.

Parfois, on n’a pas besoin d’écrire un long message de commit expliquant toutes les modifications apportées, le type de modification et son “scope”.

Parfois on veut juste écrire un message de commit rapide, directement dans le terminal, et il existe une commande pour ça.

Pour aller plus vite, vous pouvez donc directement mettre votre message en ligne de commande avec le flag -m, la commande complète étant :

git commit -m <votre_message_de_commit>

Cependant, pour écrire des messages plus complets et pertinents, préférez la commande git commit qui lancera un éditeur de texte comme Vim, Emacs ou Nano si vous travaillez dans le terminal.

Si c’est la première fois que vous utilisez Vim et que vous êtes pris au piège, tels les aventuriers de Jumanji, dans cet éditeur de texte, pas de panique : J’ai écrit un article pour vous expliquer comment quitter Vim (et n’oubliez pas de crier “Jumanji”).

git commit les changements

Pour commit les fichiers que vous avez ajoutés avec la commande git add et de commit également les fichiers que vous avez modifiés depuis.

git commit -a

git diff

Pour afficher les différences de fichiers qui ne sont pas encore staged.

git diff

git diff staged

Pour afficher les différences entre les fichiers dans staging et la version présente.

git diff –staged

git diff deux branches

Voir les différences entre les deux branches mentionnées.

git diff <branche_une> <branche_deux>

git reset

Pour retirer le fichier de staging, mais préserve son contenu.

git reset <fichier>

Parfait pour retirer un ficher staged sans faire exprès et garder des commit propres : un changement = un commit.

Pour annuler tous les commit après le commit spécifié et préserve les modifications localement.

git reset commit

git reset <hash_du_commit>

git reset hard

Pour supprimer tout l’historique et revient au commit spécifié.

git reset –hard <hash_du_commit>

git status

Pour lister tous les fichiers qui doivent être commit et leur états : untracked et to be committed.

git status

git rm

Pour supprimer le fichier de votre répertoire de travail et stage la suppression.

git rm <fichier>

git log

Pour lister l’historique des versions de la branche courante.

git log

Pour lister l’historique des versions d’un fichier, y compris le renommage des fichiers.

git log –follow <nom_du_fichier>

git show

Pour afficher les métadonnées et les modifications de contenu du commit spécifié.

git show <hash_du_commit>

git tag

Pour donner un tags au commit spécifié.

git tag <hash_du_commit>

git branch

Pour lister toutes les branches locales dans le dépôt actuel.

git branch

Pour créer une nouvelle branche.

git branch <branche>

Pour supprimer une certaine branche.

git branch -d <branche>

git checkout

Pour passer d’une branche à l’autre.

git checkout <branche>

Pour créer une nouvelle branche et switcher directement à celle-ci.

git checkout -b <branche>

Si vous avez bien suivi, c’est l’equivalent de git branch <nouvelle_branche> suivi de la commande git checkout <nouvelle_branche>

git merge

Pour fusionner l’historique de la branche spécifiée dans la branche actuelle.

git merge <branche>

git remote

Pour lier votre repo local a votre repo remote.

git remote add <nom_du_remote (origin ou autre)> <lien_du_serveur>

git push

Pour push les changements sur master.

git push <nom_du_remote> master

Pour push les commits à votre dépôt distant sur de la branche spécifiée.

git push <remote> <branche>

Pour pousser toutes les branches vers votre repo remote.

git push –all <remote>

git pull

Pour chercher et merger les modifications d’une branche du serveur git et l’applique a la branche sur laquelle vous vous trouvez.

git pull <branche>

git stash

Pour stocker temporairement tous les fichiers tracked modifiés.

git stash

ou

git stash save

Utile quand vous voulez mettre votre travail de cote pour revenir a la branche avant vos modifications temporairement. Par exemple, quand le commercial vient demander pourquoi ça ne marche pas, vous pouvez stash vos modifications, lui montrer que la branche fonctionne bien et puis revenir sur vos modifications quand vous avez la paix 😇

Pour restaurer les derniers fichiers stashed.

git stash pop

Pour lister tous vos stashes.

git stash list

Pour éliminer le dernier ensemble de modifications stashed.

git stash drop

git fetch

La commande git fetch permet de récupérer les modifications d’un repo distant sans écraser la version du projet que vous avez localement.

git fetch <remote> <branch>

git rebase

La commande git rebase permet de réorganiser l’historique d’une branche. Elle est souvent utiliser quand on a fait une erreur et qu’on veut supprimer des commits qu’on a déjà poussés sur le repo distant.

git rebase <branche>

git archive

La commande git archive permet de créer une archive à partir du contenu de votre référentiel git. La commande prend un flag --format pour le type d’archive (zip, tar, tag.gz, tar.bz2, …) et un flag --output pour le nom de l’archive, ainsi qu’un commit (nom de branche, tag, hash, …).

git archive --format=zip --output=main.zip main

git gc

La commande git gc qui vient de “Git Garbage Collection” permet de nettoyer et optimiser votre repo git. C’est une commande qui est utilisée par git sans que vous le sachiez donc vous ne devrez pas souvent la lancer explicitement.

git gc

git prune

La commande git prune permet de nettoyer l’instance locale de git s’il y a des fichiers inutiles qui ne sont pas utilisés par les différentes branches. C’est un nettoyage plus léger que git gc.

git prune

git grep

La commande git grep permet de chercher du contenu texte dans l’ensemble de vos fichiers gérés avec git.

git grep "commentcoder.com"

git cat-file

La commande git cat-file permet d’afficher des metadata, informations ou le contenu de fichiers. On l’utilise principalement pour debugger ou bien afficher le contenu pour le vérifier.

git cat-file -p HEAD

git ls-tree

La commande git ls-tree permet d’afficher la structure des différents fichiers et dossiers d’une certaine branche ou d’un commit. C’est un outil pour explorer l’arborescence des fichiers avec git.

git ls-tree HEAD

git fsck

fsck est de base une commande Linux qui permet de vérifier la cohérence d’un système de fichiers son nom vient de “File System Check”. Git propose sa version de fsck avec la commande git fsck pour verifier l’intégrité des fichiers d’un dépôt.

git fsck

Tableau récapitulatif des commandes git les plus utiles

Pour vous y retrouver plus facilement, j’ai compilé les commandes de cet article dans un tableau :

Aller plus loin avec Git

Git est un outil très complet et vous pourrez continuer a l’apprendre au long de votre carrière. Il existe aussi des interfaces graphiques (GUI), github a d’ailleurs son propre client pour gérer vos commit visuellement.

Je vous recommanderais cependant de vous forcer a utiliser git en ligne de commande au debut pour bien apprendre les commandes par coeur !