Jour 27 – Débuter avec Git, tutoriel complet pour débutant

Git est un logiciel qui vous aide à garder un historique de toutes les modifications que vous apportez à votre code. Il vous permet de suivre les différentes étapes de votre travail, de revenir en arrière si nécessaire, et de travailler proprement, même si vous êtes seul sur un projet.

Qu’est-ce que Git ?

Ce système de suivi des modifications est ce qu’on appelle un système de contrôle de version. Cela signifie qu’il garde une trace précise de ce que vous avez fait, quand vous l’avez fait, et parfois même pourquoi vous l’avez fait (si vous laissez un message explicite à chaque modification).

Imaginez que vous écriviez un long texte. Avec Git, vous pouvez sauvegarder une version de ce texte à chaque changement important. Plus tard, si vous faites une erreur ou si vous changez d’avis, vous pouvez revenir à une version précédente en quelques secondes. C’est ça, la puissance de Git. Découvrons le ensemble à l’aide d’un cas concret : Le développement de notre projet Créa-code.

Quelle est la différence entre Git, GitHub et GitLab ?

C’est une confusion fréquente au début, et c’est bien normal.

• Git est un logiciel que vous installez sur votre ordinateur. Il fonctionne en local, sans Internet. Il gère l’historique de votre projet, vos sauvegardes internes, vos retours en arrière, vos tests, etc.
• GitHub et GitLab sont des services en ligne. Ils permettent d’héberger une copie de votre projet Git sur Internet. Grâce à eux, vous pouvez sauvegarder votre travail à distance, le partager avec d’autres, ou y accéder depuis n’importe quel ordinateur.

Vous pouvez très bien utiliser Git sans GitHub. Mais utiliser Git avec GitHub (ou GitLab) offre des avantages en matière de sauvegarde, de collaboration et d’organisation.

Pourquoi utiliser Git même quand on travaille seul ?

Vous pourriez penser que Git est utile seulement pour les grandes équipes. Mais ce n’est pas le cas.

Quand vous développez seul, vous êtes à la fois le développeur, le testeur, et le gestionnaire de projet. Git vous aide à structurer votre travail, à garder une trace claire de vos actions, et à éviter les erreurs coûteuses.

Par exemple, si vous faites une grosse modification dans votre code et que quelque chose ne fonctionne plus, vous pouvez revenir à l’état précédent facilement. Vous n’avez plus besoin de copier votre projet dans des dossiers nommés « version_finale », « version_finale_corrigée », ou « version_bis ».

Git vous aide aussi à documenter votre évolution. En lisant vos anciens messages de sauvegarde, vous comprenez ce que vous avez fait, et pourquoi. Cela devient un véritable journal de bord de votre projet.

Enfin, c’est une compétence très recherchée dans le monde du développement web. Prendre l’habitude d’utiliser Git dès maintenant vous prépare à travailler de façon professionnelle, même si vous êtes indépendant.

Installation de Git

Avant de pouvoir utiliser Git, vous devez l’installer sur votre ordinateur. Heureusement, l’installation est simple et rapide, quel que soit votre système d’exploitation.

Installer Git sur Windows

1. Rendez-vous sur le site officiel : https://git-scm.com
2. Cliquez sur le bouton de téléchargement. Le site détectera automatiquement que vous êtes sous Windows.
3. Une fois le fichier téléchargé, ouvrez-le pour lancer l’installation.
4. Pendant l’installation, vous pouvez laisser la plupart des options par défaut. Git vous proposera d’ajouter un raccourci dans le menu contextuel (clic droit) et d’intégrer Git à votre terminal. C’est très pratique, donc vous pouvez accepter.
5. Une fois l’installation terminée, ouvrez le menu Démarrer et cherchez Git Bash. C’est un terminal spécial fourni avec Git qui fonctionne très bien pour débuter.

Installer Git sur macOS

1. Ouvrez le Terminal, que vous trouverez dans le dossier Applications > Utilitaires.
2. Tapez simplement la commande suivante : git Si Git n’est pas encore installé, votre Mac vous proposera automatiquement de l’installer.
3. Cliquez sur « Installer » et laissez le système faire le travail.
4. Une fois terminé, vous pouvez retaper git dans le Terminal pour vérifier que tout est bien installé.

Installer Git sur Linux

Si vous êtes sous Ubuntu, Debian ou une autre distribution basée sur Debian, ouvrez un terminal et tapez :

sudo apt update
sudo apt install git

Sous Fedora ou Red Hat :

sudo dnf install git

Sous Arch Linux :

sudo pacman -S git

Une fois installé, vous pouvez vérifier la version de Git avec la commande suivante :

git --version

Cela vous retournera une ligne comme :

git version 2.44.0

Cela confirme que Git fonctionne.

Première configuration de Git

Une fois que Git est installé, vous devez lui dire qui vous êtes. C’est important car chaque modification que vous enregistrerez dans vos projets contiendra votre nom et votre adresse e-mail. Cela permet de suivre l’auteur de chaque changement.

Ouvrez un terminal (Git Bash sous Windows, Terminal sur macOS ou Linux), puis tapez les deux lignes suivantes en remplaçant les valeurs par les vôtres :

git config --global user.name "Votre Prénom Nom"
git config --global user.email "[email protected]"

Par exemple :

git config --global user.name "Alban L."
git config --global user.email "[email protected]"

Ces deux réglages seront valables pour tous vos projets Git.

Vérifier la configuration

Pour vérifier que Git a bien enregistré vos informations, tapez :

git config --global --list

Cela affichera un petit résumé, comme ceci :

user.name=Alban
[email protected]

C’est bon, vous êtes prêt à utiliser Git.

Démarrage d’un dépôt Git

Maintenant que Git est installé sur votre ordinateur et correctement configuré, vous pouvez commencer à l’utiliser dans vos projets. Ce chapitre vous montre comment créer un dépôt Git local, c’est-à-dire un espace dans lequel Git va suivre l’évolution de vos fichiers.

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

Un dépôt (ou « repository » en anglais) est un dossier spécial dans lequel Git enregistre tout l’historique de votre projet. Cela inclut vos fichiers actuels, mais aussi toutes les versions précédentes, les messages de sauvegarde (commits), et d’autres informations utiles pour le suivi.

Ce dépôt se compose de deux parties :

• votre projet, avec vos fichiers visibles (HTML, CSS, JS, etc.)
• un dossier caché nommé .git, qui contient toute l’histoire et les données du dépôt

Créer un nouveau dépôt

1. Ouvrez un terminal (Git Bash sous Windows, ou Terminal sur macOS ou Linux).
2. Allez dans le dossier de votre projet avec la commande cd.

Par exemple :

cd /chemin/vers/mon-projet

3. Ensuite, tapez simplement cette commande :

git init

Git crée alors le dossier .git. Ce dossier est caché, mais il est essentiel. Il signifie que le projet est maintenant « sous Git », c’est-à-dire que Git commence à suivre ce qui se passe. Faites le avec le dossier qui contient les fichiers de notre projet Créa-code.

Vérifier que Git suit le projet

Dans votre terminal, vous pouvez taper :

git status

Cette commande vous montre l’état actuel du projet. Juste après avoir initialisé Git, vous verrez un message indiquant que vous êtes sur la branche main (ou master selon la version), et qu’aucun fichier n’est encore suivi.

Ajouter des fichiers à suivre

Par défaut, Git ne suit aucun fichier. Il attend que vous lui disiez lesquels il doit surveiller. Pour cela, utilisez la commande suivante :

git add .

Le point signifie « tous les fichiers du dossier courant ». Vous pourriez aussi ajouter un fichier précis comme ceci :

git add index.html

Une fois les fichiers ajoutés, Git est prêt à enregistrer un premier instantané.

Enregistrer un premier commit

Un commit est une sorte de photo de votre projet à un moment donné. C’est ce qui vous permet ensuite de revenir en arrière si nécessaire. Chaque commit est accompagné d’un petit message pour expliquer ce que vous avez fait.

Voici la commande à utiliser :

git commit -m "Premier commit : ajout des fichiers de base"

Le -m signifie que vous ajoutez un message juste après, entre guillemets.

Git enregistre alors l’état du projet à ce moment précis. Vous venez de faire votre premier commit !

Résumé du processus

1. Vous entrez dans le dossier de votre projet
2. Vous tapez git init
3. Vous ajoutez vos fichiers avec git add .
4. Vous enregistrez un commit avec git commit -m "votre message"

Désormais, Git suit votre projet.

Gestion de l’historique

L’un des grands avantages de Git est qu’il garde une trace de toutes les modifications que vous enregistrez avec des commits. Grâce à cela, vous pouvez voir ce que vous avez fait, quand, et revenir en arrière si nécessaire.

Ce chapitre vous apprendra à consulter votre historique, comprendre ce que contiennent vos commits, et corriger ou annuler certaines actions si besoin.

Consulter l’historique des commits

La commande la plus simple est :

git log

Elle affiche la liste des commits effectués, du plus récent au plus ancien. Pour chaque commit, Git indique :

• son identifiant (un long code unique)
• l’auteur du commit
• la date
• le message que vous avez écrit avec -m

Exemple :

commit cc7d73cb3efbcf075635f975cabf7d4fa9f09e35 (HEAD -> master)
Author: Alban <[email protected]>
Date:   Fri Jul 25 15:53:21 2025 +0200

    Premier commit : ajout des fichiers de base

Vous pouvez faire défiler cette liste avec les flèches haut/bas et quitter en appuyant sur la touche q.

Affichage simplifié de l’historique

Si vous souhaitez un affichage plus lisible et plus court, tapez :

git log --oneline

Chaque commit apparaît alors sur une seule ligne avec :

• son identifiant abrégé (ex : 3e2a9d5)
• son message

Cela donne une vue d’ensemble rapide de vos modifications. Par exemple :

cc7d73c (HEAD -> master) Premier commit : ajout des fichiers de base

Voir les changements dans un commit

Pour voir ce qui a été modifié dans un commit, vous pouvez utiliser :

git show

Cela affiche le contenu du dernier commit, ligne par ligne, avec les fichiers concernés et les lignes modifiées. Les ajouts sont marqués par un +, les suppressions par un -.

Vous pouvez aussi afficher un commit précis en ajoutant son identifiant :

git show cc7d73c

Comparer l’état actuel avec le commit précédent

Si vous voulez voir ce qui a changé depuis le dernier commit, utilisez :

git diff

Cela affiche les différences entre vos fichiers actuels et leur version enregistrée dans Git. C’est très pratique avant de faire un nouveau commit, pour bien comprendre ce qui va être enregistré.

Corriger un commit récent

Si vous avez fait un commit mais que vous avez oublié d’ajouter un fichier, ou que vous voulez modifier son message, vous pouvez faire :

git add fichier_oublié.html
git commit --amend

Git ouvrira un éditeur de texte vous permettant de corriger le message du commit précédent. Si vous ne touchez rien, il gardera le message existant et ajoutera simplement le fichier oublié.

Annuler un ajout avant un commit

Si vous avez ajouté un fichier par erreur avec git add, mais que vous ne voulez finalement pas l’inclure dans le commit, tapez :

git restore --staged nom-du-fichier

Cela enlève le fichier de la « zone d’attente » sans le supprimer de votre projet.

Supprimer le dernier commit (sans perdre vos fichiers)

Si vous avez fait un commit que vous souhaitez annuler, mais que vous voulez garder vos modifications dans les fichiers, utilisez :

git reset --soft HEAD~1

Cela efface le commit le plus récent, mais laisse vos fichiers comme ils étaient. C’est utile pour corriger une erreur sans tout recommencer.

Revenir à une version antérieure

Pour revenir à une version précédente sans tout casser, la méthode recommandée est d’utiliser :

git checkout identifiant_du_commit

Mais attention, cela vous met dans un état spécial appelé « détaché », qui n’est pas fait pour travailler longtemps. Il est préférable, dans ce cas, de créer une nouvelle branche pour y faire des tests.

Vous savez maintenant :

• consulter l’historique de vos commits
• voir ce qui a changé entre deux versions
• corriger ou annuler certaines actions

C’est une base essentielle pour travailler avec confiance sur n’importe quel projet.

Branches et flux de travail

L’un des atouts majeurs de Git est sa gestion des branches. Elles vous permettent de travailler sur plusieurs versions différentes d’un projet en même temps, sans risquer de casser votre travail principal.

Qu’est-ce qu’une branche ?

Imaginez que vous travaillez sur un site web. Vous souhaitez ajouter une nouvelle fonctionnalité, par exemple un formulaire de contact. Mais vous ne voulez pas modifier directement le site en production. Avec Git, vous pouvez créer une branche à part, qui sera une copie de votre projet au moment où vous la créez.

Vous pouvez ainsi travailler sur cette branche, faire des modifications, tester, sans toucher à la version principale, appelée souvent main ou master.

Une fois que votre nouvelle fonctionnalité est prête, vous pouvez la fusionner dans la branche principale. C’est une façon propre et sécurisée d’avancer.

Cela revient au même avec notre projet. Pour les futurs ajouts de code, nous demanderons à Git de créer une branche. Enfin, quand la nouvelle fonctionnalité sera prête et fonctionnelle, nous fusionnerons cette branche avec la branche principale. Ainsi, en cas d’erreur, nous reviendrons aussitôt à la version précédente et stable.

Comment créer une branche avec Git

Pour créer une branche, utilisez la commande :

git branch nom-de-la-branche

Par exemple :

git branch formulaire-contact

Cette commande crée une nouvelle branche, mais vous restez toujours sur votre branche actuelle.

Basculer entre les branches

Pour changer de branche, utilisez :

git checkout nom-de-la-branche

Par exemple :

git checkout formulaire-contact

Depuis Git 2.23, vous pouvez aussi utiliser la commande plus simple :

git switch formulaire-contact

Créer et basculer en une seule commande

Pour créer une branche et s’y déplacer directement, tapez :

git checkout -b nom-de-la-branche

ou

git switch -c nom-de-la-branche

Par exemple :

git checkout -b formulaire-contact

Voir les branches existantes

Et comment s’y retrouver avec toutes ces branches ? Pour lister toutes les branches de votre projet, tapez :

git branch

La branche sur laquelle vous êtes actuellement est marquée par un astérisque (*).

Fusionner une branche dans une autre

Quand vous avez terminé de travailler sur votre branche, vous pouvez revenir sur la branche principale et y intégrer vos changements.

1. Revenez sur la branche principale :

git checkout main

2. Fusionnez la branche :

git merge formulaire-contact

Git va alors intégrer toutes les modifications de formulaire-contact dans main.

Résolution de conflits

Parfois, lors d’une fusion, Git ne sait pas comment combiner deux modifications contradictoires dans un même fichier. C’est ce qu’on appelle un conflit.

Git vous indique quels fichiers posent problème. Vous devrez ouvrir ces fichiers, repérer les zones en conflit marquées par Git, choisir quelles modifications garder, puis valider les corrections avec un nouveau commit.

Cela demande un peu de pratique, mais c’est un processus courant et très bien documenté.

Supprimer une branche avec Git

Une fois qu’une branche est fusionnée (ou qu’elle allait dans la mauvaise direction) et que vous n’en avez plus besoin, vous pouvez la supprimer avec :

git branch -d nom-de-la-branche

Par exemple :

git branch -d formulaire-contact

Pourquoi utiliser les branches ?

Elles permettent d’organiser votre travail de manière plus claire, de tester sans risquer d’endommager votre version principale, et d’avoir une histoire propre du projet.

C’est une bonne pratique même quand on travaille seul, car cela évite de se retrouver avec un code instable. Pensez simplement à nettoyer régulièrement les branches abandonnées.

Travailler avec un dépôt distant

Jusqu’ici, vous avez appris à utiliser Git en local, sur votre ordinateur. Mais Git devient encore plus puissant quand vous utilisez un dépôt distant, c’est-à-dire un espace en ligne où votre projet est sauvegardé et accessible depuis n’importe où.

Voici comment créer un dépôt distant (par exemple sur GitHub), comment le connecter à votre dépôt local, et comment envoyer et récupérer vos modifications.

Pourquoi utiliser un dépôt distant ?

Utiliser un dépôt distant présente plusieurs avantages majeurs :

• Sauvegarde de votre travail : même si votre ordinateur tombe en panne, votre code est en sécurité sur un serveur.
• Accès depuis plusieurs machines : vous pouvez travailler depuis votre ordinateur personnel, votre ordinateur professionnel, ou même un ordinateur public.
• Partage et collaboration : vous pouvez facilement partager votre code avec d’autres développeurs, ou demander des retours.
• Déploiement automatisé : certains serveurs peuvent récupérer automatiquement votre code pour mettre à jour un site ou une application.

Créer un compte GitHub

GitHub est la plateforme la plus populaire pour héberger des dépôts Git. Pour commencer :

1. Rendez-vous sur https://github.com
2. Cliquez sur Sign up et créez un compte gratuit.
3. Suivez les instructions pour valider votre adresse e-mail.

Créer un dépôt distant sur GitHub

Une fois connecté à GitHub :

1. Cliquez sur le bouton New repository (nouveau dépôt).
2. Donnez un nom à votre dépôt, par exemple mon-projet.
3. Vous pouvez ajouter une description si vous le souhaitez.
4. Choisissez si le dépôt sera public ou privé.
5. Ne cochez pas la case « Initialize this repository with a README » si vous avez déjà un dépôt local.
6. Cliquez sur Create repository.

Connecter votre dépôt local à GitHub

Revenez à votre terminal, dans le dossier de votre projet local. Tapez la commande suivante pour lier votre projet local au dépôt distant que vous venez de créer.

git remote add origin https://github.com/votre-utilisateur/mon-projet.git

Remplacez votre-utilisateur et mon-projet par vos propres noms.

Envoyer vos fichiers sur GitHub

Pour transférer votre code sur GitHub, tapez :

git push -u origin main

Cette commande envoie vos commits locaux vers la branche principale (main) du dépôt distant nommé origin. L’option -usignifie que vous définissez ce dépôt distant comme celui par défaut pour les prochaines commandes push et pull.

Récupérer les modifications depuis GitHub

Si vous travaillez sur un autre ordinateur ou si vous souhaitez récupérer les dernières modifications, vous pouvez taper :

git pull

Cette commande télécharge et fusionne les changements depuis GitHub vers votre dossier local.

Travailler ensuite avec Git et GitHub

Désormais, votre flux de travail sera généralement :

1. Modifier vos fichiers localement.
2. Ajouter vos fichiers avec git add.
3. Faire un commit avec git commit.
4. Envoyer vos modifications sur GitHub avec git push.
5. Récupérer les changements éventuels avec git pull.

Remarque sur l’authentification

GitHub demande aujourd’hui d’utiliser une clé SSH ou un token personnel pour s’authentifier lors des pushes. Cela remplace le simple mot de passe et améliore la sécurité.

Fichiers à ignorer et nettoyage

Quand vous travaillez sur un projet, certains fichiers ne doivent pas être suivis par Git. Par exemple, les fichiers temporaires générés par votre éditeur, les fichiers de configuration locaux, ou encore les fichiers lourds comme les images ou bases de données.

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

Il suffit d’indiquer à Git d’ignorer certains fichiers pour garder votre dépôt propre.

Pourquoi ignorer certains fichiers ?

Si vous ne dites pas à Git d’ignorer ces fichiers, ils apparaîtront dans la liste des fichiers modifiés et risquent d’être ajoutés par erreur à votre dépôt. Cela alourdit inutilement le projet et peut même poser des problèmes (exemple : fichiers secrets ou données privées).

Le fichier .gitignore

Pour indiquer à Git quels fichiers ou dossiers ne pas suivre, on crée un fichier nommé .gitignore à la racine de votre projet.

Ce fichier contient une liste de règles, une par ligne, qui correspond à des fichiers ou dossiers à ignorer.

Exemple simple de .gitignore

Voici un exemple adapté à un projet web classique :

# Ignorer les fichiers temporaires de l'éditeur
*.swp
*.tmp

# Ignorer les dossiers de dépendances (npm, composer...)
node_modules/
vendor/

# Ignorer les fichiers de logs
*.log

# Ignorer les fichiers de configuration locaux
.env

# Ignorer les dossiers système (macOS, Windows)
.DS_Store
Thumbs.db

Créer un .gitignore

1. Dans votre dossier projet, créez un fichier nommé .gitignore (attention au point au début).
2. Ajoutez-y les règles correspondant à ce que vous souhaitez ignorer.
3. Sauvegardez le fichier.

Que faire si un fichier suivi doit être ignoré ?

Si un fichier est déjà suivi par Git, le simple fait de l’ajouter à .gitignore ne le retirera pas automatiquement du dépôt.

Pour l’arrêter de le suivre, il faut taper :

git rm --cached nom-du-fichier

Par exemple :

git rm --cached .env

Puis faites un commit pour valider ce changement :

git add .gitignore
git commit -m "Ajout de .gitignore et suppression des fichiers ignorés du suivi"

Le fichier .gitignore est un outil essentiel pour garder votre dépôt propre, léger, et sécurisé. Il évite que des fichiers inutiles ou sensibles soient ajoutés par erreur.

Nettoyer le dépôt

Git propose des commandes pour nettoyer les fichiers non suivis, c’est-à-dire ceux qui ne sont pas dans le dépôt ni dans .gitignore.

Pour voir ces fichiers :

git clean -n

Pour les supprimer réellement :

git clean -f

Soyez prudent avec cette commande, car elle supprime définitivement les fichiers.

Le fichier .gitkeep

Parfois, vous voulez que Git garde un dossier vide (ce qui est impossible normalement, car Git ne suit pas les dossiers vides).

Pour cela, vous pouvez créer un fichier .gitkeep dans ce dossier. Ce fichier sert uniquement à ce que Git voie le dossier et le conserve.

Travailler proprement avec Git

Utiliser Git efficacement ne se limite pas à apprendre les commandes. Il s’agit aussi d’adopter des bonnes habitudes pour que votre historique reste clair, compréhensible, et utile, surtout quand vous y reviendrez dans plusieurs semaines ou mois. Git est un outil pour rendre votre travail plus professionnel et organisé.

Rédiger de bons messages de commit

Chaque commit doit décrire clairement ce que vous avez fait. Un bon message permet de comprendre rapidement l’historique, sans avoir à lire le code. Un message clair répond généralement à la question : qu’est-ce qui a changé et pourquoi ?

Par exemple, plutôt que d’écrire « Correction », écrivez « Correction du bug d’affichage sur la page contact ». Essayez d’être concis, précis, et utilisez l’impératif (ex. : « Ajoute le formulaire de contact », « Corrige la mise en page mobile »).

Commits petits et fréquents

Il vaut mieux faire plusieurs petits commits qui correspondent chacun à une tâche précise plutôt qu’un seul gros commit avec plein de modifications différentes.

Cela facilite la relecture, le suivi, et la correction si besoin.

Organiser votre travail avec des branches

Comme vu dans le chapitre 5, utilisez les branches pour isoler les différentes fonctionnalités, corrections ou expérimentations. Ne travaillez jamais directement sur la branche principale (main) sauf pour les versions stables.

Nettoyer votre historique avant de partager

Avant de pousser vos modifications sur un dépôt distant, prenez le temps de vérifier votre historique avec :

git log --oneline

Si vous avez fait des commits inutiles ou qui se contredisent, vous pouvez les regrouper (avec git rebase -i) ou les modifier (avec git commit --amend).

Cela permet d’avoir un historique propre et cohérent.

Utiliser des alias Git

Git propose beaucoup de commandes parfois longues à taper. Vous pouvez créer des raccourcis appelés alias pour gagner du temps.

Par exemple, pour créer un alias st pour git status, tapez :

git config --global alias.st status

Désormais, vous pouvez taper git st pour voir l’état de votre projet.

Sauvegarder souvent

Même si cela peut paraître évident, faites des commits souvent pour ne pas perdre votre travail.

N’attendez pas d’avoir fait une tonne de modifications. Chaque étape importante mérite un commit.

Faire des sauvegardes sur un dépôt distant

Poussez régulièrement vos modifications sur GitHub ou une autre plateforme distante. Cela vous protège contre la perte de données et facilite la collaboration.

Git peut sembler compliqué au début. Prenez le temps d’expérimenter et de faire des erreurs. Chaque problème rencontré est une occasion d’apprendre.

Sauvegarde et expérimentation avec Git

Git n’est pas seulement un outil pour sauvegarder vos fichiers. Il vous offre aussi des mécanismes pour expérimenter, tester des idées sans risque, et revenir rapidement en arrière en cas de problème.

Utiliser le stash pour mettre de côté des modifications temporaires

Imaginons que vous travaillez sur une fonctionnalité, mais que vous devez rapidement passer à autre chose sans perdre ce que vous avez fait. Au lieu de faire un commit incomplet, vous pouvez utiliser le stash.

Le stash met temporairement de côté vos modifications non enregistrées, puis vous permet de les récupérer plus tard.

Pour mettre de côté vos modifications :

git stash

Vos fichiers modifiés sont remis à l’état du dernier commit, et vos changements sont stockés dans une pile.

Pour récupérer vos modifications :

git stash apply

Cela remet vos modifications sur votre projet, sans les supprimer du stash.

Si vous souhaitez supprimer le stash après l’avoir appliqué :

git stash pop

Créer des tags pour marquer des versions importantes

Un tag est un marqueur que vous pouvez poser sur un commit précis, souvent utilisé pour indiquer une version stable ou une étape importante.

Par exemple, pour taguer la version 1.0 de votre projet :

git tag v1.0

Pour voir la liste des tags :

git tag

Pour envoyer les tags vers un dépôt distant (GitHub par exemple) :

git push origin --tags

Travailler dans une branche temporaire

Pour tester une idée sans risque, créez une branche temporaire :

git checkout -b test-idee

Vous pouvez expérimenter, et si cela ne fonctionne pas, revenir facilement à la branche principale sans toucher au travail principal.

Annuler des modifications dans vos fichiers

Si vous avez modifié un fichier et que vous souhaitez revenir à la dernière version enregistrée dans Git, tapez :

git restore nom-du-fichier

Cela annule les modifications locales et restaure le fichier tel qu’il était au dernier commit.

Supprimer un commit localement

Si vous avez fait un ou plusieurs commits que vous souhaitez effacer avant de les partager, utilisez :

git reset --hard HEAD~1

Cette commande supprime le dernier commit et les modifications associées (attention, c’est irréversible).

N’hésitez jamais à faire un commit et un push, même pour des petits changements. Cela vous permet de sécuriser votre travail et de pouvoir revenir facilement en arrière.

Git vous offre de nombreux outils pour sauvegarder, tester et revenir sur vos modifications. En les utilisant bien, vous gagnerez en confiance et en productivité.

Interface graphique et IDE

Bien que Git soit un outil puissant en ligne de commande, il existe de nombreuses interfaces graphiques (GUI) et intégrations dans les éditeurs de code qui facilitent son utilisation, surtout pour les débutants. Ce chapitre vous présente ces solutions pour travailler plus facilement avec Git.

Git dans Visual Studio Code

Visual Studio Code (VS Code) est un éditeur très populaire, qui intègre Git de manière native. Vous n’avez donc pas besoin d’installer d’outil supplémentaire.

Dans VS Code, vous pouvez :

• Voir les fichiers modifiés dans la barre latérale.
• Ajouter des fichiers à l’index (staging) en un clic.
• Faire des commits avec un champ de message.
• Visualiser l’historique des commits.
• Gérer les branches et les conflits.
• Pousser (push) et tirer (pull) depuis un dépôt distant.

Pour accéder à ces fonctionnalités, cliquez sur l’icône Source Control (ou Contrôle de source) dans la barre latérale gauche.

GitHub Desktop

GitHub Desktop est une application gratuite et simple d’utilisation, disponible sur Windows et macOS.

Elle vous permet de :

• Cloner des dépôts GitHub en quelques clics.
• Gérer vos branches visuellement.
• Faire des commits et voir les changements.
• Résoudre les conflits avec une interface intuitive.
• Envoyer (push) et récupérer (pull) les modifications.

Pour les utilisateurs débutants, c’est une excellente option pour se familiariser avec Git sans la ligne de commande.

Autres interfaces graphiques populaires

• Sourcetree : puissante, gratuite, compatible Git et Mercurial.
• GitKraken : moderne et ergonomique, offre des fonctionnalités avancées.
• Fork : rapide et simple, très appréciée pour la gestion des branches.

Chacune de ces applications propose une interface visuelle pour gérer votre dépôt et vos commits sans taper de commandes.

Intégration Git dans d’autres éditeurs

De nombreux éditeurs de code supportent Git via des plugins ou des fonctionnalités natives :

• PhpStorm / WebStorm : intègrent Git avec une interface complète.
• Atom : support Git via des extensions.
• Sublime Text : plugins disponibles pour Git.
• Nova (Mac) : support natif de Git.
• Etc…

Avantages des interfaces graphiques

• Visualiser facilement l’état de vos fichiers.
• Réduire les erreurs de commandes.
• Résoudre les conflits avec des outils visuels.
• Gagner du temps sur les tâches répétitives.

Vous pouvez utiliser Git de plusieurs façons : en ligne de commande, avec une interface graphique, ou directement dans votre éditeur de code. Le choix dépend de votre préférence, de votre niveau et du contexte.

Récupération et dépannage

Parfois, malgré toutes les précautions, vous pouvez rencontrer des erreurs, ou vouloir revenir sur des actions qui ont mal tourné. Git offre plusieurs outils pour récupérer vos fichiers, revenir à des versions précédentes, et réparer votre dépôt.

Revenir à un commit antérieur

Si vous souhaitez revenir à un état précédent de votre projet, vous pouvez utiliser :

git checkout identifiant_du_commit

Cette commande vous place dans un état dit « détaché » (detached HEAD), ce qui signifie que vous n’êtes plus sur une branche normale. Vous pouvez explorer ce commit, mais ne faites pas de modifications dans cet état sans créer une nouvelle branche.

Restaurer un fichier supprimé ou modifié

Si vous avez supprimé ou modifié un fichier par erreur et que vous voulez le remettre comme dans le dernier commit, tapez :

git restore nom-du-fichier

Cela annule les modifications locales sur ce fichier.

Annuler le dernier commit

Si vous avez fait un commit par erreur, mais que vous voulez garder vos modifications dans les fichiers, tapez :

git reset --soft HEAD~1

Le commit est supprimé, mais vos modifications restent prêtes à être enregistrées de nouveau.

Supprimer un commit et ses modifications

Pour supprimer complètement un commit et toutes les modifications associées, utilisez :

git reset --hard HEAD~1

Attention : cette commande est irréversible. Les modifications sont perdues définitivement.

Utiliser le reflog pour retrouver un commit perdu

Si vous avez perdu un commit (par exemple après un reset), Git garde un historique temporaire appelé reflog.

Tapez :

git reflog

Vous verrez la liste des actions récentes avec leurs identifiants. Vous pouvez revenir à un commit avec :

git checkout identifiant_reflog

ou restaurer une branche dessus.

Résoudre les conflits de fusion

Quand Git ne sait pas comment fusionner deux modifications, il signale un conflit.

Dans ce cas :

1. Ouvrez les fichiers en conflit.
2. Cherchez les marqueurs <<<<<<<, ======= et >>>>>>>.
3. Choisissez quelle version garder ou combinez-les.
4. Supprimez les marqueurs.
5. Enregistrez les fichiers.
6. Faites un commit pour valider la résolution.

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

Pour savoir où vous en êtes, tapez régulièrement :

git status

Cette commande vous indique les fichiers modifiés, ceux en attente de commit, et si vous êtes en train de fusionner ou non.

Git vous offre des outils puissants pour récupérer votre travail et réparer les erreurs. Apprenez à les utiliser avec prudence, et n’hésitez pas à faire des sauvegardes avant les manipulations risquées.

Concepts avancés utiles

Dans ce chapitre, nous abordons quelques notions un peu plus avancées, mais très utiles pour mieux maîtriser Git et gérer des situations plus complexes.

Rebase vs Merge

Quand vous travaillez avec des branches, vous avez deux façons principales pour intégrer les modifications d’une branche dans une autre : la fusion (merge) et le rebasage (rebase).

• Merge : Cette méthode crée un commit spécial appelé « commit de fusion » qui combine les deux branches. L’historique garde la trace de toutes les branches et des fusions. C’est simple et sûr.
• Rebase : Cette méthode « réécrit » l’historique en appliquant les commits de votre branche par-dessus une autre branche, ce qui donne un historique plus linéaire et propre, sans commit de fusion. Cela peut faciliter la lecture, mais il faut être prudent, surtout avec des dépôts partagés.

Cherry-pick

La commande git cherry-pick permet de copier un commit précis d’une branche vers une autre, sans fusionner toute la branche.

C’est utile si vous avez corrigé un bug dans une branche, et que vous voulez appliquer seulement cette correction sur une autre branche.

Exemple :

git cherry-pick identifiant_commit

Git bisect (debug)

Git offre un outil appelé git bisect pour vous aider à trouver quel commit a introduit un bug.

Il fonctionne en testant successivement des versions intermédiaires par dichotomie, ce qui réduit le nombre de vérifications nécessaires.

Hooks Git

Les hooks sont des scripts qui s’exécutent automatiquement à certains moments dans le cycle Git, par exemple avant un commit, ou après un push.

Ils permettent d’automatiser des tâches comme la vérification du style de code, ou l’exécution de tests. Les hooks se trouvent dans le dossier .git/hooks de votre dépôt.

Ces concepts avancés vous donnent plus de contrôle et de finesse dans la gestion de vos projets Git. Ils ne sont pas indispensables dès le départ, mais vous gagnerez à les découvrir progressivement.

Cheat Sheet – Commandes principales

Pour rappel, un commit est une étape importante dans l’utilisation de Git : c’est comme une photo de votre projet à un instant donné. Il permet d’enregistrer les modifications que vous avez apportées à vos fichiers, afin de pouvoir suivre l’évolution de votre code dans le temps, collaborer plus facilement, ou revenir en arrière si nécessaire.

Pour faire un commit, vous devez d’abord sélectionner les fichiers que vous souhaitez enregistrer avec la commande git add, puis créer le commit avec git commit -m "Votre message explicatif".

Le message doit décrire brièvement ce que vous avez modifié, par exemple :

 git commit -m "Ajout de la page contact"

Ce mécanisme vous aide à garder votre travail organisé, compréhensible, et à travailler de manière plus professionnelle, même si vous développez seul.

Félicitations ! Vous êtes désormais en mesure d’utiliser Git pour notre projet Créa-code de #100JoursPourCoder, même en travaillant seul.

Aujourd’hui, nous avons appris :

• Comment Git vous aide à sauvegarder, organiser et suivre vos modifications.
• Comment créer, explorer et fusionner des branches pour tester sans crainte.
• Comment travailler en équipe grâce aux dépôts distants et aux pull requests.
• Quelles sont les bonnes pratiques pour garder un historique propre et compréhensible.
• Et enfin, comment revenir en arrière, corriger vos erreurs et garder le contrôle.

Git peut sembler complexe au début, mais comme tout outil puissant, il devient vite naturel avec la pratique. Ne soyez pas intimidé par le terminal ou les messages d’erreur : chaque problème est une occasion d’apprendre et de progresser.

Pensez à pratiquer régulièrement, notamment sur notre projet. Avec le temps, Git deviendra votre meilleur allié, votre filet de sécurité et un compagnon essentiel dans votre parcours de développeur web.

Et surtout… committez souvent, avec des messages clairs 😄

A demain pour la suite …

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr