[Tutoriel] Collaboration et versioning, Git à votre rescousse

Si tu te demandes comment utiliser Git concrètement, tu es au bon endroit. Git sert à versionner ton code, travailler à plusieurs sans te marcher dessus, revenir en arrière si besoin et garder un historique propre de tes modifications. Dans la pratique, c’est l’outil qui t’évite de perdre du travail, de casser un projet sans pouvoir revenir en arrière, ou de te demander “qui a fait quoi ?”.

Dans ce guide, tu vas voir comment créer un dépôt Git, cloner un projet existant, ajouter tes fichiers, faire un commit, envoyer tes changements sur un serveur distant et récupérer les dernières modifications sans te tromper. Je vais aussi te montrer les erreurs classiques à éviter, parce que c’est souvent là que les débutants bloquent.

Pourquoi utiliser Git ?

Git n’est pas juste un outil “technique” de plus : c’est ce qui te permet de travailler proprement, surtout dès qu’un projet devient un peu sérieux. Si tu es seul sur un petit projet, tu peux déjà y gagner en sécurité. Si tu travailles en équipe, Git devient vite indispensable.

Concrètement, Git te permet de :

• garder une trace de chaque modification importante ;
• revenir à une version précédente en cas d’erreur ;
• travailler à plusieurs sans écraser le travail des autres ;
• envoyer ton code sur un serveur distant comme GitHub, GitLab ou Bitbucket ;
• suivre l’évolution d’un projet dans le temps.

Dans la majorité des cas, les problèmes arrivent quand on modifie des fichiers “à la main” sans méthode. Git t’apporte justement un cadre simple : tu modifies, tu valides, tu envoies, tu synchronises. Ce rythme évite beaucoup d’ennuis.

Les prérequis avant de commencer

Avant de taper la moindre commande, il faut que Git soit installé sur ton ordinateur. Si tu es sur Windows, tu peux utiliser Git Bash. Sur macOS ou Linux, tu peux passer par le terminal classique.

Si tu débutes, il est aussi utile de savoir où se trouve ton dossier de travail et de comprendre la différence entre :

• ton dossier local, sur ton ordinateur ;
• le dépôt distant, sur un serveur ;
• la branche, qui représente une ligne de travail.

Ce que cela change pour toi : dès que tu comprends ces trois notions, tu évites la plupart des confusions autour de Git.

Créer un dépôt Git existant ou un nouveau projet

Récupérer un projet déjà en ligne avec git clone

Si le projet existe déjà sur un dépôt distant, la commande la plus simple est git clone. Elle copie le projet sur ton ordinateur et récupère aussi l’historique Git.

git clone url_dossier_git nom_dossier

Concrètement, cette commande crée un dossier local avec le contenu du dépôt. Si tu veux travailler sur un projet déjà partagé, c’est presque toujours le bon point de départ.

Exemple : si ton équipe héberge le code sur GitHub, tu clones le dépôt, puis tu travailles en local avant d’envoyer tes changements.

Créer un nouveau dépôt local avec git init

Si ton dossier ne contient encore aucun dépôt Git, tu dois l’initialiser. Place-toi dans le bon répertoire puis lance :

cd chemin_dossier
git init

Cette commande crée la structure Git dans ton dossier. Dans les faits, elle dit à Git : “à partir de maintenant, ce dossier sera suivi”.

Attention à un point important : git init ne publie rien en ligne. Il prépare seulement ton projet en local.

Ajouter les fichiers et enregistrer une version

Une fois ton projet prêt, tu dois dire à Git quels fichiers tu veux suivre. C’est le rôle de git add. Ensuite, tu valides l’ensemble avec un commit.

Indexer les fichiers avec git add

Pour ajouter tous les fichiers du dossier :

git add *

Si certains fichiers sont ignorés ou protégés par des règles locales, tu peux parfois forcer l’ajout avec :

git add -f *

Tu peux aussi cibler un fichier précis :

git add mon_fichier.php

Dans la pratique, il vaut mieux éviter d’ajouter “tout et n’importe quoi” sans réfléchir. Vérifie toujours ce qui va partir dans le commit, surtout si tu as des fichiers temporaires, des logs ou des éléments sensibles.

Valider les changements avec git commit

Le commit enregistre une étape de travail dans l’historique du projet :

git commit -m "titre du commit"

Le message du commit doit être clair. Par exemple : ajout page d'accueil, correction formulaire de contact ou suppression ancien projet. Plus ton message est précis, plus ton historique sera utile.

Erreur fréquente : faire des commits trop vagues comme “modif” ou “test”. Sur le terrain, ce genre de message devient vite inutile quand tu dois relire ton historique plusieurs jours plus tard.

Envoyer ton projet sur le serveur distant

Une fois ton commit prêt, tu peux publier ton travail en ligne. C’est là qu’interviennent le dépôt distant, l’alias origin et la branche cible.

Déclarer le dépôt distant

Si le dépôt distant n’est pas encore lié à ton projet local, ajoute-le avec :

git remote add origin adresse_git

origin est simplement un alias pratique pour désigner le dépôt distant. Cela t’évite de retaper l’URL complète à chaque commande.

Si tu as déjà un mauvais lien distant, tu peux le supprimer puis le recréer :

git remote rm origin
git remote add origin adresse_git

Dans certains cas, tu peux avoir un lien en HTTPS alors que le serveur attend une URL de type SSH comme git@.... C’est une cause fréquente d’erreur au moment du push.

Publier tes modifications avec git push

Pour envoyer tes changements sur la branche principale :

git push origin master

Dans cette commande, origin désigne le dépôt distant et master la branche ciblée. Aujourd’hui, selon les projets, la branche principale peut aussi s’appeler main. Si tu rencontres un blocage, vérifie bien le nom de la branche utilisée par ton dépôt.

Ce que cela implique : tant que tu n’as pas fait de push, tes changements restent uniquement sur ton ordinateur.

Récupérer les dernières modifications

Quand d’autres personnes travaillent sur le même projet, il faut régulièrement synchroniser ton dépôt local. Sinon, tu risques de travailler sur une version trop ancienne du code.

git pull origin master

Cette commande récupère les dernières modifications depuis le dépôt distant et les fusionne dans ton dossier local. Dans la majorité des cas, c’est la commande à faire avant de commencer à travailler, surtout si plusieurs personnes modifient le projet.

Bonne pratique simple : fais un git pull avant de coder, puis un git push une fois tes changements validés. Cette habitude réduit fortement les conflits.

Comprendre et éviter les conflits Git

Un conflit apparaît quand Git ne sait pas automatiquement quelle version d’un fichier conserver. Cela arrive souvent quand deux personnes modifient les mêmes lignes, ou quand tu as toi-même travaillé trop longtemps sans te synchroniser.

Concrètement, si tu rencontres un conflit :

1. ouvre le fichier concerné ;
2. identifie les parties en conflit ;
3. choisis la bonne version, ou fusionne les deux si nécessaire ;
4. enregistre le fichier ;
5. fais un nouveau git add puis un git commit.

Ce qu’il faut éviter absolument : pousser du code tant que le conflit n’est pas résolu. Sinon, tu risques d’écraser le travail d’un autre collaborateur ou de bloquer l’intégration du projet.

Les professionnels observent généralement que les conflits sont moins fréquents quand l’équipe fait des pulls réguliers et des commits plus petits. En pratique, plus tes modifications sont isolées, plus elles sont faciles à fusionner.

Les erreurs les plus fréquentes avec Git

Si tu débutes, certaines erreurs reviennent tout le temps. Les connaître te fera gagner du temps.

• Oublier de faire un pull avant de travailler sur un projet partagé.
• Faire des commits trop gros, ce qui rend le débogage difficile.
• Utiliser des messages de commit flous et inutilisables.
• Confondre dépôt local et dépôt distant.
• Pousser sans vérifier les conflits.
• Ne pas contrôler l’URL du remote quand le push échoue.

Dans la pratique, la meilleure défense reste une méthode simple : synchronise-toi souvent, commit proprement et vérifie ce que tu envoies avant de pousser.

Résumé pratique des commandes Git de base

Voici les commandes que tu vas utiliser le plus souvent :

• git clone url_dossier_git nom_dossier : récupérer un projet existant.
• git init : initialiser un nouveau dépôt local.
• git add * : indexer tous les fichiers.
• git add -f * : forcer l’ajout si nécessaire.
• git commit -m "titre du commit" : enregistrer une version.
• git remote add origin adresse_git : lier le dépôt distant.
• git push origin master : envoyer tes modifications.
• git pull origin master : récupérer les mises à jour.

Si tu veux retenir une seule logique, garde celle-ci : je prépare, je valide, je synchronise. C’est la base d’un usage propre de Git.

FAQ

Pourquoi, j’utilise Git ?

Tu utilises Git pour versionner ton travail, collaborer et garder un historique fiable de ton projet. En pratique, cela te permet aussi de revenir en arrière si une modification pose problème. C’est particulièrement utile dès que plusieurs personnes travaillent sur le même code.

Des pré-requis ?

Oui, il faut que Git soit installé sur ton ordinateur. Il faut aussi avoir accès à un terminal, comme Git Bash sur Windows ou le terminal natif sur macOS et Linux. Si tu travailles sur un dépôt distant, il te faut également l’URL du projet.

Créer son dépôt Git

Tu peux créer un dépôt Git en initialisant un dossier local avec git init. Si le projet existe déjà en ligne, tu peux aussi le récupérer avec git clone. Le bon choix dépend de ton point de départ.

Si vous voulez récupérer un dossier déjà sur Git :

Tu dois utiliser git clone url_dossier_git nom_dossier. Cette commande copie le dépôt distant sur ton ordinateur et récupère aussi son historique. C’est la méthode la plus simple pour commencer sur un projet déjà existant.

Créer un nouveau projet :

Si tu pars d’un dossier vide ou d’un nouveau projet, commence par git init. Ensuite, ajoute tes fichiers avec git add puis valide avec git commit. Si tu veux publier le projet, il faudra ensuite relier un dépôt distant.

Si votre dossier sur git est vide

Si ton dossier local n’est pas encore relié à Git, place-toi dedans puis lance git init. Cette commande initialise le dépôt local et prépare le suivi des fichiers. Ensuite, tu peux ajouter tes fichiers et faire un premier commit.

Ajoutez votre projet au répertoire git

Tu peux ajouter ton projet avec git add * pour indexer tous les fichiers. Si tu veux cibler seulement certains éléments, remplace l’astérisque par le nom du fichier ou du dossier. Pense à vérifier ce que tu ajoutes avant de valider.

Envoyez sur le serveur !

Après ton commit, tu peux envoyer ton travail avec git push origin master. Il faut que le dépôt distant soit bien configuré avec git remote add origin adresse_git. Si le push échoue, le problème vient souvent de l’URL ou du nom de la branche.

Pour finir, si vous voulez récupérer les dernières modifications, il faut taper la commande suivante :

La commande à utiliser est git pull origin master. Elle récupère les changements du dépôt distant et les fusionne dans ton dossier local. Si des conflits apparaissent, il faut les résoudre avant de faire un nouveau push.

Pour suivre le blog IUT Bethune plus facilement, retrouvez-nous sur Facebook