Git : Les commandes de bases

Listes des commandes git les plus utilisées sous forme de référenciel. Apprenez à mieux maitriser le fonctionnement de git.
  • Productivité

Git est un système de gestion de version utilisé par tous les développeurs. SVN son prédécesseur s’est vu remplacer par un outil plus pratique et plus complet.

Parmi les dépôts git en ligne les plus utiliser, on nommera GitHub, BitBucket ou encore Gitlab (que beaucoup d’entreprises utilisent pour installer des dépôts (repository) sur leur propre serveur.

Commencer avec git est assez simple si on maîtrise les quelques commandes de bases git. Si vous n’avez jamais utilisé de système de gestion de version pas de panique, la courbe d’apprentissage est très rapide ! Après avoir lu ce tutoriel, vous pourrez utiliser git au quotidien, dans votre entreprise ou pour des projets persos.

Avantages à l’utilisation de git

  • Obligatoire pour éviter de perdre du code ;
  • Pour partager du code avec d’autres personnes facilement ;
  • Toute les entreprises de la tech demande sa maîtrise (fourni avec cet article !) ;
  • Montrer la qualité de son code sur un réseau ;
  • Participer à la communauté sur de gros projets ;

Beaucoup de code logiciels / frameworks de développement se trouve sur git (Symfony, Angular, Ionic, VScode).

Bref, tout le monde utilise git ! Si vous souhaitez devenir un meilleur développeur et devenir plus productif, ce tutoriel sur git devrait vous y aider !

Installation de git

Configuration de git

Si jamais vous n’avez pas encore configuré git sur votre poste de travail.

$ git config --global user.name "Alex Soyer"
$ git config --global user.email "mail@domaine.com"

Pour vérifier ou changer globalement vos informations :

$ vim ~/.gitconfig

[user]
name = Alex Soyer
email = mail@domaine.com
[core]
autocrlf = input

Si vous souhaitez changer la configuration locale (propre à un projet), utiliser la même commande sans l’option --global.

Les principales commandes de git

Voici les principales commandes pour une utilisation de base de git. Ce sont pour moi les commandes les plus utiles pour les développeurs, je les utilise tous les jours.

J’ai longtemps utilisé cette liste de commandes utiles pour git comme un référentiel des commandes git que j’utilisais le plus souvent.

git clone

Permet de récupérer (télécharger) le contenu d’un dépôt. On récupère ainsi les sources (le code) + la configuration (où se trouve le dépôt notamment).

Exemple d’utilisation de git clone

# écrira dans "mokime/"
$ git clone https://github.com/Dinath/mokime.git 

# écrira dans "projet-wordpress"
$ git clone https://github.com/Dinath/mokime.git projet-wordpress 

# écrira dans le dossier courant
$ git clone https://github.com/Dinath/mokime.git .

git init

Permet d’initialiser un dépôt localement. De cette façon si le dépôt n’existe pas encore en ligne, vous pouvez le créer en local et le pousser avec la commande git push).

Exemple d’utilisation de git init

$ cd /tmp
$ mkdir -v "mokime"
$ cd mokime/
$ git init
Dépôt Git vide initialisé dans /tmp/mokime/.git/

git add

Permet d’ajouter des fichiers à versionner dans git. Si vous ne les ajoutez pas avec git add, les fichiers ne seront pas commité.

Attention ! Si vous ajoutez un fichier puis que vous le modifiez à nouveau, vous devez l’ajouter une seconde fois pour que votre modification soit prise en compte.

Exemple d’utilisation de git add

 # je crée / modifie un fichier à commiter
$ vim index.php

# Ajoute tous les fichiers du répertoires (dangereux)
$ git add --all

# Ajoute tous les fichiers du répertoire courant (non recommandé)
$ git add .

# Ajoute les fichiers par leur nom (recommandé)
$ git add index.php

git status

Permet de récupérer les informations courantes sur l’état des fichiers dans le dépôt.

Exemple d’utilisation de git status

$ git status
git status : vérifier l'état des fichiers sous git
Utilisation de la commande »git status »

git commit

Permet de commiter les fichiers qui ont été ajouté avec git add. Ce commit contient un message informant de la modifiée opérée.

Pour rappel un « commit » contient la modification d’un ou de plusieurs fichiers, que ce soit en ajout ou en suppression.

Exemple d’utilisation de git commit

Notre fichier a bien été ajouté avec git add, nous avons vérifié l’état des fichiers avec git status. Nous allons désormais commiter ce fichier.

$ git commit -m "Création du point d'entrée du projet index.php" # (recommandé)
[master (commit racine) 345c9bf] Création du point d'entrée du projet index.php
1 file changed, 4 insertions(+)
create mode 100644 index.php

# Ajoute automatiquement les fichiers modifiés et supprimés (pas les nouveaux) (non recommandé)
$ git commit -a -m "Création du point d'entrée du projet index.php"

git diff

Permet de faire la différence entre le commit précédent et l’état actuel des fichiers (voir git status). Ne fonctionnera pas sur les fichiers qui n’ont pas déjà été ajouté (avec git add).

Exemple d’utilisation de git diff

$ vim index.php # je modifie un fichier déjà commité
$ git diff
git diff : vérifier les différences dans les modifications
Utilisation de la commande « git diff » sur le fichier index.php

git log

Permet d’afficher les commits précédents.

Exemple d’utilisation de git log

$ git log
commit 345c9bf40b62fad4fe6cf7d24dea0f6f6819e33a (HEAD -> master)
Author: Alex Soyer mail@domaine.com
Date: Tue Apr 14 07:53:13 2020 +0200
Création du point d'entrée du projet index.php

git tag

Permet de commiter un tag, souvent utilisé pour donner des noms de versions. Sur Github, les tags se trouvent dans l’onglet « release » des projets.

Exemple d’utilisation de git tag

# Crée une version 0.1 avec le message "Version 0.1 : Réécriture des points d'entrées"
$ git tag -a v0.1 -m "Version 0.1 : Réécriture des points d'entrées"

# Récupérer la liste des tags
$ git tag
v0.1

# Voir le message associé aux tags
$ git tag -n
v0.1 Version 0.1 : Réécriture des points d'entrées

git stash

Permet de sauvegarder les changements courants et de revenir à l’état du dernier commit.

Exemple d’utilisation de git stash

# On sauvegarde le changement fait plus haut (voir git diff), et on retourne à l'état du dernier commit.
$ git stash
Copie de travail et état de l'index sauvegardés dans WIP on master: 345c9bf Création du point d'entrée du projet index.php

# Afficher les fichiers affectés par le stash
$ git stash show
index.php | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)

# Vérifier le contenu des changements opérés par le stash
$ git stash show -p
diff --git a/index.php b/index.php
index 9afefcd..31f4ec0 100644
--- a/index.php
+++ b/index.php
@@ -1,4 +1,4 @@
<?php
-echo "Je suis Alex";
+echo "Mon blog est SHZ !";

# On ré-ajoute les modifications sauvegardées à l'état courant
$ git stash pop
Sur la branche master
Modifications qui ne seront pas validées :
(utilisez "git add …" pour mettre à jour ce qui sera validé)
(utilisez "git checkout -- …" pour annuler les modifications dans la copie de travail)
modifié&nbsp;: index.php
Fichiers non suivis:
(utilisez "git add …" pour inclure dans ce qui sera validé)
controller.php
aucune modification n'a été ajoutée à la validation (utilisez "git add" ou "git commit -a")
refs/stash@{0} supprimé (d9096550d1898161ccc186a05300cad91d4285a8)

# Pop supprime l'entrée de la table de stash
$ git stash show
Aucune entrée de remisage trouvée.

git pull

Permet de récupérer les derniers éléments (commits) poussés sur le dépôt. Par défaut, lorsque l’on pull on pull le dépôt origin (le dépôt par défaut).

Rappel : On pull son projet avant de commencer à travailler dessus sous peine de conflit !

Exemple d’utilisation de git pull

$ git pull

# Même chose que la précédente
$ git pull origin

# Récupère les mises à jour de la branche sur le dépôt "autre_depot"
$ git pull autre_depot autre_branche

git push

Permet de pousser les commits vers le dépôt choisi. On utilise toujours la commande git pull avant de pousser ses modifications.

Exemple d’utilisation de git push

# Pousse les commits vers origin (le défaut)
$ git push

# Pousse les commits vers "autre_depot"
$ git push autre_depot

# Force l'envoi des commits sur le dépôt peu importe son état (Non recommandé )
$ git push --force

git checkout

Cette commande permet plusieurs choses, voir l’exemple ci-dessous.

Exemple d’utilisation de git checkout

# Crée une nouvelle branche nommée "develop" 
$ git checkout -b develop
Basculement sur la nouvelle branche 'develop'

# Permet de changer de branche
git checkout master
Basculement sur la branche 'master'

# Annule les modifications courantes du fichier
git checkout index.php

git merge

Permet de fusionner des branches, on se positionne sur une branche donnée puis merge la branche en paramètre sur la branche actuelle.

Exemple d’utilisation de git merge

# Nous ajoutons un nouveau fichier puis le commitons
$ git checkout develop
$ git add controller.php
$ git commit -m 'Ajout modèle MVC'
[develop cdadc4a] Ajout modèle MVC
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 controller.php

# develop contient désormais un fichier que master n'a pas
$ git checkout master

# fusion de develop sur master
$ git merge develop
Mise à jour 345c9bf..cdadc4a
Fast-forward
controller.php | 0
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 controller.php

git reset

Permet de supprimer un commit dans la pile des commits. Ceci n’est pas du tout recommandé, plutôt que de supprimer un commit, on préférera faire un commit inverse (voir git revert).

Exemple d’utilisation de git reset

$ git add model.php
$ git commit -m "Ajout du modèle"
[master 6a0c9c5] Ajout du modèle
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 model.php

$ git log
commit 6a0c9c57a68c526944bb78d3e600070e46f21110 (HEAD -> master)
Author: Alex Soyer email@domaine.com
Date: Wed Apr 15 06:16:59 2020 +0200
Ajout du modèle

# Supprime le dernier commit et conserve les changements courants
git reset --soft HEAD~1

# Supprime le dernier commit (ne conserve pas les changements du dernier commit)
$ git reset --hard HEAD~1
HEAD est maintenant à 4c8961a Création du point d'entrée du projet index.php

git revert

Permet de faire un commit inverse pour invalider un commit (plutôt que de le supprimer). On annule ses modifications avec un nouveau commit.

Exemple d’utilisation de git revert

# On commit une modification sur le modèle
$ git add model.php
$ git commit -m 'Ajout du champ "nom"'

# On récupère l'ID du dernier commit
$ git rev-parse HEAD # on aurait pu utiliser git log
12a56aac2c349b19a729e971cc244824a97528e6

# On effectue la modification inverse
$ git revert 12a56aac2c349b19a729e971cc244824a97528e6
Revert "Ajout du champ "nom""
This reverts commit 12a56aac2c349b19a729e971cc244824a97528e6.
Veuillez saisir le message de validation pour vos modifications. Les lignes
commençant par '#' seront ignorées, et un message vide abandonne la validation.
#
Sur la branche master
Modifications qui seront validées :
modifié : model.php
#
Fichiers non suivis:
controller.php
#

# Le dernier commit a été "annulé" par un nouveau commit
$ git log
commit 33955819b09735203387d22f46c3e2c5f9963bf7 (HEAD -> master)
Author: Alex Soyer mail@domaine.com
Date: Wed Apr 15 06:31:41 2020 +0200
Revert "Ajout du champ "nom"" This reverts commit 12a56aac2c349b19a729e971cc244824a97528e6.
commit 12a56aac2c349b19a729e971cc244824a97528e6
Author: Alex Soyer mail@domaine.com
Date: Wed Apr 15 06:31:04 2020 +0200
Ajout du champ "nom"

git remote

Permet de gérer différents dépôts. On peut ainsi pousser des modifications vers un autre serveur que le serveur git (utile pour travailler sur plusieurs serveurs git ou déployer du code directement sur le serveur).

Dans notre exemple, nous n’avons pas créé de dépôt, nous avons juste initialisé un dépôt vide avec git init. Pour se connecter à un dépôt en ligne, nous utiliserons git remote.

Exemple d’utilisation de git remote

# Lister les différents dépôts
$ git remote -v
origin https://github.com/Dinath/mokime.git (fetch)
origin https://github.com/Dinath/mokime.git (push)

# Ajouter un nouveau dépôt
$ git remote add mokime-pro https://github.com/Dinath/mokime-pro.git

$ git remote -v
mokime-pro https://github.com/Dinath/mokime-pro.git (fetch)
mokime-pro https://github.com/Dinath/mokime-pro.git (push)
origin https://github.com/Dinath/mokime.git (fetch)
origin https://github.com/Dinath/mokime.git (push)

# On peut pousser du code directement sur un dépôt (et pas un autre)
$ git push origin
$ git push mokime-pro

# Supprimer un dépôt
git remote rm mokime-pro

# Changer l'URL d'un dépôt
# On change ici l'URL par défaut (origin)
$ git remote set-url origin "https://github.com/Dinath/mokime-pro.git"

Voici les commandes principales de git que chaque développeur doit maîtriser pour améliorer la qualité de son travail.

N’hésitez pas à donner en commentaire les commandes git que vous utilisez le plus souvent !

Article publié le

Dernière modification le

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.