Utiliser Git

Sommaire

Utiliser Git
Pour aller plus loin…

Qu'est-ce que Git ?

Git est un logiciel de contrôle de version, c'est à dire qu'il permet de garder une trace des modifications effectuées sur un fichier dans le but de pouvoir suivre l'évolution du projet.

On peut donc (entre autres) :

enregistrer l'avancée du projet au fur et à mesure ;
revenir à une version antérieure si besoin ;
travailler sur le même projet dans des branches de développement différentes pour ne pas perturber une configuration qui fonctionne ;
les recombiner à tout moment ;
permettre le travail collaboratif sur un même dépôt disponible sur le réseau ;
même si le dépôt distant est injoignable, travailler sur sa copie locale ;
ouvrir plus ou moins son projet au monde ;
filtrer les modifications venant de contributeurs inconnus à incorporer dans le projet.

Il en existe d'autres (CVS, Mercurial, Subversion, Bazaar…), mais Git est à l'heure actuelle l'un des plus puissants d'entre eux.

Git est disponible sur la plupart des systèmes d'exploitation (GNU/Linux, OS X, Windows), mais ce tutoriel s'appuie sur des exemples testés sur un OS GNU/Linux.

Cette page a pour but d'exposer les commandes basiques pour l'utilisation de Git.

Comment ça marche ? (Dans les grandes lignes)

Git s'articule autour d'un système de "commits" : Il s'agit de points de sauvegarde de l'état de votre projet.

Chaque commit, à l'exception du commit racine qui est le point de départ de vôtre dépôt, possède une référence vers au minimum 1 commit parent. En interne, Git enregistre une image de chaque fichier au moment ou vous enregistrez vos commits si des changements ont été apportés, dans le cas contraire il conserve l'image précédente. L'histoire de votre projet est donc conservée comme une suite d'images afin de pouvoir facilement changer de branche, revenir en arrière, etc.

Chaque commit est identifié de manière unique dans un dépôt donné par une checksum (par exemple : 9659aef221eb16511c632eef60a621dd85ddfe95) mais les 7 premiers caractères suffisent lorsqu'on y fait référence dans une commande (9659aef suffit à identifier l'exemple précédent). Cette checksum est importante : en plus d'identifier vos commits, elle permet également de s'assurer de l'intégrité des données qu'ils contiennent.

Pour les plus curieux : Fonctionnement de Git

Installer Git

GNU/Linux

Git est en général inclus dans l'installation de base du système. Si ce n'est pas le cas, vous pouvez (et même devez) utiliser le gestionnaire de paquets de votre distribution.

Par exemple, pour Debian et ses dérivés (Ubuntu…)

$ apt-get install git

OS X

La procédure d'installation de Git se trouve ici : Installer Git sous OS X

Windows

La procédure d'installation de Git se trouve ici : Installer Git sous Windows

Utilisation basique de Git

Indiquer à Git son identité

Avant de commencer, il faut indiquer à Git qui va faire les modifications sur le dépôt avec le compte utilisé.

Le plus simple est de configurer son identité pour tous les dépôts de la machine : ce réglage n'a besoin d'être fait qu'une seule fois. Cela est possible avec les commandes suivantes :

$ git config --global user.name "<prénom> <nom>"
$ git config --global user.email <adresse mail>

D'autres options sont disponibles, mais il n'est pas nécessaire de les préciser. Pour obtenir d'avantage d'informations sur la configuration de Git : Configuration basique de Git

Initialiser un dépôt

Pour commencer, il faut d'abord initialiser un dépôt dans lequel on va pouvoir travailler. Un dépôt est simplement un dossier dans lequel se trouve un sous dossier .git que Git utilisera pour la gestion du dépôt. Ce sous-dossier a une structure spécifique et doit donc être généré par Git lui-même.

Ne jamais toucher l'intérieur du dossier .git
Vous risquez de casser de manière irréversible le système de suivi de votre dépôt

Le dossier en question peut être vide ou pas, cela ne gênera pas Git.

$ cd /chemin/vers/le/futur/dépôt
$ git init
Dépôt Git vide initialisé dans /chemin/vers/le/futur/dépôt/.git/

Vous pouvez alors taper la commande git status pour voir quels fichiers peuvent être suivis. Par exemple, si le dossier contenait un fichier test.py et un dossier test/, on aura

$ git status
Sur la branche master

Validation initiale

Fichiers non suivis:
   (utilisez "git add <fichier>..." pour inclure ce qui sera validé)

       test.py
       test/

aucune modification ajoutée à la validation mais des fichiers non suivis sont présents (utilisez "git add" pour les suivre)

Vous pouvez ajouter ceux que vous voulez suivre avec la commande indiquée :

$ git add test.py test/

ou si vous voulez tout suivre

$ git add .

Il ne reste plus qu'à effectuer le premier "commit" de votre projet.

$ git commit

Votre éditeur de texte préféré s'ouvre alors, et vous pouvez taper un commentaire sur votre commit. Par exemple, "Initialisation du projet".

Il est également possible de tout taper dans une seule commande git commit -m "Initialisation du projet". Vous devez obtenir quelque chose dans le style :

$ git commit -m "Initialisation du projet"
[master (commit racine) c890b54] Initialisation du projet
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 test.py

Voilà, votre dépôt est initialisé, l'état de vos fichiers à ce moment est enregistré, vous pouvez de nouveau travailler dessus.

Vérifier l'état du dépôt

Pour connaître l'état du dépôt à l'instant présent, vous pouvez utiliser git status

$ git status
Sur la branche master
Modifications qui seront validées :
  (utilisez "git reset HEAD <fichier>..." pour désindexer)

      modifié :         test4.sh
      nouveau fichier : README.md

Modifications qui ne seront pas validées :
  (utilisez "git add <fichier>..." pour mettre à jour ce qui sera validé)
  (utilisez "git checkout -- <fichier>..." pour pour annuler les modifications dans la copie de travail)

      modifié :         test.py

Fichiers non suivis:
  (utilisez 'git add <fichier>..." pour inclure dans ce qui sera validé)

      test2

aucune modification n'a été ajoutée à la validation (utilisez "git add" ou git commit -a")

Git vous indique ainsi la branche sur laquelle vous vous trouvez, fichiers suivis qui ont été modifiés et qui seront dans le prochain commit, ceux qui n'y seront pas, les nouveaux fichiers/dossiers non suivis…

Plus d'informations sur git status : manpage de git-status

Consulter l'historique du dépôt

Vous pouvez jeter un coup d’œil à l'histoire de votre dépôt avec la commande git log. Plusieurs variantes sont possibles en fonction de ce que vous voulez regarder :

Pour avoir la liste des commits, leurs auteurs, leurs dates et leurs descriptions
```
$ git log
```
Pour avoir les mêmes informations qu'avant avec en plus un résumé des différences enregistrées dans chaque commit
```
$ git log --summary
```
Pour avoir la liste des commits tout en ayant une vision globale des différentes branches, ainsi que les liens de parenté entre les différents commits le tout avec un peu de couleur

$ git log --oneline --decorate --all --graph

Regarder les différences entre la version actuelle d'un fichier et le dernier commit

Imaginons que votre fichier test.py contenait dans le précédent commit ce qui suit :

   1 print("Ceci est un fichier Python 3 contenu dans mon projet Git")

que vous avez depuis changé en

   1 #!/usr/bin/python3
   2 
   3 print("Ceci est un script Python 3 contenu dans mon projet Git")

en ayant pris soin d'en faire un exécutable

$ chmod 755 test.py

Git est capable de dire exactement quelles sont les différences entre la dernière version enregistrée du fichier et sa version actuelle :

   1 $ git diff test.py
   2 diff --git a/test.py b/test.py
   3 old mode 100644
   4 new mode 100755
   5 index 947dcbc..d187be4
   6 --- a/test.py
   7 +++ b/test.py
   8 @@ -1 +1,3 @@
   9 -print("Ceci est un fichier Python 3 contenu dans mon projet Git")
  10 +#!/usr/bin/python3
  11 +
  12 +print("Ceci est un script Python 3 contenu dans mon projet Git")
  13

Il est également possible de voir les différences entre deux commits quelconques avec git diff <commit 2> <commit 1>

Plus d'informations sur git diff : manpage de git-diff

Enregistrer les modifications de fichiers/dossiers dans le dépôt

Sitôt que les modifications apportées à vôtre dépôt vous conviennent, commitez-les :

$ git add test.py
$ git commit -m "Transformation de test.py en script"
[master c226e8a] Transformation de test.py en script
 1 file changed, 3 insertions(+), 1 deletion(-)
 mode changed 100644 => 100755

Plus d'informations sur git add : manpage de git-add

Plus d'informations sur git commit : manpage de git-commit

Annuler les modifications en cours d'un fichier

Plusieurs cas de figure sont possibles.

Vous avez modifié votre fichier test.py depuis le dernier commit, vous ne les avez pas ajoutées au prochain commit avec git add et vous voulez annuler lesdites modifications :
```
$ git checkout -- test.py
```
Vous avez modifié votre fichier test.py depuis le dernier commit, vous les avez ajoutées au prochain commit avec git add et vous voulez annuler lesdites modifications :

$ git reset HEAD test.py
Modifications non indexées après reset :
M     test.py
$ git checkout -- test.py

Vous voulez revenir à une version du fichier test.py présente dans le commit d5f8ab6
```
$ git checkout d5f8ab6 test.py
```

Plus d'informations sur git checkout : manpage de git-checkout

Plus d'informations sur git reset : manpage de git-reset

Retirer des fichiers du système de suivi

Si vous avez accidentellement ajouté des fichiers que vous ne vouliez pas suivre, vous pouvez les enlever du système de suivi : ils seront alors considérés comme des fichiers non suivis dans git status.

Si vous voulez retirer test.py du système de suivi:

$ git rm --cached test.py
rm 'test.py'
$ git commit -m "test.py n'est plus suivi"
[master 6bc0bb6] test.py n'est plus suivi
 1 file changed, 3 deletions(-)
 delete mode 100755 test.py

Plus d'informations sur git rm : manpage de git-rm

Ignorer des fichiers ou des dossiers

Vous pouvez dire à Git de ne pas prendre en compte certains fichiers ou dossiers présents dans votre dépôt. Aucun suivi ne sera effectué sur ces éléments, et ils n'apparaîtront plus dans le git status, à condition qu'ils n'aient jamais été suivis.

Il suffit pour cela de vous rendre dans la racine de vôtre dépôt et d'écrire un fichier .gitignore.

Si vous voulez par exemple que Git ignore tous les fichiers se terminant par .md sauf README.md, le dossier test/, tous les fichiers précompilés .pyc ou .pyo ainsi que ceux qui pourraient être contenus dans tous les sous-dossiers de votre projet :

*.md
!README.md
test/
**/*.py[co]
**/__pycache__/

N'oubliez pas de commiter votre .gitignore, afin qu'il soit disponible avec les autres éléments du dépôt

Plus d'informations sur la façon d'ignorer des éléments de votre dépôt : 'Ignoring Files' sur git-scm

Utilisation un peu plus avancée

En construction…

stash

Si vous vous retrouvez avec les modifications de quelqu'un d'autre sur les bras alors que vous voulez travailler, éviter de les jeter.

Seulement parfois, vous avez besoin de faire des opérations qui nécessitent un dépôt clean. Dans ce cas, il y a un moyen de balancer tout ce qui traîne dans un coin où son auteur pourra aller fouiller pour retrouver ses petits.

git stash save "trucs qui trainaient"

(Vous pouvez omettre le commentaire, et, si vous le faites, vous pouvez même omettre le save, mais c'est une bonne pratique de mettre un commentaire, car si vous ne le faites pas, le commentaire utilisé sera celui du dernier commit effectué. Et ça n'a souvent aucun rapport…)

On peut le faire plusieurs fois, les données s'empilent. (Donc tous leurs numéros se décalent d'un cran.)

Si vous êtes celui qui vient chercher ses petits. Pour voir ce qu'il y a dans ce tiroir fourre-tout :

git stash list

Pour voir le contenu de l'un :

git show stash@{0}

(Ils sont rangés par ordre anti-chronologique du moment où ils ont été stashé.)

Pour le faire ressortir du tiroir :

git stash apply stash@{0}

(Si vous omettez stash@{0}⁣, git supposera que vous parlez du plus récent.)

Attention, cela peut générer des conflits, et vous aurez alors à les gérer. C'est normal, peut-être que quelqu'un a travaillé sur la même chose que ce qui a été mis dans le tiroir.

Attention, apply applique les modification stashées, mais ne supprime pas la ligne de stash. On ne sait jamais, vous avez peut-être envie de la garder quand même. Pour la virer :

git stash drop stash@{0}

(Et tous les numéros sont redécalés dans l'autre sens. Donc si il y avait un stash@{1}⁣, vous pouvez faire un git stash list juste derrière ce drop, il aura pris la place du 0.)

(Pareil, si vous omettez le stash@{0}⁣, il prend le plus récent.)

Il existe un raccourci pour les deux dernières commandes (apply + drop) :

git stash pop stash@{0}

(Même remarque pour le plus récent en cas d'omission.)

…à ceci près que le drop ne sera pas effectué si le apply a généré un conflit.

Navigation