Le package xlsx dans R : mettre en forme et créer des rapports Excel riches

Q: Comment ajouter un titre, un tableau ou un graphique à un fichier Excel dans R ?

Utilisez le package xlsx. Créez un classeur avec createWorkbook(), ajoutez une feuille avec createSheet(), définissez des styles avec CellStyle() + Font()/Alignment()/Border(), puis écrivez un titre dans une cellule, ajoutez un tableau avec addDataFrame(), et intégrez un graphique avec addPicture() (après l’avoir enregistré en PNG). Enfin, appelez saveWorkbook(). L’assistant r2excel condense chacune de ces étapes en un seul appel — xlsx.addHeader(), xlsx.addTable() et xlsx.addPlot().

Q: Qu’est-ce que le package r2excel ?

r2excel est un wrapper de commodité par-dessus xlsx qui transforme ses recettes de mise en forme verbeuses en une ligne — xlsx.addHeader(), xlsx.addParagraph(), xlsx.addTable(), xlsx.addPlot() et xlsx.addHyperlink(). Installez-le depuis GitHub avec devtools::install_github("kassambara/r2excel"). Comme il dépend de xlsx, il est lui aussi basé sur Java.

Q: Faut-il utiliser xlsx ou openxlsx dans R ?

Utilisez openxlsx (ou readxl/writexl) pour la lecture et l’écriture quotidiennes — aucun d’eux n’a besoin de Java, et ils sont rapides. Utilisez xlsx lorsque vous avez besoin de sa mise en forme riche au niveau des cellules et que vous êtes à l’aise pour installer Java. En bref : lecture/écriture sans Java → openxlsx ; mise en forme poussée avec Java disponible → xlsx.

Q: Pourquoi le package xlsx a-t-il besoin de Java ?

xlsx repose sur Apache POI, une bibliothèque Java pour lire et écrire des fichiers Microsoft Office, et il communique avec elle via le pont rJava. Voilà pourquoi il vous faut un runtime Java fonctionnel installé pour que le package se charge — et pourquoi il ne peut pas s’exécuter dans un navigateur ni dans un environnement sans Java. Les alternatives sans Java (readxl, writexl, openxlsx) évitent tout cela.

Q: Comment écrire plusieurs feuilles dans un seul classeur Excel avec xlsx ?

Appelez write.xlsx() une fois par jeu de données, en passant append = TRUE à chaque appel après le premier, chacun avec son propre sheetName. Pour le faire en un seul appel, utilisez l’assistant xlsx.writeMultipleData() présenté ci-dessus (également disponible dans r2excel), qui nomme chaque feuille d’après l’objet que vous lui passez.

La boîte à outils Java pour les styles de cellules, les titres, les tableaux mis en forme, les graphiques intégrés et les rapports multi-feuilles

Programming

Un guide de référence sur le package R xlsx — la boîte à outils Java pour la mise en forme Excel riche au niveau des cellules que writexl et openxlsx ne font pas aussi facilement : titres et sous-titres, styles de cellules, tableaux mis en forme, graphiques intégrés, hyperliens et rapports multi-feuilles. Inclut l’assistant r2excel qui condense tout cela en une ligne. Pour la lecture/écriture quotidienne sans Java, les leçons modernes sont liées en références croisées.

Auteur·rice

Alboukadel Kassambara

Date de publication

10 juillet 2026

Modifié

18 juillet 2026

Ce que vous allez apprendre

Lire et écrire des feuilles Excel avec le package xlsx (les bases — brièvement, puis nous renvoyons vers la voie moderne).
Écrire plusieurs jeux de données dans un même classeur en un seul appel.
La vraie raison de recourir à xlsx : la mise en forme riche au niveau des cellules — titres et sous-titres, styles de cellules, tableaux mis en forme, graphiques intégrés et rapports multi-feuilles.
L’assistant r2excel qui condense tout ce codage manuel en une ligne (xlsx.addHeader, xlsx.addTable, xlsx.addPlot, xlsx.addHyperlink).

La plupart du temps, tout ce que vous voulez, c’est faire entrer ou sortir un data frame d’un fichier .xlsx — et pour cela, les packages modernes sans Java sont l’outil adapté (nous les couvrons dans les leçons liées ci-dessous). Mais de temps à autre, vous devez remettre à un client ou à un collègue un rapport Excel mis en forme : une feuille avec un titre, une ligne d’en-tête stylisée, un tableau avec des bordures, un graphique glissé juste à côté. C’est précisément là que le package xlsx garde toute sa valeur.

xlsx est un package R complet pour lire, écrire et — ce qui le distingue — mettre en forme des fichiers Excel avec un contrôle jusqu’à la cellule individuelle. Il gère à la fois l’ancien format .xls et le format moderne .xlsx.

Une réserve en toute honnêteté : il faut Java

xlsx est un package basé sur Java. Il dépend de rJava et de xlsxjars, ce qui signifie qu’il vous faut une installation Java fonctionnelle sur votre machine pour qu’il se charge. C’est la contrepartie de sa puissance de mise en forme, et c’est la raison pour laquelle il ne s’exécute pas dans un bac à sable de navigateur ni dans un environnement léger sans Java.

Voici donc le positionnement honnête :

Pour la lecture/écriture quotidienne, sans Java — importer une feuille dans un data frame, ou en réexporter un — recourez aux packages modernes readxl, writexl et openxlsx. Ils n’ont aucune dépendance externe et ils sont rapides. Voir les leçons pas à pas : Lire des fichiers Excel dans R et Écrire des fichiers Excel dans R.
Pour une mise en forme riche au niveau des cellules — titres stylisés, tableaux bordés, graphiques intégrés, rapports multi-feuilles — xlsx (et l’assistant r2excel ci-dessous) fait encore des choses que ces packages ne font pas aussi facilement. C’est le sujet de cette référence.

Note

Il s’agit d’une référence statique : le code ci-dessous est prêt à copier-coller pour s’exécuter dans votre propre session R (avec Java installé), mais il n’y a pas de bac à sable interactif dans le navigateur sur cette page — xlsx a besoin de Java, ce qu’un runtime de navigateur ne peut pas fournir. Chaque résultat est présenté sous forme de capture d’écran du fichier Excel qu’il produit.

Installer et charger le package xlsx

Installez-le une fois, puis chargez-le à chaque session :

install.packages("xlsx")
library("xlsx")

Notez que xlsx entraîne les packages rJava et xlsxjars. Si l’installation échoue, la solution tient presque toujours à un runtime Java manquant ou incompatible — installez un JDK et, sur certains systèmes, exécutez R CMD javareconf avant de réessayer.

Lire un fichier Excel (les bases)

Deux fonctions lisent une feuille de calcul dans un data frame :

read.xlsx(file, sheetIndex, header = TRUE, colClasses = NA)
read.xlsx2(file, sheetIndex, header = TRUE, colClasses = "character")

read.xlsx préserve les types de données — elle tente de deviner la classe de chaque colonne. Pratique, mais lente sur les grandes feuilles (plus de ~100 000 cellules).
read.xlsx2 est beaucoup plus rapide sur les gros fichiers, mais moins habile avec les types de colonnes.

Un exemple rapide, lisant la première feuille d’un fichier livré avec le package :

library(xlsx)
file <- system.file("tests", "test_import.xlsx", package = "xlsx")
res  <- read.xlsx(file, sheetIndex = 1)   # read the first sheet
head(res[, 1:6])

Les deux fonctions lisent le .xls et le .xlsx. Pour la façon moderne et sans Java de lire — y compris lire une feuille précise, une plage de cellules ou définir les types de colonnes — voir la leçon complète Lire des fichiers Excel dans R.

Écrire des données dans un fichier Excel (les bases)

L’image miroir est write.xlsx() (et la plus rapide write.xlsx2() pour de très grands data frames) :

write.xlsx(x, file, sheetName = "Sheet1",
           col.names = TRUE, row.names = TRUE, append = FALSE)

Exportez un data frame en une ligne :

library(xlsx)
write.xlsx(USArrests, file = "myworkbook.xlsx", sheetName = "USA Arrests")

Le fichier atterrit dans votre répertoire de travail courant :

Le data frame USArrests exporté, ouvert dans Excel, dans une feuille nommée « USA Arrests ».

Pour la voie d’écriture moderne et sans Java — une seule feuille, plusieurs feuilles nommées à partir d’une liste, et une mise en forme de base avec openxlsx — voir Écrire des fichiers Excel dans R.

Ajouter plusieurs feuilles par ajout successif

Pour placer plusieurs jeux de données dans le même classeur, mettez append = TRUE à chaque écriture après la première. Chaque appel ajoute une nouvelle feuille de calcul :

# First data set → a new workbook
write.xlsx(USArrests, file = "myworkbook.xlsx",
           sheetName = "USA-ARRESTS", append = FALSE)
# Second data set → a new worksheet
write.xlsx(mtcars, file = "myworkbook.xlsx",
           sheetName = "MTCARS", append = TRUE)
# Third data set
write.xlsx(Titanic, file = "myworkbook.xlsx",
           sheetName = "TITANIC", append = TRUE)

Un seul classeur Excel contenant trois feuilles de calcul — USA-ARRESTS, MTCARS et TITANIC — ajoutées par ajout successif.

Ça marche, mais c’est répétitif. La section suivante condense le tout en un seul appel.

Écrire plusieurs jeux de données en un seul appel

Voici un petit assistant — xlsx.writeMultipleData() — qui exporte un nombre quelconque d’objets R vers un seul classeur, en utilisant le nom de chaque objet comme nom de feuille. Copiez-le dans votre session :

#+++++++++++++++++++++++++++
# xlsx.writeMultipleData
#+++++++++++++++++++++++++++
# file : the path to the output file
# ...  : a list of data to write to the workbook
xlsx.writeMultipleData <- function(file, ...) {
  require(xlsx, quietly = TRUE)
  objects   <- list(...)
  fargs     <- as.list(match.call(expand.dots = TRUE))
  objnames  <- as.character(fargs)[-c(1, 2)]
  nobjects  <- length(objects)
  for (i in 1:nobjects) {
    if (i == 1)
      write.xlsx(objects[[i]], file, sheetName = objnames[i])
    else
      write.xlsx(objects[[i]], file, sheetName = objnames[i], append = TRUE)
  }
}

Il gère les data frames, les matrices, les séries temporelles et les tableaux. Donnez-lui un nom de fichier et les objets :

xlsx.writeMultipleData("myworkbook.xlsx",
                       mtcars, Titanic, AirPassengers, state.x77)

Un classeur Excel avec quatre feuilles nommées mtcars, Titanic, AirPassengers et state.x77 — un data frame, un tableau, une série temporelle et une matrice.

Les quatre feuilles portent le nom des objets — mtcars (un data frame), Titanic (un tableau), AirPassengers (une série temporelle) et state.x77 (une matrice).

La vraie force : construire un rapport Excel mis en forme

write.xlsx() fait l’affaire quand vous voulez simplement un data frame dans une feuille. Mais xlsx peut construire un rapport vraiment soigné — une feuille avec un titre, un tableau stylisé et bordé, un graphique intégré sur son propre onglet. La contrepartie, c’est la verbosité : cela demande un peu de codage manuel. Le processus tient en cinq étapes :

Créer un classeur.
Définir des styles de cellules — polices, couleurs, alignement, bordures.
Écrire des titres, un tableau et un graphique dans une feuille à l’aide de ces styles.
Enregistrer le classeur.
L’ouvrir dans Excel.

Les captures d’écran ci-dessous utilisent la matrice intégrée state.x77 (des faits sur les 50 États américains) uniquement à titre d’illustration.

Étape 1 — Créer un classeur

library(xlsx)
# type can be "xls" or "xlsx"
wb <- createWorkbook(type = "xlsx")

Étape 2 — Définir des styles de cellules

CellStyle() construit un style que vous pouvez attacher à n’importe quelle cellule ; vous le composez avec Font(), Alignment() et Border() à l’aide de +. Ici, nous définissons un titre bleu en gras, un sous-titre en italique, et une ligne d’en-tête en gras, centrée et bordée pour le tableau :

# Title and subtitle styles
TITLE_STYLE     <- CellStyle(wb) + Font(wb, heightInPoints = 16,
                                        color = "blue", isBold = TRUE, underline = 1)
SUB_TITLE_STYLE <- CellStyle(wb) + Font(wb, heightInPoints = 14,
                                        isItalic = TRUE, isBold = FALSE)

# Styles for the data-table row and column names
TABLE_ROWNAMES_STYLE <- CellStyle(wb) + Font(wb, isBold = TRUE)
TABLE_COLNAMES_STYLE <- CellStyle(wb) + Font(wb, isBold = TRUE) +
  Alignment(wrapText = TRUE, horizontal = "ALIGN_CENTER") +
  Border(color = "black", position = c("TOP", "BOTTOM"),
         pen = c("BORDER_THIN", "BORDER_THICK"))

Les briques de base :

Font() — color, heightInPoints (taille de police), isBold, isItalic, underline (0, 1 ou 2), et name pour la police de caractères.
Alignment() — wrapText, horizontal ("ALIGN_CENTER", "ALIGN_LEFT", "ALIGN_RIGHT", "ALIGN_JUSTIFY"), vertical, et rotation en degrés.
Border() — color, position ("TOP", "BOTTOM", "LEFT", "RIGHT"), et pen (style de trait, par ex. "BORDER_THIN", "BORDER_THICK", "BORDER_DASHED").

Étape 3 — Ajouter une feuille, des titres, un tableau et un graphique

D’abord, une feuille et un petit assistant qui écrit un titre dans une ligne donnée (créer une ligne → créer une cellule → définir sa valeur → définir son style) :

# A new sheet in the workbook
sheet <- createSheet(wb, sheetName = "US State Facts")

#++++++++++++++++++++++++
# Helper: add a titled row
#++++++++++++++++++++++++
xlsx.addTitle <- function(sheet, rowIndex, title, titleStyle) {
  rows       <- createRow(sheet, rowIndex = rowIndex)
  sheetTitle <- createCell(rows, colIndex = 1)
  setCellValue(sheetTitle[[1, 1]], title)
  setCellStyle(sheetTitle[[1, 1]], titleStyle)
}

# Title and subtitle
xlsx.addTitle(sheet, rowIndex = 1, title = "US State Facts",
              titleStyle = TITLE_STYLE)
xlsx.addTitle(sheet, rowIndex = 2,
              title = "Data sets related to the 50 states of USA.",
              titleStyle = SUB_TITLE_STYLE)

Ajoutez le tableau avec addDataFrame(), en appliquant les styles d’en-tête et de noms de lignes de l’étape 2, puis élargissez les colonnes pour que les nombres respirent :

addDataFrame(state.x77, sheet, startRow = 3, startColumn = 1,
             colnamesStyle = TABLE_COLNAMES_STYLE,
             rownamesStyle = TABLE_ROWNAMES_STYLE)
setColumnWidth(sheet, colIndex = 1:ncol(state.x77), colWidth = 11)

Pour intégrer un graphique, enregistrez-le d’abord dans un PNG, créez une feuille pour lui, puis placez-le avec addPicture() :

# Create a PNG plot on disk
png("boxplot.png", height = 800, width = 800, res = 250, pointsize = 8)
boxplot(count ~ spray, data = InsectSprays, col = "blue")
dev.off()

# A sheet to hold the plot, with a title
sheet <- createSheet(wb, sheetName = "boxplot")
xlsx.addTitle(sheet, rowIndex = 1,
              title = "Box plot using InsectSprays data",
              titleStyle = TITLE_STYLE)

# Drop the image in, then clean up the temporary file
addPicture("boxplot.png", sheet, scale = 1, startRow = 4, startColumn = 1)
file.remove("boxplot.png")

Étape 4 — Enregistrer le classeur

saveWorkbook(wb, "r-xlsx-report-example.xlsx")

Étape 5 — L’ouvrir et le visualiser

Ouvrez le fichier depuis votre répertoire de travail. La feuille du tableau mis en forme et la feuille du graphique intégré ressemblent à ceci :

La feuille « US State Facts » mise en forme : un titre bleu en gras, un sous-titre en italique, et le tableau state.x77 avec une ligne d’en-tête en gras, bordée et centrée.

La seconde feuille du rapport, contenant la boîte à moustaches InsectSprays intégrée comme image sous un titre stylisé.

Voilà toute la panoplie de mise en forme — styles, titres, tableaux bordés, graphiques intégrés, feuilles multiples — le tout piloté depuis R. Elle fait tout le travail, mais comme vous le voyez, cela demande beaucoup de code. La section suivante remédie à cela.

r2excel : les mêmes rapports en une ligne

Parce que la mise en forme avec xlsx brut demande tant de codage manuel, nous avons écrit r2excel — un wrapper de commodité par-dessus xlsx qui transforme chacune de ces recettes multilignes en un seul appel de fonction lisible. C’est l’un de nos propres packages open source et, comme xlsx, il est basé sur Java (il dépend de xlsx, donc la même exigence Java s’applique).

Installez-le depuis GitHub :

install.packages("devtools")
devtools::install_github("kassambara/r2excel")
library(r2excel)

Les assistants reflètent les étapes de construction du rapport ci-dessus, une fonction chacun :

xlsx.addHeader() — un en-tête/titre stylisé.
xlsx.addParagraph() — un bloc de texte.
xlsx.addTable() — un data frame mis en forme.
xlsx.addPlot() — un graphique, sans aller-retour PNG manuel.
xlsx.addHyperlink() — un lien cliquable.
xlsx.addLineBreak() — des lignes vides entre les blocs.
xlsx.readFile() / xlsx.writeFile() / xlsx.writeMultipleData() — des assistants de lecture et d’écriture.

Ajouter des en-têtes

xlsx.addHeader() prend un level (1–6, comme les titres HTML), une color et un underline (0, 1 ou 2) :

wb    <- createWorkbook(type = "xlsx")
sheet <- xlsx::createSheet(wb, sheetName = "example1")

xlsx.addHeader(wb, sheet, value = "Header 1", level = 1, color = "black")
xlsx.addHeader(wb, sheet, value = "Header 2", level = 2, color = "black")
xlsx.addHeader(wb, sheet, value = "Header 3", level = 3, color = "black")
xlsx.addHeader(wb, sheet, value = "Header 4", level = 4, color = "black")
xlsx.addHeader(wb, sheet, value = "Header 5", level = 5, color = "black")
xlsx.addHeader(wb, sheet, value = "Header 6", level = 6, color = "black")

saveWorkbook(wb, "examples_add_header.xlsx")

Une feuille Excel avec six niveaux d’en-tête écrits par xlsx.addHeader, chacun dans une police progressivement plus petite.

Ajouter un paragraphe de texte

xlsx.addParagraph() écrit un bloc de texte avec le contrôle de la couleur, de la taille, du style et du nombre de cellules qu’il couvre :

wb    <- createWorkbook(type = "xlsx")
sheet <- createSheet(wb, sheetName = "example1")

xlsx.addHeader(wb, sheet, "Add paragraph", level = 2, underline = 1)
xlsx.addLineBreak(sheet, 2)
paragraph <- "Lorem Ipsum is simply dummy text of the printing and typesetting industry."
xlsx.addParagraph(wb, sheet, paragraph, fontSize = 14, isItalic = TRUE,
                  fontColor = "darkred", colSpan = 10, rowSpan = 10)

saveWorkbook(wb, "examples_add_paragraph.xlsx")

Une feuille Excel avec un paragraphe de texte en italique rouge foncé s’étendant sur plusieurs cellules fusionnées, sous un en-tête souligné.

Ajouter un hyperlien

wb    <- createWorkbook(type = "xlsx")
sheet <- createSheet(wb, sheetName = "example1")

xlsx.addHeader(wb, sheet, "Add hyperlink", level = 2, underline = 1)
xlsx.addLineBreak(sheet, 1)
xlsx.addHyperlink(wb, sheet, "https://www.datanovia.com", "Click me!", fontSize = 12)

saveWorkbook(wb, "examples_add_hyperlink.xlsx")

Une feuille Excel avec un hyperlien bleu et cliquable « Click me! » écrit par xlsx.addHyperlink.

Ajouter un tableau mis en forme

xlsx.addTable() écrit un data frame avec un en-tête stylisé et un zébrage optionnel via rowFill (les données iris ici sont à titre d’illustration) :

wb    <- createWorkbook(type = "xlsx")
sheet <- createSheet(wb, sheetName = "example1")
data(iris)

# Default styling
xlsx.addHeader(wb, sheet, value = "Add iris table (default settings)")
xlsx.addLineBreak(sheet, 1)
xlsx.addTable(wb, sheet, head(iris))
xlsx.addLineBreak(sheet, 2)

# Customised: dark-blue text, alternating white / light-blue rows
xlsx.addHeader(wb, sheet, value = "Customized table")
xlsx.addLineBreak(sheet, 1)
xlsx.addTable(wb, sheet, data = head(iris),
              fontColor = "darkblue", fontSize = 14,
              rowFill = c("white", "lightblue"))

saveWorkbook(wb, "examples_add_table.xlsx")

Une feuille Excel avec deux tableaux iris — un par défaut et un personnalisé avec du texte bleu foncé et des lignes alternées blanches / bleu clair.

Ajouter un graphique

xlsx.addPlot() prend une fonction de tracé et intègre directement le résultat — sans png()/dev.off() manuel :

wb    <- createWorkbook(type = "xlsx")
sheet <- createSheet(wb, sheetName = "example1")

# A base-R box plot
data(ToothGrowth)
xlsx.addHeader(wb, sheet, "Basic box plot")
xlsx.addLineBreak(sheet, 1)
xlsx.addPlot(wb, sheet, function() {
  boxplot(len ~ dose, data = ToothGrowth, col = 1:3)
})

# A ggplot2 plot
library(ggplot2)
xlsx.addHeader(wb, sheet, "ggplot2")
xlsx.addLineBreak(sheet, 1)
xlsx.addPlot(wb, sheet, function() {
  print(qplot(mpg, wt, data = mtcars))
})

saveWorkbook(wb, "examples_add_plot.xlsx")

Une feuille Excel avec une boîte à moustaches base-R intégrée de ToothGrowth par dose.

Une feuille Excel avec un nuage de points ggplot2 intégré de mpg en fonction de wt à partir de mtcars.

Assembler le tout

En enchaînant ces assistants — xlsx.addHeader(), xlsx.addTable(), xlsx.addParagraph(), xlsx.addPlot(), xlsx.addHyperlink(), puis saveWorkbook() — vous construisez un rapport complet et mis en forme avec bien moins de code que xlsx brut. Chaque assistant écrit sur la même feuille à la suite, si bien qu’un titre, un tableau, une note et un graphique s’empilent dans un seul classeur soigné.

Quel package utiliser ?

Restez simple :

Lecture/écriture quotidienne, sans Java → readxl / writexl / openxlsx. Rapides, légers en dépendances, et couverts pas à pas dans Lire des fichiers Excel dans R et Écrire des fichiers Excel dans R.
Mise en forme riche, et vous avez Java → xlsx pour un contrôle complet au niveau des cellules, ou r2excel pour obtenir les mêmes rapports avec bien moins de code.

Il n’y a pas de « meilleur » package unique — c’est un compromis entre la dépendance à Java et le niveau de contrôle de mise en forme dont vous avez besoin. Si vous ne faites que déplacer des données entrantes et sortantes, restez sans Java. Si vous remettez régulièrement à des gens des rapports Excel mis en forme depuis R, xlsx et r2excel valent bien la configuration de Java.

Questions fréquentes

Comment ajouter un titre, un tableau ou un graphique à un fichier Excel dans R ?

Utilisez le package xlsx. Créez un classeur avec createWorkbook(), ajoutez une feuille avec createSheet(), définissez des styles avec CellStyle() + Font()/Alignment()/Border(), puis écrivez un titre dans une cellule, ajoutez un tableau avec addDataFrame(), et intégrez un graphique avec addPicture() (après l’avoir enregistré en PNG). Enfin, appelez saveWorkbook(). L’assistant r2excel condense chacune de ces étapes en un seul appel — xlsx.addHeader(), xlsx.addTable() et xlsx.addPlot().

Qu’est-ce que le package r2excel ?

r2excel est un wrapper de commodité par-dessus xlsx qui transforme ses recettes de mise en forme verbeuses en une ligne — xlsx.addHeader(), xlsx.addParagraph(), xlsx.addTable(), xlsx.addPlot() et xlsx.addHyperlink(). Installez-le depuis GitHub avec devtools::install_github("kassambara/r2excel"). Comme il dépend de xlsx, il est lui aussi basé sur Java.

Faut-il utiliser xlsx ou openxlsx dans R ?

Utilisez openxlsx (ou readxl/writexl) pour la lecture et l’écriture quotidiennes — aucun d’eux n’a besoin de Java, et ils sont rapides. Utilisez xlsx lorsque vous avez besoin de sa mise en forme riche au niveau des cellules et que vous êtes à l’aise pour installer Java. En bref : lecture/écriture sans Java → openxlsx ; mise en forme poussée avec Java disponible → xlsx.

Pourquoi le package xlsx a-t-il besoin de Java ?

xlsx repose sur Apache POI, une bibliothèque Java pour lire et écrire des fichiers Microsoft Office, et il communique avec elle via le pont rJava. Voilà pourquoi il vous faut un runtime Java fonctionnel installé pour que le package se charge — et pourquoi il ne peut pas s’exécuter dans un navigateur ni dans un environnement sans Java. Les alternatives sans Java (readxl, writexl, openxlsx) évitent tout cela.

Comment écrire plusieurs feuilles dans un seul classeur Excel avec xlsx ?

Appelez write.xlsx() une fois par jeu de données, en passant append = TRUE à chaque appel après le premier, chacun avec son propre sheetName. Pour le faire en un seul appel, utilisez l’assistant xlsx.writeMultipleData() présenté ci-dessus (également disponible dans r2excel), qui nomme chaque feuille d’après l’objet que vous lui passez.

Conclusion

Le package xlsx est le cheval de trait basé sur Java pour la mise en forme de fichiers Excel depuis R — styles de cellules, feuilles avec titres, tableaux bordés, graphiques intégrés et rapports multi-feuilles que writexl et openxlsx ne produisent pas aussi facilement. La contrepartie, c’est la dépendance à Java et une bonne quantité de code ; l’assistant r2excel supprime l’essentiel du code. Pour la lecture et l’écriture simples, sans Java, restez avec les packages modernes et les leçons liées ci-dessous.

Citation

BibTeX

@online{kassambara2026,
  author = {Kassambara, Alboukadel},
  title = {Le package xlsx dans R : mettre en forme et créer des
    rapports Excel riches},
  date = {2026-07-10},
  url = {https://www.datanovia.com/blog/xlsx-package-in-r},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

Kassambara, Alboukadel. 2026. “Le package xlsx dans R : mettre en forme et créer des rapports Excel riches.” July 10. https://www.datanovia.com/blog/xlsx-package-in-r.