🔝 Retour au Sommaire

Félicitations pour avoir terminé le Module 1 ! Vous savez maintenant ce qu'est Git, comment l'installer, le configurer, et vous avez créé votre premier dépôt. C'est une excellente base.

Le Module 2 va approfondir considérablement votre compréhension de Git. Nous allons explorer les concepts fondamentaux qui sous-tendent tout ce que vous faites avec Git. Ces concepts sont essentiels : une fois que vous les maîtriserez, tout le reste de Git deviendra logique et intuitif.

Ce module est parfait pour vous si :

• Vous avez complété le Module 1 (ou avez des bases équivalentes)
• Vous voulez comprendre comment Git fonctionne vraiment, pas juste quoi faire
• Vous utilisez Git mais certaines commandes vous semblent mystérieuses
• Vous voulez gagner en confiance dans votre utilisation quotidienne de Git
• Vous préparez un environnement professionnel où la maîtrise de Git est attendue

Prérequis : Avoir Git installé et avoir créé au moins un commit. Si ce n'est pas le cas, retournez au Module 1.

À la fin de ce module, vous serez capable de :

✅ Comprendre en profondeur les trois états de Git (Working Directory, Staging Area, Repository)
✅ Expliquer l'architecture interne de Git et ce que contient le dossier .git
✅ Utiliser avec assurance git status, git add et git commit dans tous les scénarios
✅ Explorer l'historique avec git log, git show et git diff de manière experte
✅ Visualiser et interpréter le graphe de l'historique Git
✅ Créer et gérer un fichier .gitignore efficace

Ce module est divisé en six sections qui construisent progressivement votre expertise :

1. Les 3 états de Git : Working Directory, Staging Area, Repository Le concept le plus important de Git : comprendre comment vos fichiers transitent entre ces trois zones.

2. Les fichiers .git et l'architecture interne Découvrir ce qui se passe "sous le capot" : comment Git stocke réellement vos données.

3. Suivi des fichiers : git status, git add, git commit Maîtriser le trio fondamental de commandes que vous utiliserez quotidiennement.

4. Exploration de l'historique : git log, git show, git diff Apprendre à naviguer dans l'historique et comprendre l'évolution de votre projet.

5. Visualiser l'historique : git log --graph et la notion de graphe Comprendre que l'historique Git est un graphe, et savoir le visualiser et l'interpréter.

6. .gitignore : ignorer des fichiers Configurer Git pour ignorer les fichiers non pertinents et garder un dépôt propre.

Sans comprendre les trois états de Git (Working Directory, Staging Area, Repository), vous utilisez Git "à l'aveugle". Avec cette compréhension, chaque commande devient logique et prévisible.

Savoir comment Git stocke vos données vous aide à :

• Comprendre pourquoi Git est si rapide
• Résoudre des problèmes complexes
• Utiliser Git avec confiance

Les commandes git status, git add et git commit constituent 80% de votre utilisation de Git. Les maîtriser vous rend productif.

L'historique est la raison d'être de Git. Savoir l'explorer et le comprendre est essentiel pour :

• Déboguer des problèmes
• Comprendre l'évolution du projet
• Collaborer efficacement

Git n'est pas une ligne droite de commits, c'est un graphe. Comprendre cette structure est crucial quand vous commencerez à travailler avec des branches (Module 4).

Un bon .gitignore évite des dizaines de problèmes : dépôt pollué, secrets commités par erreur, conflits inutiles.

Ce module adopte une approche conceptuelle et pratique :

• Approfondir la compréhension : Nous n'allons pas juste apprendre des commandes, mais comprendre pourquoi elles fonctionnent ainsi
• Exemples concrets : Chaque concept est illustré avec des commandes réelles que vous pouvez tester
• Analogies accessibles : Des comparaisons avec le monde réel pour rendre les concepts abstraits plus tangibles
• Visualisations : Des schémas ASCII pour représenter les structures de Git
• Progression logique : Chaque section s'appuie sur les précédentes

Les deux premières sections sont plus conceptuelles :

• Comment Git organise vos fichiers
• Comment Git stocke les données

Ne les sautez pas ! Ces concepts sont la fondation de tout le reste.

Les sections 3 et 4 sont très pratiques :

• Les commandes quotidiennes que vous utiliserez sans cesse
• Comment explorer et comprendre votre historique

Pratiquez en même temps : Ouvrez un terminal et testez chaque commande.

Les deux dernières sections approfondissent :

• La visualisation graphique de l'historique
• La configuration de .gitignore

Prenez votre temps : Ces concepts deviennent plus clairs avec la pratique.

Les sections sont conçues pour être lues séquentiellement. Chacune s'appuie sur les précédentes.

Ne lisez pas passivement. Ouvrez un terminal et testez :

# Créez un projet de test pour ce module
mkdir git-module2-test  
cd git-module2-test  
git init

Utilisez ce dépôt pour expérimenter toutes les commandes du module.

Notez les concepts qui vous semblent importants, créez vos propres schémas, reformulez avec vos mots.

Git est conçu pour être sûr. Les commandes d'exploration (status, log, show, diff) ne modifient rien. Expérimentez librement !

Si un concept vous semble flou, relisez la section précédente. Tout est interconnecté.

Au fur et à mesure, créez des raccourcis pour les commandes que vous utilisez souvent :

git config --global alias.st status  
git config --global alias.lg "log --graph --oneline --all"

Pour compléter ce module à votre rythme :

• Lecture seule : 2-3 heures
• Avec pratique active : 4-6 heures
• Avec expérimentation approfondie : 6-8 heures

Ce module est plus dense que le Module 1. C'est normal : nous entrons dans le cœur de Git.

Conseil : Faites des pauses entre les sections. Laissez le temps aux concepts de "décanter".

Les mêmes conventions que le Module 1 s'appliquent :

Commandes à taper :

git status

Résultats affichés :

On branch main  
nothing to commit, working tree clean

Notes importantes :

Note : Information utile à retenir

Avertissements :

Attention : Point critique à ne pas manquer

Conseils pratiques :

Astuce : Raccourci ou bonne pratique

Ce module contient de nombreux schémas ASCII pour visualiser les concepts :

Working Directory → Staging Area → Repository

Ces visualisations sont essentielles pour comprendre. Prenez le temps de les étudier.

Chaque concept est accompagné d'exemples pratiques que vous pouvez copier-coller dans votre terminal.

À la fin de chaque section, vous trouverez des tableaux résumant les commandes principales.

Vous avez appris :

• Ce qu'est Git
• Comment l'installer et le configurer
• Comment créer un dépôt et faire des commits

Le Module 2 approfondit ces bases.

Une fois ce module complété, vous serez prêt pour :

• Corriger des erreurs (amend, reset, revert)
• Annuler des modifications
• Récupérer des fichiers d'anciennes versions

Le Module 3 s'appuiera sur votre compréhension des trois états et de l'historique.

Les concepts de graphe et de visualisation de ce module sont essentiels pour comprendre les branches (Module 4).

Cette section est la plus technique du module. C'est normal si tout ne "clique" pas immédiatement.

Conseil : Lisez-la une première fois pour avoir une vue d'ensemble. Revenez-y après avoir pratiqué les commandes des sections suivantes.

Le concept de graphe peut être abstrait au début, surtout si vous n'avez pas encore travaillé avec des branches.

Conseil : Concentrez-vous sur les exemples simples. La complexité viendra naturellement avec la pratique.

Si vous voulez approfondir certains points :

• Documentation officielle : git-scm.com/doc
• Pro Git Book (gratuit) : git-scm.com/book
• Visualisation interactive : git-school.github.io/visualizing-git

À la fin de chaque section, posez-vous ces questions :

Section 1 : Puis-je expliquer les trois états de Git avec mes propres mots ?
Section 2 : Est-ce que je comprends où Git stocke les données ?
Section 3 : Suis-je à l'aise avec status, add et commit ?
Section 4 : Puis-je explorer l'historique efficacement ?
Section 5 : Suis-je capable de lire un graphe Git ?
Section 6 : Ai-je créé un .gitignore pour mes projets ?

Si vous répondez "oui" à toutes ces questions, vous avez réussi le module !

Les concepts de ce module sont plus abstraits que ceux du Module 1. Il est normal de devoir relire certaines sections.

Ne cherchez pas à mémoriser toutes les options de toutes les commandes. Cherchez à comprendre la logique de Git. Le reste viendra naturellement.

Git est très sûr. La plupart des erreurs peuvent être corrigées. N'ayez pas peur de tester des commandes.

Dessinez des schémas si ça vous aide. Représentez visuellement les trois états, le graphe des commits, etc.

Vous avez maintenant toutes les informations pour aborder ce module avec confiance.

Le Module 2 est un investissement dans votre compréhension de Git. Le temps que vous passez ici vous fera gagner des heures (voire des jours) plus tard, quand vous utiliserez Git au quotidien.

Points clés à retenir :

• Ce module approfondit les concepts fondamentaux
• La pratique active est essentielle
• Prenez votre temps, c'est normal de relire
• Ces concepts sont la fondation de tout le reste

Une fois ce module maîtrisé, vous ne serez plus un utilisateur "basique" de Git, mais quelqu'un qui comprend vraiment l'outil.

Conseil final : Gardez un terminal ouvert à côté de ce tutoriel. Testez chaque commande, créez des commits, explorez votre historique. La compréhension vient de la pratique.

Alors, sans plus attendre, plongeons dans les concepts fondamentaux de Git !

Passons maintenant à la première section : Les 3 états de Git : Working Directory, Staging Area, Repository

⏭️ Les 3 états de Git : Working Directory, Staging Area, Repository