Les chaînes de caractères en R : paste, sprintf, gsub, substr et plus

Créer des chaînes en R

Une chaîne en R, c'est du texte entre guillemets. Les guillemets doubles et simples fonctionnent tous les deux et signifient exactement la même chose ; la convention est le guillemet double, avec passage au simple quand le texte contient lui-même un guillemet double :

name <- "Ada"
motto <- 'said "make it work" twice'
escaped <- "or escape \"quotes\" with a backslash"

cat(motto, "\n")
cat(escaped, "\n")

Les séquences d'échappement par antislash fonctionnent comme dans la plupart des langages : \" pour un guillemet littéral, \n pour un saut de ligne, \t pour une tabulation, \\ pour un antislash lui-même.

Et voici l'erreur que tout débutant en R commet exactement une fois : demander à une chaîne sa longueur avec length().

s <- "hello"
cat(nchar(s), "\n")
cat(length(s), "\n")

nchar() compte les caractères - 5. length() compte les éléments du vecteur, et une chaîne seule est un vecteur d'un élément - donc il dit 1. En R tout est un vecteur, y compris le texte, et toutes les fonctions de cette page travaillent discrètement élément par élément sur des vecteurs de caractères entiers. C'est une fonctionnalité, une fois que ça cesse de te surprendre.

Assembler des chaînes : paste() et paste0()

R n'a pas de + pour les chaînes. La concaténation, c'est paste(), qui joint ses arguments avec une espace par défaut, et paste0(), qui joint sans rien :

cat(paste("data", "science"), "\n")
cat(paste("data", "science", sep = "-"), "\n")
cat(paste0("file_", "2026"), "\n")

Comme paste est vectorisé, lui donner un vecteur construit plusieurs chaînes d'un coup - c'est ainsi qu'on génère des noms de fichiers, des étiquettes et des identifiants en une ligne :

print(paste0("file_", 1:3))

Et l'argument collapse fait l'inverse : il fusionne tout un vecteur en une seule chaîne avec le séparateur choisi :

words <- c("ready", "set", "go")
cat(paste(words, collapse = "... "), "\n")

Retiens la séparation : sep contrôle la colle entre les arguments, collapse la colle entre les éléments d'un même vecteur. Tu peux utiliser les deux dans un même appel.

Formater avec sprintf()

Quand tu as besoin de nombres formatés dans du texte - décimales fixes, largeurs complétées - paste() s'essouffle et sprintf() prend le relais. Il utilise des codes de format à la C : %s pour les chaînes, %d pour les entiers, %f pour les décimaux :

cat(sprintf("%s scored %d points (%.1f%%)\n", "Rosa", 87, 92.5))
cat(sprintf("%.3f\n", pi))
cat(sprintf("invoice %05d\n", 42))

%.1f signifie « une décimale », %.3f trois, et %05d complète à cinq chiffres avec des zéros. Un %% doublé produit un signe pourcent littéral. sprintf() est aussi vectorisé, il peut donc formater toute une colonne de valeurs en un seul appel - voir entrée et sortie pour le motif de rapport sprintf() + cat().

Changer la casse et découper : toupper(), tolower(), substr()

La conversion de casse fait exactement ce qu'elle dit :

s <- "Programming in R"
cat(toupper(s), "\n")
cat(tolower(s), "\n")

tolower() gagne sa place en normalisant des données brouillonnes avant comparaison - "Yes", "YES" et "yes" deviennent tous la même valeur.

substr(x, start, stop) extrait une tranche par position de caractère, en comptant à partir de 1 (R indexe à partir de 1 partout) :

s <- "Programming in R"
cat(substr(s, 1, 11), "\n")
cat(substr(s, 16, 16), "\n")

Les deux bornes sont incluses : les positions 1 à 11 donnent "Programming".

Chercher et remplacer : sub(), gsub() et grepl()

sub() remplace la première occurrence d'un motif ; gsub() (« global substitute ») les remplace toutes :

s <- "good code, good tests, good docs"
cat(sub("good", "great", s), "\n")
cat(gsub("good", "great", s), "\n")

Un détail critique : le motif est une expression régulière par défaut, pas du texte littéral. Les caractères regex comme ., *, ( et ? ont des significations spéciales - un simple . correspond à n'importe quel caractère. Quand tu veux le texte littéral, passe fixed = TRUE :

cat(gsub(".", "-", "a.b.c", fixed = TRUE), "\n")
cat(gsub(".", "-", "a.b.c"), "\n")

La première ligne donne a-b-c ; la seconde donne -----, parce qu'en tant que regex le . a correspondu à chaque caractère. Tant que tu n'as pas appris les regex, fais de fixed = TRUE ton réflexe et tu ne te feras jamais avoir.

grepl() ne remplace pas - il teste si chaque élément correspond, en renvoyant un vecteur logique. C'est donc l'outil standard pour filtrer du texte :

files <- c("report.csv", "notes.txt", "data.csv")
print(grepl(".csv", files, fixed = TRUE))
print(files[grepl(".csv", files, fixed = TRUE)])

Le premier résultat indique quels noms de fichiers contiennent .csv ; le second utilise ce vecteur logique pour ne garder que les correspondances.

Découper et nettoyer : strsplit() et trimws()

strsplit() coupe une chaîne sur un séparateur. Sa particularité : il renvoie une liste, parce qu'il peut découper plusieurs chaînes d'un coup. Pour une seule chaîne, prends le premier élément avec [[1]] :

parts <- strsplit("2026-08-07", "-")[[1]]
print(parts)
cat("year:", parts[1], "\n")

Et trimws() retire les espaces dont les données du monde réel sont toujours entourées :

raw <- "   padded input   "
cat("[", trimws(raw), "]\n", sep = "")

Par défaut il rogne des deux côtés ; which = "left" ou "right" ne rogne qu'un côté (les noms désignent le début et la fin de la chaîne).

L'alternative stringr

Tout ce qui précède est du R de base - toujours disponible, aucune installation. Le package stringr du tidyverse enveloppe les mêmes opérations dans un schéma de nommage cohérent str_*, avec la chaîne toujours en premier argument, ce que beaucoup trouvent plus facile à retenir (voir les packages pour l'installer) :

library(stringr)

str_detect(files, "csv")            # like grepl(), data first
str_replace_all(s, "good", "great") # like gsub(), arguments reordered
str_length("hello")                 # like nchar()

Les fonctions de chaînes de R de base valent le coup d'être connues de toute façon - tu les croiseras dans chaque script, chaque réponse Stack Overflow et chaque message d'erreur jamais écrits. Apprends d'abord les noms de base ; adopte stringr quand l'incohérence des ordres d'arguments commencera à t'agacer.

Ce que tu retiens

• Les chaînes utilisent des guillemets doubles par convention ; nchar() compte les caractères, length() compte les éléments du vecteur.
• Concatène avec paste() / paste0() ; sep colle les arguments, collapse colle un vecteur en une seule chaîne.
• sprintf() gère la sortie formatée : %s, %d, %.2f.
• sub() remplace la première correspondance, gsub() toutes, grepl() teste la présence d'une correspondance - tous en regex par défaut, alors passe fixed = TRUE pour du texte littéral.
• strsplit() renvoie une liste (prends [[1]]) ; trimws() nettoie les entrées entourées d'espaces.

Prochaine étape : faire entrer et sortir du texte de tes programmes - afficher avec print() et cat(), et lire les saisies de l'utilisateur.