Premiers pas avec Git et GitHub

Git : le versionneur local

Git est un logiciel installé sur ta machine qui suit l'historique de tes fichiers. Il fonctionne sans internet. Chaque modification, chaque retour en arrière, chaque comparaison entre versions passe par Git.

GitHub : la plateforme de partage

GitHub est un service en ligne qui héberge des dépôts Git. C'est là que tu sauvegardes ton code, que tu collabores avec d'autres dev, que tu publies tes projets open source. Il y en a d'autres (GitLab, Bitbucket, Gitea), GitHub est le plus utilisé.

Le vocabulaire de base

• Dépôt (repository, repo) : un projet versionné
• Commit : une photo de ton projet à un instant T, avec un message qui décrit le changement
• Branche (branch) : une ligne d'évolution indépendante du code
• Remote : un dépôt distant (sur GitHub par exemple), connecté à ton dépôt local

git --version
# git version 2.45.0 ou plus récent

Installation

• macOS : brew install git (recommandé), ou via les Xcode Command Line Tools
• Windows : télécharge Git for Windows sur git-scm.com
• Linux : via le gestionnaire de paquets, ex sudo apt install git sur Ubuntu

Configurer ton identité

Chaque commit que tu fais est signé avec un nom et un email. À toi de les configurer une bonne fois pour toutes :

git config --global user.name "Prénom Nom"
git config --global user.email "ton.email@exemple.fr"

# Branche par défaut sur "main" pour tout nouveau projet
git config --global init.defaultBranch main

# Éditeur par défaut (VS Code dans cet exemple)
git config --global core.editor "code --wait"

# Vérifier la config
git config --list

Les trois zones de Git

• Working directory : ton dossier, où tu modifies les fichiers
• Staging area (index) : la zone où tu prépares ce qui ira dans le prochain commit
• Dépôt (repository) : l'historique des commits enregistrés

Le cycle de base : tu modifies → tu places dans le staging avec git add → tu enregistres avec git commit.

Les commandes essentielles

# Dans le dossier de ton projet
git init

# Voir l'état des fichiers en permanence
git status

# Ajouter un fichier au staging
git add README.md

# Tout ajouter (à utiliser avec un .gitignore propre)
git add .

# Enregistrer un commit avec un message clair
git commit -m "Init : structure du projet"

# Voir l'historique
git log --oneline

Le .gitignore : ce que Git ne doit pas suivre

Certains fichiers ne doivent jamais être versionnés : dépendances installées (node_modules), secrets (.env), artefacts de build (dist, build). Crée un fichier .gitignore à la racine :

node_modules/
.env
.env.local
dist/
build/
.DS_Store
*.log

Pourquoi des branches

• Isoler une nouvelle fonctionnalité du code stable
• Travailler à plusieurs sans s'écraser
• Pouvoir abandonner un essai sans bousiller main
• Préparer une release pendant que le dev continue ailleurs

Les commandes

# Créer une branche et basculer dessus
git switch -c feat/page-contact

# Lister les branches (l'actuelle est marquée *)
git branch

# Basculer sur une branche existante
git switch main

# Fusionner une branche dans la branche courante
git merge feat/page-contact

# Supprimer une branche fusionnée
git branch -d feat/page-contact

git switch vs git checkout

Les vieux tutos utilisent git checkout pour changer de branche. Depuis Git 2.23, la commande dédiée est git switch, plus claire. checkout reste pour restaurer des fichiers. Préfère switch pour les branches.

Créer un dépôt sur GitHub

Sur github.com, clique New repository. Donne-lui un nom, laisse-le vide (pas de README, pas de .gitignore) pour pouvoir y pousser ton dépôt local sans conflit.

Authentification : token ou clé SSH

Option recommandée : clé SSH

# Génère une clé SSH
ssh-keygen -t ed25519 -C "ton.email@exemple.fr"

# Affiche la clé publique pour la copier
cat ~/.ssh/id_ed25519.pub

Colle la clé publique sur GitHub : Settings → SSH and GPG keys → New SSH key. Ensuite, tu peux pousser sans jamais retaper de mot de passe.

Relier ton dépôt local

# Ajoute le remote (l'URL SSH du dépôt GitHub vide)
git remote add origin git@github.com:tonpseudo/mon-projet.git

# Pousse la branche main pour la première fois (-u : track)
git push -u origin main

Cloner un dépôt existant

git clone git@github.com:equipe/projet.git
cd projet

git clone récupère le dépôt complet : tout l'historique, toutes les branches, configurées automatiquement comme remote origin.

Le cycle pull → code → push

# Avant de coder : récupérer les changements des autres
git pull

# Tu codes, tu fais tes commits
git add .
git commit -m "feat: ajout du formulaire de contact"

# Tu pousses tes commits sur GitHub
git push

Gérer un conflit

Un conflit arrive quand deux personnes ont modifié les mêmes lignes du même fichier. Git ne sait pas choisir. Il te demande de trancher.

<<<<<<< HEAD
Texte de ta version locale
=======
Texte de la version distante
>>>>>>> origin/main

Ouvre le fichier, choisis la bonne version (ou fais un mélange), supprime les marqueurs <<<, ===, >>>, puis git add + git commit.

Le flux complet

1. Tu crées une branche dédiée : git switch -c fix/typo-readme
2. Tu codes, tu commits
3. Tu pousses ta branche : git push -u origin fix/typo-readme
4. Sur GitHub, tu ouvres une Pull request avec un titre clair et une description du changement
5. Tes coéquipier·es relisent, commentent, demandent des ajustements
6. Tu pousses des commits supplémentaires sur la branche, la PR se met à jour automatiquement
7. Une fois approuvée, tu cliques Merge pull request sur GitHub
8. Tu supprimes la branche fusionnée (GitHub propose le bouton)

Squash, merge, rebase : quel bouton ?

• Squash and merge (recommandé pour les équipes) : tous tes commits deviennent un seul commit propre sur main
• Merge commit : garde tous tes commits + un commit de merge en plus
• Rebase and merge : rejoue tes commits sur main sans commit de merge

Des commits propres

• Un commit = une intention claire (pas 12 sujets dans le même commit)
• Message à l'impératif, court mais explicite : fix: gestion du null sur le formulaire de login
• Commits fréquents : plus c'est petit, plus c'est facile à relire et à annuler
• Conventions Conventional Commits (feat:, fix:, chore:...) facilitent les releases automatiques

Annuler proprement

# Annuler des modifs non commitées sur un fichier
git restore fichier.md

# Annuler un commit déjà poussé sur la branche partagée
# (crée un nouveau commit qui annule le précédent)
git revert <hash-du-commit>

# Modifier le dernier commit (avant push uniquement)
git commit --amend

Lire l'historique

# Historique condensé avec graphe des branches
git log --oneline --graph --all

# Voir les changements d'un commit
git show <hash>

# Voir qui a modifié quoi sur un fichier
git blame fichier.md