Les git commandes débutant que tu vas découvrir ici sont celles que tu utiliseras tous les jours en entreprise, en stage ou sur tes projets perso. Git, c’est le système de versioning utilisé par la quasi-totalité des développeurs dans le monde. Que tu sois en BTS SIO option SLAM ou SISR, en reconversion, ou en train de préparer ton premier entretien technique, maîtriser Git n’est pas optionnel. C’est un prérequis. Le problème, c’est que beaucoup de tutos te balancent 40 commandes d’un coup sans t’expliquer lesquelles tu vas réellement taper au quotidien. Ici, on va faire l’inverse : on part des commandes essentielles, on les comprend vraiment, et on construit un workflow concret. À la fin de cet article, tu sauras initialiser un projet, versionner ton code, collaborer sur GitHub et résoudre les situations courantes sans paniquer.

Installer et configurer Git avant de commencer

Avant de taper la moindre commande, il faut que Git soit installé et configuré correctement sur ta machine.

Installation selon ton OS

Sur Linux (Debian/Ubuntu), c’est une ligne :

sudo apt update && sudo apt install git

Sur macOS, Git est souvent préinstallé. Sinon, installé-le via Homebrew :

brew install git

Sur Windows, télécharge l’installeur depuis le site officiel de Git et suis l’assistant. Coche l’option « Git Bash » pour avoir un terminal Unix-like.

Vérifie que tout fonctionne :

git, version

Tu devrais obtenir quelque chose comme git version 2.47.x.

Configuration initiale obligatoire

Git a besoin de savoir qui tu es pour associer ton nom à chaque modification :

git config, global user.name "Ton Prénom Nom"
git config, global user.email "[email protected]"

Ces informations apparaîtront dans chaque commit. Utilisé la même adresse email que ton compte GitHub ou GitLab. Pour vérifier ta config :

git config, list

Les commandes Git fondamentales

Voici le socle. Ces commandes représentent 80 % de ce que tu feras avec Git au quotidien.

git init : créer un dépôt

git init transforme un dossier ordinaire en dépôt Git. Un dossier caché .git est créé ; c’est lui qui contient tout l’historique de ton projet.

mkdir mon-projet
cd mon-projet
git init

Résultat : Initialized empty Git repository in /chemin/mon-projet/.git/

Tu ne fais cette commande qu’une seule fois par projet, au démarrage.

git status : comprendre l’état de ton projet

C’est la commande que tu taperas le plus souvent. Elle te dit exactement où tu en es : quels fichiers ont été modifiés, lesquels sont prêts à être sauvegardés, lesquels sont nouveaux.

git status

Prends le réflexe de la lancer avant et après chaque action. C’est ta boussole.

git add : préparer les fichiers pour la sauvegarde

Git fonctionne en deux temps. D’abord tu prépares (staging), ensuite tu sauvegardes (commit). git add place les fichiers dans la zone de staging :

git add index.html
git add style.css script.js
git add .

La dernière ligne (git add .) ajoute tous les fichiers modifiés du dossier courant. Pratique, mais attention à ne pas inclure des fichiers sensibles (mots de passé, clés API). On verra plus bas comment les exclure avec .gitignore.

git commit : sauvegarder une version

Le commit, c’est la photo de ton code à un instant T. Chaque commit à un identifiant unique et un message qui décrit ce que tu as fait :

git commit -m "Ajoute la page d'accueil avec le header"

Un bon message de commit est court, au présent, et décrit ce que fait la modification (pas « j’ai fait » ou « modification du fichier »). Exemples corrects :

• « Corrige le bug d’affichage sur mobile »
• « Ajoute la validation du formulaire contact »
• « Supprime les imports inutilisés »

git log : consulter l’historique

Pour voir la liste des commits :

git log

L’affichage par défaut est verbeux. Pour une vue compacte, une ligne par commit :

git log, oneline

a3f7c2d Ajoute la validation du formulaire contact
e91b4a1 Corrige le bug d'affichage sur mobile
7d2c8f0 Ajoute la page d'accueil avec le header

Travailler avec un dépôt distant : GitHub, GitLab

C’est ici qu’on entre dans la collaboration. Un dépôt distant (remote) est une copie de ton projet hébergée en ligne. GitHub est la plateforme la plus utilisée, mais GitLab et Bitbucket fonctionnent de la même manière.

git clone : récupérer un projet existant

git clone télécharge un dépôt distant sur ta machine, avec tout son historique :

git clone https://github.com/utilisateur/nom-du-projet.git

Un dossier nom-du-projet est créé automatiquement. C’est la commande que tu utilises quand tu rejoins un projet existant ou quand tu veux travailler sur un dépôt open source.

git push : envoyer tes modifications

Après avoir fait tes commits en local, git push les envoie sur le dépôt distant :

git push origin main

origin désigne le dépôt distant par défaut, main la branche principale. Si c’est ton premier push sur une nouvelle branche :

git push -u origin main

Le flag -u associe ta branche locale à la branche distante. Les prochains push n’auront besoin que de git push.

git pull : récupérer les modifications des autres

git pull télécharge les dernières modifications du dépôt distant et les fusionne dans ta branche locale :

git pull origin main

Règle d’or : fais toujours un git pull avant de commencer à travailler le matin. Ça t’évite de bosser sur une version obsolète du code.

Les branches : travailler sans tout casser

Les branches sont l’un des concepts les plus puissants de Git. Une branche te permet de développer une fonctionnalité isolément, sans toucher au code principal.

Créer et changer de branche

git branch ma-fonctionnalite
git checkout ma-fonctionnalite

Ou en une seule commande (plus rapide) :

git checkout -b ma-fonctionnalite

Tu es maintenant sur une branche séparée. Tous tes commits iront sur cette branche, sans affecter main.

Lister et supprimer des branches

git branch
git branch -d ma-fonctionnalite

La première commande liste toutes les branches locales (celle avec un * est la branche active). La seconde supprime une branche déjà fusionnée.

Fusionner une branche : git merge

Quand ta fonctionnalité est prête, tu la ramènes dans main :

git checkout main
git merge ma-fonctionnalite

Git intègre les modifications de ma-fonctionnalite dans main. Si les mêmes lignes ont été modifiées des deux côtés, un conflit apparaît. Pas de panique : Git te montre exactement quelles lignes posent problème, et tu choisis manuellement quelle version garder.

Le fichier .gitignore : exclure les fichiers inutiles

Certains fichiers n’ont rien à faire dans un dépôt : fichiers de configuration locale, dossiers node_modules, fichiers .env contenant des mots de passé.

Crée un fichier .gitignore à la racine de ton projet :

# Dépendances
node_modules/
__pycache__/

# Variables d'environnement
.env
.env.local

# Fichiers système
.DS_Store
Thumbs.db

# IDE
.vscode/
.idea/

Git ignorera tout ce qui correspond à ces patterns. Ajoute ce fichier dès le début du projet.

Cheat sheet : les commandes Git essentielles en tableau

Voici un récapitulatif des commandes Git de base à garder sous la main :

Workflow quotidien concret

Voici la séquence que tu reproduiras chaque jour en stage ou en entreprise :

# 1. Récupérer les dernières modifications
git pull origin main

# 2. Créer une branche pour ta tâche
git checkout -b feature/ajout-formulaire

# 3. Coder... puis vérifier l'état
git status

# 4. Ajouter les fichiers modifiés
git add formulaire.html style.css

# 5. Commiter avec un message clair
git commit -m "Ajoute le formulaire de contact avec validation"

# 6. Envoyer ta branche sur le distant
git push -u origin feature/ajout-formulaire

# 7. Ouvrir une Pull Request sur GitHub pour review

Ce workflow s’appelle le feature branch workflow. C’est le standard dans la majorité des équipes. Tu ne travailles jamais directement sur main ; chaque fonctionnalité ou correction a sa propre branche.

Les erreurs courantes et comment s’en sortir

Annuler un git add

Tu as ajouté un fichier par erreur dans le staging :

git restore, staged fichier.txt

Modifier le dernier message de commit

Tu as fait une faute dans ton message :

git commit, amend -m "Le bon message cette fois"

Attention : ne fais jamais , amend sur un commit déjà pushé, sauf si tu travailles seul sur la branche.

Voir les différences avant de commiter

git diff
git diff, staged

La première montre les modifications non stagées, la seconde celles qui sont prêtes à être commitées. Prends l’habitude de vérifier avant chaque commit.

Conclusion

Tu as maintenant les bases solides pour utiliser Git dans tes projets. Les commandes présentées ici couvrent la grande majorité des situations que tu rencontreras en BTS SIO et en stage. La prochaine étape : crée un compte GitHub, initialise un dépôt pour ton prochain projet (même un petit TP), et applique le workflow feature branch dès aujourd’hui. N’essaie pas d’apprendre toutes les commandes d’un coup. Maîtrise d’abord add, commit, push, pull. Le reste viendra naturellement avec la pratique.

Lucie Moreau

Formatrice IT indépendante depuis 2016, ancienne étudiante BTS SIO SLAM. 6 ans d'expérience en entreprise.