Lire et écrire le presse-papier en R avec clipr

Q: Quelle est la différence entre read_clip() et read_clip_tbl() ?

read_clip() renvoie le contenu brut du presse-papier sous forme de vecteur de caractères, un élément par ligne — utilisez-le pour du texte simple comme une seule colonne de valeurs. read_clip_tbl() transmet ce texte à read.table() et renvoie un data frame ; c’est donc le bon choix quand vous avez copié une plage rectangulaire (avec en-tête) depuis Excel ou Google Sheets.

Q: Pourquoi clipr ne fonctionne-t-il pas quand je knit un document R Markdown ou Quarto ?

Le knit, le rendu et CI s’exécutent tous dans une session non interactive sans presse-papier, donc clipr_available() vaut FALSE et les appels de lecture/écriture ne font rien (ou échouent). Le presse-papier est une fonctionnalité de votre session de bureau active — clipr est un outil interactif. Pour des documents reproductibles, lisez et écrivez plutôt dans de vrais fichiers.

Q: Comment coller des données d’Excel dans R sans enregistrer de fichier ?

Sélectionnez la plage dans Excel (en incluant la ligne d’en-tête), appuyez sur Ctrl + C (Cmd + C sur macOS), puis dans R exécutez my_data <- clipr::read_clip_tbl(). Parce qu’une feuille de calcul copie ses cellules sous forme de texte séparé par des tabulations avec un en-tête, les valeurs par défaut de read_clip_tbl() l’analysent directement en un data frame — sans .csv.

Q: Ai-je vraiment besoin de clipr, ou R base peut-il le faire ?

Sur macOS et Windows, R base peut atteindre le presse-papier directement (pipe("pbpaste")/pipe("pbcopy") et readClipboard()/writeClipboard() respectivement). Sur Linux, il n’existe aucune connexion de presse-papier intégrée — il vous faut xclip ou xsel. clipr existe pour masquer ces différences entre systèmes derrière un jeu de fonctions cohérent, afin que le même code fonctionne partout ; utilisez-le quand vous voulez du code portable, et les connexions R base quand vous ne pouvez pas ajouter de dépendance.

Q: Puis-je copier un data frame R dans Excel ?

Oui — clipr::write_clip(my_df) écrit le data frame sur le presse-papier sous forme de texte séparé par des tabulations ; passez à Excel et collez avec Ctrl + V, et il remplit les cellules. Ajoutez row.names = FALSE si vous ne voulez pas que les noms de lignes de R deviennent une colonne en tête.

Copiez une plage d’Excel ou Google Sheets directement dans un data frame R — et recopiez la sortie R — sans jamais enregistrer de fichier

Programming

Déplacez de petits tableaux entre Excel ou Google Sheets et R sans fichier, grâce au package clipr : read_clip() et read_clip_tbl() pour coller une plage copiée dans un data frame, write_clip() pour recopier un résultat R, la protection clipr_available() pour les scripts, et les solutions de repli en R base (pbpaste/pbcopy, readClipboard/writeClipboard, xclip/xsel) sur macOS, Windows et Linux.

Auteur·rice

Alboukadel Kassambara

Date de publication

13 juillet 2026

Modifié

13 juillet 2026

A data-flow diagram: a spreadsheet range on the left flows through the system clipboard in the centre to an R data frame on the right, showing how clipr bridges Excel and R.

Ce que vous allez apprendre

Collez une plage copiée depuis Excel ou Google Sheets directement dans un data frame R avec clipr — sans .csv, sans boîte de dialogue de fichier.
Lisez le texte brut du presse-papier avec read_clip() et un tableau avec read_clip_tbl() ; copiez un résultat R vers le presse-papier avec write_clip().
Protégez vos scripts avec clipr_available() pour qu’ils ne se bloquent jamais sur une machine sans presse-papier.
Les solutions de repli en R base multiplateformes — pbpaste/pbcopy (macOS), readClipboard/writeClipboard (Windows), xclip/xsel (Linux) — quand vous ne pouvez pas ajouter de dépendance.

Vous avez un petit tableau dans Excel ou Google Sheets et vous voulez simplement l’avoir dans R — tout de suite, sans enregistrer de fichier, l’ouvrir, puis le supprimer ensuite. Le package clipr (contraction de clipboard reader, « lecteur de presse-papier ») transforme le presse-papier système en un pont d’une seule ligne : copiez la plage dans votre feuille de calcul, appelez read_clip_tbl(), et vous obtenez un data frame. Dans l’autre sens, write_clip() place un résultat R sur le presse-papier pour que vous puissiez le recoller dans une cellule.

C’est la façon la plus rapide de déplacer un petit tableau au cours d’un travail interactif. (Pour tout ce que vous réutiliserez ou partagerez, enregistrez un vrai fichier — voir les leçons Importer et exporter des données.)

Note

Ceci est une référence statique — et cela ne peut pas être autrement. Le presse-papier est une fonctionnalité de votre session de bureau, donc clipr ne fonctionne que dans une session R interactive sur votre propre machine. Un serveur sans interface graphique, un knit/render ou un exécuteur CI (CI = intégration continue, les serveurs de build automatisés qui vérifient le code) n’a aucun presse-papier — là, clipr_available() renvoie FALSE et les appels de lecture/écriture ne font rien. C’est pourquoi les blocs clipr ci-dessous sont présentés comme du code prêt à copier-coller avec un exemple de sortie sous forme de texte, et non exécutés en direct sur cette page. Copiez n’importe quel bloc et exécutez-le dans votre propre session R interactive pour le reproduire. Le seul bloc qui s’exécute ici (la démo d’analyse read.table()) n’a besoin d’aucun presse-papier.

Installer et charger clipr

clipr est sur le CRAN (le Comprehensive R Archive Network, le dépôt officiel de packages de R). Installez-le une fois, puis chargez-le dans chaque session :

install.packages("clipr")
library(clipr)

Avertissement

Linux a besoin d’un outil système. Sur macOS et Windows, le presse-papier fonctionne d’emblée. Sur Linux, clipr s’appuie sur xclip ou xsel, que vous installez avec votre gestionnaire de paquets système — par exemple sudo apt-get install xclip sur Debian/Ubuntu. Sans l’un d’eux, clipr ne peut pas atteindre le presse-papier.

Lire ce qui se trouve sur le presse-papier

read_clip() renvoie le contenu brut du presse-papier sous forme de vecteur de caractères, un élément par ligne. C’est le lecteur de bas niveau — utilisez-le quand le presse-papier contient du texte simple (une liste de noms, une colonne d’identifiants) plutôt qu’un tableau complet.

# First copy some text (e.g. a column from a spreadsheet), then:
my_text <- read_clip()
my_text
#> [1] "Alice"   "Bob"     "Carol"   "Dan"

Si le presse-papier est vide, read_clip() renvoie NULL avec un avertissement — un script peut donc tester le résultat avant de l’utiliser.

Copier un tableau d’Excel ou Sheets vers R

La fonction que vous utiliserez le plus souvent est read_clip_tbl(). Elle transmet le texte du presse-papier à read.table() de R base et renvoie un data frame, de sorte qu’une plage de feuille de calcul copiée arrive dans R avec ses colonnes intactes.

Le déroulé se fait en deux étapes :

Dans Excel ou Google Sheets, sélectionnez la plage en incluant la ligne d’en-tête et appuyez sur Ctrl + C (Cmd + C sur macOS).
Dans R, appelez read_clip_tbl() :

my_data <- read_clip_tbl()
my_data
#>              name  mpg cyl disp  hp drat
#> 1       Mazda RX4 21.0   6  160 110 3.90
#> 2   Mazda RX4 Wag 21.0   6  160 110 3.90
#> 3      Datsun 710 22.8   4  108  93 3.85
#> 4  Hornet 4 Drive 21.4   6  258 110 3.08
#> 5         Valiant 18.1   6  225 105 2.76

Par défaut, read_clip_tbl() suppose que le bloc copié est séparé par des tabulations avec une ligne d’en-tête (sep = "\t", header = TRUE, stringsAsFactors = FALSE) — exactement ce qu’une feuille de calcul place sur le presse-papier. Tout argument supplémentaire est transmis directement à read.table(), ce qui vous permet de remplacer les valeurs par défaut quand le texte copié est inhabituel :

# A block with no header row, and commas instead of tabs:
my_data <- read_clip_tbl(header = FALSE, sep = ",")

Voir l’analyse exacte — sans presse-papier

Parce que read_clip_tbl() n’est rien d’autre que read.table() alimenté depuis le presse-papier, vous pouvez reproduire ici l’analyse exacte, sans aucun presse-papier, en fournissant à read.table() le même texte séparé par des tabulations que la copie d’une plage de feuille de calcul y placerait. Ce bloc s’exécute en direct :

# The tab-separated ("\t") text that copying this Excel range would put on the clipboard.
# read_clip_tbl() would hand this same string to read.table() for you.
excel_block <- "name\tmpg\tcyl\tdisp\thp
Mazda RX4\t21.0\t6\t160\t110
Datsun 710\t22.8\t4\t108\t93
Hornet 4 Drive\t21.4\t6\t258\t110
Valiant\t18.1\t6\t225\t105"

my_data <- read.table(text = excel_block, header = TRUE, sep = "\t",
                      stringsAsFactors = FALSE)
my_data

            name  mpg cyl disp  hp
1      Mazda RX4 21.0   6  160 110
2     Datsun 710 22.8   4  108  93
3 Hornet 4 Drive 21.4   6  258 110
4        Valiant 18.1   6  225 105

Le résultat est un véritable data frame — et str() confirme que les colonnes numériques sont bien arrivées sous forme de nombres, et non de texte, ce qui vous permet de calculer dessus immédiatement :

str(my_data)

'data.frame':   4 obs. of  5 variables:
 $ name: chr  "Mazda RX4" "Datsun 710" "Hornet 4 Drive" "Valiant"
 $ mpg : num  21 22.8 21.4 18.1
 $ cyl : int  6 4 6 6
 $ disp: int  160 108 258 225
 $ hp  : int  110 93 110 105

C’est précisément ce que read_clip_tbl() renvoie après avoir copié une plage dans Excel ; elle lit simplement le presse-papier à votre place au lieu que vous saisissiez le texte dans text =.

Écrire des données de R vers le presse-papier

write_clip() copie un objet R sur le presse-papier pour que vous puissiez le coller dans une feuille de calcul, un e-mail ou une messagerie. Passez-lui un data frame et elle écrit du texte séparé par des tabulations qui se répartit proprement dans les cellules :

# Put a data frame on the clipboard, then paste into Excel with Ctrl + V:
write_clip(mtcars)

Par défaut, write_clip() devine le type de l’objet (object_type = "auto") : un data frame ou une matrice est écrit sous forme de tableau, et un vecteur simple est écrit sous forme de lignes de texte. Pour un data frame, elle utilise write.table() en interne, donc les noms de lignes sont inclus — passez row.names = FALSE (transmis à write.table()) si vous n’en voulez pas :

write_clip(mtcars, row.names = FALSE)

Un vecteur de caractères est écrit à raison d’un élément par ligne :

write_clip(c("Alpha", "Bravo", "Charlie"))
# Clipboard now holds:
# Alpha
# Bravo
# Charlie

Capturer et personnaliser ce qui est écrit

write_clip() renvoie son entrée de façon invisible, ce qui lui permet de s’insérer dans un pipe sans rompre la chaîne. Pour capturer la chaîne exacte qu’elle a placée sur le presse-papier, mettez return_new = TRUE ; pour changer la façon dont les éléments du vecteur sont assemblés, mettez breaks :

# Return the string that was written (instead of the original object):
cb <- write_clip(c("Text", "for", "clipboard"), return_new = TRUE)
cb
#> [1] "Text\nfor\nclipboard"

# Join the elements with ", " instead of line breaks:
cb <- write_clip(c("Text", "for", "clipboard"), breaks = ", ", return_new = TRUE)
cb
#> [1] "Text, for, clipboard"

write_clip() refuse de s’exécuter en mode non interactif — délibérément

Depuis la version 0.5.0, write_clip() ne touche pas au presse-papier dans une session non interactive (un script lancé via Rscript, un knit ou CI) sauf si vous l’y autorisez explicitement en définissant la variable d’environnement CLIPR_ALLOW=TRUE. C’est une protection pour qu’une tâche automatisée n’écrase jamais en silence ce qu’un utilisateur avait copié. En usage interactif normal, vous ne la voyez jamais ; dans un script, définissez la variable (Sys.setenv(CLIPR_ALLOW = TRUE)) uniquement si vous voulez réellement écrire. Voir la documentation de clipr pour plus de détails.

Protégez vos scripts avec `clipr_available()`

Tout script qui lit ou écrit sur le presse-papier devrait d’abord vérifier qu’un presse-papier existe réellement — sinon il échoue sur un serveur sans interface graphique ou sur la machine Linux d’un collègue dépourvue de xclip. clipr_available() renvoie TRUE ou FALSE, ce qui vous permet de créer un branchement propre :

if (clipr_available()) {
  my_data <- read_clip_tbl()
} else {
  message("No clipboard here — falling back to a file.")
  my_data <- read.csv("data.csv")
}

Pour un diagnostic ponctuel des raisons pour lesquelles le presse-papier est indisponible, dr_clipr() affiche un bref rapport (xclip/xsel manquant, session non interactive, etc.).

Pas de dépendance ? Les solutions de repli en R base

Si vous ne pouvez pas ajouter de package — un environnement verrouillé, la machine de quelqu’un d’autre — R peut tout de même atteindre le presse-papier sur macOS et Windows grâce à des connexions intégrées. clipr existe précisément parce que celles-ci diffèrent selon le système d’exploitation et que Linux n’en a aucune intégrée ; le tableau montre ce que clipr masque :

Système d’exploitation	Lire le presse-papier	Écrire sur le presse-papier
macOS	`pipe("pbpaste")`	`pipe("pbcopy", "w")`
Windows	`readClipboard()`, ou `"clipboard"` comme fichier	`writeClipboard()`, ou `"clipboard"` comme fichier
Linux	aucune intégrée — nécessite `xclip`/`xsel` (utilisez `clipr`)	aucune intégrée — nécessite `xclip`/`xsel` (utilisez `clipr`)

macOS — lire un tableau copié et en réécrire un via les outils en ligne de commande pbpaste/pbcopy :

# Read a copied table:
my_data <- read.table(pipe("pbpaste"), sep = "\t", header = TRUE)

# Write a data frame to the clipboard:
clip <- pipe("pbcopy", "w")
write.table(mtcars, file = clip, sep = "\t", row.names = FALSE)
close(clip)

Windows — R base traite "clipboard" comme une connexion de fichier, et utils ajoute des fonctions dédiées :

# Read a copied table:
my_data <- read.table("clipboard", sep = "\t", header = TRUE)

# Write a data frame to the clipboard:
write.table(mtcars, "clipboard", sep = "\t", row.names = FALSE)

# Or the character-vector helpers:
lines <- readClipboard()
writeClipboard(c("Alpha", "Bravo", "Charlie"))

Elles fonctionnent, mais elles sont spécifiques à chaque système d’exploitation — ce qui est précisément la raison pour laquelle clipr les enveloppe derrière un unique jeu de fonctions qui se comportent de la même façon partout.

Le flux aller-retour

Assemblez les morceaux et le presse-papier devient un brouillon bidirectionnel entre votre feuille de calcul et R :

Dans Excel/Sheets, copiez la plage (Ctrl/Cmd + C).
Dans R, my_data <- read_clip_tbl() — c’est maintenant un data frame.
Faites le travail — filtrer, résumer, modéliser, tracer.
write_clip(result) — le résultat est de retour sur le presse-papier.
Passez à la feuille de calcul et collez (Ctrl/Cmd + V).

Aucun fichier n’est jamais créé. C’est parfait pour des déplacements rapides et jetables au cours d’une analyse interactive — et dès que les données ont assez d’importance pour être conservées, enregistrez-les plutôt dans un vrai fichier (voir Lire des fichiers Excel dans R).

Problèmes courants

read_clip_tbl() renvoie une seule grosse colonne, ou des colonnes mal alignées. Le bloc copié n’est pas séparé par des tabulations comme read.table() s’y attend (fréquent quand la source utilisait des virgules ou plusieurs espaces). Indiquez le bon séparateur : read_clip_tbl(sep = ","), ou lisez les lignes brutes avec read_clip() et analysez-les vous-même.
Error: Clipboard on X11 requires that the DISPLAY envvar be configured — ou rien ne se passe sur un serveur. Il n’y a aucun presse-papier dans cette session. C’est attendu sur les machines sans interface graphique et en CI. Protégez avec clipr_available() et repliez-vous sur un fichier.
write_clip() semble ne rien faire dans un script. Dans une session non interactive, elle refuse d’écrire tant que CLIPR_ALLOW=TRUE n’est pas défini — une protection délibérée, et non un bug (voir la note ci-dessus).

Questions fréquentes

Quelle est la différence entre read_clip() et read_clip_tbl() ?

read_clip() renvoie le contenu brut du presse-papier sous forme de vecteur de caractères, un élément par ligne — utilisez-le pour du texte simple comme une seule colonne de valeurs. read_clip_tbl() transmet ce texte à read.table() et renvoie un data frame ; c’est donc le bon choix quand vous avez copié une plage rectangulaire (avec en-tête) depuis Excel ou Google Sheets.

Pourquoi clipr ne fonctionne-t-il pas quand je knit un document R Markdown ou Quarto ?

Le knit, le rendu et CI s’exécutent tous dans une session non interactive sans presse-papier, donc clipr_available() vaut FALSE et les appels de lecture/écriture ne font rien (ou échouent). Le presse-papier est une fonctionnalité de votre session de bureau active — clipr est un outil interactif. Pour des documents reproductibles, lisez et écrivez plutôt dans de vrais fichiers.

Comment coller des données d’Excel dans R sans enregistrer de fichier ?

Sélectionnez la plage dans Excel (en incluant la ligne d’en-tête), appuyez sur Ctrl + C (Cmd + C sur macOS), puis dans R exécutez my_data <- clipr::read_clip_tbl(). Parce qu’une feuille de calcul copie ses cellules sous forme de texte séparé par des tabulations avec un en-tête, les valeurs par défaut de read_clip_tbl() l’analysent directement en un data frame — sans .csv.

Ai-je vraiment besoin de clipr, ou R base peut-il le faire ?

Sur macOS et Windows, R base peut atteindre le presse-papier directement (pipe("pbpaste")/pipe("pbcopy") et readClipboard()/writeClipboard() respectivement). Sur Linux, il n’existe aucune connexion de presse-papier intégrée — il vous faut xclip ou xsel. clipr existe pour masquer ces différences entre systèmes derrière un jeu de fonctions cohérent, afin que le même code fonctionne partout ; utilisez-le quand vous voulez du code portable, et les connexions R base quand vous ne pouvez pas ajouter de dépendance.

Puis-je copier un data frame R dans Excel ?

Oui — clipr::write_clip(my_df) écrit le data frame sur le presse-papier sous forme de texte séparé par des tabulations ; passez à Excel et collez avec Ctrl + V, et il remplit les cellules. Ajoutez row.names = FALSE si vous ne voulez pas que les noms de lignes de R deviennent une colonne en tête.

Pour aller plus loin dans `/learn`

Le presse-papier est idéal pour des déplacements rapides et jetables. Pour des données que vous conserverez, réutiliserez ou partagerez, enregistrez un vrai fichier — les leçons pas à pas couvrent tous les formats :

Lire des fichiers Excel dans R et Écrire des fichiers Excel dans R — la voie moderne sans Java avec readxl/writexl, exécutée en direct dans votre navigateur.
Lire des fichiers CSV et texte dans R — le cheval de bataille de l’import au quotidien.
Importer et exporter des données dans R — la série complète.

Pour aller plus loin

Le package xlsx en R — mettez en forme, stylisez et construisez de riches rapports Excel depuis R. · Importer et exporter des données — la série complète du pilier.

🟢 Avec un agent IA

Demandez à Prova « J’ai copié un tableau depuis Excel — lis-le dans un data frame R avec clipr, puis rends-moi les moyennes de colonnes sur le presse-papier » — elle répond avec du code que vous pouvez exécuter sur vos propres données. The runtime is the judge. Demander à Prova →

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

Citation

BibTeX

@online{kassambara2026,
  author = {Kassambara, Alboukadel},
  title = {Lire et écrire le presse-papier en R avec clipr},
  date = {2026-07-13},
  url = {https://www.datanovia.com/blog/read-write-clipboard-in-r-clipr},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

Kassambara, Alboukadel. 2026. “Lire et écrire le presse-papier en R avec clipr.” July 13. https://www.datanovia.com/blog/read-write-clipboard-in-r-clipr.