Les bases #1

Introduction

Dans ce tutoriel, nous allons aborder la base de git : c’est à dire comment initialiser un dépôt local, effectuer des commits et revenir à une version précédente, le tout uniquement en local.

Créer un dépôt local

La première étape consiste à définir un dépôt (en anglais : repository), c’est à dire un emplacement où git va pouvoir comparer et archiver les versions de tous les fichiers qui s’y trouvent. Cette action s’execute avec la fonction init.

Pour cela :

1. Placez vous dans un dossier vide, qui sera la base de votre projet. Par exemple :

    cd /home/mon-nom/mon-projet-git
   

2. Exécutez la commande init qui va créer le dépôt dans l’emplacement actuel :

    git init
   

Cette commande va vous renvoyer quelques informations sur votre dépôt actuel mais cela devrait ressembler à cela :

hint: Using 'master' as the name for the initial branch. This default branch name
hint: is subject to change. To configure the initial branch name to use in all
hint: of your new repositories, which will suppress this warning, call:
hint: 
hint: 	git config --global init.defaultBranch <name>
hint: 
hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and
hint: 'development'. The just-created branch can be renamed via this command:
hint: 
hint: 	git branch -m <name>
Initialized empty Git repository in /home/mon-nom/mon-projet/.git/

Les messages d’indices nous parlent de branch, un concept clé de git que nous verrons dans un futur tuto.

C’est aussi simple que cela! Vous avez maintenant un dépôt local qui est prêt à fonctionner. Maintenant nous allons voir comment utiliser concrètement git pour ce pour quoi il a été conçu : la gestion de version.

Ajouter et suivre des fichiers

Commits

Maintenant que votre dépôt est initialisé, nous allons utiliser les fonctionnalités centrales de git : suivre les modifications des éléments du dépôt, effectuer des commits et naviguer entre les versions.

1. Créez un fichier, par exemple hello.py :

    touch hello.py
   

2. Ouvrez le avec votre éditeur préféré et ajoutez du contenu :

    def hello():
        print("Hello, world!")
   	
    hello()
   

3. Nous allons maintenant dire à git de sauvegarder ce fichier dans son état actuel car c’est un fichier important. Nous allons utiliser la commande add, qui comme son nom l’indique ajoute l’objet précisé à ceux surveillés par git.

    git add hello.py
   

4. Enfin, nous allons sauvegarder l’état du dépôt dans ce que l’on appelle un commit. Un commit est une sauvegarde d’un dépôt à un instant donné. Il se compose de l’ensemble des éléments ajoutés depuis le dernier add et éventuellement (mais de manière fortement recommandée) d’un message explicatif. Pour créer un commit, utilisez la commande commit, avec -m l’option qui permet d’ajouter un commentaire.

    git commit -m "ajout du fichier hello.py"
   

   Le message de commit est très important car il permet à toute personne de comprendre rapidement quel était le but de ce commit. C’est pourquoi il est bon de prendre l’habitude de faire des messages de commit précis.

Le retour de la commande commit indique quelques informations intéressantes :

[master (root-commit) 97565e6] ajout du fichier hello.py
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 hello.py

Nous pouvons donc voir que git comptabilise les modifications et les répartit en 2 catégories :

• insertions : le nombre de lignes ajoutées (par fichier suivi)
• deletions : le nombre de lignes supprimées (idem)

Ici nous voyons 0 insertions et 0 deletions car c’est la première fois que git suit ce fichier dans ce dépôt. Cela est donc compté comme un ajout de fichier.

Continuons maintenant à modifier ce fichier pour voir comment git va suivre son évolution. Pour cela modifiez le fichier hello.py comme vous le voulez. Par exemple :

def hello():
	print("Hello, world 2e version!")
	
hello()

N’importe quelle modification de fichier est automatiquement détectée, peu importe sa taille et son importance (même un simple ajout d’espace).

Ajoutez maintenant ces modifications au dépôt avec les commandes add et commit :

git add hello.py
git commit -m "deuxième version du hello"

Historique des commits

Imaginons un moment que les modifications effectuées sur les fichiers ne vous conviennent pas car elles ont créé des bugs. Ou bien que vous souhaitez juste voir comment a évolué un fichier au cours des versions. Vous cherchez donc à lire l’historique des commits sur ce dépôt.

Pour cela, il faut utiliser la commande log, qui affiche tous les commits, avec leurs messages descriptifs respectifs, leur nom, leur date et leur auteur.

Lancez la commande :

git log

Vous devriez avoir quelque chose de ce style :

commit 5dd92319ca0cf98c944fc75d82e51237ea75715c (HEAD -> master)
Author: monnom <mon.email@exemple.fr>
Date:   Sat Jul 5 20:27:24 2025 +1000

    deuxième version du hello

commit 0ce73e0255125270fe7401db76704023d8f88fe6
Author: monnom <mon.email@exemple.fr>
Date:   Sat Jul 5 20:26:32 2025 +1000

    ajout du fichier hello.py

(END)

On remarque que les modifications ne sont pas explicitement indiquées, d’où la nécessité de faire des messages de commits clairs.

Dans notre scénario, il faut donc revenir à la version du commit précédent (c’est à dire sans le 2e version). Cela peut être fait en demande à git de revenir à la version précédente du commit, avec la commande checkout.

Notez donc les 7 premiers caractères du commit précédent (ici Oce73e0) et effectuez cette commande :

git checkout 0ce73e0

On peut aussi utiliser la touche tab après avoir tapé checkout pour afficher la liste des commits et leur numéro.

Si vous regardez le contenu du fichier hello.py vous verrez qu’il est revenu au même état que dans le commit précisé! Ici réside la simplicité et la force de git : vous pouvez naviguer à souhait entre les versions de votre projet pour tester, explorer ou vérifier. Nos exemples sont simplistes mais cela fonctionne exactement de la même manière pour un projet de 10 lignes de codes que pour un système à 60000 lignes réparties entre 300 fichiers.

Bilan

Dans ce tuto, vous avez appris les bases de git avec la création du repository, comment envoyer des commit et revenir à des versions précédentes.

Voici un petit schéma illustrant les principes des fonctions add et commit :

Prochaine étape

Dans le prochain tuto, nous verrons la deuxième composante fondamentale de git : le remote ou comment placer son travail dans un réseau partagé.