Git est l'outil de gestion de versions le plus répandu dans le développement logiciel. Il enregistre l'historique de vos fichiers, permet de revenir en arrière, de travailler sur plusieurs idées en parallèle et de collaborer sans écraser le travail des autres. Ce guide présente les commandes essentielles, un flux de travail typique et les bons réflexes pour corriger une erreur, en utilisant la syntaxe moderne de Git (`git switch` et `git restore`).

## Les notions de base

Avant de taper la moindre commande, trois notions sont à comprendre :

- **Le dépôt (repository)** : le dossier de votre projet, accompagné d'un sous-dossier caché `.git` qui contient tout l'historique.
- **Le commit** : un instantané de vos fichiers à un moment donné, accompagné d'un message qui décrit la modification.
- **La zone de préparation (staging area ou index)** : un espace intermédiaire où l'on choisit précisément les modifications qui feront partie du prochain commit.

Un fichier passe donc par trois états : **modifié** dans le répertoire de travail, **indexé** dans la zone de préparation, puis **validé** dans l'historique.

### Configurer Git une première fois

Après l'installation, indiquez votre identité, qui sera associée à chacun de vos commits :

```bash
git config --global user.name "Prénom Nom"
git config --global user.email "vous@example.com"
git config --global init.defaultBranch main
```

La dernière ligne fait en sorte que la branche principale des nouveaux dépôts s'appelle `main`.

## Créer un dépôt et enregistrer ses modifications

### git init

Placez-vous dans le dossier de votre projet et initialisez le dépôt :

```bash
cd mon-projet
git init
```

### git status

C'est la commande que vous utiliserez le plus. Elle indique la branche courante, les fichiers modifiés, ceux qui sont indexés et ceux que Git ne suit pas encore :

```bash
git status
```

### git add

Pour ajouter des modifications à la zone de préparation :

```bash
git add index.html          # un fichier précis
git add css/                # tout un dossier
git add .                   # toutes les modifications du dossier courant
```

### git commit

Pour enregistrer un instantané avec un message explicite :

```bash
git commit -m "Ajoute la page d'accueil"
```

Un bon message de commit est court, écrit à l'impératif ou au présent, et décrit **ce que fait** la modification. Évitez les messages vagues comme « modifs » ou « correction ».

### git log

Pour consulter l'historique :

```bash
git log                 # historique détaillé
git log --oneline       # une ligne par commit
git log --oneline --graph --all   # vue graphique de toutes les branches
```

Pour voir les différences avant de valider, utilisez `git diff` (modifications non indexées) et `git diff --staged` (modifications indexées).

## Travailler avec les branches

Une branche est une ligne de développement indépendante. Elle permet de tester une fonctionnalité sans toucher à la version stable.

### Créer et changer de branche

```bash
git branch                      # liste les branches locales
git branch nouvelle-page        # crée une branche
git switch nouvelle-page        # se place sur cette branche
git switch -c formulaire        # crée la branche et s'y place en une fois
git switch main                 # revient sur la branche principale
```

La commande `git switch` a été introduite pour remplacer l'usage de `git checkout` pour les branches, qui faisait trop de choses à la fois. `git checkout` fonctionne toujours, mais `switch` est plus clair.

### Fusionner une branche

Une fois le travail terminé sur `formulaire`, revenez sur `main` et fusionnez :

```bash
git switch main
git merge formulaire
```

Si les deux branches ont modifié les mêmes lignes d'un fichier, Git signale un **conflit**. Il insère alors des marqueurs `<<<<<<<`, `=======` et `>>>>>>>` dans le fichier concerné. Il faut éditer ce fichier pour conserver la bonne version, supprimer les marqueurs, puis :

```bash
git add fichier-en-conflit.html
git commit
```

Pour abandonner une fusion en cours : `git merge --abort`.

Une branche fusionnée peut ensuite être supprimée avec `git branch -d formulaire`.

## Travailler avec un dépôt distant

Un dépôt distant est une copie du projet hébergée sur un serveur ou une forge en ligne. Il sert de point d'échange entre collaborateurs et de sauvegarde.

### Les commandes principales

```bash
git clone https://example.com/equipe/projet.git   # copie un dépôt existant
git remote add origin https://example.com/vous/projet.git   # associe un distant
git remote -v                                     # liste les distants
git push -u origin main                           # envoie main et mémorise le lien
git push                                          # envois suivants
git pull                                          # récupère et intègre les nouveautés
git fetch                                         # récupère sans intégrer
```

L'option `-u` (ou `--set-upstream`) établit le lien entre votre branche locale et la branche distante : ensuite, un simple `git push` ou `git pull` suffit.

## Ignorer des fichiers avec .gitignore

Certains fichiers ne doivent jamais être versionnés : dépendances téléchargées, fichiers générés, fichiers de configuration contenant des mots de passe. Créez un fichier `.gitignore` à la racine du projet :

```gitignore
# Dépendances
node_modules/
vendor/

# Fichiers d'environnement et secrets
.env

# Fichiers générés
dist/
*.log

# Fichiers système
.DS_Store
Thumbs.db
```

Attention : `.gitignore` n'a aucun effet sur un fichier **déjà suivi** par Git. Pour cesser de le suivre sans le supprimer du disque, utilisez `git rm --cached nom-du-fichier`, puis validez.

## Un flux de travail typique

Voici l'enchaînement que l'on retrouve au quotidien sur un projet partagé :

1. Mettre à jour sa branche principale : `git switch main` puis `git pull`.
2. Créer une branche pour la tâche : `git switch -c correction-menu`.
3. Modifier les fichiers, vérifier avec `git status` et `git diff`.
4. Indexer et valider par petites étapes cohérentes : `git add` puis `git commit -m "..."`.
5. Envoyer la branche : `git push -u origin correction-menu`.
6. Faire relire puis fusionner la branche dans `main` (directement ou via une demande de fusion sur la forge).
7. Revenir sur `main`, récupérer la version à jour et supprimer la branche locale.

Des commits petits et fréquents rendent l'historique lisible et les retours en arrière beaucoup plus simples.

## Corriger ses erreurs

Git offre plusieurs moyens d'annuler une action. Le choix dépend de l'endroit où se trouve la modification.

| Situation | Commande |
|---|---|
| Annuler les modifications non indexées d'un fichier | `git restore fichier` |
| Retirer un fichier de la zone de préparation (sans perdre les modifications) | `git restore --staged fichier` |
| Corriger le message ou le contenu du dernier commit non publié | `git commit --amend` |
| Annuler un commit déjà publié en créant un commit inverse | `git revert <identifiant>` |
| Récupérer la version d'un fichier telle qu'elle était dans un commit | `git restore --source=<identifiant> fichier` |

### git restore

`git restore fichier` remplace le fichier par sa dernière version indexée ou validée. **Attention : les modifications non enregistrées sont alors définitivement perdues.**

### git revert

`git revert` est la méthode sûre pour annuler un commit déjà partagé : au lieu d'effacer l'historique, il crée un nouveau commit qui applique l'inverse des changements. Les collaborateurs n'ont donc aucun conflit d'historique à gérer.

```bash
git log --oneline
git revert a1b2c3d
```

### Les erreurs fréquentes des débutants

- **Oublier `git add`** avant `git commit` : rien n'est validé. Vérifiez toujours avec `git status`.
- **Valider des secrets** (mots de passe, clés d'API) : même supprimés ensuite, ils restent dans l'historique. Ajoutez `.env` au `.gitignore` dès le départ, et considérez comme compromis tout secret déjà publié.
- **Travailler directement sur `main`** : préférez une branche par tâche.
- **Réécrire un historique déjà publié** (avec `git commit --amend` ou `git reset` puis `git push --force`) : cela perturbe les collaborateurs. Réservez ces commandes aux commits encore locaux.
- **Faire `git pull` avec des modifications non validées** : validez ou mettez de côté votre travail avec `git stash` avant de récupérer les nouveautés.

## En résumé

- Git suit vos fichiers à travers trois états : modifié, indexé, validé.
- Le trio de base est `git status`, `git add` et `git commit`, complété par `git log` et `git diff` pour consulter l'historique.
- Les branches se gèrent avec `git branch`, `git switch` et `git merge`.
- Le travail se partage avec `git push`, `git pull` et `git clone`.
- Le fichier `.gitignore` évite de versionner dépendances, fichiers générés et secrets.
- Pour annuler : `git restore` pour le travail en cours, `git revert` pour un commit déjà publié.

Avec ces commandes, vous couvrez l'essentiel des usages quotidiens. Le reste s'apprend progressivement, au fil des projets.