Gestion de versions avec Git pour les projets R dans VS Code
Initialisez, indexez, validez, comparez et poussez vos projets R avec le Contrôle de code source intégré de VS Code.
Gérez les versions de vos projets R dans VS Code : initialisez un dépôt avec usethis, indexez et validez vos modifications depuis le panneau Contrôle de code source intégré, examinez les différences, résolvez les conflits de fusion et poussez vers GitHub, le tout sans quitter l’éditeur.
- Laissez R créer le dépôt.
usethis::use_git()initialise Git et réalise le premier commit en un seul appel — plus besoin d’enchaînergit init/git add/git commitdans le terminal. - Le panneau Contrôle de code source est votre outil quotidien. La vue Contrôle de code source intégrée de VS Code (
Ctrl+Shift+G) indexe, compare et valide les fichiers modifiés sans une seule commande Git. - Ignorez le bruit dès le premier jour.
.Rproj.user/,.Rhistory,.RDataet les sorties générées n’ont pas leur place dans l’historique —usethis::use_git_ignore()les ajoute au.gitignore. - Publiez en une seule étape.
usethis::use_github()crée le dépôt GitHub, ajoute le dépôt distant et pousse — une fois que vous avez enregistré un jeton. - Les conflits se résolvent dans l’éditeur, pas en ligne de commande. VS Code signale chaque conflit avec les boutons Accept Current / Accept Incoming / Accept Both juste au-dessus des lignes en conflit.
Introduction
Tout projet R — une analyse ponctuelle, une application Shiny, un package — est un dossier de fichiers en texte brut, ce qui en fait un candidat idéal pour Git, le système de gestion de versions qui enregistre l’historique de ces fichiers. La gestion de versions vous offre un filet de sécurité (revenir sur une modification qui a cassé votre analyse), une couche de collaboration (fusionner le travail d’un collègue sans faire circuler analysis_final_v3.R par e-mail) et une sauvegarde hors machine dès que vous poussez vers GitHub.
Si vous écrivez déjà du R dans Visual Studio Code, vous n’avez pas besoin d’un client Git séparé. VS Code est livré avec un panneau Contrôle de code source qui indexe, compare, valide et pousse, et le package usethis gère la configuration propre à R — initialiser le dépôt, écrire un .gitignore adapté à R et créer le dépôt distant GitHub — si bien que vous touchez rarement à une commande Git brute.
Cette leçon fait passer un projet R de l’état non suivi en gestion de versions à l’état poussé sur GitHub, entièrement dans VS Code. Elle suppose que vous avez déjà configuré R dans VS Code. Si Git est totalement nouveau pour vous, la référence canonique centrée sur R est l’ouvrage gratuit Happy Git and GitHub for the useR de Jenny Bryan — cette leçon en est le déroulé côté VS Code.
Installer et configurer Git une bonne fois
Git est un programme distinct de R et de VS Code, alors installez-le en premier.
- Installez Git. Téléchargez-le depuis le site officiel de Git et lancez l’installateur avec les options par défaut. Vérifiez qu’il est bien dans votre
PATHen exécutantgit --versiondans n’importe quel terminal. - Indiquez à Git qui vous êtes. Chaque commit est estampillé d’un nom et d’une adresse e-mail. Définissez-les une fois pour toutes, globalement. Vous pouvez exécuter les commandes Git brutes dans le terminal intégré de VS Code :
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"Ou définissez les mêmes valeurs depuis une console R avec usethis::use_git_config(), ce qui est pratique quand vous êtes déjà dans R :
usethis::use_git_config(
user.name = "Your Name",
user.email = "your.email@example.com"
)À tout moment, vous pouvez demander à usethis un rapport de votre configuration Git et GitHub avec usethis::git_sitrep() (« situation report ») — un moyen rapide de vérifier le nom, l’adresse e-mail et les identifiants que Git utilisera réellement avant de commencer à valider.
Initialiser un dépôt avec usethis
Ouvrez le dossier de votre projet R comme espace de travail VS Code (File → Open Folder…), puis ouvrez un terminal R (Command Palette → R: Create R terminal) et exécutez :
usethis::use_git()use_git() fait ce que font les trois commandes classiques (git init, git add, git commit), mais en une seule étape adaptée à R : il initialise le dépôt .git, indexe les fichiers existants du projet et réalise un commit initial. Il demande confirmation avant de valider et — parce qu’un dépôt tout neuf n’a aucun historique à protéger — peut proposer de redémarrer la session. C’est la manière recommandée de démarrer la gestion de versions pour un projet R, selon le guide de configuration de usethis.
Si vous préférez la voie Git brute, l’équivalent dans le terminal intégré est :
git init
git add .
git commit -m "Initial commit"Dans les deux cas, le projet est désormais un dépôt Git, et le panneau Contrôle de code source de VS Code s’active.
Ignorer ce qui n’a pas sa place dans l’historique
Une session R encombre le répertoire de travail de fichiers qui ne devraient jamais être validés : le cache de projet RStudio (.Rproj.user/), l’historique des commandes (.Rhistory), un espace de travail sauvegardé (.RData), et généralement vos sorties générées et vos données. Les valider alourdit le dépôt et divulgue un état propre à votre machine.
usethis::use_git() écrit pour vous un .gitignore R raisonnable. Pour ajouter d’autres entrées par la suite, utilisez usethis::use_git_ignore() depuis la console R :
usethis::use_git_ignore(c(".Rhistory", ".RData", ".Rproj.user"))Un .gitignore de départ typique pour un projet R ressemble à ceci — vous pouvez aussi le coller directement dans le fichier :
.Rproj.user
.Rhistory
.RData
.Ruserdata
*.Rproj
/data/Gardez les données brutes hors de Git, sauf si elles sont petites et que vous souhaitez les versionner ; les données volumineuses ou sensibles ont leur place dans un stockage dédié, pas dans l’historique de vos commits.
La boucle quotidienne : indexer, comparer, valider
Ouvrez le panneau Contrôle de code source avec l’icône de branche dans la barre d’activités ou Ctrl+Shift+G (Cmd+Shift+G sur macOS). Il liste, sous Changes, chaque fichier que vous avez modifié depuis le dernier commit. Cliquez sur un fichier pour ouvrir un diff côte à côte — suppressions à gauche, ajouts à droite — afin d’examiner exactement ce que vous vous apprêtez à enregistrer.
La boucle quotidienne, c’est trois gestes :
- Indexez les modifications que vous voulez inclure dans ce commit — survolez un fichier et cliquez sur le
+, ou cliquez sur le+à côté de Changes pour tout indexer d’un coup. Les fichiers indexés passent dans un groupe Staged Changes. - Rédigez un message de commit dans la zone en haut. Faites-le court et à l’impératif : « Add outlier check to cleaning script », pas « changes ».
- Validez avec le bouton en forme de coche ou
Ctrl+Enter. Les fichiers indexés sont enregistrés dans l’historique et le panneau se vide.
C’est l’équivalent de git add + git commit -m "…", mais vous voyez le diff avant de valider — ce qui rattrape bien plus souvent le print() oublié par mégarde qu’un git add . à l’aveugle. Le comportement complet du panneau est documenté dans la présentation du Contrôle de code source de VS Code.
Validez petit et souvent. Un commit par modification logique — une modification que vous pourriez décrire en une seule phrase — vous donne un historique réellement lisible et sur lequel revenir, au lieu d’un mur de « misc updates ».
Des branches pour les fonctionnalités et les expérimentations
Une branche vous permet de développer une nouvelle fonctionnalité ou de tenter un remaniement risqué sans perturber votre branche de travail main. VS Code affiche la branche courante dans la barre d’état (en bas à gauche) ; cliquez dessus pour créer une branche ou en changer, ou utilisez la Command Palette (Git: Create Branch… / Git: Checkout to…).
Les équivalents en terminal, si vous les préférez :
git checkout -b feature/new-model # create and switch to a new branch
git checkout main # switch back to mainTravaillez sur la branche, validez comme d’habitude, puis fusionnez-la dans main quand elle est prête — soit localement, soit via une pull request sur GitHub (ci-dessous), qui est la façon révisable de procéder sur un projet partagé.
Pousser vers GitHub
Pour sauvegarder et partager le projet, connectez-le à un dépôt distant sur GitHub. usethis réalise toute la négociation en un seul appel — il crée le dépôt GitHub, l’ajoute comme dépôt distant origin et pousse vos commits :
usethis::use_github()Pour que cela fonctionne, usethis a besoin d’un jeton d’accès personnel (PAT) GitHub — un identifiant qui l’autorise à agir sur votre compte GitHub — enregistré sur votre machine. Créez-en un avec usethis::create_github_token() (cela ouvre la page GitHub avec les bonnes portées pré-sélectionnées), puis enregistrez-le avec gitcreds::gitcreds_set(). Le guide complet et à jour se trouve dans le chapitre Personal access token de Happy Git.
Une fois le dépôt distant en place, vous n’appelez plus use_github() — vous vous contentez de pousser vos nouveaux commits. Dans le panneau Contrôle de code source, utilisez le menu ⋯ → Push (ou Sync Changes, qui tire puis pousse). L’équivalent en terminal est :
git pushSi vous avez d’abord créé le dépôt sur GitHub et que vous voulez le lier à la main plutôt qu’avec use_github(), ajoutez le dépôt distant et poussez une première fois avec l’option upstream :
git remote add origin https://github.com/yourname/your-repo.git
git push -u origin mainRésoudre les conflits de fusion dans l’éditeur
Un conflit de fusion survient quand deux commits modifient les mêmes lignes d’un fichier et que Git ne peut pas décider lesquelles conserver — par exemple, vous et un collègue avez tous deux modifié la même fonction. Git met la fusion en pause et signale le heurt directement dans le fichier avec les marqueurs <<<<<<<, ======= et >>>>>>>.
VS Code transforme ces marqueurs en un résolveur visuel piloté par des boutons. Au-dessus de chaque bloc en conflit, il affiche Accept Current Change, Accept Incoming Change, Accept Both Changes et Compare Changes — cliquez sur celui que vous voulez, ou modifiez le résultat fusionné à la main :
Parcourez chaque fichier en conflit, puis indexez les fichiers résolus et validez pour terminer la fusion — exactement la boucle habituelle indexer-valider vue plus haut. Les outils de résolution de conflits sont décrits dans la documentation VS Code sur les conflits de fusion.
La meilleure façon d’éviter les conflits est de tirer avant de pousser et de garder des branches éphémères, pour que votre copie ne s’éloigne jamais trop de celle des autres.
Optionnel : un historique plus riche avec GitLens
Le panneau intégré couvre tout le flux de travail quotidien. Si vous voulez plus tard une vue plus approfondie de l’historique — qui a modifié une ligne et quand, des annotations blame en ligne, un graphe visuel des commits — installez l’extension GitLens. Elle se superpose au support Git intégré au lieu de le remplacer, si bien que rien de ce qui précède ne change ; vous gagnez simplement des perspectives supplémentaires sur le même dépôt. C’est optionnel : vous pouvez tout à fait gérer les versions de vos projets R sans elle.
Collaborer via GitHub
Une fois votre projet sur GitHub, les fonctionnalités de collaboration se trouvent là-bas, pas dans l’éditeur :
- Pull requests (PR) — une PR propose de fusionner une branche dans une autre et l’ouvre à la revue et à la discussion avant que le code n’arrive. C’est la manière standard de contribuer à un projet partagé.
- Issues — suivez les bugs, les tâches et les demandes de fonctionnalités, et reliez-les aux commits qui les résolvent.
Une boucle typique de projet partagé relie tout cela : usethis::use_git() pour démarrer, une branche de fonctionnalité pour chaque tâche, de petits commits poussés avec Sync Changes, une pull request pour la revue, et une fusion dans main une fois approuvée.
Questions fréquentes
Installez Git et définissez votre nom et votre adresse e-mail une fois pour toutes (git config --global user.name …). Ouvrez le dossier du projet dans VS Code, puis exécutez usethis::use_git() dans le terminal R — il initialise le dépôt et réalise le premier commit. Ensuite, indexez et validez depuis le panneau Contrôle de code source intégré (Ctrl+Shift+G).
Non. Le panneau Contrôle de code source de VS Code indexe, compare, valide, pousse, tire et résout les conflits de fusion via des boutons et des menus — aucune commande Git requise. Les commandes brutes (git add, git commit, git push) fonctionnent toujours dans le terminal intégré si vous les préférez, et les deux opèrent sur le même dépôt.
Au minimum, ignorez le cache RStudio et les fichiers de session : .Rproj.user/, .Rhistory, .RData et .Ruserdata, ainsi que les sorties générées et (généralement) /data/. usethis::use_git() écrit automatiquement un .gitignore R raisonnable, et vous pouvez ajouter d’autres entrées par la suite avec usethis::use_git_ignore().
La voie la plus rapide est usethis::use_github() dans le terminal R — il crée le dépôt GitHub, ajoute le dépôt distant et pousse en une seule étape (il vous faut d’abord un jeton d’accès personnel enregistré). Ensuite, poussez vos nouveaux commits avec Sync Changes ou le menu ⋯ → Push dans le panneau Contrôle de code source.
Ouvrez le fichier en conflit : VS Code met en évidence chaque bloc en conflit avec les boutons Accept Current Change, Accept Incoming Change et Accept Both Changes. Cliquez sur celui que vous voulez (ou modifiez le résultat à la main), puis indexez le fichier résolu et validez pour terminer la fusion — la même boucle indexer-valider que vous utilisez pour toute modification.
Tâche. Vous venez d’écrire un tout nouveau script d’analyse R dans un dossier qui n’est pas encore suivi en gestion de versions. En utilisant uniquement des commandes R depuis le terminal R de VS Code, placez le projet sous Git et assurez-vous que les fichiers de cache RStudio ne soient jamais validés. Que lancez-vous, et que fait chaque appel ?
Une fonction usethis initialise à la fois le dépôt et réalise le premier commit — vous ne devriez pas avoir besoin de git init, git add ni git commit. Une seconde fonction usethis gère les entrées du .gitignore.
Exécutez :
usethis::use_git()
usethis::use_git_ignore(c(".Rhistory", ".RData", ".Rproj.user"))use_git() initialise le dépôt .git, indexe les fichiers existants et réalise le commit initial — remplaçant git init + git add + git commit en un seul appel adapté à R. use_git_ignore() ajoute le cache RStudio et les fichiers de session au .gitignore afin qu’ils ne soient jamais indexés. En pratique, use_git() écrit déjà un .gitignore R raisonnable ; use_git_ignore() est le moyen d’ajouter ce qu’il aurait manqué.
Le commit d’un collègue et le vôtre ont tous deux modifié les mêmes lignes de clean_data.R. Lorsque vous fusionnez, VS Code affiche des boutons au-dessus du bloc en conflit. Quelle action conserve votre version de ces lignes ?
A. Accept Incoming Change (accepter la modification entrante) B. Accept Current Change (accepter la modification actuelle) C. Accept Both Changes (accepter les deux modifications)
B — Accept Current Change. « Current » est la version déjà présente sur votre branche (vos lignes) ; « Incoming » est la version qui arrive de la branche que vous fusionnez. Accept Both Changes (C) conserve les deux ensembles de lignes, l’un après l’autre, que vous nettoyez ensuite à la main.
Conclusion
La gestion de versions des projets R dans VS Code se résume à une boucle courte et répétable : usethis::use_git() pour démarrer, un .gitignore adapté à R pour tenir le bruit à l’écart, et le panneau Contrôle de code source intégré pour indexer, comparer et valider au fil de votre travail — en examinant chaque modification avant qu’elle n’entre dans l’historique. Publiez et sauvegardez avec usethis::use_github(), créez une branche pour tout ce qui est expérimental, et résolvez les rares conflits de fusion avec les boutons Accept Current / Incoming / Both intégrés de VS Code. C’est le flux de travail Git complet, piloté depuis l’éditeur que vous utilisez déjà pour R.
Leçons connexes
- Configurer R dans VS Code — installez R, l’extension vscode-R et les outils sur lesquels repose ce flux de travail. · Développement de packages R dans VS Code — là où la gestion de versions compte le plus, avec toute la boucle
devtoolsautour. · Programmation R interactive dans VS Code — la boucle d’envoi vers la console que vous utilisez pendant que vous écrivez le code à valider. · Configurations VS Code recommandées pour R — des réglages qui fluidifient l’éditeur au quotidien. - Pour aller plus loin : R dans VS Code — la série complète. · Science computationnelle et IA — le pilier.
Cette leçon est un guide reproductible de gestion de versions : chaque commande et chaque réglage montrés ci-dessus sont exactement ce que vous exécutez dans votre propre console R, votre terminal VS Code et votre panneau Contrôle de code source — copiez n’importe quel bloc et exécutez-le pour reproduire ce flux de travail sur votre machine. The runtime is the judge.
Réutilisation
Citation
@online{2026,
author = {},
title = {Gestion de versions avec Git pour les projets R dans VS Code},
date = {2026-07-08},
url = {https://www.datanovia.com/learn/programming/r-in-vscode/version-control-with-git-for-r-projects},
langid = {fr}
}