Créer son premier dépôt Git sous Ubuntu : comprendregit init, git status, git add et git commit

Introduction

Git est un système de gestion de versions qui permet de suivre les modifications apportées aux fichiers d’un projet et de conserver un historique de son évolution.

Dans les tutoriels précédents, nous avons vu comment installer et configurer Git sous Ubuntu, puis comment utiliser SSH pour connecter Git à GitHub.

Avant d’envoyer un projet sur GitHub, il est important de comprendre comment Git fonctionne localement.

Dans ce tutoriel, nous allons découvrir quatre commandes essentielles :

git init
git status
git add
git commit

Elles permettent respectivement d’initialiser un dépôt Git, de consulter son état, de préparer les modifications et de créer des commits.

Toutes les manipulations présentées dans ce tutoriel sont réalisées sous Ubuntu.

Qu’est-ce qu’un dépôt Git ?

Un dépôt Git, également appelé repository, est un dossier dans lequel Git est utilisé pour suivre l’évolution des fichiers.

Un dossier classique peut par exemple contenir :

mon-projet/
├── README.md
├── index.html
└── style.css

À ce stade, il s’agit simplement d’un dossier contenant plusieurs fichiers.

Git ne suit pas automatiquement tous les dossiers présents sur l’ordinateur. Il faut indiquer explicitement qu’un dossier doit devenir un dépôt Git.

Une fois Git initialisé dans le dossier, celui-ci contient un répertoire caché supplémentaire :

mon-projet/
├── .git/
├── README.md
├── index.html
└── style.css

Le dossier .git contient les informations internes nécessaires au fonctionnement du dépôt, notamment l’historique des commits, la configuration locale du dépôt et différentes références utilisées par Git.

C’est la présence de ce dossier qui permet à Git de reconnaître le projet comme un dépôt.

Initialiser un dépôt avec git init

La commande git init permet d’initialiser un dépôt Git dans le dossier courant.

Avant de l’utiliser, il faut donc se placer dans le dossier du projet concerné.

Par exemple :

cd mon-projet

Il est possible de vérifier le dossier actuel avec :

pwd

Une fois dans le projet, le dépôt peut être initialisé avec :

git init

Git affiche alors un message similaire à celui-ci :

Initialized empty Git repository in /home/utilisateur/mon-projet/.git/

Cela signifie que Git a créé le dossier caché .git et que le répertoire mon-projet est désormais un dépôt Git local.

Il est possible de vérifier sa présence avec :

ls -la

Parmi les fichiers et dossiers affichés, nous retrouvons .git.

Il est généralement inutile de modifier manuellement le contenu de ce dossier. Git se charge lui-même de gérer les informations qu’il contient.

La commande :

git init

n’envoie également aucune donnée sur Internet.

Le dépôt existe uniquement sur la machine locale. À ce stade, GitHub n’intervient pas encore.

Vérifier l’état du dépôt avec git status

Une fois le dépôt initialisé, l’une des commandes les plus importantes est :

git status

Cette commande permet de connaître l’état actuel du dépôt et des fichiers.

Elle indique notamment si des fichiers ont été créés, modifiés ou supprimés, et si certaines modifications ont déjà été préparées pour le prochain commit.

Dans un dépôt ne contenant aucune modification à enregistrer, Git peut par exemple afficher :

Le résultat dépend de l’état du projet et de la configuration de Git.

git status ne modifie rien dans le projet. Cette commande sert uniquement à obtenir des informations.

Il est donc possible de l’utiliser régulièrement afin de vérifier ce que Git détecte.

Comprendre les fichiers non suivis

Lorsqu’un nouveau fichier apparaît dans un dépôt Git, celui-ci n’est pas automatiquement intégré à l’historique.

Par exemple, si le projet contient un nouveau fichier README.md, la commande :

git status

peut afficher :

Le terme Untracked signifie que le fichier est non suivi.

Git voit que README.md existe dans le dossier, mais ce fichier n’a pas encore été ajouté au suivi Git.

Cela permet de garder le contrôle sur les fichiers qui doivent ou non être intégrés au projet.

Tous les fichiers présents dans le dossier n’ont pas forcément vocation à être enregistrés dans Git.

Comprendre le fonctionnement de Git

Avant de découvrir git add et git commit, il est important de comprendre les différentes étapes par lesquelles passent les modifications.

On peut simplifier le fonctionnement de Git en trois parties :

Le Working Directory, ou répertoire de travail, correspond aux fichiers sur lesquels nous travaillons actuellement.

Lorsqu’un fichier est créé ou modifié, les changements se trouvent d’abord dans ce répertoire de travail.

La Staging Area, également appelée zone de préparation ou index, est une étape intermédiaire. Elle permet de sélectionner précisément les modifications qui seront incluses dans le prochain commit.

Enfin, l’historique Git contient les commits déjà enregistrés.

Le fonctionnement général est donc :

Cette étape intermédiaire est importante car elle permet de choisir ce que nous souhaitons réellement enregistrer dans un commit.

Préparer un fichier avec git add

La commande git add permet d’ajouter une modification à la Staging Area.

Pour préparer un fichier précis, nous pouvons utiliser :

git add README.md

Après cette commande, le fichier n’est pas encore enregistré définitivement dans l’historique.

Il est simplement préparé pour le prochain commit.

Nous pouvons vérifier son état avec :

git status

Git peut maintenant afficher :

Cela signifie qu’il se trouve dans la zone de préparation et qu’il sera inclus dans le prochain commit.

Il faut donc retenir que :

git add ? git commit

git add prépare les modifications.

git commit les enregistre dans l’historique.

Ajouter plusieurs modifications avec git add .

Lorsqu’un projet contient plusieurs modifications, il est possible d’ajouter les fichiers individuellement :

git add README.md
git add index.html
git add style.css

Mais Git permet également de préparer les modifications à partir du répertoire courant avec :

git add .

Le point . représente le répertoire courant.

Cette commande est très pratique, mais il est recommandé de vérifier l’état du dépôt avant de l’utiliser :

git status

Puis de contrôler une nouvelle fois ce qui a été placé dans la zone de préparation :

git status

Cela permet d’éviter d’inclure accidentellement des fichiers qui ne devraient pas faire partie du prochain commit.

Comprendre les fichiers modifiés

Lorsqu’un fichier déjà suivi par Git est modifié après un commit, git status peut afficher :

La mention Changes not staged for commit signifie que Git a détecté une modification, mais que celle-ci n’a pas encore été placée dans la Staging Area.

Le fichier doit donc être préparé à nouveau :

git add README.md

Après cette commande, git status le placera dans la zone des modifications prêtes à être enregistrées :

Cela montre également un point important : git add ne sert pas uniquement à ajouter de nouveaux fichiers.

La commande permet aussi de préparer les nouvelles modifications apportées à des fichiers déjà suivis par Git.

Créer un commit avec git commit

Une fois les modifications placées dans la Staging Area, elles peuvent être enregistrées dans l’historique avec git commit.

La commande peut être utilisée de cette manière :

git commit -m "Ajout du fichier README"

L’option -m permet d’indiquer directement le message associé au commit.

Git peut alors afficher un résultat similaire à :

Un commit vient d’être créé.

Les modifications préparées avec git add sont désormais enregistrées dans l’historique local du dépôt.

Qu’est-ce qu’un commit ?

Un commit représente un point enregistré dans l’historique d’un projet Git.

Chaque commit possède notamment un identifiant unique, un auteur, une date et un message.

Par exemple, l’historique d’un projet pourrait évoluer ainsi :

Les commits permettent ainsi de conserver une trace structurée de l’évolution du projet.

Le message du commit doit permettre de comprendre rapidement ce qui a été modifié.

Par exemple :

git commit -m "Ajout de la page de connexion"

est généralement plus explicite que :

git commit -m "Modification"

Des messages clairs rendent l’historique beaucoup plus facile à comprendre, particulièrement lorsque le projet contient de nombreux commits ou lorsque plusieurs personnes travaillent dessus.

Vérifier l’état après un commit

Une fois le commit créé, il est possible d’utiliser à nouveau :

git status

Si aucune nouvelle modification n’a été effectuée, Git peut afficher :

La mention copie du travail est propre signifie que le répertoire de travail ne contient actuellement aucune modification différente du dernier commit enregistré.

Notre projet est donc à jour par rapport à son historique Git local.

Consulter l’historique avec git log

Une fois plusieurs commits créés, Git permet de consulter leur historique.

La commande git log affiche des informations détaillées sur les commits.

Par exemple :

Nous retrouvons notamment l’identifiant du commit, son auteur, sa date et son message.

L’identifiant du commit est souvent appelé hash.

Git permet également d’afficher une version plus compacte de l’historique avec :

git log --oneline

Le résultat peut ressembler à :

Cette représentation devient particulièrement pratique lorsque le dépôt contient de nombreux commits.

Le cycle complet d’une modification

Les quatre commandes principales de ce tutoriel permettent maintenant de comprendre le fonctionnement de base d’un dépôt Git.

La première étape consiste à initialiser le dépôt avec git init.

Ensuite, Git permet de consulter l’état du projet avec git status.

Lorsque des modifications doivent être intégrées au prochain commit, elles sont préparées avec :

git add README.md

ou, selon le besoin :

git add .

Enfin, les modifications présentes dans la Staging Area sont enregistrées :

git commit -m "Description des modifications"

Le cycle peut donc être représenté ainsi :

Après l’initialisation du dépôt, ce sont surtout git status, git add et git commit qui seront utilisés régulièrement au fur et à mesure de l’évolution du projet.

Conclusion

Dans ce tutoriel, nous avons découvert le fonctionnement de base d’un dépôt Git sous Ubuntu.

La commande git init permet de transformer un dossier classique en dépôt Git local.

git status permet ensuite de surveiller l’état du projet et de savoir quels fichiers ont été ajoutés ou modifiés.

git add permet de sélectionner les modifications qui doivent être placées dans la zone de préparation, tandis que git commit permet de les enregistrer dans l’historique du projet.

Le fonctionnement essentiel de Git peut donc être résumé ainsi :

À ce stade, tous les commits sont enregistrés localement sur la machine Ubuntu.

Dans le prochain tutoriel, nous verrons comment créer un dépôt sur GitHub, connecter notre dépôt Git local et envoyer nos commits avec git push.