Fiche de lecture

Cours Complet et Structuré

sur Git et GitHub

PROPENTA TECH SAVVING SOLUTIONS

14 Octobre 2024
Bienvenue dans ce cours complet sur Git et GitHub . Ce guide est conçu pour
vous fournir une compréhension approfondie de ces outils essentiels pour le
développement logiciel moderne. Vous apprendrez les concepts fondamentaux,
les commandes principales, des exemples pratiques, des scénarios réels et des
exercices pour renforcer vos compétences.

1
Table des Matières

1. Introduction à Git et GitHub

2. Installation et Configuration
3. Concepts de Base de Git
4. Commandes Principales de Git
○ Revenir à une Version Précédente
5. Introduction à GitHub
○ Étapes pour Envoyer son Code sur GitHub
6. Cas d'Usage Concrets
7. Scénarios Pratiques
8. Exercices pour S'entraîner
9. Ressources Supplémentaires

2
Introduction à Git et GitHub

Qu'est-ce que Git ?

Git est un système de contrôle de version distribué créé par Linus

Torvalds en 2005. Il permet de suivre les modifications apportées au
code source au fil du temps, facilitant la collaboration entre plusieurs
développeurs.

Qu'est-ce que GitHub ?

GitHub est une plateforme de développement collaboratif basée sur

Git. Elle offre des fonctionnalités supplémentaires telles que
l'hébergement de dépôts, la gestion des problèmes (issues), les
demandes de tirage (pull requests), et bien plus encore.

Installation et Configuration

Installation de Git

1. Windows :
○ Téléchargez l'installateur depuis [Link].
○ Exécutez l'installateur et suivez les instructions.
2. Linux :
○ sudo apt-get update
○ sudo apt-get install git

3
Configuration Initiale

Après l'installation, configurez votre identité utilisateur :

git config --global [Link] "Votre Nom"

git config --global [Link] "[Link]@[Link]"

Vérifiez la configuration :

git config --list

Concepts de Base de Git

Repository (Dépôt)

Un repository est un dossier où Git stocke tous les fichiers du projet et

l'historique des modifications.

Commit

Un commit est un instantané des fichiers à un moment donné. Chaque

commit a un identifiant unique (hash).

Branch

4
Une branche permet de développer des fonctionnalités
indépendamment de la branche principale (généralement main ou
master).

Merge

Le merge permet de combiner les modifications de différentes

branches.

Clone

La commande clone crée une copie locale d'un dépôt distant.

Revert et Reset

Ces concepts permettent de revenir à des versions précédentes du

code, soit en annulant des commits spécifiques, soit en réinitialisant
l'état du dépôt.

Commandes Principales de Git

Initialiser un Dépôt

git init

5
Cloner un Dépôt

git clone [Link]

Vérifier l'État du Dépôt

git status

Ajouter des Fichiers à l'Index

git add [Link]

###### Ou ajouter tous les fichiers ######

git add .

Committer les Modifications

git commit -m "Message de commit descriptif"

Afficher l'Historique des Commits

git log

6
Créer une Nouvelle Branche

git branch nom-de-branche

Changer de Branche

git checkout nom-de-branche

Fusionner une Branche

git merge nom-de-branche

Pousser les Modifications vers le Dépôt Distant

git push origin nom-de-branche

Tirer les Modifications du Dépôt Distant

git pull origin nom-de-branche

Résoudre les Conflits

En cas de conflit lors d'un merge ou d'un pull, Git marquera les fichiers
concernés. Vous devrez éditer ces fichiers pour résoudre les conflits,
puis :

7
git add fichier-ré[Link]

git commit -m "Résolution des conflits"

Revenir à une Version Précédente

Il existe plusieurs façons de revenir à une version précédente du code.

Voici les principales méthodes :

1. Utiliser git checkout pour Explorer une Version Antérieure

Cette méthode vous permet de consulter une version antérieure sans

modifier l'historique.

git checkout <commit_hash>

Exemple : git checkout a1b2c3d4

Note : En mode détaché (detached HEAD), les modifications ne seront

pas conservées sur une branche. Pour revenir à la branche principale :

git checkout main

2. Utiliser git revert pour Annuler un Commit Spécifique

git revert crée un nouveau commit qui annule les modifications

d'un commit précédent.

git revert <commit_hash>

8
Exemple : git revert a1b2c3d4

3. Utiliser git reset pour Réinitialiser l'État du Dépôt

git reset modifie l'historique des commits. Il existe trois modes

principaux :

● Soft Reset : Garde les modifications dans l'index.

git reset --soft <commit_hash>

● Mixed Reset (par défaut) : Garde les modifications dans le

répertoire de travail mais les retire de l'index.

git reset --mixed <commit_hash>

● Hard Reset : Supprime toutes les modifications dans l'index et le

répertoire de travail.

git reset --hard <commit_hash>

Exemple :

Pour réinitialiser le dépôt à un commit spécifique et supprimer toutes

les modifications ultérieures :

git reset --hard a1b2c3d4

9
Attention : Utiliser git reset --hard peut entraîner la perte de
données non sauvegardées. Utilisez-le avec précaution, surtout si le
dépôt est partagé avec d'autres collaborateurs.

10
Introduction à GitHub

Création d'un Compte GitHub

1. Rendez-vous sur [Link].

2. Cliquez sur "Sign up" et suivez les instructions pour créer un
compte.

Créer un Nouveau Dépôt

1. Connectez-vous à GitHub.
2. Cliquez sur le bouton "New" pour créer un nouveau dépôt.
3. Remplissez les informations (nom, description, public/privé).
4. Initialisez avec un README si souhaité.

Cloner un Dépôt GitHub

git clone [Link]

Gestion des Issues

Les issues permettent de suivre les tâches, bugs et fonctionnalités à

implémenter.

Pull Requests

Les pull requests facilitent la revue de code et la fusion des

modifications dans la branche principale.

Étapes pour Envoyer son Code sur GitHub

Pour envoyer (pousser) votre code local sur GitHub, suivez ces étapes :

11
1. Créer un Dépôt Local :

Si ce n'est pas déjà fait, initialisez un dépôt Git dans votre projet.

git init

2. Ajouter les Fichiers et Faire un Commit :

git add .

git commit -m "Premier commit"

3. Créer un Dépôt sur GitHub :

Allez sur GitHub et créez un nouveau dépôt.

Ne cochez pas l'option pour initialiser avec un README si vous

avez déjà un dépôt local.

4. Ajouter le Dépôt Distant :

Copiez l'URL du dépôt GitHub (HTTPS ou SSH) et ajoutez-la
comme distant dans votre dépôt local.

git remote add origin

[Link]

5. Pousser les Modifications Locales vers GitHub :

git push -u origin main

Remarque : Si votre branche principale est nommée master au

lieu de main, ajustez la commande en conséquence.

12
 6. Vérifier sur GitHub :

Rafraîchissez la page de votre dépôt GitHub pour voir les fichiers

poussés.

Cas d'Usage Concrets

Collaboration sur un Projet

● Scénario : Plusieurs développeurs travaillent sur le même projet.

● Solution : Utiliser des branches pour chaque fonctionnalité, créer
des pull requests pour les revues de code, fusionner après
validation.

Gestion de Versions

● Scénario : Maintenir plusieurs versions d'un logiciel (par exemple,

v1.0, v2.0).
● Solution : Utiliser des branches ou des tags pour marquer les
versions.

Contribution à un Projet Open Source

● Scénario : Vous souhaitez contribuer à un projet open source.

● Solution : Forker le dépôt, créer une branche, apporter les
modifications, soumettre une pull request.

13
Revenir à une Version Précédente

● Scénario : Une fonctionnalité introduit un bug et vous souhaitez

revenir à l'état précédent.
● Solution : Utiliser git revert pour annuler le commit
problématique ou git reset pour réinitialiser l'état du dépôt.

Scénarios Pratiques

Scénario 1 : Création et Gestion d'un Projet

1. Initialisation :
○ Créez un nouveau répertoire.
○ Initialisez Git : git init
○ Créez un fichier [Link].
○ Ajoutez et commit : git add [Link] puis git
commit -m "Initial commit"
2. Création d'une Branche de Fonctionnalité :
○ git branch feature-xyz
○ git checkout feature-xyz
3. Développement :
○ Ajoutez des fichiers ou modifiez le code.
○ git add .
○ git commit -m "Ajout de la fonctionnalité
XYZ"
4. Fusion :
○ git checkout main

14
 ○ git merge feature-xyz
○ Pousser vers GitHub : git push origin main

Scénario 2 : Revenir à une Version Précédente

1. Afficher l'historique des commits :

git log

2. Identifier le commit cible (par exemple, a1b2c3d4).

3. Revenir à ce commit sans modifier l'historique :

git checkout a1b2c3d4

4. Créer une nouvelle branche à partir de ce commit (optionnel) :

git checkout -b ancienne-version

5. Ou réinitialiser l'historique (attention aux implications) :

git reset --hard a1b2c3d4

6. Pousser les modifications vers GitHub (si applicable) :

git push origin main --force

Note : L'utilisation de --force peut réécrire l'historique du dépôt

distant. Utilisez-le avec précaution, surtout dans des environnements
collaboratifs.

15
Exercices pour S'entraîner

Exercice 1 : Initialiser un Dépôt Local

1. Créez un répertoire nommé mon-projet.

2. Initialisez Git dans ce répertoire.
3. Créez un fichier [Link] avec un contenu basique.
4. Ajoutez et commit ce fichier avec un message approprié.

Exercice 2 : Travailler avec des Branches

1. Dans votre dépôt mon-projet, créez une branche nommée

develop.
2. Basculez sur la branche develop.
3. Ajoutez une nouvelle fonctionnalité (par exemple, un fichier
[Link]).
4. Ajoutez et commit vos modifications.
5. Revenez à la branche main et fusionnez la branche develop.

Exercice 3 : Revenir à une Version Précédente

1. Faites plusieurs commits dans votre dépôt mon-projet.

2. Identifiez un commit antérieur avec git log.
3. Utilisez git checkout pour explorer ce commit.
4. Revenez à la branche principale.
5. Utilisez git revert pour annuler un commit spécifique.
6. Vérifiez l'historique des commits pour voir le commit de
réversion.
7. Poussez les modifications vers GitHub.

16
Conclusion

Félicitations ! Vous avez terminé ce cours sur Git et GitHub. Continuez

à pratiquer avec les exercices proposés et explorez les ressources
supplémentaires pour approfondir vos connaissances. Bonne utilisation
de Git et GitHub dans vos projets de développement !

17