Le gestionnaire de source est, avec l’EDI, l’un des outils dont on ne peut se passer aujourd’hui. Il permet de travailler en équipe, de garder un historique des développements, de mieux dormir la nuit etc.
Ce tutoriel va vous accompagner pas à pas dans la découverte de cet outil qu’il est primordial de bien maîtriser.
1. Prérequis
En pre-requis pour cette introduction à Git, il est nécessaire d’installer les outils suivants :
- Git : https://git-scm.com/downloads
- Visual Studio Code : https://code.visualstudio.com/
Afin de vérifier que Git est correctement installé sur votre machine, vous pouvez ouvrir un terminal et tapez la commande suivante :
git --version
2. Configurer Git Bash (Bourne-Again SHell)
Afin de faciliter l’utilisation de Git Bash, nous allons customiser la configuration de base de Git.
Pour cela :
- allez dans le répertoire : C:/Users/[Nom d’utilisateur Windows]/,
- ouvrez le fichier .gitconfig
- et remplacez le contenu du fichier par celui-ci :
[user]
name = VotreNom
email = Votre@dresse.mail
[color]
ui = auto
[alias]
lg = log --graph --date=relative --pretty=tformat:'%Cred%h%Creset -%C(auto)%d%Creset %s %Cgreen(%an %ad)%Creset'
[log]
abbrevCommit = true
follow = true
[status]
submoduleSummary = true
showUntrackedFiles = all
[color "branch"]
upstream = cyan
[init]
defaultBranch = main
Cette configuration permet d’utiliser Git Bash de façon plus lisible.
Vous verrez surtout la différence avec la commande git lg.
3. Mon 1er dépôt (repository)
Ouvrez une invite de commande et créez un dossier avec la commande :
mkdir mon-premier-repo
Dans Visual Studio Code :
- Ouvrez le dossier
mon-premier-repo. - Ouvrez un terminal : Ctrl + ù ou View > Terminal.
- Ouvrez un Git Bash dans Visual Studio Code :
Pour créer votre premier dépôt, tapez la commande suivante dans le Git Bash :
git init
Une fois cette commande exécutée.
Le dossier mon-premier-repo a été créé et il contient votre dépôt.
Le dépôt est le dossier nommé .git où Git stocke ses informations.
Sous Windows, c’est un dossier caché.
A partir de maintenant, toutes les modifications apportées au dossier mon-premier-repo et à son contenu seront détectées par Git.
Si tout s’est bien passé, vous devez avoir (main) au bout du chemin indiqué dans le Git bash :
MINGW64 ~/source/repos/agora/github/mon-premier-repo (main)
4. Status
Afin de savoir où en est notre dépôt, nous allons utiliser la commande suivante :
git status
MINGW64 ~/source/repos/agora/github/mon-premier-repo (main)
$ git status
On branch main
No commits yet
nothing to commit (create/copy files and use "git add" to track)
Git nous indique ici où il en est : No commits yet, nothing to commit.
Cette commande est très pratique.
Git fournit toujours des informations utiles.
Nous allons l’utiliser régulièrement afin de savoir quel est l’état de notre dépôt.
5. Track / Stage
Pour l’instant notre dépôt est vide.
Nous allons donc créer un fichier dans le dossier mon-premier-repo avec la commande :
touch 1erFichier.txt
Utilisez la commande git status.
MINGW64 ~/source/repos/agora/github/mon-premier-repo (main)
$ git status
On branch main
No commits yet
Untracked files:
(use "git add <file>..." to include in what will be committed)
1erFichier.txt
nothing added to commit but untracked files present (use "git add" to track)
Git vous indique maintenant qu’un fichier a été ajouté mais qu’il n’est pas suivi (tracked) : Untracked files : 1erFichier.txt.
En plus de cela, il vous indique comment ajouter ce fichier!
Vous pouvez donc utiliser la commande proposée par Git :
git add 1erFichier.txt
Utilisez la commande git status.
MINGW64 ~/source/repos/agora/github/mon-premier-repo (main)
$ git status
On branch main
No commits yet
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file: 1erFichier.txt
Notez la différence par rapport à l’exécution précédente : Changes to be committed: new file: 1erFichier.txt.
Dans Visual Studio Code, ouvrez 1erFichier.txt.
Modifiez son contenu puis sauvegardez (CTRL+S).
Utilisez la commande git status.
MINGW64 ~/source/repos/agora/github/mon-premier-repo (main)
$ git status
On branch main
No commits yet
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file: 1erFichier.txt
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: 1erFichier.txt
A présent Git vous indique que vous avez une modification à commit et une modification qui n’est pas staged for commit.
6. Commit et Staging Area
Commit signifie “engagement” et Stage signifie “étape”.
Un commit est une liste de modifications apportées à vos fichiers/dossiers.
Cela peut être des ajouts ou des suppressions de fichier, des modifications de contenu, un renommage etc.
Git fonctionne en delta.
Un commit ne contient pas l’intégralité de votre dossier mais uniquement les modifications effectuées depuis le dernier commit (de la branche courante).
Ce qui est stocké dans un dépôt Git et la liste des commits que vous avez effectués depuis la création du dépôt.
Pour l’instant votre dépôt ne contient pas encore de commit.
Git vous met à disposition un état intermédiaire nommé la staging area.
Les fichiers qui sont stockés dans la staging area seront intégrés lors de votre prochain commit.
Les modifications qui ne le sont pas ne seront pas intégrées au commit mais elles ne seront pas perdues pour autant!
Pour le vérifier, nous allons effectuer notre premier commit avec la commande suivante :
git commit -m "creation du dépôt ajout de 1erFichier.txt"
Faites à présent un git status, vous verrez que Git ne plus parle que de votre modification de fichier :
MINGW64 ~/source/repos/agora/github/mon-premier-repo (main)
$ git status
On branch main
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: 1erFichier.txt
no changes added to commit (use "git add" and/or "git commit -a")
Pour résumer voici un schéma qui décrit les concepts que nous venons de voir :
7. Log
Ajouter maintenant un nouveau fichier avec la commande :
touch 2emeFichier.txt
A présent vous avez deux modifications en cours qui ne sont pas suivies.
Afin d’ajouter toutes les modifications en cours (non “commitées”) à votre Staging Area, utilisez :
git add .
Puis effectuez un commit :
git commit -m "ajout de 2emeFichier.txt et modification de 1erFichier.txt"
Pour visualiser la liste des modifications nous pouvez utiliser la commande de base git log ou la commande git lg (permise grace à notre configuration custom .gitconfig).
Ces commandes permettent de consulter l’historique des commits présents dans un dépôt.
Si vous souhaitez ne voir que les n derniers commits, vous pouvez l’utiliser comme suit :
git lg -n
Exemple :
MINGW64 ~/source/repos/agora/github/mon-premier-repo (main)
$ git lg -1
* d17c78e - (HEAD -> main) ajout de 2emeFichier.txt et modification de 1erFichier.txt
8. Short Hash
Les commits sont identifiés par leurs ids.
Il correspond à un hash basé notamment sur : contenu, date, auteur, commit précédent…
Le risque de collision est très faible.
Lorsqu’on utilise la commande git lg, on affiche la version courte des ids des commits :
MINGW64 ~/source/repos/agora/github/mon-premier-repo (main)
$ git lg
* d17c78e - (HEAD -> main) ajout de 2emeFichier.txt et modification de 1erFichier.txt
* 38db667 - creation du dépôt ajout de 1erFichier.txt
Cette forme est plus pratique et permet de faire énormément de choses.
Par exemple : restaurer le contenu de tout notre dossier mon-premier-repo.
En une seule commande nous pouvons utiliser le Short Hash du premier commit et la commande checkout, exemple :
git checkout 38db667
Suite à la dernière commande (git checkout 38db667), le dépôt n’est plus rattaché à une branche.
MINGW64 ~/source/repos/agora/github/mon-premier-repo ((38db667...))
$
La suite
La notion de branche est la plus importante de Git et c’est que nous verrons dans notre prochain post sur Git : 2 - les branches!