Maîtrise Git: Le Guide Complet pour Débutants

1. Introduction à Git

Git est l’un des systèmes de contrôle de version les plus populaires et les plus puissants disponibles aujourd’hui. Mais qu’est-ce que cela signifie exactement ?

Un système de contrôle de version, comme son nom l’indique, est un outil qui permet de garder une trace des différentes versions d’un fichier ou d’un ensemble de fichiers au fil du temps. Cela signifie que si tu fais une erreur, tu peux toujours revenir à une version précédente de ton code. De plus, il facilite grandement la collaboration en permettant à plusieurs personnes de travailler sur le même projet sans se marcher sur les pieds.

Git, en particulier, est un système de contrôle de version décentralisé. Cela signifie que chaque développeur possède une copie complète du projet sur son ordinateur, avec l’historique complet des changements. C’est très différent des systèmes de contrôle de version centralisés, où l’historique est stocké sur un serveur central.

La décentralisation a de nombreux avantages. Par exemple, elle rend le travail hors ligne possible (tu peux faire des commits même sans connexion internet), et elle rend le système plus résilient (si le serveur central tombe en panne dans un système centralisé, tu perds tout l’historique des changements).

Voici quelques concepts clés pour comprendre comment fonctionne Git:

• Dépôt (repository): Un dépôt Git est l’endroit où Git stocke tous les fichiers et l’historique des modifications. Un dépôt peut être local (sur ton ordinateur) ou distant (sur un serveur comme GitHub).
• Commit : Un commit est une capture instantanée de l’état de ton projet à un moment donné. Chaque commit a un identifiant unique (un « hash ») qui te permet de retrouver cet état précis si nécessaire.
• Branche (branch) : Une branche est une version du projet qui diverge de la version principale. Les branches sont utilisées pour développer de nouvelles fonctionnalités sans perturber le code principal.
• Merge : L’opération de fusion permet d’intégrer les changements d’une branche à une autre.

Git peut sembler complexe au début, mais une fois que tu as compris ces concepts de base, tu verras qu’il est en fait très logique et puissant. Dans les sections suivantes, nous explorerons chaque aspect de Git en détail, avec des exemples concrets pour illustrer chaque point. Alors, restons branchés !

2. Installation et Configuration de Git

Maintenant que tu comprends ce qu’est Git et pourquoi il est si utile, passons à la partie pratique : installer et configurer Git sur ton ordinateur.

Installation de Git

Pour commencer, tu dois installer Git. Le processus d’installation varie en fonction de ton système d’exploitation :

• Windows : Télécharge l’installateur de Git depuis le site officiel de Git et suis les instructions.
• Mac : Si tu as déjà installé Xcode, Git est probablement déjà installé sur ton système. Sinon, tu peux l’installer en utilisant Homebrew avec la commande brew install git dans le terminal.
• Linux : Dans la plupart des distributions Linux, tu peux installer Git à partir du gestionnaire de paquets. Par exemple, sur Ubuntu, tu peux utiliser la commande sudo apt-get install git dans le terminal.

Pour vérifier que Git est correctement installé, ouvre un terminal (ou une invite de commandes, si tu es sur Windows), et tape git --version. Tu devrais voir une ligne indiquant la version de Git installée sur ton système.

Configuration de Git

Une fois Git installé, il est recommandé de configurer certaines informations de base. Git utilise ces informations pour attribuer les commits à un utilisateur.

Pour configurer ton nom et ton adresse e-mail, tape les commandes suivantes dans le terminal (en remplaçant « Ton nom » et « tonemail@exemple.com » par tes propres informations) :

git config --global user.name "Ton nom"
git config --global user.email "tonemail@exemple.com"

Ces commandes vont créer un fichier de configuration Git global sur ton système, avec ton nom et ton adresse e-mail. Tous les commits que tu feras seront attribués à cette identité.

Félicitations ! Tu as installé et configuré Git sur ton ordinateur. Dans la prochaine section, nous verrons comment créer ton premier dépôt Git.

3. Création et Clonage d’un Dépôt Git

Maintenant que Git est installé et configuré, nous pouvons commencer à travailler avec des dépôts Git. Dans cette section, nous verrons comment créer un nouveau dépôt Git et comment cloner un dépôt existant.

Création d’un nouveau dépôt Git

Pour créer un nouveau dépôt Git, ouvre un terminal, navigue jusqu’à l’emplacement où tu souhaites créer le dépôt (par exemple, cd ~/Documents/mon_projet) et utilise la commande git init.

Voici à quoi cela ressemble :

$ cd ~/Documents/mon_projet
$ git init
Initialized empty Git repository in /Users/toi/Documents/mon_projet/.git/

Cette commande crée un nouveau dépôt Git dans le dossier mon_projet. Ce dépôt est pour l’instant vide, ce qui signifie qu’il ne contient aucun fichier ou commit.

Clonage d’un dépôt existant

Si tu souhaites travailler sur un projet existant qui est hébergé sur un serveur Git (comme GitHub, GitLab, ou Bitbucket), tu peux cloner ce dépôt sur ton ordinateur. Pour ce faire, tu as besoin de l’URL du dépôt, qui ressemble généralement à https://github.com/user/repo.git.

Pour cloner un dépôt, utilise la commande git clone suivie de l’URL du dépôt. Par exemple, pour cloner le dépôt Git qui contient le code source de Git lui-même, tu peux utiliser cette commande :

$ git clone https://github.com/git/git.git

Cette commande crée une copie du dépôt git dans un nouveau dossier git dans ton répertoire de travail actuel. Elle copie tous les fichiers et tout l’historique des commits de ce dépôt.

Félicitations ! Tu sais maintenant comment créer un nouveau dépôt Git et comment cloner un dépôt existant. Dans la prochaine section, nous verrons comment travailler avec les branches Git.

4. Travail avec les Branches Git

Les branches sont l’un des concepts les plus puissants de Git. Elles te permettent de développer des fonctionnalités ou de corriger des bugs sans affecter la branche principale de ton projet (souvent appelée master ou main). Dans cette section, nous allons apprendre comment créer, passer entre et supprimer des branches.

Créer une nouvelle branche

Pour créer une nouvelle branche, tu peux utiliser la commande git branch suivie du nom de la branche. Par exemple, si tu veux créer une branche pour développer une nouvelle fonctionnalité appelée fonctionnalité1, tu peux taper :

$ git branch fonctionnalité1

Cette commande crée une nouvelle branche appelée fonctionnalité1, mais ne te fait pas basculer sur cette branche. Tu es toujours sur la branche précédente (probablement main ou master).

Passer d’une branche à une autre

Pour passer à la branche fonctionnalité1 que tu viens de créer, tu peux utiliser la commande git checkout :

$ git checkout fonctionnalité1

Cette commande fait en sorte que tous les nouveaux commits soient ajoutés à la branche fonctionnalité1, et non à la branche main ou master.

Supprimer une branche

Une fois que tu as terminé avec une branche (par exemple, après avoir fusionné ses changements dans la branche principale), tu peux la supprimer avec la commande git branch -d :

$ git branch -d fonctionnalité1

Cette commande supprime la branche fonctionnalité1. Note que tu ne peux pas supprimer une branche si tu es actuellement dessus. Tu devrais d’abord passer à une autre branche (par exemple, git checkout main).

Félicitations ! Tu sais maintenant comment travailler avec les branches Git. Dans la prochaine section, nous verrons comment enregistrer les changements dans Git en utilisant des commits.

5. Les Commitments: Enregistrer les Changements

Un commit dans Git est une capture instantanée de l’état de ton projet à un moment donné. En d’autres termes, il s’agit d’une photo de ton code à un instant précis, que tu peux toujours retrouver plus tard si nécessaire. Dans cette section, nous allons apprendre comment faire un commit.

Staging Area (Zone de Préparation)

Avant de pouvoir faire un commit, tu dois ajouter les fichiers que tu veux commiter à la « staging area » ou zone de préparation. Cette étape te permet de sélectionner exactement les fichiers (et les changements) que tu veux inclure dans le commit.

Pour ajouter un fichier à la zone de préparation, utilise la commande git add suivie du nom du fichier. Par exemple, pour ajouter le fichier fichier1.txt, tape :

$ git add fichier1.txt

Si tu veux ajouter tous les fichiers modifiés à la zone de préparation, tu peux utiliser la commande git add ..

Faire un Commit

Une fois que tu as ajouté tous les fichiers que tu veux commiter à la zone de préparation, tu peux faire un commit avec la commande git commit. Tu dois inclure un message de commit qui décrit les changements que tu as faits. Par exemple :

$ git commit -m "Ajout de la fonctionnalité1"

Cette commande crée un nouveau commit avec le message « Ajout de la fonctionnalité1 ». Ce commit est une capture instantanée de tous les fichiers que tu as ajoutés à la zone de préparation.

Voir l’historique des Commits

Pour voir l’historique des commits de ton projet, tu peux utiliser la commande git log. Cette commande affiche une liste de tous les commits, avec le plus récent en haut. Pour chaque commit, elle montre l’identifiant du commit (un long numéro hexadécimal), l’auteur du commit, la date du commit et le message du commit.

Félicitations ! Tu sais maintenant comment faire des commits dans Git. Dans la prochaine section, nous verrons comment fusionner les branches en utilisant git merge et git rebase.

6. Fusionner les Branches: Comprendre le Git Merge et le Git Rebase

Une fois que tu as terminé de travailler sur une branche (par exemple, après avoir développé une nouvelle fonctionnalité ou corrigé un bug), tu voudras probablement intégrer ces changements dans la branche principale de ton projet. C’est là que les commandes git merge et git rebase entrent en jeu. Dans cette section, nous allons expliquer comment elles fonctionnent.

Git Merge

La commande git merge te permet de fusionner les changements d’une branche dans une autre. Par exemple, si tu es sur la branche main et que tu veux fusionner la branche fonctionnalité1, tu peux taper :

$ git merge fonctionnalité1

Cette commande crée un nouveau « commit de fusion » dans la branche main qui comprend tous les changements de la branche fonctionnalité1.

Git Rebase

La commande git rebase est une alternative à git merge. Au lieu de créer un commit de fusion, git rebase « rejoue » les commits de ta branche sur la branche que tu rebases. Cela crée une histoire de commits plus propre, sans commits de fusion.

Par exemple, si tu es sur la branche fonctionnalité1 et que tu veux la rebaser sur la branche main, tu peux taper :

$ git rebase main

Cette commande déplace tous les commits de la branche fonctionnalité1 de sorte qu’ils se trouvent après les derniers commits de la branche main.

Merge vs Rebase

Alors, devrais-tu utiliser git merge ou git rebase ? Cela dépend de la situation. git merge est plus simple et plus sûr, donc si tu es débutant, c’est probablement le meilleur choix. D’un autre côté, git rebase crée une histoire de commits plus propre, ce qui peut faciliter la lecture de l’historique des commits.

Cependant, il faut être prudent avec git rebase, car il modifie l’historique des commits, ce qui peut causer des problèmes si d’autres personnes travaillent sur la même branche.

Félicitations ! Tu comprends maintenant comment fusionner les branches avec git merge et git rebase. Dans la prochaine section, nous verrons comment collaborer avec Git en utilisant les commandes push, pull et fetch.

7. Collaboration avec Git: Push, Pull et Fetch

Git est conçu pour la collaboration. Il te permet de travailler avec d’autres sur le même projet, même si vous êtes sur des continents différents. Dans cette section, nous allons voir comment partager ton travail avec les autres en utilisant les commandes git push, git pull et git fetch.

Git Push

La commande git push te permet d’envoyer tes commits à un dépôt Git distant. Par exemple, si tu as fait des commits sur la branche main et que tu veux les envoyer à GitHub, tu peux utiliser la commande :

$ git push origin main

Cette commande envoie tous les commits de la branche main qui ne sont pas encore sur GitHub.

Git Pull

La commande git pull est l’inverse de git push: elle te permet de recevoir les derniers commits d’un dépôt distant. Par exemple, si tu travailles avec un coéquipier et que tu veux obtenir les derniers commits de GitHub, tu peux utiliser la commande :

$ git pull origin main

Cette commande récupère tous les commits de la branche main de GitHub que tu n’as pas encore sur ton ordinateur.

Git Fetch

La commande git fetch est similaire à git pull, mais avec une différence clé : elle récupère les derniers commits d’un dépôt distant, mais ne les fusionne pas automatiquement avec ta branche locale. Cela te donne l’opportunité de voir les commits avant de les fusionner.

Par exemple, pour récupérer les derniers commits de GitHub sans les fusionner, tu peux utiliser la commande :

$ git fetch origin

Après avoir utilisé git fetch, tu peux utiliser git merge pour fusionner les commits récupérés.

Félicitations ! Tu sais maintenant comment partager ton travail et collaborer avec les autres en utilisant Git. Dans la prochaine et dernière section, nous allons voir comment résoudre les conflits de fusion dans Git.

8. Résolution des Conflits de Fusion

Lorsque tu travailles avec d’autres sur un même projet, il peut arriver que plusieurs personnes modifient le même fichier en même temps. Lorsque ces modifications sont incompatibles, cela crée un « conflit de fusion ». Dans cette section, nous allons voir comment résoudre ces conflits.

Identifier les Conflits

Lorsque tu essayes de fusionner deux branches avec git merge ou git rebase, et que Git ne peut pas fusionner automatiquement les modifications, il t’indiquera qu’il y a un conflit. Par exemple :

$ git merge fonctionnalité1
Auto-merging fichier1.txt
CONFLICT (content): Merge conflict in fichier1.txt
Automatic merge failed; fix conflicts and then commit the result.

Cela signifie qu’il y a un conflit dans le fichier fichier1.txt que tu dois résoudre manuellement.

Résoudre les Conflits

Pour résoudre un conflit, tu dois ouvrir le fichier avec un éditeur de texte et rechercher les marqueurs de conflit. Un conflit ressemble à ceci :

>>>>>>> HEAD
Contenu de ta branche
=======
Contenu de l'autre branche
>>>>>>> fonctionnalité1

Ta tâche est de décider quel contenu garder. Tu peux choisir le contenu de ta branche, le contenu de l’autre branche, ou une combinaison des deux. Supprime les marqueurs de conflit et le contenu que tu ne veux pas garder, puis sauvegarde le fichier.

Finaliser la Fusion

Une fois que tu as résolu tous les conflits, tu peux finaliser la fusion en ajoutant les fichiers résolus à la zone de préparation avec git add, puis en faisant un commit avec git commit. Par exemple :

$ git add fichier1.txt
$ git commit -m "Résolution des conflits de fusion"

Cette commande crée un nouveau commit qui finalise la fusion des deux branches.

Félicitations ! Tu sais maintenant comment résoudre les conflits de fusion dans Git. Avec ces connaissances, tu es prêt à commencer à utiliser Git dans tes propres projets. Bon codage !

9. Conclusion et Ressources Supplémentaires

Maintenant que tu as une bonne compréhension de Git et de son fonctionnement, tu es prêt à commencer à l’utiliser pour tes propres projets. C’est un outil puissant qui, lorsqu’il est bien utilisé, peut grandement améliorer ta productivité et la qualité de ton code.

Cependant, il y a encore beaucoup plus à apprendre sur Git. Voici quelques ressources supplémentaires que tu peux utiliser pour approfondir tes connaissances :

1. Documentation officielle de Git: Une ressource incontournable pour tout ce qui concerne Git. Elle est très détaillée et couvre pratiquement tous les aspects de Git.
2. Pro Git book: Un livre en ligne gratuit qui donne une explication détaillée de Git et de son utilisation.
3. Try Git: Un tutoriel interactif en ligne qui te guide à travers les commandes Git de base.
4. GitHub Learning Lab: Des cours interactifs qui te guident à travers les différentes étapes de l’utilisation de Git et GitHub.

Enfin, n’oublie pas que la meilleure façon d’apprendre Git est de l’utiliser régulièrement. Plus tu l’utilises, plus tu te sentiras à l’aise avec.

Et voilà, tu as maintenant toutes les clés en main pour devenir un as de Git ! Bonne programmation !