1. Livres & vidéos
  2. Git - Maîtrisez la gestion de vos versions (concepts, utilisation et cas pratiques) (5e édition)

Git Maîtrisez la gestion de vos versions (concepts, utilisation et cas pratiques) (5e édition)

Informations

Livraison possible dès le 20 avril 2026
  • Livraison à partir de 0,01 €
  • Version en ligne offerte pendant 1 an
  • Livres rédigés par des auteurs francophones et imprimés à Nantes

Informations

  • Consultable en ligne immédiatement après validation du paiement et pour une durée de 10 ans.
  • Version HTML
  • Livres rédigés par des auteurs francophones et imprimés à Nantes

Les points forts du livre :

  • Un apprentissage progressif de Git, depuis l’installation et la configuration jusqu’à la maîtrise des branches, du partage de dépôts et des workflows professionnels comme git-flow,
  • Des scénarios réalistes et cas d’usage en équipe illustrant la gestion de versions complète d’un projet, incluant l’utilisation de plateformes collaboratives et l’intégration continue,
  • Une exploration approfondie des fonctionnalités avancées (stash, submodules, hooks, bisect, reflog, worktree) accompagnée d’alias et d’astuces pratiques pour optimiser l’utilisation quotidienne de Git
Consulter des extraits du livre en ligne Aperçu de la version papier
  • Niveau Confirmé à Expert
  • Nombre de pages 452 pages
  • Parution avril 2026
  • Niveau Confirmé à Expert
  • Parution avril 2026

En 2026, Git est devenu la référence incontournable de la gestion de versions ; pour un développeur, sa maîtrise n’est plus une option. Ce livre s’adresse principalement aux développeurs et aux chefs de projet mais également aux professionnels appelés à modifier des codes sources (graphiste, webdesigner, administrateurs système, etc.).

Le livre retrace tout d’abord l’historique des solutions de gestion de versions et met en lumière l’intérêt de ces outils dans la conduite de projets modernes. Il permet ensuite au lecteur d’installer et de configurer Git puis de l’utiliser tout au long de cinq chapitres progressifs (fonctionnement des branches, partage d’un dépôt...). Un chapitre est consacré à git-flow, une méthode très populaire pour gérer efficacement les différentes versions d’un projet en entreprise.

Deux chapitres présentent la gestion de versions de manière très pragmatique en utilisant deux scénarios mettant en œuvre des développeurs. Le premier scénario reprend les bases de l’utilisation de Git et montre l’utilisation des principales commandes dans des cas quasi réels. Le deuxième scénario met en scène une équipe de développeurs : de l’installation de GitLab, jusqu’à une utilisation de la méthode git-flow par l’équipe. Ce chapitre détaille les principales étapes par lesquelles l’équipe doit passer pour versionner un projet existant.

Un autre chapitre explore en profondeur les outils internes de Git, illustrés par des cas d’usage concrets : git stash, git submodules, git bisect, git reflog, hooks Git, git notes, git worktree, gestion de patches et mise en place d’un laboratoire Git.

Un chapitre présente une liste d’alias et de commandes prêtes à l’emploi, fruit d’années de pratique de Git de l’auteur, afin que le lecteur utilise Git plus efficacement et puisse obtenir des solutions de problèmes communs. Le dernier chapitre présente un cas réel d’intégration continue 100% Git dans le cadre d’un développement web avec le framework Django.

En annexe, un aide-mémoire permet de visualiser rapidement les principales commandes et leurs principales options. Une présentation de la plateforme GitHub et des changements qu’elle apporte dans la collaboration entre développeurs est également proposée par l’auteur.

Caractéristiques

  • Livre (broché) - 17 x 21 cm
  • ISBN : 978-2-409-05353-5
  • EAN : 9782409053535
  • Ref. ENI : EI5GIT

Caractéristiques

  • HTML
  • ISBN : 978-2-409-05354-2
  • EAN : 9782409053542
  • Ref. ENI : LNEI5GIT

Téléchargements

Avant-propos
  1. À qui s’adresse cet ouvrage ?
  2. Objectifs de l'ouvrage
  3. Prérequis
  4. Progression
  5. Détail des chapitres
  6. Un point sur les langues
  7. Remerciements
  8. Introduction à Git
Git et la gestion de versions
  1. La gestion de versions
  2. Les intérêts de la gestion de versions
    1. 1. Une véritable machine à remonterle temps
    2. 2. Une documentation détaillée et datée
    3. 3. Une pierre de Rosette pour collaborer
  3. Histoire de la gestion de versions
    1. 1. Systèmes de gestion de versions locaux
    2. 2. Systèmes de gestion de versions centralisés
    3. 3. Systèmes de gestion de versions décentralisés
  4. Pourquoi Git ?
Installation de Git
  1. Installation sous Linux
    1. 1. Installation à partir de paquets préexistants
    2. 2. Installation à partir des sources
  2. Installation sous macOS
  3. Installation sous Windows
  4. L’aide de Git
    1. 1. Généralités
    2. 2. Types de commandes Git
      1. a. Les commandes de porcelaine
      2. b. Les commandes de plomberie
  5. Configuration requise
    1. 1. Configurer le nom de l’utilisateur
    2. 2. Configurer l’e-mail de l’utilisateur
Création d’un dépôt
  1. Créer un dépôt local
  2. Le contenu du dossier .git
  3. Le fichier README
  4. Markdown
    1. 1. Présentation
    2. 2. Éléments de syntaxe
      1. a. Titres
      2. b. Listes non ordonnées
      3. c. Listes ordonnées
      4. d. Mettre en gras
      5. e. Mettre en italique
      6. f. Ligne horizontale
      7. g. Code
      8. h. Tableaux
      9. i. Liens
      10. j. Notes de bas de page
  5. reStructuredText
    1. 1. Présentation
    2. 2. Éléments de syntaxe
      1. a. Titres
      2. b. Listes autonumérotées
    3. 3. Logiciels
  6. Outils pour travailler avec Markdown
    1. 1. Sublime Text
    2. 2. Texts
    3. 3. Ulysses
  7. Configurer le dépôt local
    1. 1. Configuration minimale
    2. 2. Niveaux de configuration
      1. a. Le niveau système
      2. b. Le niveau utilisateur
      3. c. Le niveau dépôt
    3. 3. Les paramètres configurables
      1. a. Définir l’éditeur de texte
      2. b. Modèle de commit
      3. c. Ignorer des fichiers
      4. d. Hashs abrégés
    4. 4. Définition d’alias Git
  8. Les options de configuration avancées
    1. 1. Pagination
    2. 2. Expressions régulières étendues
    3. 3. Séparateur de mots
    4. 4. Ancêtre commun des conflits
    5. 5. Configurer le cache de l’authentification
Manipulation des fichiers et commit
  1. Gestion des fichiers et commit
  2. Une histoire de hash
    1. 1. Une identification par contenu
    2. 2. Risque de collision
    3. 3. Fonctionnalité expérimentale dehash SHA2-256
  3. Les trois zones d’un fichier
    1. 1. Le répertoire de travail
    2. 2. L’index
    3. 3. Le dépôt
  4. Manipuler les fichiers
    1. 1. Ajouter des fichiers dans l’index
    2. 2. Déplacer ou renommer des fichiers
    3. 3. Supprimer des fichiers
    4. 4. Arrêter de suivre un fichier
    5. 5. Ignorer des fichiers
  5. Commiter ou enregistrer des modifications
    1. 1. Effectuer un premier commit
    2. 2. Rédiger un bon message de commit
      1. a. Les règles d’un message de commit
      2. b. Méthode pour trouver un bon titre
      3. c. En quelle langue ?
  6. Le garbage collector de Git
Consultation et manipulation de l’historique
  1. Lister les commits avec git log
    1. 1. Limiter le nombre de commits affichés
    2. 2. Afficher les statistiques
    3. 3. Afficher chaque commit sur une seule ligne
    4. 4. Filtrer les commits chronologiquement
    5. 5. Filtrer les commits selon les intervenants
    6. 6. Afficher le graphique des branches
    7. 7. Spécifier un format de sortie
    8. 8. Prendre en compte les merges
    9. 9. Lister les commits impactant un fichier
    10. 10. Afficher des dates plus lisibles
  2. Afficher les différences de contenu
    1. 1. Différences en cours dans le répertoire
    2. 2. Différences entre l’index et HEAD
    3. 3. Différences entre le répertoirede travail et HEAD
    4. 4. Différences introduites par un ou plusieurscommits
    5. 5. Différences de mots
    6. 6. Visualiser les blocs de code déplacés
  3. Identifier l’auteur d’une ligne de code
  4. Rechercher des commits avec le mode pick axe
  5. Supprimer les modifications du répertoire de travail
  6. Supprimer les modifications de l'index
  7. Revenir à un état antérieur
  8. Modifier le dernier commit
  9. Afficher un résumé des commits
  10. Fusionner (squash) des commits
    1. 1. Première méthode : rebase interactif
    2. 2. Deuxième méthode : git merge squash
    3. 3. Troisième méthode : git reset soft
  11. Supprimer un commit
    1. 1. Quel est le réel besoin ?
    2. 2. Mise en œuvre des solutions
      1. a. Supprimer des commits avec git reset
      2. b. Supprimer des commits avec git rebase -i
      3. c. Inverser un commit avec git revert
    3. 3. Vous avez modifié l’historique par erreur?
      1. a. Commits supprimés avec git reset
      2. b. Commits supprimés avec git rebase -i
      3. c. Commits inversés avec git revert
Les branches et les tags
  1. Les tags
    1. 1. Numérotation des versions
    2. 2. Différents types de tags
    3. 3. Création des tags
    4. 4. Création d’un tag annoté
    5. 5. Liste des tags
    6. 6. Détails d’un tag
    7. 7. Envoi des tags vers le dépôt distant
    8. 8. Suppression d’un tag
  2. Les branches
    1. 1. Liste des branches existantes
    2. 2. Création d’une branche
    3. 3. Positionnement sur une branche
    4. 4. Fusionner deux branches
      1. a. L’avance rapide
      2. b. Nettoyer le dépôt
      3. c. Les conflits de fusion
    5. 5. Supprimer une branche
    6. 6. Rebaser une branche dans une autre
  3. Mettre à jour des branches dépendantes
Partager un dépôt
  1. Qu'est-ce qu'un dépôt distant ?
  2. Créer un dépôt distant
    1. 1. Pour un nouveau projet
    2. 2. Pour un projet existant
  3. Cloner un dépôt distant
  4. Les protocoles d'échange
  5. Fonctionnement interne et branches distantes
    1. 1. Les dépôts distants liés
    2. 2. Les branches distantes suivies
  6. Envoyer ses modifications
  7. Recevoir les modifications
  8. Les branches divergentes
Git-Flow : workflow d’entreprise
  1. Un système de gestion des branches
    1. 1. Les branches éternelles
      1. a. La branche de production (master)
      2. b. La branche de développement (develop)
    2. 2. Les branches éphémères
      1. a. Les branches de versions (release)
      2. b. Les branches de correctifs (hotfix)
      3. c. Les branches de fonctionnalités (feature)
      4. d. Plusieurs commits dans une branche éphémère ?
  2. Exemple de workflow
Les outils de Git
  1. Mettre de côté des modifications avec git stash
  2. Dépôts intégrés avec submodules
    1. 1. Ajout du dépôt intégré
    2. 2. Cloner un dépôt et ses dépôtsintégrés
    3. 3. Modification des dépôts intégrés
    4. 4. Supprimer un dépôt intégré
    5. 5. Inconvénients des dépôtsintégrés
  3. Retrouver un commit erroné
    1. 1. Utilisation pratique de git bisect
    2. 2. Automatiser git bisect
  4. Journal des références (reflog)
  5. Les hooks
    1. 1. Les différents types de hooks
    2. 2. Comment utiliser les hooks ?
    3. 3. Exemple de hook : validation de message
    4. 4. Partager les hooks dans le dépôt
  6. Les notes Git
    1. 1. Créer une note
    2. 2. Afficher les notes
      1. a. Lister les notes
      2. b. Consulter les notes d’un commit
    3. 3. Éditer une note
    4. 4. Supprimer une note
    5. 5. Envoyer les notes vers le serveur
  7. git worktree
    1. 1. Pourquoi utiliser git worktree ?
    2. 2. Utiliser les worktrees
  8. Les patchs Git
    1. 1. Les patchs bruts ou patchs de différence
    2. 2. Les patchs formatés basés sur lescommits
  9. Labo Git : testez par vous-même
    1. 1. Situation commune
    2. 2. Déplacement de fichier sans git mv
    3. 3. Déplacement de fichier avec git mv
Scénario de développeur indépendant
  1. But de ce chapitre
  2. Contexte du scénario
  3. Création du dépôt
  4. Début du développement
  5. Enregistrer des modifications
  6. Bitbucket
    1. 1. Création d’un compte
    2. 2. Envoyer un dépôt local vers Bitbucket
    3. 3. Éditer un fichier sur Bitbucket
    4. 4. Récupérer les modifications du dépôtdistant
  7. Intégrer un nouveau développement
    1. 1. Vérifier son code avant l’indexation
    2. 2. Commiter le nouveau développement
  8. Annuler les modifications d'un fichier
  9. .gitignore : ignorer une bibliothèque
  10. Commiter tous les fichiers ajoutés ou modifiés
  11. Envoyer les commits au dépôt distant
  12. Afficher les différences entre deux commits
  13. Cloner le dépôt distant
  14. Une branche, ça sert à quoi ?
  15. Changer de branche
  16. Fusionner deux branches
Scénario d’équipe
  1. Contexte du scénario
  2. Aperçu du projet
    1. 1. Installation de Python
    2. 2. Récupération du dépôt
    3. 3. Installation des dépendances Python
    4. 4. Initialisation des dépôts intégrés
    5. 5. Génération des bibliothèques
    6. 6. Création du fichier de configuration
    7. 7. Création de la base
    8. 8. Création d’un compte root
    9. 9. Lancement du serveur
  3. Installation de GitLab
  4. Création des comptes utilisateurs
  5. Création du projet
  6. Attribuer des projets aux utilisateurs
  7. Premier commit du projet
    1. 1. Rédaction du fichier .gitignore
      1. a. Ignorer les bibliothèques
      2. b. Ignorer les fichiers propres à la technologie
      3. c. Ignorer les données sensibles
      4. d. Ajouter les dépôts intégrés
      5. e. Le fichier README
    2. 2. Commit du projet
    3. 3. Création de la branche develop pour Git-Flow
  8. Phase de développement
    1. 1. Fonctionnalité graphique
    2. 2. Correctif de temps négatif
    3. 3. Intégration du correctif
    4. 4. Fonctionnalité type de tâche
    5. 5. Finalisation des graphiques
    6. 6. Finalisation des types de tâches
    7. 7. Création de la branche de version
    8. 8. Export CSV
    9. 9. Correctif de version
    10. 10. Nouvelle version stable
    11. 11. Finalisation de l’export CSV
  9. Mise en ligne du dépôt sur GitHub
    1. 1. Création d’un compte GitHub
    2. 2. Création d’un dépôt
    3. 3. Ajout du remote au dépôt local
    4. 4. Envoi des branches
    5. 5. Le fichier LICENSE
    6. 6. Le fichier README
Productivité maximale avec Git
  1. Alias prêts à l'emploi
    1. 1. Alias simples
      1. a. git lvc
      2. b. git aliases
      3. c. git last
      4. d. git aa
      5. e. git bv
      6. f. git ba
      7. g. git bd
      8. h. git bdp
      9. i. git pushn
      10. j. git ca
      11. k. git cb
      12. l. git cmf
      13. m. git co
      14. n. git di
      15. o. git dc
      16. p. git mnff
      17. q. git st
      18. r. git tg
      19. s. git pu
      20. t. git ss
      21. u. git ssu
      22. v. git sr
      23. w. git srp
      24. x. git sl
      25. y. git sp
      26. z. git sa
      27. aa. git sd_f
      28. ab. git sb
      29. ac. git na
      30. ad. git nl
      31. ae. git napp
      32. af. git ne
      33. ag. git ns
      34. ah. git nr
      35. ai. git ready
      36. aj. git reflogv
      37. ak. git diff-bb
      38. al. git rebaseon
      39. am. git restore-bb
      40. an. git reset-soft-bb
    2. 2. Alias complexes
      1. a. git bnew
      2. b. git bold
      3. c. git ll
      4. d. git ld
      5. e. git ldv
      6. f. git lpa
      7. g. git ls
      8. h. git ln
      9. i. git slv
      10. j. git np
      11. k. git bvn
      12. l. git churn
      13. m. git srr
      14. n. git spr
      15. o. git sar
      16. p. git sdr
      17. q. git st-b
    3. 3. Récupérer les alias sur GitHub
  2. Commandes prêtes à l’emploi
    1. 1. Commandes liées à la configuration
      1. a. Fichier de configuration actif pour une option
      2. b. Afficher sa configuration
      3. c. Éditer facilement un niveau de configuration
    2. 2. Commandes d’affichage
      1. a. Afficher les informations techniques d’un commit
      2. b. Afficher les parents des commits
      3. c. Afficher les fichiers en conflit
      4. d. Afficher la liste des fichiers modifiés
      5. e. Afficher l’ancêtre commun
      6. f. Afficher le premier commit d’une branche
      7. g. Utiliser git show en masquant le diff
      8. h. Vérifier une branche sur un dépôtdistant
      9. i. Fusionner des branches sans ancêtre commun
      10. j. Afficher les dépôts distants etleur lien externe
      11. k. Afficher les fichiers modifiés par un commit
      12. l. Afficher le chemin du dépôt versionné
      13. m. Consulter l’historique des commandes git
      14. n. Afficher le nombre de commits par auteur
      15. o. Afficher le nombre de commits d’un auteur
      16. p. Afficher la dernière date de modificationdes branches
      17. q. Lister les branches contenant un commit précis
      18. r. Afficher l’historique avec les diff
      19. s. Chercher un texte/regex dans les commits
      20. t. Chercher un texte/regex dans les stashs
      21. u. Lister les commits des branches
      22. v. Comparer un fichier antérieur
      23. w. Afficher les branches déjà fusionnéesdans master
      24. x. Lister les branches non mergées dans master
      25. y. Lister les commits d’une branche non mergée à master
    3. 3. Commandes de manipulation
      1. a. Supprimer ou inverser les modifications d’un commit
      2. b. Supprimer du dépôt les fichiersdéjà supprimés du projet
      3. c. Retirer des modifications de l’index
      4. d. Récupérer le fichier d’un autrecommit
      5. e. Supprimer les fichiers non suivis du répertoire
      6. f. Supprimer les modifications des fichiers suivis
      7. g. Supprimer une branche distante
Git en déploiement continu
  1. Objectifs du chapitre
  2. Le projet
  3. Présentation de Django
  4. Développement de la version initiale
    1. 1. Installation
    2. 2. Création du projet
      1. a. Création du projet Django
      2. b. Création du fichier .gitignore
      3. c. Enregistrement des bibliothèques Python
      4. d. Premier commit
    3. 3. Création des applications users et articles
    4. 4. Création des modèles Django
      1. a. Le modèle BaseModel
      2. b. Le modèle User
      3. c. Le modèle Article
    5. 5. Mise en place du module d’administration
      1. a. Démarrer le serveur de développement
      2. b. Création des pages utilisateur
      3. c. Templates parents
      4. d. Liste des articles
      5. e. Page de consultation d’un article
      6. f. Page "À propos"
  5. Déploiement initial
    1. 1. Configuration des identifiants SSH
    2. 2. Création du site web Webfaction
    3. 3. Création des applications Webfaction
    4. 4. Création de la base de données
    5. 5. Externalisation du dépôt de la configuration
    6. 6. Préparer le dossier du projet et créerle dépôt
    7. 7. Configuration du dépôt en déploiementautomatisé
    8. 8. Configuration du remote et premier push
    9. 9. Création de l’environnement virtuel
    10. 10. Configuration d’Apache
    11. 11. Envoi de la configuration de production
    12. 12. Exécuter les migrations
    13. 13. Synchroniser les fichiers statiques
    14. 14. Redémarrer Apache
  6. Déploiement automatisé
    1. 1. Développement du hook dans le dépôt
    2. 2. Configuration du dépôt distant
  7. Fonctionnalité : champ WYSIWYG pour l'article
    1. 1. Développement
    2. 2. Déploiement automatisé
Aide-mémoire
  1. Les références
    1. 1. HEAD
    2. 2. Les branches
    3. 3. Les tags
    4. 4. Référence des ancêtres
  2. Les commandes
    1. 1. git add
    2. 2. git archive
    3. 3. git bisect
    4. 4. git blame
    5. 5. git branch
    6. 6. git checkout
    7. 7. git cherry-pick
    8. 8. git clean
    9. 9. git clone
    10. 10. git commit
    11. 11. git config
    12. 12. git diff
    13. 13. git fetch
    14. 14. git gc
    15. 15. git help
    16. 16. git init
    17. 17. git log
    18. 18. git merge
    19. 19. git mv
    20. 20. git pull
    21. 21. git push
    22. 22. git rebase
    23. 23. git reflog
    24. 24. git remote
    25. 25. git reset
    26. 26. git revert
    27. 27. git rm
    28. 28. git show
    29. 29. git stash
    30. 30. git submodule
    31. 31. git tag
  3. GitHub
    1. 1. Gestion des dépôts
    2. 2. GitHub-Flow (fork et pull request)
    3. 3. Les "issues" GitHub

Samuel DAUZON

Samuel DAUZON est le fondateur de Je suis ma santé, une application de suivi nutritionnel.

Déjà auteur des livres Meteor et Ionic aux Editions ENI et Django Essentials aux Editions Packt Publishing, il partage volontiers son expertise sur le développement et sur Git, pour le plus grand bénéfice des lecteurs.

 

Nos nouveautés

voir plus