Pourquoi Git est indispensable en développement web

Quand on débute en développement web, on commence souvent par créer des fichiers index.html, style.css ou script.js, puis à les modifier directement. Au début, cela semble suffisant. Mais très vite, une question apparaît : comment revenir à une version qui fonctionnait hier ? Comment comprendre ce qui a changé ? Comment travailler à plusieurs sans s’envoyer des fichiers projet-final-v3-vraiment-final.zip ?

C’est exactement le rôle de Git. Git est un système de gestion de versions. Il enregistre l’évolution de votre code dans le temps. Il permet de sauvegarder des étapes importantes, de comparer les modifications, de revenir en arrière et de travailler sur plusieurs idées sans casser la version principale du projet.

GitHub, de son côté, est une plateforme en ligne qui héberge des dépôts Git. Elle permet de sauvegarder son code à distance, de le partager, de collaborer avec d’autres développeurs et de contribuer à des projets open source.

Git n’est donc pas réservé aux experts. C’est une compétence de base, au même titre que comprendre HTML, CSS, JavaScript ou le fonctionnement général du Web.

Git, GitHub, dépôt : clarifier le vocabulaire

Avant de taper des commandes, il faut distinguer quelques notions.

Un dépôt Git, ou repository, est un dossier suivi par Git. Il contient votre code, mais aussi un historique des modifications. Cet historique est stocké dans un dossier caché appelé .git.

Un commit est une sauvegarde explicite d’un état du projet. Il contient les modifications sélectionnées, un auteur, une date et un message.

Une branche est une ligne de travail indépendante. Elle permet de développer une fonctionnalité, corriger un bug ou tester une idée sans modifier directement la branche principale.

Un dépôt distant, souvent appelé remote, est une copie du dépôt hébergée en ligne, par exemple sur GitHub. Votre dépôt local vit sur votre ordinateur ; le dépôt distant sert à partager et sauvegarder votre travail.

Git est l’outil de versionnement. GitHub est un service qui s’appuie sur Git.

Installer Git et vérifier la configuration

Après installation depuis le site officiel de Git, vous pouvez vérifier que tout fonctionne avec :

git --version

La première configuration à faire consiste à indiquer votre nom et votre adresse email. Ces informations seront associées à vos commits.

git config --global user.name "Alice Dupont"
git config --global user.email "alice@example.com"

Vous pouvez vérifier la configuration avec :

git config --global --list

Cette étape paraît administrative, mais elle est importante. Dans un projet collaboratif, chaque modification doit pouvoir être attribuée clairement.

Créer son premier dépôt Git

Prenons un petit projet web très simple :

mkdir mon-site
cd mon-site

Ajoutons un fichier HTML :

<!doctype html>
<html lang="fr">
  <head>
    <meta charset="utf-8" />
    <title>Mon site</title>
  </head>
  <body>
    <h1>Bonjour Git</h1>
  </body>
</html>

Pour transformer ce dossier en dépôt Git, utilisez :

git init

Git crée alors un dossier caché .git. À partir de maintenant, il peut suivre l’évolution du projet.

Pour voir l’état du dépôt :

git status

Git vous indique que le fichier index.html existe, mais qu’il n’est pas encore suivi. Il faut l’ajouter à la zone de préparation, appelée staging area.

git add index.html

Puis créer un commit :

git commit -m "Créer la page HTML initiale"

Vous venez de créer une première version sauvegardée du projet.

Comprendre le cycle add, commit, status

Le cycle de base de Git repose sur trois commandes :

git status
git add .
git commit -m "Message clair"

git status sert à inspecter ce qui a changé. C’est une commande à utiliser souvent, presque comme un réflexe.

git add sélectionne les fichiers à inclure dans le prochain commit. Avec git add ., vous ajoutez toutes les modifications du dossier courant. C’est pratique, mais il faut vérifier ce que l’on ajoute avant de valider.

git commit crée une sauvegarde dans l’historique. Un commit doit représenter une étape cohérente : ajout d’un composant, correction d’un bug, amélioration d’un style, configuration d’un outil.

Évitez les messages vagues comme :

git commit -m "modifs"
git commit -m "test"
git commit -m "correction"

Préférez des messages précis :

git commit -m "Ajouter le formulaire de contact"
git commit -m "Corriger l’espacement des cartes produit"
git commit -m "Configurer les scripts de test"

Ces messages deviennent très utiles lorsque vous relisez l’historique plusieurs semaines plus tard.

Voir les différences et l’historique

Avant de créer un commit, il est souvent utile de voir exactement ce qui a changé :

git diff

Cette commande affiche les lignes ajoutées, supprimées ou modifiées. Elle aide à repérer une erreur avant de l’enregistrer.

Pour consulter l’historique des commits :

git log

Pour une version plus compacte :

git log --oneline

Vous verrez une liste de commits avec leurs identifiants courts. Chaque commit est une photographie du projet à un instant donné.

Cette logique est particulièrement utile quand vos projets deviennent plus structurés : intégration d’une API, architecture frontend, tests, configuration DevOps ou travail en équipe. Elle complète naturellement des pratiques abordées dans des sujets comme les tests end-to-end avec Playwright ou l’injection de dépendances en TypeScript, car un code fiable doit aussi être traçable.

Ignorer les fichiers inutiles avec .gitignore

Tous les fichiers d’un projet ne doivent pas être suivis par Git. Par exemple, le dossier node_modules peut contenir des milliers de fichiers générés automatiquement. Les fichiers d’environnement peuvent aussi contenir des secrets.

On utilise pour cela un fichier .gitignore :

touch .gitignore

Exemple pour un projet JavaScript ou TypeScript :

node_modules/
dist/
.env
.DS_Store
coverage/

Ce fichier indique à Git ce qu’il doit ignorer. Il doit être créé tôt dans le projet, idéalement avant le premier commit important.

Attention : .gitignore n’efface pas un fichier déjà suivi par Git. Si vous avez déjà commité un fichier sensible, il faut le retirer de l’historique ou changer immédiatement les secrets concernés.

Travailler avec des branches

Une branche permet d’isoler un travail en cours. Par défaut, beaucoup de projets utilisent une branche principale appelée main.

Pour créer une branche :

git switch -c ajouter-menu

Vous pouvez alors modifier le code sans toucher directement à main. Quand le travail est terminé, vous revenez sur la branche principale :

git switch main

Puis vous fusionnez la branche :

git merge ajouter-menu

Cette organisation permet de travailler proprement. Une branche peut correspondre à une fonctionnalité, une correction ou une expérimentation. Dans une équipe, elle permet aussi de relire le code avant intégration.

Même seul, utiliser des branches est une bonne habitude. Cela évite de transformer la branche principale en zone de brouillon permanent.

Envoyer son code sur GitHub

Pour héberger votre projet sur GitHub, vous créez d’abord un dépôt vide depuis l’interface du site. GitHub vous fournit ensuite une URL distante.

Dans votre projet local, vous reliez le dépôt local au dépôt distant :

git remote add origin git@github.com:alice/mon-site.git

Puis vous envoyez votre branche principale :

git push -u origin main

À partir de là, votre code est disponible sur GitHub. Les commits suivants pourront être envoyés avec :

git push

Si vous travaillez depuis une autre machine, vous pouvez récupérer le dépôt avec :

git clone git@github.com:alice/mon-site.git

Pour récupérer les modifications distantes dans un dépôt déjà existant :

git pull

On peut résumer ainsi : push envoie vos commits vers GitHub, pull récupère les commits depuis GitHub.

Collaborer avec les pull requests

Sur GitHub, une pull request permet de proposer des modifications avant de les fusionner dans la branche principale. C’est un outil central de collaboration.

Un flux simple ressemble à ceci :

  1. créer une branche pour une fonctionnalité ;
  2. faire des commits réguliers ;
  3. pousser la branche sur GitHub ;
  4. ouvrir une pull request ;
  5. relire, discuter et corriger si nécessaire ;
  6. fusionner dans main.

La pull request n’est pas seulement une formalité. Elle documente une décision technique, facilite la relecture et réduit le risque d’intégrer du code incomplet.

Dans les projets professionnels, elle peut aussi déclencher des tests automatiques, une vérification TypeScript, un linting ou un déploiement de prévisualisation. C’est une première porte d’entrée vers les pratiques DevOps.

Gérer les conflits sans paniquer

Un conflit Git arrive lorsque deux modifications incompatibles touchent la même partie d’un fichier. Git ne peut pas décider seul quelle version garder.

Dans le fichier concerné, vous verrez une structure de ce type :

<<<<<<< HEAD
Version locale
=======
Version distante
>>>>>>> ajouter-menu

Il faut alors modifier le fichier à la main pour garder la bonne version, supprimer les marqueurs de conflit, puis enregistrer la résolution :

git add index.html
git commit -m "Résoudre le conflit sur le menu"

Un conflit n’est pas une catastrophe. C’est simplement Git qui vous demande une décision explicite. Plus les commits sont petits et les branches synchronisées régulièrement, moins les conflits sont difficiles à résoudre.

Bonnes pratiques pour débuter

Commitez souvent, mais pas n’importe comment. Un commit doit être assez petit pour être compris, mais assez complet pour représenter une étape logique.

Avant chaque commit, utilisez :

git status
git diff

Ne versionnez pas les fichiers générés, les dépendances installées ou les secrets. Configurez .gitignore dès le début.

Écrivez des messages de commit lisibles. Votre futur vous, vos collègues et vos formateurs vous remercieront.

Utilisez des branches pour les changements importants. Même pour un projet personnel, cela vous apprend une méthode de travail professionnelle.

Enfin, ne considérez pas GitHub comme une simple sauvegarde. C’est aussi un espace de collaboration, de documentation et de revue. Un dépôt propre, avec un README.md, des commits clairs et une structure lisible, donne immédiatement une meilleure impression.

Conclusion

Git permet de suivre l’histoire de votre code. GitHub permet de la partager. Ensemble, ils forment un socle indispensable pour tout développeur web, qu’il travaille sur une simple page HTML, une application frontend, une API Node.js ou un projet full stack.

Les commandes de base à retenir sont peu nombreuses : git init, git status, git add, git commit, git log, git switch, git push et git pull. Ce qui compte surtout, c’est de comprendre le modèle mental : modifier, sélectionner, sauvegarder, partager.

En apprenant Git tôt, vous gagnez en sécurité, en méthode et en autonomie. Vous ne codez plus seulement des fichiers : vous construisez un historique clair, exploitable et collaboratif.