Sauvegarder RDS et RData en R : saveRDS, readRDS, save, load

Q: Comment sauvegarder un objet R dans un fichier ?

Pour un objet unique, utilisez saveRDS(my_object, "my_object.rds") et relisez-le avec my_object <- readRDS("my_object.rds"). Pour plusieurs objets à la fois, utilisez save(a, b, file = "data.RData") et restaurez-les avec load("data.RData"). Les formats natifs de R conservent les types, facteurs et attributs que CSV perd.

Q: Quelle est la différence entre .rds et .RData ?

Un fichier .rds contient un seul objet, et vous lui assignez le nom que vous voulez quand vous le lisez avec readRDS(). Un fichier .RData contient un ou plusieurs objets, et load() les restaure sous leurs noms d’origine. Préférez .rds pour un objet unique (nommage explicite, pas d’écrasement accidentel) ; utilisez .RData pour regrouper des objets liés ou faire un point de sauvegarde d’un espace de travail.

Q: Quelle est la différence entre saveRDS et save ?

saveRDS() écrit un objet ; readRDS() le retourne pour que vous l’assigniez — le nom est votre choix. save() écrit un nombre quelconque d’objets nommés ; load() les restaure dans l’environnement sous leurs noms sauvegardés (sans assignation, et il peut écraser des variables existantes). Utilisez saveRDS pour un objet unique, save pour un lot.

Q: Pourquoi readRDS a-t-il besoin d’une assignation alors que load n’en a pas besoin ?

readRDS() retourne l’objet, vous le capturez donc avec x <- readRDS("file.rds"). load() fonctionne différemment : il restaure les objets sauvegardés directement dans votre environnement sous leurs noms d’origine, si bien qu’il ne retourne que les noms qu’il a créés — il n’y a rien à assigner.

Q: Comment sauvegarder mon espace de travail R entier ?

Utilisez save.image("workspace.RData") pour écrire chaque objet actuellement en mémoire, puis load("workspace.RData") pour les restaurer. Appelé sans nom de fichier, save.image() écrit dans .RData dans votre répertoire de travail — le fichier que R propose de recharger au démarrage. Pour partager ou réexécuter, sauvegardez plutôt les objets précis dont vous avez besoin que l’espace de travail entier.

Stockez des objets R sur disque et rechargez-les avec leurs types et facteurs intacts

Sauvegardez des objets R sur disque et restaurez-les avec saveRDS()/readRDS() (un seul objet, que vous nommez à la lecture) ou save()/load() (plusieurs objets nommés, restaurés dans l’environnement), plus save.image() pour l’espace de travail entier. Apprenez la différence .rds vs .RData, la compression, et lequel utiliser pour des pipelines reproductibles.

Date de publication

26 juin 2026

Modifié

7 juillet 2026

Points clés

saveRDS(obj, "x.rds") + readRDS("x.rds") sauvegardent un seul objet — vous lui assignez le nom que vous voulez à la lecture.
save(a, b, file = "x.RData") + load("x.RData") sauvegardent plusieurs objets — leurs noms d’origine sont restaurés.
Le contraste essentiel : .rds = un objet, c’est vous qui le nommez (plus sûr, explicite) ; .RData = plusieurs objets, noms figés dans le fichier.
save.image("ws.RData") stocke votre espace de travail entier — chaque objet actuellement en mémoire.
Les formats natifs de R préservent les types, facteurs et attributs que CSV/Excel perdent, et compressent vers un fichier plus petit.

Introduction

Vous avez nettoyé un jeu de données, ajusté un modèle, construit une liste — et vous voulez le retrouver à la prochaine session exactement tel quel, sans tout réexécuter. Écrire vers CSV ou Excel perd la structure : les facteurs deviennent du texte, les types de colonnes dérivent, et un modèle ajusté n’a tout simplement pas sa place dans un tableur. Les formats natifs de R conservent tout et compressent le fichier.

Il existe trois outils, et le choix entre eux constitue toute la leçon :

saveRDS() / readRDS() — sauvegardent un seul objet ; vous choisissez son nom au moment de le relire.
save() / load() — sauvegardent un ou plusieurs objets ; leurs noms reviennent exactement tels qu’ils étaient.
save.image() — sauvegarde votre espace de travail entier en un seul appel.

Cette leçon présente chacun avec un aller-retour autonome — sauvegarder, relire, confirmer que c’est identique — pour que le code s’exécute ici comme dans votre navigateur.

Sauvegarder un seul objet — `saveRDS()` et `readRDS()`

saveRDS() écrit un unique objet R dans un fichier .rds. readRDS() le relit et le retourne — vous l’assignez donc au nom que vous voulez. C’est sa caractéristique déterminante : le nom vit dans votre code, pas dans le fichier.

rds_path <- tempfile(fileext = ".rds")        # your own path: "cars.rds"

# save one object
saveRDS(mtcars, rds_path)

# read it back — assign it any name you want
my_cars <- readRDS(rds_path)
head(my_cars, 3)

               mpg cyl disp  hp drat    wt  qsec vs am gear carb
Mazda RX4     21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
Mazda RX4 Wag 21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
Datsun 710    22.8   4  108  93 3.85 2.320 18.61  1  1    4    1

Vous avez sauvegardé mtcars et l’avez relu sous le nom my_cars. Rien dans le fichier n’impose le nom — readRDS() vous remet l’objet et c’est vous qui décidez. Cela fait de .rds le choix sûr dans les scripts : relire un objet n’écrase jamais silencieusement une variable que vous avez déjà.

Les types et les facteurs survivent

C’est la raison d’utiliser un format natif plutôt que CSV. Un facteur reste un facteur ; un entier reste un entier :

df <- data.frame(
  group = factor(c("low", "high", "low")),
  score = c(10L, 20L, 30L)
)
p <- tempfile(fileext = ".rds")
saveRDS(df, p)

back <- readRDS(p)
identical(back, df)        # TRUE — structure preserved exactly

[1] TRUE

identical() retourne TRUE : l’objet restauré correspond à l’original jusqu’aux niveaux du facteur et au type entier — autant d’éléments qu’un aller-retour CSV ne conserverait pas.

Sauvegarder plusieurs objets — `save()` et `load()`

save() écrit un ou plusieurs objets dans un unique fichier .RData (ou .rda). load() les relit — mais voici la différence avec readRDS() : il ne les retourne pas pour que vous les assigniez. Il les restaure dans votre environnement sous leurs noms d’origine.

flowers <- head(iris, 3)
cars    <- head(mtcars, 3)
rdata_path <- tempfile(fileext = ".RData")

# save two objects together
save(flowers, cars, file = rdata_path)

# wipe them, then load — they come back by their original names
rm(flowers, cars)
load(rdata_path)

ls()                       # flowers and cars are back

 [1] "back"            "cars"            "df"              "flowers"        
 [5] "my_cars"         "p"               "pandoc_dir"      "quarto_bin_path"
 [9] "rdata_path"      "rds_path"

Après load(), flowers et cars existent de nouveau — vous ne les avez pas (et ne pouvez pas les) renommer au passage. load() retourne les noms qu’il a restaurés (un vecteur de caractères), ce qui explique pourquoi l’assigner (x <- load(...)) vous donne les noms, pas les données.

Avertissement

Comme load() restaure directement les noms, il peut écraser silencieusement des objets que vous avez déjà en mémoire portant le même nom. readRDS() ne peut pas faire cela — une raison de plus de préférer .rds pour un objet unique dans les scripts que vous réexécutez.

Sauvegarder l’espace de travail entier — `save.image()`

save.image() est save() appliqué à tout ce qui se trouve actuellement en mémoire. C’est ce que RStudio propose de faire quand vous quittez (« Save workspace image? »). Donnez-lui un nom de fichier pour être explicite :

ws_path <- tempfile(fileext = ".RData")
save.image(file = ws_path)
file.exists(ws_path)

[1] TRUE

load(ws_path) restaure ensuite chaque objet. Appelé sans argument, save.image() écrit dans un fichier littéralement nommé .RData dans votre répertoire de travail, que R propose de recharger au démarrage suivant. Utilisez-le pour faire un point de sauvegarde d’une longue session — mais pour tout ce que vous partagerez ou réexécuterez, sauvegardez les objets précis dont vous avez besoin, pas l’espace de travail entier (souvent encombré).

`.rds` vs `.RData` — lequel utiliser

	`.rds` (`saveRDS`)	`.RData` (`save`)
Combien d’objets	exactement un	un ou plusieurs
Nom à la lecture	vous le choisissez (`x <- readRDS()`)	noms d’origine restaurés
Peut écraser une variable silencieusement	non	oui
Fonction de lecture	`readRDS()` (retourne l’objet)	`load()` (restaure dans l’env)
Idéal pour	un objet unique dans un pipeline	un lot d’objets liés, un espace de travail

La règle générale : un objet → .rds (explicite, sûr, le choix pour les pipelines reproductibles et les résultats intermédiaires) ; un lot d’objets liés ou un point de sauvegarde de session → .RData. En cas de doute, préférez .rds — être obligé de nommer l’objet que vous lisez rend les scripts plus clairs et évite les écrasements accidentels.

Compression

Les deux formats compressent par défaut, si bien qu’un objet sauvegardé est souvent plus petit que son CSV. Vous pouvez échanger un peu de taille contre de la vitesse en désactivant la compression sur saveRDS() :

big <- data.frame(a = rnorm(5000), b = rnorm(5000))

compressed   <- tempfile(fileext = ".rds"); saveRDS(big, compressed)
uncompressed <- tempfile(fileext = ".rds"); saveRDS(big, uncompressed, compress = FALSE)

c(compressed = file.size(compressed), uncompressed = file.size(uncompressed))

  compressed uncompressed 
       76955        80186

Le défaut (compress = TRUE) donne le fichier le plus petit ; compress = FALSE écrit plus vite mais plus volumineux. Pour la plupart des données, le défaut est le bon choix. Pour de très gros objets où la vitesse de sauvegarde/chargement compte, le paquet qs est une alternative moderne plus rapide qu’il est bon de connaître.

Essayez en direct

Les blocs ci-dessus se sont exécutés au moment de la construction. Modifiez celui-ci et appuyez sur Run — il sauvegarde un objet des deux façons et relit chacun, entièrement dans votre navigateur via webR (aucune installation).

🟢 Avec un agent IA

Demandez à Prova « devrais-je sauvegarder ceci en .rds ou en .RData ? » avec une ligne sur ce que vous stockez — elle explique le compromis pour votre cas et écrit l’appel, et comme le runtime est juste là, vous exécutez l’aller-retour pour confirmer que l’objet revient identique. Demander à Prova →

Problèmes courants

readRDS() a retourné l’objet mais « rien ne s’est passé ». readRDS() retourne l’objet — vous devez l’assigner : x <- readRDS("file.rds"). Appeler readRDS("file.rds") seul ne fait que l’afficher avant de le jeter. C’est l’inverse de load(), qui restaure directement les noms sans assignation.

load() a écrasé une variable que j’utilisais. load() restaure les objets sous leurs noms sauvegardés, remplaçant silencieusement tout ce qui se trouve en mémoire sous le même nom. Sauvegardez plutôt un objet unique avec saveRDS()/readRDS(), ainsi vous contrôlez le nom à la lecture ; ou faites load() dans un nouvel environnement : e <- new.env(); load("x.RData", envir = e).

x <- load("file.RData") m’a donné des noms, pas les données. load() retourne le vecteur de caractères des noms qu’il a restaurés, pas les objets — les objets atterrissent directement dans votre environnement. Si vous voulez une valeur à assigner, vous avez sauvegardé de la mauvaise façon : utilisez saveRDS() pour que readRDS() retourne l’objet.

Questions fréquentes

Comment sauvegarder un objet R dans un fichier ?

Pour un objet unique, utilisez saveRDS(my_object, "my_object.rds") et relisez-le avec my_object <- readRDS("my_object.rds"). Pour plusieurs objets à la fois, utilisez save(a, b, file = "data.RData") et restaurez-les avec load("data.RData"). Les formats natifs de R conservent les types, facteurs et attributs que CSV perd.

Quelle est la différence entre .rds et .RData ?

Un fichier .rds contient un seul objet, et vous lui assignez le nom que vous voulez quand vous le lisez avec readRDS(). Un fichier .RData contient un ou plusieurs objets, et load() les restaure sous leurs noms d’origine. Préférez .rds pour un objet unique (nommage explicite, pas d’écrasement accidentel) ; utilisez .RData pour regrouper des objets liés ou faire un point de sauvegarde d’un espace de travail.

Quelle est la différence entre saveRDS et save ?

saveRDS() écrit un objet ; readRDS() le retourne pour que vous l’assigniez — le nom est votre choix. save() écrit un nombre quelconque d’objets nommés ; load() les restaure dans l’environnement sous leurs noms sauvegardés (sans assignation, et il peut écraser des variables existantes). Utilisez saveRDS pour un objet unique, save pour un lot.

Pourquoi readRDS a-t-il besoin d’une assignation alors que load n’en a pas besoin ?

readRDS() retourne l’objet, vous le capturez donc avec x <- readRDS("file.rds"). load() fonctionne différemment : il restaure les objets sauvegardés directement dans votre environnement sous leurs noms d’origine, si bien qu’il ne retourne que les noms qu’il a créés — il n’y a rien à assigner.

Comment sauvegarder mon espace de travail R entier ?

Utilisez save.image("workspace.RData") pour écrire chaque objet actuellement en mémoire, puis load("workspace.RData") pour les restaurer. Appelé sans nom de fichier, save.image() écrit dans .RData dans votre répertoire de travail — le fichier que R propose de recharger au démarrage. Pour partager ou réexécuter, sauvegardez plutôt les objets précis dont vous avez besoin que l’espace de travail entier.

Testez vos connaissances

Exercice : aller-retour des deux façons

Sauvegardez iris en .rds, relisez-le sous un nouveau nom, et confirmez qu’il est identique. Puis sauvegardez iris et mtcars ensemble en .RData, supprimez-les, faites load(), et confirmez que les deux sont revenus.

# 1. one object → .rds
rds_path <- tempfile(fileext = ".rds")
saveRDS(iris, rds_path)
flowers <- readRDS(rds_path)
print(identical(flowers, iris))            # TRUE

# 2. two objects → .RData
rdata_path <- tempfile(fileext = ".RData")
save(iris, mtcars, file = rdata_path)
rm(iris, mtcars)
load(rdata_path)
print(c(iris = exists("iris"), mtcars = exists("mtcars")))  # both TRUE

Vérification rapide : lequel sauvegarde UN objet que vous pouvez renommer à la lecture ?

Vous voulez stocker un seul data frame nettoyé et le relire sous le nom df. Lequel est correct ?

A. save(clean, file = "clean.RData"), puis load("clean.RData") B. saveRDS(clean, "clean.rds"), puis df <- readRDS("clean.rds") C. save.image("clean.RData"), puis load("clean.RData")

Afficher la réponse

B. saveRDS()/readRDS() stockent un objet et vous laissent le nommer à la lecture — df <- readRDS(...). A restaure l’objet sous son nom sauvegardé clean (vous ne pouvez pas le renommer). C sauvegarde votre espace de travail entier, bien plus qu’un seul objet.

Conclusion

Les formats natifs de R sauvegardent les objets avec leur structure intacte et compressent le fichier. Utilisez saveRDS()/readRDS() pour un seul objet — vous le nommez à la lecture, ce qui garde les scripts explicites et évite les écrasements accidentels, ce qui en fait le choix pour les pipelines et les résultats intermédiaires. Utilisez save()/load() pour regrouper plusieurs objets nommés, et save.image() pour faire un point de sauvegarde d’une session entière. En cas de doute, optez pour .rds.

Leçons connexes

Exporter des données depuis R — l’aperçu complet de la sortie de données, y compris write.csv pour partager avec d’autres outils. · Lire des fichiers CSV et texte en R — recharger des fichiers plats. · Lire des fichiers Excel en R — la voie readxl / openxlsx pour les tableurs. · Renommer des colonnes en R — nettoyer un objet avant de le sauvegarder.
Pour aller plus loin : Importer et exporter des données — la série complète. · Science computationnelle et IA — le pilier.

Cette page vous a-t-elle été utile ?

Prouvez que vous savez le faire. Maîtrisez toute la série Importer et exporter des données en R — suivez votre parcours, construisez des projets et obtenez un certificat.

Commencer gratuitement →

Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.

dès 15 $/mois facturé annuellement

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Note

Cette leçon est reproductible : chaque résultat de cette page a été produit par le code affiché — modifiez n’importe quel bloc et appuyez sur Run pour le reproduire dans votre navigateur. The runtime is the judge.

Réutilisation

CC BY-NC-SA 4.0

Citation

BibTeX

@online{2026,
  author = {},
  title = {Sauvegarder RDS et RData en R : saveRDS, readRDS, save, load},
  date = {2026-06-26},
  url = {https://www.datanovia.com/learn/programming/importing-exporting-data/save-rds-rdata},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Sauvegarder RDS et RData en R : saveRDS, readRDS, save, load.” 2026. June 26. https://www.datanovia.com/learn/programming/importing-exporting-data/save-rds-rdata.