Utilisation de Git

Partie 1 : Les Bases

1. Configuration Initiale

Avant toute chose, dites à Git qui vous êtes. Ces informations seront associées à chaque commit (instantané) que vous créez.

# Configure votre nom d'utilisateur
git config --global user.name "Votre Nom"

# Configure votre adresse e-mail
git config --global user.email "votre.email@example.com"

2. Démarrer un projet

On à deux façons de commencer à travailler avec Git.

Option A : Cloner un dépôt existant C'est le cas le plus courant. On récupère un projet qui existe déjà sur une plateforme comme GitHub, GitLab, ou Bitbucket.

# Clone (télécharge) le projet dans un dossier du même nom
git clone https://github.com/nom-utilisateur/nom-du-projet.git

# Naviguez dans le dossier nouvellement créé
cd nom-du-projet

Option B : Initialiser un nouveau dépôt Si on démarre un projet de zéro sur votre machine.

# Créez un dossier pour votre projet
mkdir mon-super-projet
cd mon-super-projet

# Initialise un dépôt Git vide dans ce dossier
git init

3. Cycle de Travail

Une fois dans votre projet, le cycle est toujours le même : Modifier -> Ajouter -> Valider -> Pousser.

Étape 1 : Voir l'état du projet (git status) C'est la commande la plus importante. Elle vous dit quels fichiers ont été modifiés, lesquels sont nouveaux, et sur quelle branche vous êtes.

git status

* Untracked files: Fichiers que Git ne suit pas encore. * Changes not staged for commit: Fichiers modifiés que vous n'avez pas encore "sélectionnés" pour le prochain enregistrement. * Changes to be committed: Fichiers que vous avez sélectionnés (via git add).

Étape 2 : Ajouter des fichiers à l'index (git add) L'index (ou "staging area") est une zone de préparation. On y place les modifications qu'on souhaite inclure dans le prochain commit.

# Ajoute un fichier spécifique
git add nom_du_fichier.html

# Ajoute tous les fichiers modifiés et les nouveaux fichiers du dossier courant
git add .

Étape 3 : Valider les changements (git commit) Un commit est un instantané de votre projet à un moment T, accompagné d'un message descriptif. C'est un point de sauvegarde dans votre historique local.

# Ouvre un éditeur de texte pour écrire un message de commit détaillé
git commit

# Ou, pour un message court et direct :
git commit -m "Ajout de la page de contact avec formulaire"

Bonne pratique : Les messages de commit doivent être clairs, concis et au présent de l'impératif (ex: "Ajoute la fonctionnalité X" plutôt que "J'ai ajouté la fonctionnalité X").

Étape 4 : Envoyer les changements vers le dépôt distant (git push) Votre commit n'existe que sur votre machine. Pour le partager avec vos collaborateurs, vous devez le "pousser" vers le serveur distant (celui d'où vous avez cloné).

# Envoie les commits de votre branche actuelle vers le dépôt distant
git push

La première fois, Git pourrait vous demander de spécifier la branche distante : git push --set-upstream origin nom-de-la-branche.

Étape 5 : Récupérer les changements du dépôt distant (git pull) Si vos collaborateurs ont poussé des changements, vous devez les récupérer pour être à jour.

# Récupère les changements du dépôt distant et les fusionne dans votre branche locale
git pull

Réflexe : Toujours faire un git pull avant de commencer à travailler pour éviter les conflits.

Partie 2 : Les Branches

Une branche est comme une ligne de développement parallèle. Vous pouvez créer une branche pour travailler sur une nouvelle fonctionnalité sans affecter la branche principale (main ou master).

1. Lister et Créer des Branches

# Lister toutes les branches locales. L'* indique la branche active.
git branch

# Lister toutes les branches (locales et distantes)
git branch -a

# Créer une nouvelle branche (mais sans basculer dessus)
git branch nom-de-la-nouvelle-fonctionnalite

# Créer une nouvelle branche ET basculer dessus directement (méthode moderne)
git switch -c nom-de-la-nouvelle-fonctionnalite

# (Méthode ancienne mais très courante)
git checkout -b nom-de-la-nouvelle-fonctionnalite

2. Changer de Branche

# Basculer vers une branche existante (méthode moderne)
git switch nom-de-la-branche

# (Méthode ancienne)
git checkout nom-de-la-branche

Warning

checkout peut être dangereux si on va on se déplace hors d'un main ou d'une autre branche

3. Fusionner les Branches (`git merge`)

Une fois votre fonctionnalité terminée sur sa branche, vous voudrez la rapatrier dans la branche principale (main).

# 1. Revenez sur la branche qui doit RECEVOIR les changements
git switch main

# 2. Assurez-vous qu'elle est à jour
git pull

# 3. Fusionnez votre branche de fonctionnalité DANS main
git merge nom-de-la-nouvelle-fonctionnalite

4. Supprimer une Branche

Une fois la branche fusionnée, vous pouvez la supprimer pour garder le projet propre.

# Supprimer la branche en local
git branch -d nom-de-la-nouvelle-fonctionnalite

# Supprimer la branche sur le dépôt distant
git push origin --delete nom-de-la-nouvelle-fonctionnalite

Partie 3 : Utilisation avancée et Corriger les Erreurs

Les erreurs arrivent. Git est votre filet de sécurité.

1. Consulter l'Historique (`git log`)

git log vous montre la liste de tous les commits.

# Historique complet
git log

# Historique concis, sur une seule ligne par commit
git log --oneline

# Historique avec une représentation graphique des branches
git log --oneline --graph --decorate --all

2. Modifier le Dernier Commit (`git commit --amend`)

Vous avez fait une faute de frappe dans votre dernier message de commit ? Ou oublié un fichier ?

# Ajoutez le fichier oublié
git add fichier_oublie.txt

# "Amendez" le commit précédent. Cela n'en crée pas un nouveau, mais modifie le dernier.
git commit --amend

Attention : Ne jamais amender un commit qui a déjà été poussé (push) sur une branche partagée !

3. Annuler des Modifications Locales

Vous avez modifié un fichier mais vous voulez annuler tous vos changements et revenir à la version du dernier commit.

# Annule les modifications sur un fichier spécifique
# ATTENTION : C'est destructif, les changements sont perdus.
git restore nom_du_fichier.txt

# Annule TOUTES les modifications dans le répertoire de travail
git restore .

4. Revenir en Arrière de Manière Sûre (`git revert`)

git revert est la méthode la plus sûre pour annuler un commit qui a déjà été partagé. Il ne supprime pas le commit, mais crée un nouveau commit qui fait l'inverse des changements.

# Crée un nouveau commit qui annule les changements du commit spécifié
# (remplacez <hash_du_commit> par l'identifiant trouvé via git log)
git revert <hash_du_commit>

5. Revenir en Arrière de Manière "Brutale" (`git reset`)

git reset réécrit l'historique. C'est puissant mais dangereux si vous ne savez pas ce que vous faites. À n'utiliser que sur des commits locaux qui n'ont pas été poussés.

# --soft : Annule le dernier commit, mais garde les changements "stagés" (prêts à être commit)
git reset --soft HEAD~1

# --mixed (défaut) : Annule le dernier commit et "déstagise" les changements (ils apparaissent comme modifiés mais non stagés)
git reset HEAD~1

# --hard : DANGER. Annule le dernier commit et EFFACE DÉFINITIVEMENT tous les changements associés.
git reset --hard HEAD~1

HEAD~1 signifie "un commit avant la position actuelle".

Partie 4 : Pour les Sorciers de Git (Concepts Avancés)

1. Le Rebase (`git rebase`)

Le rebase est une alternative au merge pour intégrer des changements. Au lieu de créer un "commit de fusion", il déplace votre branche pour la faire partir du dernier commit de la branche cible, créant un historique linéaire et propre.

# Sur votre branche de fonctionnalité
git rebase main

La Règle d'Or du Rebase : Ne jamais, JAMAIS, faire un rebase sur une branche publique (comme main ou develop) que d'autres personnes utilisent. Cela réécrit l'historique et créera le chaos pour vos collaborateurs.

2. Le Rebase Interactif (`git rebase -i`)

C'est le couteau suisse de la modification d'historique. Il vous permet de réorganiser, fusionner, modifier ou supprimer des commits avant de les fusionner.

# Lance un rebase interactif sur les 3 derniers commits
git rebase -i HEAD~3

Un éditeur de texte s'ouvre avec une liste de vos commits. Vous pouvez changer pick en : * reword ou r : pour changer le message du commit. * squash ou s : pour fusionner le commit avec le précédent. * fixup ou f : comme squash, mais jette le message du commit. * drop ou d : pour supprimer complètement le commit.

C'est l'outil parfait pour "nettoyer" votre branche de fonctionnalité avant de la proposer en fusion.

3. Le Stash (`git stash`)

Imaginez : vous êtes au milieu d'une modification, et on vous demande de corriger un bug urgent sur une autre branche. Vos changements ne sont pas prêts à être commités. Que faire ? Le stash !

Mini-Tuto : Changer de branche sans perdre son travail

Si vous utilisez git switch nom-de-la-branche alors que vous avez des fichiers modifiés, Git peut refuser le changement. Voici comment faire :

1. Mettre de côté (stasher) votre travail :

git stash

2. Changer de branche :

git switch main  # ou une autre branche

3. Revenir sur votre branche initiale :

git switch -     # le raccourci '-' revient à la branche précédente

4. Récupérer votre travail :

git stash pop    # réapplique les modifs et supprime le stash

Autres options pour le Stash

Récupérer sans supprimer : git stash apply (garde le stash dans la liste).
Voir la liste des stashs : git stash list.
Supprimer un stash : git stash drop (ou git stash drop stash@{0} pour un spécifique).

Alternative : Le Commit Temporaire

Si vous préférez garder une trace dans l'historique (même temporairement) :

git add .
git commit -m "WIP: Travail en cours"
git switch main
# ... après être revenu sur la branche ...
git reset HEAD~1  # Annule le commit mais garde les fichiers modifiés

Nettoyage : Abandonner vos modifications

Si après avoir fait un git stash ou des modifications, vous décidez de ne plus rien garder pour retrouver un état propre :

# Pour supprimer le stash (si vous avez stashé)
git stash drop

# Pour supprimer les fichiers non traqués et annuler les modifs en cours
git clean -fd
git checkout .

4. Le Cherry-Pick (`git cherry-pick`)

Permet de prendre un commit spécifique d'une autre branche et de l'appliquer sur votre branche actuelle. Très utile pour récupérer un correctif de bug sans fusionner toute la branche.

# Applique le commit spécifié sur la branche actuelle
git cherry-pick <hash_du_commit_a_recuperer>

5. Le Reflog : Votre Filet de Sécurité Ultime (`git reflog`)

Vous avez fait un git reset --hard par erreur et pensez avoir tout perdu ? Le reflog est là. Il enregistre TOUT ce que HEAD (votre position actuelle) a fait.

# Affiche l'historique de toutes les positions de HEAD
git reflog

Vous verrez une liste de toutes vos actions (commit, checkout, reset...). Trouvez l'état dans lequel vous voulez revenir, et utilisez git reset --hard <hash_du_reflog> pour y retourner. Le reflog vous a sauvé la vie.

Avancé

Git diff

Pour visualiser les modifications apportées à l'index (zone de préparation pour le prochain commit) :

git diff

Pour visualiser les modifications apportées à repo de la branche sur lesquelle on travaille :

git diff HEAD

Git ignore

On peut crée un fichier git ignore pour évité de la suivie de version de certain fichier grace au fichier .gitignore

exemple :

# Fichiers de secrets - NE JAMAIS COMMITER
.env
.env.local
.env.productionw
.env.staging
.ssh

# Fichiers de sauvegarde
*.bak
*.backup
*.old

# Ignore "monfichier" dans TOUS les répertoires (racine ET sous-dossiers)
**/monfichier

Résolution de Problème

sauvegarder les identifiants sur l'instance linux :

git config --global credential.helper store

source : Stack Overflow