# Option 1 — via Homebrew (recommandé)
brew install git

# Option 2 — Git est souvent déjà présent
git --version

sudo apt update && sudo apt install git

git --version
# git version 2.43.0

git config --global user.name "Prénom Nom"
git config --global user.email "toi@exemple.com"

# Définir VS Code comme éditeur par défaut (pour les messages de merge, etc.)
git config --global core.editor "code --wait"

# Vérifier la configuration
git config --list

# Windows
git config --global core.autocrlf true

# macOS / Linux
git config --global core.autocrlf input

# Se placer dans le dossier de ton projet
cd mon-projet

# Initialiser Git (crée un dossier caché .git/)
git init

# Voir ce que Git voit
git status

git init mon-nouveau-projet
cd mon-nouveau-projet

# Ajouter tous les fichiers à la zone de stage
git add .

# Créer le premier commit
git commit -m "Initial commit"

# Vérifier l'état — doit être "nothing to commit"
git status

# Dépendances (Node.js)
node_modules/

# Dossiers de build
dist/
build/
.next/

# Variables d'environnement (JAMAIS versionner les mots de passe !)
.env
.env.local
.env.production

# Fichiers système
.DS_Store        # macOS
Thumbs.db        # Windows

# IDE
.idea/           # IntelliJ / PhpStorm
.vscode/         # VS Code (optionnel)

# Logs
*.log
logs/

# Cache
.cache/
tmp/

# Vérifier si un fichier est ignoré
git check-ignore -v mon-fichier.env

# Si tu as déjà commité un fichier par erreur, le retirer du suivi
git rm --cached mon-fichier.env
git commit -m "Retirer .env du suivi Git"

git status

# Exemple de sortie :
# On branch main
# Changes not staged for commit:
#   modified:   src/app.js
# Untracked files:
#   src/nouveau-fichier.js

# Voir les lignes modifiées (fichiers non stagés)
git diff

# Voir les lignes modifiées (fichiers déjà stagés)
git diff --staged

# Ajouter un fichier précis
git add src/app.js

# Ajouter tous les fichiers modifiés
git add .

# Ajouter interactivement (choisir quelles lignes inclure)
git add -p

git commit -m "Ajouter la page de connexion"

# Astuce : stager ET commiter les fichiers déjà suivis en une commande
git commit -am "Corriger le bug d'affichage du menu"

# Liste complète des commits
git log

# Version compacte (une ligne par commit)
git log --oneline

# Avec un graphe des branches
git log --oneline --graph --all

# Les 5 derniers commits
git log -5 --oneline

# Commits d'un fichier précis
git log --oneline -- src/app.js

# Voir ce qui a changé dans un commit précis
git show a3f7c12

# Restaurer un fichier à son état au dernier commit
git restore src/app.js

# Restaurer tous les fichiers modifiés
git restore .

# Tu as fait git add par erreur ? Annule sans perdre les modifs
git restore --staged src/app.js

# Corriger le message du dernier commit
git commit --amend -m "Nouveau message corrigé"

# Ajouter un fichier oublié dans le dernier commit
git add fichier-oublie.js
git commit --amend --no-edit

# Crée un nouveau commit qui annule le commit ciblé
# (n'efface pas l'historique — méthode recommandée)
git revert a3f7c12

# ⚠ Efface les commits APRÈS le hash ciblé
# Utilise uniquement si ces commits ne sont PAS encore sur GitHub
git reset --hard a3f7c12

# Voir toutes les branches (étoile = branche courante)
git branch

# Créer une nouvelle branche
git branch ma-fonctionnalite

# Basculer sur une branche existante
git checkout ma-fonctionnalite

# Créer ET basculer en une commande (recommandé)
git checkout -b ma-fonctionnalite

# Syntaxe moderne (Git 2.23+)
git switch -c ma-fonctionnalite

# Voir sur quelle branche on est
git branch --show-current

# Renommer une branche
git branch -m ancien-nom nouveau-nom

# Supprimer une branche locale (fusionnée)
git branch -d ma-fonctionnalite

# Forcer la suppression (non fusionnée)
git branch -D ma-fonctionnalite

# 1. Retourner sur main
git checkout main

# 2. Récupérer les dernières modifs distantes
git pull origin main

# 3. Fusionner ta branche
git merge ma-fonctionnalite

# 4. Supprimer la branche devenue inutile
git branch -d ma-fonctionnalite

# Forcer un commit de merge même si fast-forward possible
# (garde une trace de la branche dans l'historique)
git merge --no-ff ma-fonctionnalite

<<<<<<< HEAD
// Ton code sur main
const message = "Bonjour";
=======
// Le code de ta branche feature
const message = "Hello";
>>>>>>> ma-fonctionnalite

# Après avoir édité manuellement le fichier :
git add src/app.js
git commit -m "Résoudre conflit sur src/app.js"

# Annuler le merge en cours (pour repartir de zéro)
git merge --abort

# Lier ton dépôt local à GitHub
# (après avoir créé le repo vide sur github.com)
git remote add origin https://github.com/tonuser/ton-repo.git

# Vérifier la connexion
git remote -v
# origin  https://github.com/tonuser/ton-repo.git (fetch)
# origin  https://github.com/tonuser/ton-repo.git (push)

# HTTPS — plus simple, demande mot de passe ou token
git remote add origin https://github.com/tonuser/ton-repo.git

# SSH — plus pratique au quotidien, pas de mot de passe
git remote add origin git@github.com:tonuser/ton-repo.git

# Changer l'URL (ex: passer de HTTPS à SSH)
git remote set-url origin git@github.com:tonuser/ton-repo.git

# Générer une clé SSH
ssh-keygen -t ed25519 -C "toi@exemple.com"

# Afficher ta clé publique (à copier sur GitHub)
cat ~/.ssh/id_ed25519.pub

# Tester la connexion
ssh -T git@github.com
# Hi tonuser! You've successfully authenticated.

# Cloner (crée un dossier du même nom que le repo)
git clone https://github.com/tonuser/ton-repo.git

# Cloner dans un dossier avec un nom spécifique
git clone https://github.com/tonuser/ton-repo.git mon-dossier

# Cloner uniquement la branche main (plus rapide sur gros projets)
git clone --single-branch --branch main https://github.com/tonuser/ton-repo.git

# Cloner via SSH
git clone git@github.com:tonuser/ton-repo.git

# Premier push (définit la branche distante de référence)
git push -u origin main

# Push suivants (plus court grâce à -u)
git push

# Pousser une branche spécifique
git push origin ma-fonctionnalite

# Supprimer une branche distante
git push origin --delete ma-fonctionnalite

# Récupérer et fusionner les commits distants
git pull

# Équivaut à :
git fetch origin   # télécharge les commits
git merge origin/main  # les intègre

# Pull avec rebase (historique plus propre)
git pull --rebase

# Créer un tag annoté (recommandé pour les releases)
git tag -a v1.0.0 -m "Version 1.0.0 — première mise en ligne"

# Créer un tag léger (simple pointeur)
git tag v1.0.0

# Lister les tags
git tag

# Voir les détails d'un tag
git show v1.0.0

# Pousser les tags sur GitHub
git push origin v1.0.0        # un seul tag
git push origin --tags        # tous les tags

# Supprimer un tag local
git tag -d v1.0.0

# Supprimer un tag distant
git push origin --delete v1.0.0

# Mettre de côté les modifications en cours
git stash

# Voir la liste des stash
git stash list
# stash@{0}: WIP on main: abc1234 Dernier commit

# Récupérer le dernier stash (et le supprimer de la liste)
git stash pop

# Récupérer sans le supprimer
git stash apply

# Récupérer un stash précis
git stash apply stash@{1}

# Donner un nom à un stash
git stash push -m "WIP: nouvelle page contact"

# Supprimer un stash
git stash drop stash@{0}

# Vider tous les stash
git stash clear