Introduction à Git et GitHub

Git est un système de contrôle de version distribué, conçu pour suivre les modifications apportées aux fichiers et coordonner le travail entre plusieurs personnes sur un projet. Contrairement aux systèmes centralisés, chaque développeur dispose d'une copie complète du dépôt, permettant une grande flexibilité et résilience. GitHub, quant à lui, est une plateforme web populaire qui héberge des dépôts Git, facilitant la collaboration et le partage de code pour des projets open source et privés.

Opérations Fondamentales de Git

1. Cloner un Dépôt Distant

Pour commencer à travailler sur un projet existant, la première étape est de cloner le dépôt depuis une source distante. Par défaut, cette commande clone la branche principale (souvent nommée main ou master).

git clone <URL_DU_DÉPÔT>

L'URL du dépôt est généralement disponible sur la plateforme d'hébergement (par exemple, GitHub). Si vous souhaitez cloner une branche spécifique, utilisez l'option -b :

git clone -b <NOM_DE_BRANCHE> <URL_DU_DÉPÔT>

2. Soumettre des Modifications Locales

Le processus de soumission des modifications locales implique trois étapes principales : ajouter les fichiers à l'index (zone de staging), créer un commit, puis pousser les modifications vers le dépôt distant.

cd votre-projet/                      # Assurez-vous d'être dans le répertoire du dépôt Git
git add .                             # Ajoute toutes les modifications du répertoire de travail à l'index
git commit -m "Description concise des changements" # Crée un instantané des fichiers indexés
git push origin main                  # Envoie les commits de la branche locale 'main' vers la branche 'main' distante

2.1 Soumissions Partielles

Si vous ne souhaitez soumettre qu'une partie des fichiers modifiés, vous pouvez spécifier les fichiers ou les répertoires à ajouter individuellement à l'index :

git add dossier_test/
git add fichier_test.py

Pour ignorer des fichiers de manière persistante, listez-les dans un fichier .gitignore à la racine de votre dépôt. Si vous avez accidentellement ajouté des fichiers que vous vouliez ignorer après un git add ., vous pouvez les retirer de l'index avant de commiter :

git restore --staged fichier_a_ignorer.log

Ou avec l'ancienne syntaxe :

git reset HEAD fichier_a_ignorer.log

2.2 Forcer le Suivi de Fichiers Ignorés

Les fichiers listés dans .gitignore ne sont pas suivis par Git. Si, pour une raison spécifique, vous devez forcer le suivi d'un fichier qui est normalement ignoré, utilisez l'option -f (force) :

git add -f dossier_recupere/

2.3 Ignorer des Fichiers Déjà Suivis

Si un fichier a déjà été commité et poussé mais que vous souhaitez l'ignorer par la suite (par exemple, des fichiers de cache de build ou des logs), vous devez le retirer de l'historique de Git tout en le conservant localement. Cette opération supprime le fichier de l'index Git sans le supprimer de votre système de fichiers local.

git rm --cached -r dossier_a_ignorer_par_la_suite/
git commit -m "Suppression du dossier des fichiers suivis par Git"
git push origin main

Pour ignorer les *modifications futures* d'un fichier déjà suivi sans le retirer de l'historique, vous pouvez utiliser :

git update-index --assume-unchanged <nom_du_fichier>

Pour annuler cette commande :

git update-index --no-assume-unchanged <nom_du_fichier>

3. Mettre à Jour le Code Local

Pour synchroniser votre dépôt local avec les dernières modifications du dépôt distant, utilisez la commande git pull. Cela récupère les nouvelles données et les fusionne automatiquement dans votre branche actuelle.

git pull

4. Gérer les Branches

Les branches permettent de travailler sur différentes fonctionnalités ou corrections de bugs en parallèle, sans affecter le code principal.

Afficher les Branches

Pour voir la liste de toutes les branches locales et savoir sur quelle branche vous êtes actuellement (indiquée par un astérisque) :

git branch

Créer une Nouvelle Branche

Pour créer une nouvelle branche basée sur la branche actuelle :

git branch <NOM_NOUVELLE_BRANCHE>

Changer de Branche

Pour passer à une autre branche :

git switch <NOM_DE_BRANCHE>

Alternativement, l'ancienne commande git checkout est toujours valide :

git checkout <NOM_DE_BRANCHE>

Fusionner une Branche

Le processus de fusion intègre les modifications d'une branche dans une autre. Par exemple, pour fusionner une branche de fonctionnalité (dev-feature) dans la branche principale (main) :

git switch main                         # Passez à la branche cible (main)
git pull origin main                    # Mettez à jour la branche cible avec les dernières modifications distantes
git merge dev-feature                   # Fusionne les changements de 'dev-feature' dans 'main'
git push origin main                    # Envoie la branche 'main' fusionnée vers le dépôt distant
git branch -d dev-feature               # Supprime la branche 'dev-feature' après la fusion réussie

Annuler et Réécrire l'Historique

1. Annuler des Modifications Indexées (add)

Si vous avez ajouté des fichiers à l'index avec git add mais que vous ne souhaitez pas les commiter, vous pouvez les retirer de l'index.

• Annuler les modifications indexées d'un fichier spécifique :

git restore --staged <fichier>
    

ou

git reset HEAD <fichier>
   

55. Annuler les modifications indexées de tous les fichiers :

git restore --staged .
   

ou

git reset HEAD .
   

Pour annuler complètement les modifications locales (non indexées et indexées), en les supprimant du répertoire de travail :

• Annuler et supprimer les changements d'un fichier spécifique :

git restore <fichier>
    

ou

git checkout -- <fichier>
   

64. Annuler et supprimer tous les changements locaux :

git restore .
   

ou

git checkout -- .
   

2. Annuler des Commmits Locaux

Les commandes git reset sont puissantes pour annuler des commits locaux. L'option HEAD^ fait référence au commit précédent. Vous pouvez aussi utiliser un hash de commmit spécifique.

• --soft : Annule le dernier commit, mais conserve les modifications dans l'index (staging area) et le répertoire de travail.

git reset --soft HEAD^
    

72. --mixed (par défaut) : Annule le dernier commit et déplace les modifications dans le répertoire de travail, les retirant de l'index.

git reset --mixed HEAD^
   

74. --hard : Annule le dernier commit et supprime toutes les modifications du répertoire de travail et de l'index. Attention : toutes les modifications non commises seront perdues !

git reset --hard HEAD^
   

3. Annuler des Commits Après un Push

Annuler des commits déjà poussés vers un dépôt distant est une opération délicate qui doit être effectuée avec une extrême prudence, car elle réécrit l'historique et peut causer des problèmes pour les autres collaborateurs. Il existe deux approches principales :

Méthode 1: Utiliser git revert (Recommandé pour les branches partagées)

git revert crée un nouveau commit qui annule les modifications d'un ou plusieurs commits précédents. Cette méthode est non destructive car elle n'altère pas l'historique existant.

git log --oneline              # Trouvez le hash du commit à annuler
git revert <hash_du_commit>    # Crée un nouveau commit annulant les changements
git push origin <nom_de_branche>

Méthode 2: Réécrire l'Historique avec git reset --hard et git push --force (Dangereux)

Cette méthode supprime littéralement un ou plusieurs commits de l'historique. Elle est fortement déconseillée sur des branches partagées car elle peut rendre les dépôts des autres développeurs incohérents.

1. Identifiez le commit "sain" : Utilisez git log pour trouver le hash du commit *avant* celui (ou ceux) que vous souhaitez supprimer.

git log

3. Réinitialisez votre historique local : Déplacez la tête de votre branche locale à ce commit sain, supprimant tous les commits ultérieurs.

git reset --hard <hash_du_commit_sain>

5. Forcez la mise à jour du dépôt distant : Pousez cette nouvelle version de l'historique vers le dépôt distant.

git push --force origin <nom_de_branche>

Avertissement : L'utilisation de git push --force doit être coordonnée avec toute l'équipe, car elle écrase l'historique distant et peut entraîner une perte de travail si d'autres ont basé leur travail sur les commits supprimés.