Écrire des fichiers Excel en R : writexl & openxlsx

Q: Comment écrire un data frame dans un fichier Excel en R ?

Installez et chargez writexl, puis appelez write_xlsx(df, "out.xlsx"). Il crée un .xlsx propre avec vos données, sans Java ni autre dépendance. Relisez-le avec readxl::read_excel("out.xlsx") pour confirmer l’export.

Q: Comment écrire plusieurs feuilles dans un seul fichier Excel en R ?

Passez une liste nommée de data frames : write_xlsx(list(Sheet1 = df1, Sheet2 = df2), "out.xlsx"). Chaque nom devient un onglet. openxlsx::write.xlsx() accepte la même forme de liste nommée. Cela remplace l’ancienne boucle append = TRUE qu’exigeait le package Java xlsx.

Q: Quelle est la différence entre writexl et openxlsx pour écrire dans Excel ?

writexl est minimal et rapide — write_xlsx() exporte des données (et plusieurs feuilles) avec zéro dépendance. openxlsx écrit aussi des .xlsx mais ajoute la mise en forme : en-têtes en gras, couleurs, bordures, ajustement automatique de la largeur, tableaux Excel natifs et une API de classeur cellule par cellule. Utilisez writexl pour un export simple, openxlsx quand l’apparence du fichier compte.

Q: Comment ajouter de la mise en forme ou l’ajustement automatique de la largeur lors d’un export vers Excel en R ?

Utilisez openxlsx : write.xlsx(df, "out.xlsx", asTable = TRUE, headerStyle = createStyle(textDecoration = "bold"), colWidths = "auto"). Pour un contrôle complet, construisez un classeur avec createWorkbook(), addWorksheet(), writeData(), appliquez des styles avec addStyle(), et saveWorkbook(). writexl ne met pas en forme — il écrit uniquement les données.

Q: Comment ajouter un graphique ou une image à un fichier Excel en R ?

Utilisez openxlsx. Rendez d’abord le graphique dans un PNG — png("plot.png"); plot(...); dev.off() (ou ggsave("plot.png", p) pour un ggplot) — puis placez-le avec insertImage(wb, "Sheet", "plot.png", startRow = 2, startCol = 2) et saveWorkbook(). insertPlot() intègre directement le graphique du périphérique courant si vous sautez le fichier. C’est le remplacement moderne, sans Java, de l’ancien xlsx::addPicture().

Q: Devrais-je utiliser le package xlsx pour écrire des fichiers Excel ?

Non. Le package xlsx est basé sur Java (rJava) et échoue fréquemment à s’installer. Utilisez writexl pour des exports simples et openxlsx quand vous avez besoin de mise en forme — tous deux sont en pur R/C++, plus rapides, et s’installent sans JDK.

Exporter un data frame en xlsx — une feuille ou plusieurs onglets nommés en un seul appel

Écrivez des data frames vers Excel (xlsx) en R avec writexl::write_xlsx() et openxlsx::write.xlsx(). Exportez une seule feuille, écrivez plusieurs feuilles à partir d’une liste nommée, ajoutez une mise en forme de base et l’ajustement automatique de la largeur avec openxlsx, et vérifiez le fichier en le relisant — les deux packages côte à côte.

Date de publication

26 juin 2026

Modifié

11 juillet 2026

Points clés

writexl : write_xlsx(df, "out.xlsx") exporte un data frame — zéro dépendance, rapide, pas de Java.
Écrivez plusieurs feuilles en passant une liste nommée : write_xlsx(list(Sheet1 = df1, Sheet2 = df2), "out.xlsx").
openxlsx : write.xlsx(df, "out.xlsx") écrit aussi des fichiers multi-feuilles et ajoute la mise en forme / l’ajustement automatique de la largeur.
Choisissez writexl pour un export propre et léger ; openxlsx quand vous avez besoin de mise en forme dans le classeur.
Vérifiez tout export en le relisant avec read_excel() — l’aller-retour doit vous rendre vos données.

Introduction

Votre analyse est terminée et un collègue veut le résultat sous forme de .xlsx qu’il peut ouvrir dans Excel. L’outil le plus léger et le plus fiable est writexl : une seule fonction, zéro dépendance (pas de Java, pas de Perl), et il écrit un classeur propre rapidement.

Cette leçon exporte des data frames vers Excel de deux façons : une seule feuille, plusieurs feuilles nommées en un seul appel, et un classeur mis en forme. Chaque bloc écrit un vrai fichier et le relit pour prouver que l’export a fonctionné — la même vérification aller-retour que vous devriez exécuter sur vos propres exports.

Deux packages couvrent le domaine :

writexl write_xlsx() — la valeur par défaut moderne pour écrire : minimal, rapide, sans dépendance.
openxlsx write.xlsx() — quand vous avez aussi besoin de mise en forme, d’ajustement automatique de la largeur, ou de construire le classeur cellule par cellule.

Écrire une seule feuille avec writexl

write_xlsx() prend le data frame et un chemin. Ici nous écrivons iris dans un fichier temporaire pour que la page s’exécute partout — remplacez le chemin par le vôtre (par ex. "results.xlsx").

library(writexl)
out_path <- tempfile(fileext = ".xlsx")   # your own path goes here: "results.xlsx"
write_xlsx(iris, out_path)
file.exists(out_path)

[1] TRUE

Voilà toute la recette : write_xlsx(df, "results.xlsx") et vous avez un fichier Excel. Par défaut, les noms de lignes sont abandonnés (les utilisateurs d’Excel les veulent rarement) et les noms de colonnes deviennent la ligne d’en-tête.

Vérifier l’aller-retour

Relisez toujours un export pour confirmer qu’il s’est bien déroulé — en particulier les noms et les types de colonnes.

library(readxl)
read_excel(out_path)

# A tibble: 150 × 5
   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
          <dbl>       <dbl>        <dbl>       <dbl> <chr>  
 1          5.1         3.5          1.4         0.2 setosa 
 2          4.9         3            1.4         0.2 setosa 
 3          4.7         3.2          1.3         0.2 setosa 
 4          4.6         3.1          1.5         0.2 setosa 
 5          5           3.6          1.4         0.2 setosa 
 6          5.4         3.9          1.7         0.4 setosa 
 7          4.6         3.4          1.4         0.3 setosa 
 8          5           3.4          1.5         0.2 setosa 
 9          4.4         2.9          1.4         0.2 setosa 
10          4.9         3.1          1.5         0.1 setosa 
# ℹ 140 more rows

Les données reviennent inchangées : mêmes colonnes, mêmes valeurs. L’aller-retour est votre vérification de cohérence la moins coûteuse.

Écrire plusieurs feuilles — passer une liste nommée

Pour mettre plusieurs data frames dans un seul classeur, donnez à write_xlsx() une liste nommée. Chaque nom devient un nom de feuille (onglet) ; chaque élément devient le contenu de cet onglet.

library(writexl)
multi_path <- tempfile(fileext = ".xlsx")
write_xlsx(
  list(
    flowers = head(iris, 5),
    cars    = head(mtcars[, 1:4], 4)
  ),
  multi_path
)

# confirm both tabs exist
readxl::excel_sheets(multi_path)

[1] "flowers" "cars"

Les noms de la liste sont les noms de feuilles — gardez-les courts et conformes à Excel (pas de []:*?/\\, ≤31 caractères). Cet appel unique remplace la boucle répétitive append = TRUE qu’exigeait l’ancien package Java xlsx.

Écrire avec openxlsx — plusieurs feuilles et mise en forme

openxlsx écrit également des .xlsx, et ajoute de la mise en forme. La voie rapide reflète writexl : passez un data frame, ou une liste nommée pour plusieurs feuilles.

library(openxlsx)
ox_path <- tempfile(fileext = ".xlsx")
write.xlsx(
  list(USA = head(USArrests, 4), Plants = head(PlantGrowth, 4)),
  file = ox_path
)
getSheetNames(ox_path)

[1] "USA"    "Plants"

Pour un rapport soigné — en-têtes en gras, colonnes ajustées automatiquement — write.xlsx() prend directement des arguments de mise en forme :

library(openxlsx)
styled_path <- tempfile(fileext = ".xlsx")
write.xlsx(
  head(iris, 6),
  file       = styled_path,
  asTable    = TRUE,                                  # write as a filterable Excel table
  headerStyle = createStyle(textDecoration = "bold"), # bold header row
  colWidths  = "auto"                                 # auto-fit column widths
)
file.exists(styled_path)

[1] TRUE

asTable = TRUE en fait un tableau Excel natif (triable/filtrable) ; createStyle() contrôle les polices, les remplissages et les bordures ; colWidths = "auto" dimensionne les colonnes selon leur contenu. Pour un contrôle complet cellule par cellule, construisez un classeur avec createWorkbook() + addWorksheet() + writeData() + saveWorkbook().

Ajouter un graphique à une feuille de calcul

Les rapports ont souvent besoin de la figure à côté des chiffres. openxlsx le fait en deux étapes : rendre le graphique dans un PNG temporaire, puis insertImage() place ce PNG dans une feuille à un ancrage de cellule (startRow / startCol), dimensionné en pouces (width / height).

library(openxlsx)
# 1. save the plot to a temporary PNG
png(img <- tempfile(fileext = ".png"), width = 1000, height = 700, res = 120)
plot(mtcars$wt, mtcars$mpg, pch = 19, col = "#3a86d4",
     xlab = "Weight (1000 lbs)", ylab = "Miles per gallon")
invisible(dev.off())   # invisible(): dev.off() prints a platform-varying device id
# 2. build a workbook, embed the image, save
wb <- createWorkbook()
addWorksheet(wb, "Plot")
insertImage(wb, "Plot", img, width = 5, height = 3.5, startRow = 2, startCol = 2)
path <- tempfile(fileext = ".xlsx")
saveWorkbook(wb, path, overwrite = TRUE)
file.exists(path)

[1] TRUE

Le classeur contient maintenant votre nuage de points intégré dans la feuille Plot ; ouvrez-le dans Excel et l’image se trouve en B2. Un ggplot fonctionne de la même façon — enregistrez-le avec ggsave("plot.png", p, width = 5, height = 3.5), puis passez ce PNG à insertImage().

Si vous venez de tracer un graphique et ne voulez pas du fichier intermédiaire, insertPlot(wb, "Plot", width = 5, height = 3.5) intègre directement le graphique du périphérique graphique courant. C’est une commande en une ligne bien pratique, mais elle dépend de l’état du périphérique, donc la recette png() + insertImage() ci-dessus est la voie la plus fiable.

writexl ou openxlsx — lequel utiliser

                               Need            writexl           openxlsx
1                Plain, fast export yes — write_xlsx() yes — write.xlsx()
2                   Multiple sheets   yes — named list   yes — named list
3 Bold/coloured headers, auto-width                 no                yes
4      Cell-by-cell report building                 no yes (workbook API)
5                      Dependencies none (lightweight)     none (no Java)

Les deux évitent Java, donc les deux s’installent proprement. Utilisez writexl quand vous avez juste besoin des données dans une feuille ; tournez-vous vers openxlsx quand le classeur lui-même doit avoir une certaine apparence.

Essayez en direct

Les blocs ci-dessus se sont exécutés au moment de la compilation. Modifiez celui-ci et appuyez sur Run — il écrit un classeur à deux feuilles, puis le relit pour vérifier, entièrement dans votre navigateur via webR (sans installation).

🟢 Avec un agent IA

Dites à Prova « exporte ces trois data frames vers un seul fichier Excel, un par onglet » et elle écrit l’appel write_xlsx(list(...)). Parce que le runtime est juste ici, vous l’exécutez et relisez le fichier pour confirmer que les trois onglets sont bien arrivés — une preuve qu’une réponse en texte ne peut pas vous donner. Demander à Prova →

Vous travaillez en Python ? Un guide pandas to_excel arrive dans la série Python.

Problèmes courants

« Permission denied » à l’écriture. Excel verrouille un fichier tant qu’il est ouvert. Fermez le classeur dans Excel avant de réexécuter write_xlsx(), ou écrivez vers un nouveau chemin. La même chose s’applique si le fichier est synchronisé et momentanément verrouillé par OneDrive/Dropbox.

Vos noms de feuilles ont été tronqués ou renommés. Les noms de feuilles Excel doivent faire ≤31 caractères et ne peuvent pas contenir [ ] : * ? / \. Les deux packages corrigent silencieusement les noms illégaux — gardez les noms de la liste courts et propres pour contrôler le résultat.

Les noms de lignes sont absents (ou vous les vouliez). write_xlsx() n’écrit jamais les noms de lignes. S’ils comptent (par ex. les noms de voitures de mtcars), placez-les d’abord dans une vraie colonne : df$id <- rownames(df) avant d’écrire. openxlsx a un argument rowNames = TRUE si vous préférez.

Vous avez utilisé l’ancien xlsx::write.xlsx et rencontré des erreurs Java. Le package xlsx basé sur Java nécessite rJava/JDK et échoue souvent à s’installer. Passez à writexl::write_xlsx() (léger) ou openxlsx::write.xlsx() (mise en forme) — tous deux sont en pur R/C++.

Questions fréquentes

Comment écrire un data frame dans un fichier Excel en R ?

Installez et chargez writexl, puis appelez write_xlsx(df, "out.xlsx"). Il crée un .xlsx propre avec vos données, sans Java ni autre dépendance. Relisez-le avec readxl::read_excel("out.xlsx") pour confirmer l’export.

Comment écrire plusieurs feuilles dans un seul fichier Excel en R ?

Passez une liste nommée de data frames : write_xlsx(list(Sheet1 = df1, Sheet2 = df2), "out.xlsx"). Chaque nom devient un onglet. openxlsx::write.xlsx() accepte la même forme de liste nommée. Cela remplace l’ancienne boucle append = TRUE qu’exigeait le package Java xlsx.

Quelle est la différence entre writexl et openxlsx pour écrire dans Excel ?

writexl est minimal et rapide — write_xlsx() exporte des données (et plusieurs feuilles) avec zéro dépendance. openxlsx écrit aussi des .xlsx mais ajoute la mise en forme : en-têtes en gras, couleurs, bordures, ajustement automatique de la largeur, tableaux Excel natifs et une API de classeur cellule par cellule. Utilisez writexl pour un export simple, openxlsx quand l’apparence du fichier compte.

Comment ajouter de la mise en forme ou l’ajustement automatique de la largeur lors d’un export vers Excel en R ?

Utilisez openxlsx : write.xlsx(df, "out.xlsx", asTable = TRUE, headerStyle = createStyle(textDecoration = "bold"), colWidths = "auto"). Pour un contrôle complet, construisez un classeur avec createWorkbook(), addWorksheet(), writeData(), appliquez des styles avec addStyle(), et saveWorkbook(). writexl ne met pas en forme — il écrit uniquement les données.

Comment ajouter un graphique ou une image à un fichier Excel en R ?

Utilisez openxlsx. Rendez d’abord le graphique dans un PNG — png("plot.png"); plot(...); dev.off() (ou ggsave("plot.png", p) pour un ggplot) — puis placez-le avec insertImage(wb, "Sheet", "plot.png", startRow = 2, startCol = 2) et saveWorkbook(). insertPlot() intègre directement le graphique du périphérique courant si vous sautez le fichier. C’est le remplacement moderne, sans Java, de l’ancien xlsx::addPicture().

Devrais-je utiliser le package xlsx pour écrire des fichiers Excel ?

Non. Le package xlsx est basé sur Java (rJava) et échoue fréquemment à s’installer. Utilisez writexl pour des exports simples et openxlsx quand vous avez besoin de mise en forme — tous deux sont en pur R/C++, plus rapides, et s’installent sans JDK.

Testez vos connaissances

Exercice : écrire deux feuilles, puis vérifier

Écrivez iris (5 premières lignes) et mtcars (4 premières lignes, colonnes 1–3) dans un seul classeur sous forme d’onglets "flowers" et "cars". Puis relisez l’onglet "cars" pour confirmer l’export.

library(writexl)
library(readxl)

path <- tempfile(fileext = ".xlsx")

write_xlsx(list(flowers = head(iris, 5), cars = head(mtcars[, 1:3], 4)), path)

read_excel(path, sheet = "cars")   # mpg, cyl, disp

Vérification rapide : comment écrire deux feuilles en un seul appel ?

Vous voulez df1 sur un onglet nommé "raw" et df2 sur "clean", dans un seul fichier. Lequel est correct ?

A. write_xlsx(df1, df2, "out.xlsx") B. write_xlsx(list(raw = df1, clean = df2), "out.xlsx") C. write_xlsx(c(df1, df2), "out.xlsx")

Afficher la réponse

B. write_xlsx() prend un seul objet puis le chemin ; pour plusieurs feuilles cet objet est une liste nommée, et les noms deviennent les noms d’onglets. A passe deux data frames comme arguments distincts (le 2e est lu comme le chemin). C concatène les data frames en un seul objet et perd la structure des feuilles.

Conclusion

Écrire dans Excel depuis R tient en une ligne avec writexl : write_xlsx(df, "out.xlsx"), et write_xlsx(list(...), ...) pour plusieurs feuilles nommées. Passez à openxlsx quand le classeur a besoin de mise en forme, d’ajustement automatique de la largeur, ou de tableaux natifs. Quel que soit votre choix, relisez le fichier avec read_excel() pour vérifier — et laissez de côté le package xlsx basé sur Java.

Leçons connexes

Lire des fichiers Excel en R — importer un .xls/.xlsx dans un data frame. · Lire des fichiers CSV & texte en R — la voie des fichiers plats avec readr / base R. · Enregistrer RDS & RData — stocker des objets R natifs pour un rechargement instantané. · Exporter des données depuis R — la vue d’ensemble complète sur la sortie des données.
Aller plus loin : Importer & Exporter des données — la série complète. · Science computationnelle & 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 = {Écrire des fichiers Excel en R : writexl \& openxlsx},
  date = {2026-06-26},
  url = {https://www.datanovia.com/learn/programming/importing-exporting-data/write-excel-files-in-r},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Écrire des fichiers Excel en R : writexl & openxlsx.” 2026. June 26. https://www.datanovia.com/learn/programming/importing-exporting-data/write-excel-files-in-r.