Expressions régulières

Source : vignettes/expressions régulières. Rmd

Les expressions régulières sont un outil concis et flexible pour décrire
motifs dans les chaînes. Cette vignette décrit les principales
caractéristiques de stringr, telles qu’implémentées par stringi. Il ne
s’agit pas d’un tutoriel, donc si vous n’êtes pas familier avec les
expressions régulières, je vous recommande à partir
de https://r4ds.had.co.nz/strings.html. Si vous souhaitez maîtrisez les
détails, je vous recommande de lire le classique Mastering Expressions
régulières par Jeffrey E. F. Friedl.

Les expressions régulières sont le moteur de motifs par défaut dans

stringr. Cela signifie que lorsque vous utilisez une fonction de
correspondance de motifs avec une chaîne de caractères nue, elle est
équivalent à l’encapsuler dans un appel à :regex()
# The regular call:
str_extract(fruit, "nana")
# Is shorthand for
str_extract(fruit, regex("nana"))
Vous devrez l’utiliser explicitement si vous souhaitez Remplacez les
options par défaut, comme vous le verrez dans les exemples ci-
dessous.regex()

Correspondances de base
Les motifs les plus simples correspondent à des chaînes exactes :
x <- c("apple", "banana", "pear")
str_extract(x, "an")
#> [1] NA "an" NA
Vous pouvez effectuer une correspondance insensible à la casse à l’aide
de :ignore_case = TRUE
bananas <- c("banana", "Banana", "BANANA")
str_detect(bananas, "banana")
#> [1] TRUE FALSE FALSE
str_detect(bananas, regex("banana", ignore_case = TRUE))
#> [1] TRUE TRUE TRUE
L’étape suivante en matière de complexité est , qui correspond à
n’importe quel caractère sauf un saut de ligne :.
str_extract(x, ".a.")
#> [1] NA "ban" "ear"
Vous pouvez permettre de tout assortir, y compris , en définissant :.\
ndotall = TRUE

str_detect("\nX\n", ".X.")
#> [1] FALSE
str_detect("\nX\n", regex(".X.", dotall = TRUE))
#> [1] TRUE

Échapper
Si « » correspond à n’importe quel caractère, comment faire
correspondre un littéral “”? Vous devez utiliser un « échappement » pour
dire à l’habitué expression que vous souhaitez lui correspondre
exactement, et non utiliser son comportement particulier. Comme les
chaînes de caractères, les expressions rationnelles utilisent la barre
oblique inverse, , pour échapper comportement particulier. Donc, pour
correspondre à un , vous avez besoin de l’expression rationnelle .
Malheureusement, cela crée un problème. Nous utilisons des cordes
pour représentent des expressions régulières, et est également utilisé
comme Symbole d’échappement dans les chaînes. Donc, pour créer
l’expression régulière, nous avons besoin de la chaîne ...\.\.\\."\\."
# To create the regular expression, we need \\
dot <- "\\."

# But the expression itself only contains one:

writeLines(dot)
#> \.

# And this tells R to look for an explicit .

str_extract(c("abc", "a.c", "bef"), "a\\.c")
#> [1] NA "a.c" NA
If est utilisé comme caractère d’échappement dans les expressions,
comment faire correspondre un littéral ? Eh bien, vous devez Échappez-
le, en créant l’expression régulière . Pour créer cette expression
régulière, vous devez utiliser une chaîne, qui doit également échapper.
Cela signifie correspondre à un vous littéral need to write — vous avez
besoin de quatre barres obliques inverses pour correspondre
Un!\\\\\\"\\\\"
x <- "a\\b"
writeLines(x)
#> a\b
str_extract(x, "\\\\")
#> [1] "\\"
Dans cette vignette, j’ai l’habitude de désigner le expression, et pour
désigner la chaîne qui représente l’expression régulière.\."\\."

Un autre mécanisme de cotation est : tous les Les caractères de sont

traités comme des correspondances exactes. C’est utile si vous voulez
faire correspondre exactement les entrées de l’utilisateur dans le cadre
d’un expression.\Q...\E...
x <- c("a.b.c.d", "aeb")
starts_with <- "a.b"

str_detect(x, paste0("^", starts_with))

#> [1] TRUE TRUE
str_detect(x, paste0("^\\Q", starts_with, "\\E"))
#> [1] TRUE FALSE

Caractères spéciaux
Les échappements vous permettent également de spécifier des
caractères individuels qui sont sinon, difficile à taper. Vous pouvez
spécifier des caractères Unicode individuels dans cinq façons, soit sous
la forme d’un nombre variable de chiffres hexadécimaux (quatre est le
plus commun), ou par son nom :

 \xhh: 2 chiffres hexadécimaux.

 \x{hhhh}: 1-6 chiffres hexagonaux.
 \uhhhh: 4 chiffres hexadécimaux.
 \Uhhhhhhhh: 8 chiffres hexadécimaux.
 \N{name}, p. ex. correspond à l’emoji souriant de base.\
N{grinning face}

De même, vous pouvez spécifier de nombreux caractères de contrôle

courants :

 \a:cloche.
 \cX: correspond à un caractère de contrôle-X.
 \e: échappement ().\u001B
 \f: saut de page ().\u000C
 \n: saut de ligne ().\u000A
 \r: retour chariot ().\u000D
  \t: tabulation horizontale ().\u0009
 \0ooo correspondre à un caractère octal. 'ooo' est de un à Trois
chiffres octals, de 000 à 0377. Le zéro non significatif est
Obligatoire.

(Beaucoup d’entre eux n’ont qu’un intérêt historique et ne sont inclus

que ici par souci d’exhaustivité.)

Correspondance de plusieurs caractères

Il existe un certain nombre de modèles qui correspondent à plus d’un
personnage. Vous avez déjà vu , qui correspond à n’importe quel
personnage (sauf un saut de ligne). Un opérateur étroitement lié est , qui
correspond à un cluster de graphèmes, un ensemble d’éléments
individuels qui forment un seul symbole. Par exemple, une façon de
représenter « á » est comme le la lettre « a » plus un accent :
correspondra au composant « a », tandis que correspondra au symbole
complet :.\X.\X
x <- "a\u0301"
str_extract(x, ".")
#> [1] "a"
str_extract(x, "\\X")
#> [1] "á"
Il existe cinq autres paires échappées qui correspondent à des classes
plus étroites de caractères:

 \d: correspond à n’importe quel chiffre. Le complément, ,

correspond à tout caractère qui n’est pas un chiffre décimal.\D
 str_extract_all("1 + 2 = 3", "\\d+")[[1]]
#> [1] "1" "2" "3"
Techniquement, inclut n’importe quel caractère dans l’Unicode
Catégorie de Nd (« Nombre, chiffre décimal »), qui comprend
également les chiffres Symboles d’autres langues :\d
# Some Laotian numbers
str_detect("១២៣", "\\d")
#> [1] TRUE
 \s: correspond à n’importe quel espace. Cela inclut les onglets,
sauts de ligne, les sauts de formulaire et tout caractère de la
catégorie Z Unicode (qui comprend une variété de caractères
 d’espace et d’autres séparateurs.). Le complement, , correspond à
n’importe quel caractère autre qu’un espace.\S
 (text <- "Some \t badly\n\t\tspaced \f text")
 #> [1] "Some \t badly\n\t\tspaced \f text"
 str_replace_all(text, "\\s+", " ")
#> [1] "Some badly spaced text"
 \p{property name} correspond à n’importe quel caractère avec
propriété Unicode spécifique, comme ou . Le complément, ,
correspond à tous les caractères sans le propriété. Une liste
complète des propriétés Unicode se trouve à l’adresse
http://www.unicode.org/reports/tr44/#Property_Index.\
p{Uppercase}\p{Diacritic}\P{property name}
 (text <- c('"Double quotes"', "«Guillemet»", "“Fancy quotes”"))
 #> [1] "\"Double quotes\"" "«Guillemet»" "“Fancy quotes”"
 str_replace_all(text, "\\p{quotation mark}", "'")
#> [1] "'Double quotes'" "'Guillemet'" "'Fancy quotes'"
 \w correspond à n’importe quel caractère « mot », y compris
caractères alphabétiques, marques et nombres décimaux. Le
complément, , correspond à n’importe quel caractère non verbal.\
W
 str_extract_all("Don't eat that!", "\\w+")[[1]]
 #> [1] "Don" "t" "eat" "that"
 str_split("Don't eat that!", "\\W")[[1]]
#> [1] "Don" "t" "eat" "that" ""
Techniquement, correspond également à la ponctuation du
connecteur, (connecteur de largeur zéro) et (joint de largeur zéro),
mais ceux-ci sont rarement vus dans la nature.\w\u200c\u200d

 \b correspond aux limites des mots, la transition entre caractères

verbaux et non verbaux. correspond à l’inverse : limites
comportant à la fois des caractères verbaux ou non verbaux côté.\
B
 str_replace_all("The quick brown fox", "\\b", "_")
 #> [1] "_The_ _quick_ _brown_ _fox_"
 str_replace_all("The quick brown fox", "\\B", "_")
#> [1] "T_h_e q_u_i_c_k b_r_o_w_n f_o_x"
Vous pouvez également créer vos propres classes de personnages en
utilisant :[]

 [abc]: correspond à A, B ou C.
 [a-z]: correspond à chaque caractère entre a et z (dans Ordre des
points de code Unicode).
 [^abc]: correspond à tout sauf A, B ou C.
 [\^\-]: correspond ou .^-
Il existe un certain nombre de classes prédéfinies que vous pouvez
utiliser à l’intérieur :[]

 [:punct:]:ponctuation.
 [:alpha:]:lettres.
 [:lower:]: lettres minuscules.
 [:upper:]: lettres de la classe supérieure.
 [:digit:]:Chiffres.
 [:xdigit:]: chiffres hexadécimaux.
 [:alnum:]: lettres et chiffres.
 [:cntrl:]: caractères de contrôle.
 [:graph:]: lettres, chiffres et ponctuation.
 [:print:]: lettres, chiffres, ponctuation, et Espaces.
 [:space:]: caractères d’espace (essentiellement équivalents à ).\s
 [:blank:]: espace et tabulation.

Tous ces éléments vont à l’intérieur des classes de personnages, c.-à-d.

correspond à tous les chiffres, A et X.[][[:digit:]AX]

Vous pouvez également utiliser des propriétés Unicode, comme , et

diverses opérations d’ensemble, comme . Pour plus de détails, reportez-
vous à la section .[\p{Letter}][\p{Letter}--\p{script=latin}]?"stringi-
search-charclass"

Alternance
| est l’opérateur d’alternance, qui choisira entre une ou plusieurs
correspondances possibles. Par exemple, correspondra à ou :abc|
defabcdef

str_detect(c("abc", "def", "ghi"), "abc|def")

#> [1] TRUE TRUE FALSE
Notez que la priorité pour est faible : est équivalente à non .|abc|
def(abc)|(def)ab(c|d)ef

Groupement
Vous pouvez utiliser des parenthèses pour remplacer les règles de
priorité par défaut :
str_extract(c("grey", "gray"), "gre|ay")
#> [1] "gre" "ay"
str_extract(c("grey", "gray"), "gr(e|a)y")
#> [1] "grey" "gray"
Les parenthèses définissent également des « groupes » auxquels vous
pouvez vous référer avec des références arrière, comme , etc., et qui
peuvent être extraits avec . Par exemple L’expression régulière suivante
trouve tous les fruits qui ont une paire de lettres :\1\2str_match()
pattern <- "(..)\\1"
fruit %>%
str_subset(pattern)
#> [1] "banana" "coconut" "cucumber" "jujube" "papaya"
#> [6] "salal berry"

fruit %>%
str_subset(pattern) %>%
str_match(pattern)
#> [,1] [,2]
#> [1,] "anan" "an"
#> [2,] "coco" "co"
#> [3,] "cucu" "cu"
#> [4,] "juju" "ju"
#> [5,] "papa" "pa"
#> [6,] "alal" "al"
Vous pouvez utiliser , les parenthèses non groupables, pour Contrôlez la
priorité, mais ne capturez pas la correspondance dans un groupe. C’est
légèrement plus efficace que la capture de parenthèses.(?:...)
str_match(c("grey", "gray"), "gr(e|a)y")
#> [,1] [,2]
#> [1,] "grey" "e"
#> [2,] "gray" "a"
str_match(c("grey", "gray"), "gr(?:e|a)y")
#> [,1]
#> [1,] "grey"
#> [2,] "gray"
Ceci est particulièrement utile pour les cas plus complexes où vous
devez capturer correspond et contrôle la priorité indépendamment.

Ancres
Par défaut, les expressions régulières correspondent à n’importe quelle
partie d’une chaîne. C’est souvent utile pour ancrer l’expression
régulière de sorte que Il correspond à partir du début ou de la fin de la
chaîne :

 ^ correspond au début de la chaîne.

  $ correspond à l’extrémité de la chaîne.

x <- c("apple", "banana", "pear")

str_extract(x, "^a")
#> [1] "a" NA NA
str_extract(x, "a$")
#> [1] NA "a" NA
Pour correspondre à un « $ » ou « ^ » littéral, vous devez les échapper, ,
et .\$\^

Pour les chaînes multilignes, vous pouvez utiliser . Cela modifie le

comportement de et , et introduit trois nouveaux
Opérateurs:regex(multiline = TRUE)^$

 ^ correspond désormais au début de chaque ligne.

 $ correspond désormais à la fin de chaque ligne.
 \A correspond au début de l’entrée.
 \z correspond à la fin de l’entrée.
 \Z correspond à la fin de l’entrée, mais avant le Terminateur de
ligne finale, s’il existe.
x <- "Line 1\nLine 2\nLine 3\n"
str_extract_all(x, "^Line..")[[1]]
#> [1] "Line 1"
str_extract_all(x, regex("^Line..", multiline = TRUE))[[1]]
#> [1] "Line 1" "Line 2" "Line 3"
str_extract_all(x, regex("\\ALine..", multiline = TRUE))[[1]]
#> [1] "Line 1"

Répétition
Vous pouvez contrôler le nombre de fois qu’un motif correspond à la
répétition Opérateurs:

 ?: 0 ou 1.
 +: 1 ou plus.
 *: 0 ou plus.

x <- "1888 is the longest year in Roman numerals: MDCCCLXXXVIII"

str_extract(x, "CC?")
#> [1] "CC"
str_extract(x, "CC+")
#> [1] "CCC"
str_extract(x, 'C[LX]+')
#> [1] "CLXXX"
Notez que la priorité de ces opérateurs est élevée, vous pouvez donc
write : pour correspondre à l’américain ou au britannique Orthographes.
Cela signifie que la plupart des utilisations auront besoin de
parenthèses, comme .colou?rbana(na)+

Vous pouvez également spécifier le nombre de correspondances avec

précision :

 {n}: exactement n
 {n,}: n ou plus
 {n,m}: entre n et m

str_extract(x, "C{2}")
#> [1] "CC"
str_extract(x, "C{2,}")
#> [1] "CCC"
str_extract(x, "C{2,3}")
#> [1] "CCC"
Par défaut ces correspondances sont « gourmandes » : elles
correspondront les plus longues Chaîne possible. Vous pouvez les
rendre « paresseux », en faisant correspondre la chaîne la plus courte
possible en mettant un après eux :?

 ??: 0 ou 1, préférez 0.
 +?: 1 ou plus, associez le moins de fois possible.
 *?: 0 ou plus, faites correspondre le moins de fois possible.
 {n,}?: n ou plus, faites correspondre le moins de fois possible.
 {n,m}?: entre n et m, , correspond aussi peu de fois que possible,
mais au moins n.
str_extract(x, c("C{2,3}", "C{2,3}?"))
#> [1] "CCC" "CC"
str_extract(x, c("C[LX]+", "C[LX]+?"))
#> [1] "CLXXX" "CL"
Vous pouvez également rendre les correspondances possessives en
mettant un après elles, ce qui signifie que si les parties ultérieures de la
partie échouent, le La répétition ne sera pas réessayée avec un nombre
inférieur de caractères. Il s’agit d’une fonctionnalité avancée utilisée
pour améliorer les performances dans le pire des cas scénarios (appelés
« retour en arrière catastrophique »).+

 ?+: 0 ou 1, possessif.
  ++: 1 ou plus, possessif.
 *+: 0 ou plus, possessif.
 {n}+: exactement n, possessif.
 {n,}+: n ou plus, possessif.
 {n,m}+: entre n et m, possessif.

Un concept apparenté est la parenthèse atomique, . Si une

correspondance ultérieure échoue et que le moteur doit retour en
arrière, une correspondance atomique est conservée telle quelle : elle
réussit ou échoue en tant que entier. Comparez les deux expressions
régulières suivantes :(?>...)
str_detect("ABC", "(?>A|.B)C")
#> [1] FALSE
str_detect("ABC", "(?:A|.B)C")
#> [1] TRUE
La correspondance atomique échoue parce qu’elle correspond à A, puis
à la suivante est un C, donc il échoue. Le match régulier réussit parce
qu’il correspond à A, mais C ne correspond pas, alors il fait marche
arrière et essaie B au lieu de.

Regardez autour de vous

Ces affirmations regardent en avant ou en arrière du match en cours
sans « consommer » n’importe quel caractère (c’est-à-dire changer la
position d’entrée).

 (?=...): affirmation positive de l’avenir. Correspond si correspond à

l’entrée actuelle....
 (?!...): affirmation négative de prévision. Correspond si ne
correspond pas à l’actuel entrée....
 (?<=...): affirmation positive de l’arrière-garde. Allumettes if
correspond au texte précédant la position actuelle, avec le dernier
personnage de la partie étant le personnage juste avant le position
actuelle. La longueur doit être bornée
(c’est-à-dire pas ou )....*+
 (?<!...): affirmation négative de look-behind. Allumettes if ne
correspond pas au texte précédant le position actuelle. La
 longueur doit être bornée
(c’est-à-dire pas ou )....*+

Ceux-ci sont utiles lorsque vous souhaitez vérifier qu’un motif existe,
mais que vous Vous ne souhaitez pas l’inclure dans le résultat :
x <- c("1 piece", "2 pieces", "3")
str_extract(x, "\\d+(?= pieces?)")
#> [1] "1" "2" NA

y <- c("100", "$400")

str_extract(y, "(?<=\\$)\\d+")
#> [1] NA "400"

Commentaires
Il existe deux façons d’inclure des commentaires dans une expression
régulière. Le La première est avec :(?#...)
str_detect("xyz", "x(?#this is a comment)")
#> [1] TRUE
La seconde consiste à utiliser . Ce formulaire ignore les espaces et les
sauts de ligne, et tout ce qui suit . Pour correspondre à un espace
littéral, vous devrez l’échapper : . Il s’agit d’une façon utile de décrire des
Expressions:regex(comments = TRUE)#"\\ "
phone <- regex("
\\(? # optional opening parens
(\\d{3}) # area code
\\)? # optional closing parens
(?:-|\\ )? # optional dash or space
(\\d{3}) # another three numbers
(?:-|\\ )? # optional dash or space
(\\d{3}) # three more numbers
", comments = TRUE)

str_match(c("514-791-8141", "(514) 791 8141"), phone)

#> [,1] [,2] [,3] [,4]
#> [1,] "514-791-814" "514" "791" "814"
#> [2,] "(514) 791 814" "514" "791" "814"

String R
14 cordes
Vous lisez la première édition de R4DS ; pour les dernières
informations sur ce sujet, voir le chapitre Strings dans la
deuxième édition.

14.1 Présentation
Ce chapitre vous présente la manipulation de chaînes dans R.
Vous apprendrez les bases du fonctionnement des chaînes de
caractères et comment les créer à la main, mais ce chapitre se
concentrera sur les expressions régulières, ou expressions
rationnelles en abrégé. Les expressions régulières sont utiles car
les chaînes contiennent généralement des données non
structurées ou semi-structurées, et les expressions rationnelles
sont un langage concis pour décrire les motifs dans les chaînes.
Lorsque vous regardez une expression régulière pour la première
fois, vous penserez qu’un chat a marché sur votre clavier, mais à
mesure que votre compréhension s’améliore, elles commenceront
bientôt à avoir un sens.

14.1.1 Conditions préalables

Ce chapitre se concentrera sur le paquet stringr pour la
manipulation des cordes, qui fait partie du tidyverse de base.

library(tidyverse)

14.2 Principes de base des cordes

Vous pouvez créer des chaînes avec des guillemets simples ou
des guillemets doubles. Contrairement à d’autres langues, il n’y a
pas de différence de comportement. Je recommande de toujours
utiliser , sauf si vous souhaitez créer une chaîne contenant
plusieurs .""

string1 <- "This is a string"

string2 <- 'If I want to include a "quote" inside a string, I use single
quotes'
Si vous oubliez de fermer un guillemet, vous verrez , le caractère
de continuation :+

> "This is a string without a closing quote

+
+
+ HELP I'M STUCK
Si cela vous arrive, appuyez sur Élire et réessayez !
Pour inclure un guillemet simple ou double littéral dans une
chaîne, vous pouvez l’utiliser pour l'"échapper » :\

double_quote <- "\"" # or '"'

single_quote <- '\'' # or "'"
Cela signifie que si vous souhaitez inclure une barre oblique
inverse littérale, vous devrez la doubler : . "\\"

Attention, la représentation imprimée d’une chaîne n’est pas la

même que la chaîne elle-même, car la représentation imprimée
montre les échappements. Pour voir le contenu brut de la chaîne,
utilisez :writeLines()

x <- c("\"", "\\")

x
#> [1] "\"" "\\"
writeLines(x)
#> "
#> \
Il y a une poignée d’autres personnages spéciaux. Les plus
courants sont , saut de ligne et , tab, mais vous pouvez voir la
liste complète en demandant de l’aide sur : , ou . Vous verrez
aussi parfois des chaînes de caractères comme , c’est une façon
d’écrire des caractères non anglais qui fonctionne sur toutes les
plateformes :"\n""\t""?'"'?"'""\u00b5"

x <- "\u00b5"
x
#> [1] "µ"
Plusieurs chaînes de caractères sont souvent stockées dans un
vecteur de caractères, que vous pouvez créer avec : c()

c("one", "two", "three")

#> [1] "one" "two" "three"

14.2.1 Longueur de la corde

Base R contient de nombreuses fonctions pour travailler avec des
chaînes de caractères, mais nous les éviterons car elles peuvent
être incohérentes, ce qui les rend difficiles à retenir. Au lieu de
cela, nous utiliserons les fonctions de stringr. Ceux-ci ont des
noms plus intuitifs et commencent tous par . Par exemple, vous
indique le nombre de caractères d’une chaîne : str_str_length()

str_length(c("a", "R for data science", NA))

#> [1] 1 18 NA
Le préfixe commun est particulièrement utile si vous utilisez
RStudio, car la saisie déclenchera l’autocomplétion, ce qui vous
permettra de voir toutes les fonctions de stringr : str_str_
14.2.2 Combinaison de cordes
Pour combiner deux ou plusieurs cordes, utilisez : str_c()

str_c("x", "y")
#> [1] "xy"
str_c("x", "y", "z")
#> [1] "xyz"
Utilisez l’argument pour contrôler la façon dont ils sont
séparés :sep

str_c("x", "y", sep = ", ")

#> [1] "x, y"
Comme la plupart des autres fonctions de R, les valeurs
manquantes sont contagieuses. Si vous souhaitez qu’ils
s’impriment au format , utilisez :"NA"str_replace_na()

x <- c("abc", NA)

str_c("|-", x, "-|")
#> [1] "|-abc-|" NA
str_c("|-", str_replace_na(x), "-|")
#> [1] "|-abc-|" "|-NA-|"
Comme indiqué ci-dessus, est vectorisé, et il recycle
automatiquement les vecteurs les plus courts à la même longueur
que les plus longs :str_c()

str_c("prefix-", c("a", "b", "c"), "-suffix")

#> [1] "prefix-a-suffix" "prefix-b-suffix" "prefix-c-suffix"
Les objets de longueur 0 sont déposés silencieusement. Ceci est
particulièrement utile en conjonction avec :if

name <- "Hadley"

time_of_day <- "morning"
birthday <- FALSE

str_c(
"Good ", time_of_day, " ", name,
if (birthday) " and HAPPY BIRTHDAY",
"."
)
#> [1] "Good morning Hadley."
Pour réduire un vecteur de chaînes en une seule chaîne,
utilisez :collapse

str_c(c("x", "y", "z"), collapse = ", ")

#> [1] "x, y, z"

14.2.3 Sous-ensemble de chaînes

Vous pouvez extraire des parties d’une chaîne à l’aide de . Ainsi
que la chaîne, les prises et les arguments qui donnent la position
(inclusive) de la sous-chaîne :str_sub()str_sub()startend

x <- c("Apple", "Banana", "Pear")

str_sub(x, 1, 3)
#> [1] "App" "Ban" "Pea"
# negative numbers count backwards from end
str_sub(x, -3, -1)
#> [1] "ple" "ana" "ear"
Notez qu’il n’échouera pas si la chaîne est trop courte : elle
renverra simplement autant que possible :str_sub()

str_sub("a", 1, 5)
#> [1] "a"
Vous pouvez également utiliser le formulaire d’affectation de pour
modifier les chaînes de caractères :str_sub()

str_sub(x, 1, 1) <- str_to_lower(str_sub(x, 1, 1))

x
#> [1] "apple" "banana" "pear"

14.2.4 Locales
Ci-dessus, j’avais l’habitude de changer le texte en minuscules.
Vous pouvez également utiliser ou . Cependant, changer de casse
est plus compliqué qu’il n’y paraît à première vue, car différentes
langues ont des règles différentes pour changer de casse. Vous
pouvez choisir l’ensemble de règles à utiliser en spécifiant des
paramètres
régionaux :str_to_lower()str_to_upper()str_to_title()

# Turkish has two i's: with and without a dot, and it

# has a different rule for capitalising them:
str_to_upper(c("i", "ı"))
#> [1] "I" "I"
str_to_upper(c("i", "ı"), locale = "tr")
#> [1] "İ" "I"
Les paramètres régionaux sont spécifiés sous la forme d’un code
de langue ISO 639, qui est une abréviation de deux ou trois
lettres. Si vous ne connaissez pas encore le code de votre
langue, Wikipédia a une bonne liste. Si vous laissez les
paramètres régionaux vides, ils utiliseront les paramètres
régionaux actuels, tels qu’ils sont fournis par votre système
d’exploitation.

Une autre opération importante qui est affectée par les

paramètres régionaux est le tri. Le R de base et les fonctions
trient les chaînes à l’aide des paramètres régionaux actuels. Si
vous souhaitez un comportement robuste sur différents
ordinateurs, vous pouvez utiliser et qui prennent un argument
supplémentaire :order()sort()str_sort()str_order()locale

x <- c("apple", "eggplant", "banana")

str_sort(x, locale = "en") # English

#> [1] "apple" "banana" "eggplant"

str_sort(x, locale = "haw") # Hawaiian

#> [1] "apple" "eggplant" "banana"

14.2.5 Exercices
1. Dans le code qui n’utilise pas stringr, vous verrez souvent
et . Quelle est la différence entre les deux fonctions ? Qu’est-
ce que la fonction stringr ? Ils équivalent à ? En quoi les
fonctions diffèrent-elles dans leur manipulation de ?
paste()paste0()NA

2. Dans vos propres mots, décrivez la différence entre les

arguments et de .sepcollapsestr_c()

3. Utilisez et pour extraire le caractère du milieu de une corde.

Que ferez-vous si la chaîne comporte un nombre pair de
caractères ?str_length()str_sub()

4. Qu’est-ce que ça fait ? Quand pourriez-vous vouloir

l’utiliser ?str_wrap()

5. Qu’est-ce que ça fait ? Quel est le contraire de ?

str_trim()str_trim()

6. Écrivez une fonction qui transforme (par exemple) un

vecteur en la chaîne . Réfléchissez bien à ce qu’il devrait
faire si étant donné un vecteur de longueur 0, 1 ou 2. c("a",
"b", "c")a, b, and c

14.3 Correspondance de motifs avec des

expressions régulières
Les expressions rationnelles sont un langage très laconique qui
vous permet de décrire des motifs en chaînes. Il faut un peu de
temps pour s’y retrouver, mais une fois que vous les aurez
compris, vous les trouverez extrêmement utiles.

Pour apprendre les expressions régulières, nous allons utiliser et .

Ces fonctions prennent un vecteur de caractère et une expression
régulière, et vous montrent comment ils correspondent. Nous
allons commencer par des expressions régulières très simples,
puis devenir progressivement de plus en plus compliqués. Une fois
que vous aurez maîtrisé le filtrage des motifs, vous apprendrez à
appliquer ces idées avec diverses fonctions de
cordage.str_view()str_view_all()

14.3.1 Correspondances de base

Les motifs les plus simples correspondent à des chaînes exactes :

x <- c("apple", "banana", "pear")

str_view(x, "an")
#> [2] │ b<an><an>a
L’étape suivante en termes de complexité est , qui correspond à
n’importe quel caractère (à l’exception d’un saut de ligne) : .

str_view(x, ".a.")
#> [2] │ <ban>ana
#> [3] │ p<ear>
Mais si « » correspond à n’importe quel caractère, comment
faites-vous correspondre au caractère « » ? Vous devez utiliser un
« échappement » pour indiquer à l’expression régulière que vous
souhaitez lui correspondre exactement, et non utiliser son
comportement spécial. Comme les chaînes, les expressions
rationnelles utilisent la barre oblique inverse, , pour échapper à un
comportement spécial. Donc, pour correspondre à un , vous avez
besoin de l’expression rationnelle . Malheureusement, cela crée
un problème. Nous utilisons des chaînes de caractères pour
représenter des expressions régulières, et il est également utilisé
comme symbole d’échappement dans les chaînes. Donc, pour
créer l’expression régulière, nous avons besoin de la
chaîne ...\.\.\\."\\."

# To create the regular expression, we need \\

dot <- "\\."

# But the expression itself only contains one:

writeLines(dot)
#> \.

# And this tells R to look for an explicit .

str_view(c("abc", "a.c", "bef"), "a\\.c")
#> [2] │ <a.c>
Si est utilisé comme caractère d’échappement dans les
expressions régulières, comment faire correspondre un littéral ?
Eh bien, vous devez l’échapper, en créant l’expression régulière .
Pour créer cette expression régulière, vous devez utiliser une
chaîne, qui doit également échapper . Cela signifie que pour
correspondre à un littéral, vous devez écrire - vous avez besoin de
quatre barres obliques inverses pour correspondre à
une !\\\\\\"\\\\"

x <- "a\\b"
writeLines(x)
#> a\b

str_view(x, "\\\\")
#> [1] │ a<\>b
Dans ce livre, je vais écrire l’expression régulière comme et les
chaînes qui représentent l’expression régulière comme . \."\\."

14.3.1.1 Exercices
1. Expliquez pourquoi chacune de ces chaînes ne correspond
pas à un : , , .\"\""\\""\\\"

2. Comment assortiriez-vous la séquence ?"'\

3. À quels modèles l’expression régulière correspondra-t-elle ?

Comment le représenteriez-vous sous forme de chaîne de
caractères ?\..\..\..

14.3.2 Ancrages
Par défaut, les expressions régulières correspondent à n’importe
quelle partie d’une chaîne. Il est souvent
utile d’ancrer l’expression régulière de manière à ce qu’elle
corresponde au début ou à la fin de la chaîne. Vous pouvez utiliser
:

 ^ pour correspondre au début de la chaîne.

 $ pour correspondre à l’extrémité de la chaîne.

x <- c("apple", "banana", "pear")

str_view(x, "^a")
#> [1] │ <a>pple
str_view(x, "a$")
#> [2] │ banan<a>
Pour vous rappeler lequel est lequel, essayez ce moyen
mnémotechnique que j’ai appris d’Evan Misshula : si vous
commencez par le pouvoir (), vous finissez par l’argent (). ^$
Pour forcer une expression régulière à ne correspondre qu’à une
chaîne complète, ancrez-la avec et :^$

x <- c("apple pie", "apple", "apple cake")

str_view(x, "apple")
#> [1] │ <apple> pie
#> [2] │ <apple>
#> [3] │ <apple> cake
str_view(x, "^apple$")
#> [2] │ <apple>
Vous pouvez également faire correspondre la limite entre les mots
avec . Je ne l’utilise pas souvent dans R, mais je l’utilise parfois
lorsque je fais une recherche dans RStudio lorsque je veux trouver
le nom d’une fonction qui est un composant d’autres fonctions.
Par exemple, je vais rechercher pour éviter de correspondre à , ,
et ainsi de suite.\b\bsum\bsummarisesummaryrowsum

14.3.2.1 Exercices
1. Comment feriez-vous correspondre la chaîne littérale ? "$^$"

2. Étant donné le corpus de mots courants dans , créer des

expressions qui trouvent tous les mots qui :stringr::words

1. Commencez par « y ».
2. Terminez par « x »
3. Font exactement trois lettres. (Ne trichez pas en
utilisant !)str_length()
4. Avoir sept lettres ou plus.

Étant donné que cette liste est longue, vous pouvez utiliser
l’argument pour afficher uniquement les mots
correspondants ou non correspondants.matchstr_view()

14.3.3 Classes de personnages et alternatives

Il existe un certain nombre de motifs spéciaux qui correspondent
à plus d’un personnage. Vous avez déjà vu , qui correspond à
n’importe quel caractère à l’exception d’un saut de ligne. Il existe
quatre autres outils utiles :.

 \d: correspond à n’importe quel chiffre.

 \s: correspond à n’importe quel espace (par exemple,
espace, tabulation, nouvelle ligne).
 [abc]: correspond à A, B ou C.
 [^abc]: correspond à tout sauf A, B ou C.
N’oubliez pas que pour créer une expression régulière contenant
ou , vous devez échapper le pour la chaîne, vous devez donc taper
ou .\d\s\"\\d""\\s"

Une classe de caractères contenant un seul caractère est une

bonne alternative aux échappements de barre oblique inverse
lorsque vous souhaitez inclure un seul métacaractère dans une
expression régulière. Beaucoup de gens trouvent cela plus lisible.

# Look for a literal character that normally has special meaning in a regex
str_view(c("abc", "a.c", "a*c", "a c"), "a[.]c")
#> [2] │ <a.c>
str_view(c("abc", "a.c", "a*c", "a c"), ".[*]c")
#> [3] │ <a*c>
str_view(c("abc", "a.c", "a*c", "a c"), "a[ ]")
#> [4] │ <a >c
Cela fonctionne pour la plupart (mais pas tous) des
métacaractères regex : . Malheureusement, quelques caractères
ont une signification particulière même à l’intérieur d’une classe
de caractères et doivent être gérés avec des échappements de
barre oblique inverse : et .$.|?*+()[{]\^-

Vous pouvez utiliser l’alternance pour choisir entre un ou plusieurs

motifs alternatifs. Par exemple, correspondra soit '"abc"', soit .
Notez que l’ordre de priorité pour est faible, de sorte que
correspond ou non ou . Comme pour les expressions
mathématiques, si la priorité devient déroutante, utilisez des
parenthèses pour indiquer clairement ce que vous voulez : abc|
d..f"deaf"|abc|xyzabcxyzabcyzabxyz

str_view(c("grey", "gray"), "gr(e|a)y")

#> [1] │ <grey>
#> [2] │ <gray>

14.3.3.1 Exercices
1. Créez des expressions régulières pour rechercher tous les
mots qui :

1. Commencez par une voyelle.

2. Qui ne contiennent que des consonnes. (Astuce :

penser à l’appariement voyelles « not ».)

3. Terminez par , mais pas par .edeed

4. Terminez par ou .ingise

2. Vérifier empiriquement la règle « i avant e sauf après c ».

 3. Le « q » est-il toujours suivi d’un « u » ?

4. Écrivez une expression régulière qui correspond à un mot s’il

est probablement écrit en anglais britannique, pas en anglais
américain.

5. Créez une expression régulière qui correspondra aux

numéros de téléphone comme c’est le cas rédigés dans
votre pays.

14.3.4 Répétition
L’étape suivante consiste à contrôler le nombre de fois qu’un
motif correspond :

 ?: 0 ou 1
 +: 1 ou plus
 *: 0 ou plus

x <- "1888 is the longest year in Roman numerals: MDCCCLXXXVIII"

str_view(x, "CC?")
#> [1] │ 1888 is the longest year in Roman numerals: MD<CC><C>LXXXVIII
str_view(x, "CC+")
#> [1] │ 1888 is the longest year in Roman numerals: MD<CCC>LXXXVIII
str_view(x, 'C[LX]+')
#> [1] │ 1888 is the longest year in Roman numerals: MDCC<CLXXX>VIII
Notez que la priorité de ces opérateurs est élevée, vous pouvez
donc écrire : pour correspondre aux orthographes américaines ou
britanniques. Cela signifie que la plupart des utilisations auront
besoin de parenthèses, comme .colou?rbana(na)+

Vous pouvez également spécifier le nombre de correspondances

avec précision :

 {n}: exactement n
 {n,}: n ou plus
 {,m}: au plus m
 {n,m}: entre n et m

str_view(x, "C{2}")
#> [1] │ 1888 is the longest year in Roman numerals: MD<CC>CLXXXVIII
str_view(x, "C{2,}")
#> [1] │ 1888 is the longest year in Roman numerals: MD<CCC>LXXXVIII
str_view(x, "C{2,3}")
#> [1] │ 1888 is the longest year in Roman numerals: MD<CCC>LXXXVIII
Par défaut ces correspondances sont « gourmandes » : elles
correspondront à la chaîne la plus longue possible. Vous pouvez
les rendre « paresseux », en faisant correspondre la chaîne la plus
courte possible en mettant un après eux. Il s’agit d’une
fonctionnalité avancée des expressions régulières, mais il est utile
de savoir qu’elle existe :?

str_view(x, 'C{2,3}?')
#> [1] │ 1888 is the longest year in Roman numerals: MD<CC>CLXXXVIII
str_view(x, 'C[LX]+?')
#> [1] │ 1888 is the longest year in Roman numerals: MDCC<CL>XXXVIII

14.3.4.1 Exercices
1. Décrivez les équivalents de , , sous la forme. ?+*{m,n}

2. Décrivez en mots ce à quoi correspondent ces expressions

régulières : (lisez attentivement pour voir si j’utilise une
expression régulière ou une chaîne de caractères qui définit
une expression régulière.)

1. ^.*$
2. "\\{.+\\}"
3. \d{4}-\d{2}-\d{2}
4. "\\\\{4}"
3. Créez des expressions régulières pour rechercher tous les
mots qui :

1. Commencez par trois consonnes.

2. Avoir trois voyelles ou plus à la suite.
3. Avoir deux paires voyelle-consonnes ou plus à la suite.
4. Résolvez les mots croisés regexp pour débutants
à https://regexcrossword.com/challenges/beginner.

14.3.5 Regroupement et références arrière

Plus tôt, vous avez appris les parenthèses comme moyen de
désambiguïser des expressions complexes. Les parenthèses
créent également un groupe de capture numéroté (numéro 1, 2,
etc.). Un groupe de capture stocke la partie de la
chaîne correspondant à la partie de l’expression régulière à
l’intérieur des parenthèses. Vous pouvez faire référence au même
texte que celui précédemment mis en correspondance par un
groupe de capture avec des références arrière, comme , etc. Par
exemple, l’expression régulière suivante trouve tous les fruits qui
ont une paire de lettres répétées.\1\2

str_view(fruit, "(..)\\1", match = TRUE)

#> [4] │ b<anan>a
#> [20] │ <coco>nut
#> [22] │ <cucu>mber
#> [41] │ <juju>be
#> [56] │ <papa>ya
#> [73] │ s<alal> berry
(Vous verrez également sous peu comment ils sont utiles en
conjonction avec .)str_match()

14.3.5.1 Exercices
1. Décris, en mots, ce que ces expressions correspondront :

1. (.)\1\1
2. "(.)(.)\\2\\1"
3. (..)\1
4. "(.).\\1.\\1"
5. "(.)(.)(.).*\\3\\2\\1"
2. Construire des expressions régulières pour correspondre à
des mots qui :

1. Commencez et terminez avec le même personnage.

2. Contenir une paire de lettres répétée (Par exemple,

« église » contient « ch » répété deux fois.)

3. Contenir une lettre répétée à au moins trois endroits

(Par exemple, « onze » contient trois « e ».)

14.4 Outils
Maintenant que vous avez appris les bases des expressions
régulières, il est temps d’apprendre à les appliquer à des
problèmes réels. Dans cette section, vous allez découvrir un large
éventail de fonctions de stringr qui vous permettent de :

 Déterminez quelles cordes correspondent à un motif.

 Trouvez les positions des correspondances.
 Extraire le contenu des matchs.
 Remplacez les correspondances par de nouvelles valeurs.
 Divisez une chaîne en fonction d’une correspondance.

Une mise en garde avant de continuer : parce que les expressions

régulières sont si puissantes, il est facile d’essayer de résoudre
chaque problème avec une seule expression régulière. Comme l’a
dit Jamie Zawinski :

Certaines personnes, lorsqu’elles sont confrontées à un problème,

se disent « Je sais, je vais utiliser des expressions. Maintenant, ils
ont deux problèmes.
À titre d’avertissement, consultez cette expression régulière qui
vérifie si une adresse e-mail est valide :

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?

[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:
(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:
(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\
n)?[
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \
000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\
031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\]
(?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\
r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:
(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\
n)?[
\t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?
[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\
n)?[
\t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \
t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?
[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \
t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \
t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:
(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:
(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[
\t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\
031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\
031]+(?
:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\]
(?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\
n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\
[\]
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\
r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:
[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\
[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?
[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\
["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \
t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\
["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \
000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\
r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:
[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\
[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:
[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\
[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:
[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\
[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\]
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\]
\0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\
r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:
[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\
[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \
t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\
["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \
t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\
[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\
s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\
["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.
(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|
(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[
\t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
\t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \
t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \
t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|
(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\
["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\
r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?
=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\
r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\
["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\
n)?[
\t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\
["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?
[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\
["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \
t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\
["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:
(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?
=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \
t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \
t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)
(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\
>(?:(
?:\r\n)?[ \t])*))*)?;\s*)
Il s’agit d’un exemple quelque peu pathologique (car les adresses
e-mail sont en fait étonnamment complexes), mais il est utilisé
dans le code réel. Voir la discussion stackoverflow
à http://stackoverflow.com/a/201378 pour plus de détails.

N’oubliez pas que vous êtes dans un langage de programmation

et que vous avez d’autres outils à votre disposition. Au lieu de
créer une expression régulière complexe, il est souvent plus facile
d’écrire une série d’expressions rationnelles plus simples. Si vous
vous retrouvez coincé à essayer de créer une seule expression
rationnelle qui résout votre problème, prenez du recul et
réfléchissez à la possibilité de décomposer le problème en petits
morceaux, en résolvant chaque défi avant de passer au suivant.

14.4.1 Détecter les correspondances

Pour déterminer si un vecteur de caractère correspond à un motif,
utilisez . Il renvoie un vecteur logique de la même longueur que
l’entrée :str_detect()

x <- c("apple", "banana", "pear")

str_detect(x, "e")
#> [1] TRUE FALSE TRUE
N’oubliez pas que lorsque vous utilisez un vecteur logique dans un
contexte numérique, devient 0 et devient 1. C’est utile si vous
voulez répondre à des questions sur les correspondances sur un
vecteur plus grand :FALSETRUEsum()mean()

# How many common words start with t?

sum(str_detect(words, "^t"))
#> [1] 65
# What proportion of common words end with a vowel?
mean(str_detect(words, "[aeiou]$"))
#> [1] 0.2765306
Lorsque vous avez des conditions logiques complexes (par
exemple, correspondre à a ou b mais pas à c sauf d), il est
souvent plus facile de combiner plusieurs appels avec des
opérateurs logiques, plutôt que d’essayer de créer une seule
expression régulière. Par exemple, voici deux façons de trouver
tous les mots qui ne contiennent pas de voyelles : str_detect()

# Find all words containing at least one vowel, and negate

no_vowels_1 <- !str_detect(words, "[aeiou]")
# Find all words consisting only of consonants (non-vowels)
no_vowels_2 <- str_detect(words, "^[^aeiou]+$")
identical(no_vowels_1, no_vowels_2)
#> [1] TRUE
Les résultats sont identiques, mais je pense que la première
approche est nettement plus facile à comprendre. Si votre
expression régulière devient trop compliquée, essayez de la
diviser en petits morceaux, en donnant un nom à chaque élément,
puis en combinant les éléments avec des opérations logiques.

Une utilisation courante de consiste à sélectionner les éléments

qui correspondent à un motif. Vous pouvez le faire avec le sous-
ensemble logique, ou l’enveloppe
pratique :str_detect()str_subset()
words[str_detect(words, "x$")]
#> [1] "box" "sex" "six" "tax"
str_subset(words, "x$")
#> [1] "box" "sex" "six" "tax"
En règle générale, cependant, vos chaînes seront une colonne
d’un bloc de données, et vous voudrez utiliser un filtre à la place :

df <- tibble(
word = words,
i = seq_along(word)
)
df %>%
filter(str_detect(word, "x$"))
#> # A tibble: 4 × 2
#> word i
#> <chr> <int>
#> 1 box 108
#> 2 sex 747
#> 3 six 772
#> 4 tax 841
Une variante de is : plutôt qu’un simple oui ou non, il vous indique
combien de correspondances il y a dans une
chaîne :str_detect()str_count()

x <- c("apple", "banana", "pear")

str_count(x, "a")
#> [1] 1 3 1

# On average, how many vowels per word?

mean(str_count(words, "[aeiou]"))
#> [1] 1.991837
Il est naturel de l’utiliser avec :str_count()mutate()

df %>%
mutate(
vowels = str_count(word, "[aeiou]"),
consonants = str_count(word, "[^aeiou]")
)
#> # A tibble: 980 × 4
#> word i vowels consonants
#> <chr> <int> <int> <int>
#> 1 a 1 1 0
#> 2 able 2 2 2
#> 3 about 3 3 2
#> 4 absolute 4 4 4
#> 5 accept 5 2 4
#> 6 account 6 3 4
#> # ℹ 974 more rows
Notez que les correspondances ne se chevauchent jamais. Par
exemple, dans , combien de fois le motif correspondra-t-il ? Les
expressions régulières disent deux, pas trois : "abababa""aba"

str_count("abababa", "aba")
#> [1] 2
str_view_all("abababa", "aba")
#> Warning: `str_view()` was deprecated in stringr 1.5.0.
#> ℹ Please use `str_view_all()` instead.
#> This warning is displayed once every 8 hours.
#> Call `lifecycle::last_lifecycle_warnings()` to see where this warning
was
#> generated.
#> [1] │ <aba>b<aba>
Notez l’utilisation de . Comme vous l’apprendrez bientôt, de
nombreuses fonctions de stringr sont disponibles par paires : une
fonction fonctionne avec une seule correspondance, et l’autre
fonctionne avec toutes les correspondances. La deuxième fonction
aura le suffixe .str_view_all()_all

14.4.1.1 Exercices
1. Pour chacun des défis suivants, essayez de le résoudre en
utilisant à la fois un seul expression régulière et une
combinaison de plusieurs appels.str_detect()

1. Recherchez tous les mots qui commencent ou se

terminent par .x

2. Trouvez tous les mots qui commencent par une voyelle

et se terminent par une consonne.

3. Y a-t-il des mots qui contiennent au moins un de

chaque différent ? voyelle?

2. Quel mot a le plus grand nombre de voyelles ? Quel mot a le

plus haut proportion de voyelles ? (Indice : quel est le
dénominateur ?)

14.4.2 Extraire les correspondances

Pour extraire le texte réel d’une correspondance, utilisez . Pour le
montrer, nous allons avoir besoin d’un exemple plus compliqué. Je
vais utiliser les phrases de Harvard, qui ont été conçues pour
tester les systèmes VOIP, mais qui sont également utiles pour
pratiquer les expressions régulières. Ceux-ci sont fournis
en :str_extract()stringr::sentences

length(sentences)
#> [1] 720
head(sentences)
#> [1] "The birch canoe slid on the smooth planks."
#> [2] "Glue the sheet to the dark blue background."
#> [3] "It's easy to tell the depth of a well."
#> [4] "These days a chicken leg is a rare dish."
#> [5] "Rice is often served in round bowls."
#> [6] "The juice of lemons makes fine punch."
Imaginons que nous voulions trouver toutes les phrases qui
contiennent une couleur. Nous créons d’abord un vecteur de noms
de couleurs, puis nous le transformons en une seule expression
régulière :

colours <- c("red", "orange", "yellow", "green", "blue", "purple")

colour_match <- str_c(colours, collapse = "|")
colour_match
#> [1] "red|orange|yellow|green|blue|purple"
Maintenant, nous pouvons sélectionner les phrases qui
contiennent une couleur, puis extraire la couleur pour déterminer
de quelle couleur il s’agit :

has_colour <- str_subset(sentences, colour_match)

matches <- str_extract(has_colour, colour_match)
head(matches)
#> [1] "blue" "blue" "red" "red" "red" "blue"
Notez que n’extrait que la première correspondance. Nous
pouvons le voir plus facilement en sélectionnant d’abord toutes
les phrases qui ont plus de 1 correspondance : str_extract()

more <- sentences[str_count(sentences, colour_match) > 1]

str_view_all(more, colour_match)
#> [1] │ It is hard to erase <blue> or <red> ink.
#> [2] │ The <green> light in the brown box flicke<red>.
#> [3] │ The sky in the west is tinged with <orange> <red>.

str_extract(more, colour_match)
#> [1] "blue" "green" "orange"
Il s’agit d’un modèle courant pour les fonctions stringr, car
l’utilisation d’une seule correspondance vous permet d’utiliser des
structures de données beaucoup plus simples. Pour obtenir toutes
les correspondances, utilisez . Il renvoie une
liste :str_extract_all()

str_extract_all(more, colour_match)
#> [[1]]
#> [1] "blue" "red"
#>
#> [[2]]
#> [1] "green" "red"
#>
#> [[3]]
#> [1] "orange" "red"
Vous allez en savoir plus sur les listes dans les listes et l’itération.

Si vous utilisez , vous obtiendrez une matrice avec des

correspondances courtes étendues à la même longueur que la
plus longue :simplify = TRUEstr_extract_all()

str_extract_all(more, colour_match, simplify = TRUE)

#> [,1] [,2]
#> [1,] "blue" "red"
#> [2,] "green" "red"
#> [3,] "orange" "red"

x <- c("a", "a b", "a b c")

str_extract_all(x, "[a-z]", simplify = TRUE)
#> [,1] [,2] [,3]
#> [1,] "a" "" ""
#> [2,] "a" "b" ""
#> [3,] "a" "b" "c"

14.4.2.1 Exercices
1. Dans l’exemple précédent, vous avez peut-être remarqué
que la variable l’expression correspondait à « flickered », qui
n’est pas une couleur. Modifier le regex pour résoudre le
problème.

2. Extrait des données des phrases de Harvard :

1. Le premier mot de chaque phrase.

2. Tous les mots se terminant par .ing
3. Tous les pluriels.

14.4.3 Matchs groupés

Plus tôt dans ce chapitre, nous avons parlé de l’utilisation des
parenthèses pour clarifier la priorité et pour les références arrière
lors de la correspondance. Vous pouvez également utiliser des
parenthèses pour extraire des parties d’une correspondance
complexe. Par exemple, imaginons que nous voulions extraire des
noms des phrases. En tant qu’heuristique, nous chercherons
n’importe quel mot qui vient après « a » ou « the ». Définir un
« mot » dans une expression régulière est un peu délicat, donc
j’utilise ici une approximation simple : une séquence d’au moins
un caractère qui n’est pas un espace.

noun <- "(a|the) ([^ ]+)"

has_noun <- sentences %>%

str_subset(noun) %>%
head(10)
has_noun %>%
str_extract(noun)
#> [1] "the smooth" "the sheet" "the depth" "a chicken" "the parked"
#> [6] "the sun" "the huge" "the ball" "the woman" "a helps"
str_extract() nous donne le match complet ; donne chaque
composant individuel. Au lieu d’un vecteur de caractères, il
renvoie une matrice, avec une colonne pour la correspondance
complète suivie d’une colonne pour chaque groupe : str_match()
has_noun %>%
str_match(noun)
#> [,1] [,2] [,3]
#> [1,] "the smooth" "the" "smooth"
#> [2,] "the sheet" "the" "sheet"
#> [3,] "the depth" "the" "depth"
#> [4,] "a chicken" "a" "chicken"
#> [5,] "the parked" "the" "parked"
#> [6,] "the sun" "the" "sun"
#> [7,] "the huge" "the" "huge"
#> [8,] "the ball" "the" "ball"
#> [9,] "the woman" "the" "woman"
#> [10,] "a helps" "a" "helps"
(Sans surprise, notre heuristique pour détecter les noms est
médiocre, et reprend également des adjectifs comme lisse et
parqué.)

Si vos données se trouvent dans un tibble, il est souvent plus

facile de l’utiliser. Cela fonctionne comme mais vous oblige à
nommer les correspondances, qui sont ensuite placées dans de
nouvelles colonnes :tidyr::extract()str_match()

tibble(sentence = sentences) %>%

tidyr::extract(
sentence, c("article", "noun"), "(a|the) ([^ ]+)",
remove = FALSE
)
#> # A tibble: 720 × 3
#> sentence article noun
#> <chr> <chr> <chr>
#> 1 The birch canoe slid on the smooth planks. the smooth
#> 2 Glue the sheet to the dark blue background. the sheet
#> 3 It's easy to tell the depth of a well. the depth
#> 4 These days a chicken leg is a rare dish. a chicken
#> 5 Rice is often served in round bowls. <NA> <NA>
#> 6 The juice of lemons makes fine punch. <NA> <NA>
#> # ℹ 714 more rows
Par exemple, si vous voulez que toutes les correspondances
correspondent à chaque chaîne, vous aurez besoin
de .str_extract()str_match_all()

14.4.3.1 Exercices
1. Trouvez tous les mots qui viennent après un « nombre »
comme « un », « deux », « trois », etc. Sortez à la fois le
chiffre et le mot.

2. Trouvez toutes les contractions. Séparez les morceaux avant

et après le apostrophe.
14.4.4 Remplacement des allumettes
str_replace() et vous permettent de remplacer les
correspondances par de nouvelles chaînes. L’utilisation la plus
simple consiste à remplacer un motif par une ficelle
fixe :str_replace_all()

x <- c("apple", "pear", "banana")

str_replace(x, "[aeiou]", "-")
#> [1] "-pple" "p-ar" "b-nana"
str_replace_all(x, "[aeiou]", "-")
#> [1] "-ppl-" "p--r" "b-n-n-"
Avec vous pouvez effectuer plusieurs remplacements en
fournissant un vecteur nommé :str_replace_all()

x <- c("1 house", "2 cars", "3 people")

str_replace_all(x, c("1" = "one", "2" = "two", "3" = "three"))
#> [1] "one house" "two cars" "three people"
Au lieu de remplacer par une chaîne fixe, vous pouvez utiliser des
références arrière pour insérer des composants de la
correspondance. Dans le code suivant, j’inverse l’ordre des
deuxième et troisième mots.

sentences %>%
str_replace("([^ ]+) ([^ ]+) ([^ ]+)", "\\1 \\3 \\2") %>%
head(5)
#> [1] "The canoe birch slid on the smooth planks."
#> [2] "Glue sheet the to the dark blue background."
#> [3] "It's to easy tell the depth of a well."
#> [4] "These a days chicken leg is a rare dish."
#> [5] "Rice often is served in round bowls."

14.4.4.1 Exercices
1. Remplacez toutes les barres obliques d’une chaîne par des
barres obliques inverses.

2. Implémentez une version simple de l’utilisation

de .str_to_lower()replace_all()

3. Basculez la première et la dernière lettre dans . Laquelle de

ces cordes Sont-ils encore des mots ?words

14.4.5 Fractionnement
Utilisez-le pour diviser une ficelle en morceaux. Par exemple, nous
pourrions diviser des phrases en mots :str_split()

sentences %>%
head(5) %>%
str_split(" ")
#> [[1]]
#> [1] "The" "birch" "canoe" "slid" "on" "the" "smooth"
#> [8] "planks."
#>
#> [[2]]
#> [1] "Glue" "the" "sheet" "to" "the"
#> [6] "dark" "blue" "background."
#>
#> [[3]]
#> [1] "It's" "easy" "to" "tell" "the" "depth" "of" "a"
"well."
#>
#> [[4]]
#> [1] "These" "days" "a" "chicken" "leg" "is" "a"
#> [8] "rare" "dish."
#>
#> [[5]]
#> [1] "Rice" "is" "often" "served" "in" "round" "bowls."
Étant donné que chaque composant peut contenir un nombre
différent de pièces, cela renvoie une liste. Si vous travaillez avec
un vecteur de longueur 1, la chose la plus simple est d’extraire
simplement le premier élément de la liste :

"a|b|c|d" %>%
str_split("\\|") %>%
.[[1]]
#> [1] "a" "b" "c" "d"
Sinon, comme les autres fonctions stringr qui renvoient une liste,
vous pouvez utiliser pour retourner une matrice : simplify = TRUE

sentences %>%
head(5) %>%
str_split(" ", simplify = TRUE)
#> [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
#> [1,] "The" "birch" "canoe" "slid" "on" "the" "smooth" "planks."
#> [2,] "Glue" "the" "sheet" "to" "the" "dark" "blue"
"background."
#> [3,] "It's" "easy" "to" "tell" "the" "depth" "of" "a"
#> [4,] "These" "days" "a" "chicken" "leg" "is" "a" "rare"
#> [5,] "Rice" "is" "often" "served" "in" "round" "bowls." ""
#> [,9]
#> [1,] ""
#> [2,] ""
#> [3,] "well."
#> [4,] "dish."
#> [5,] ""
Vous pouvez également demander un nombre maximum de
pièces :

fields <- c("Name: Hadley", "Country: NZ", "Age: 35")

fields %>% str_split(": ", n = 2, simplify = TRUE)
#> [,1] [,2]
#> [1,] "Name" "Hadley"
#> [2,] "Country" "NZ"
#> [3,] "Age" "35"
Au lieu de diviser les chaînes par motifs, vous pouvez également
diviser par caractère, ligne, phrase et mot s : boundary()
x <- "This is a sentence. This is another sentence."
str_view_all(x, boundary("word"))
#> [1] │ <This> <is> <a> <sentence>. <This> <is> <another> <sentence>.

str_split(x, " ")[[1]]

#> [1] "This" "is" "a" "sentence." "" "This"
#> [7] "is" "another" "sentence."
str_split(x, boundary("word"))[[1]]
#> [1] "This" "is" "a" "sentence" "This" "is"
"another"
#> [8] "sentence"

14.4.5.1 Exercices
1. Diviser une chaîne de caractères en individu
Composants."apples, pears, and bananas"

2. Pourquoi est-il préférable de se séparer par plutôt que ?

boundary("word")" "

3. À quoi sert le fractionnement avec une chaîne vide () ?

Expérimenter, et Lisez ensuite la documentation. ""

14.4.6 Trouver des correspondances

str_locate() et vous donne les positions de départ et d’arrivée de
chaque match. Celles-ci sont particulièrement utiles lorsqu’aucune
des autres fonctions ne fait exactement ce que vous voulez. Vous
pouvez l’utiliser pour trouver le motif correspondant, pour
l’extraire et/ou le modifier.str_locate_all()str_locate()str_sub()

14.5 Autres types de motifs

Lorsque vous utilisez un motif qui est une chaîne de caractères, il
est automatiquement encapsulé dans un appel à : regex()

# The regular call:

str_view(fruit, "nana")
# Is shorthand for
str_view(fruit, regex("nana"))
Vous pouvez utiliser les autres arguments de pour contrôler les
détails de la correspondance :regex()

 permet aux caractères de correspondre soit

ignore_case = TRUE
à leurs majuscules, soit à Formes minuscules. Cela utilise
toujours les paramètres régionaux actuels.

 bananas <- c("banana", "Banana", "BANANA")

 str_view(bananas, "banana")
 #> [1] │ <banana>
 str_view(bananas, regex("banana", ignore_case = TRUE))
 #> [1] │ <banana>
  #> [2] │ <Banana>
#> [3] │ <BANANA>
 permet et de correspondre au début et à la fin
multiline = TRUE
de chaque plutôt que le début et la fin de la chaîne
complète.^$

 x <- "Line 1\nLine 2\nLine 3"

 str_extract_all(x, "^Line")[[1]]
 #> [1] "Line"
 str_extract_all(x, regex("^Line", multiline = TRUE))[[1]]
#> [1] "Line" "Line" "Line"
 comments = TRUEvous permet d’utiliser des commentaires et
des espaces pour les expressions régulières complexes sont
plus compréhensibles. Les espaces sont ignorés, tels quels
tout ce qui a suivi . Pour correspondre à un espace littéral,
vous devrez l’échapper : .#"\\ "

 phone <- regex("

 \\(? # optional opening parens
 (\\d{3}) # area code
 [) -]? # optional closing parens, space, or dash
 (\\d{3}) # another three numbers
 [ -]? # optional space or dash
 (\\d{3}) # three more numbers
 ", comments = TRUE)

 str_match("514-791-8141", phone)
 #> [,1] [,2] [,3] [,4]
#> [1,] "514-791-814" "514" "791" "814"
 dotall = TRUE permet de tout assortir, y compris ..\n

Il y a trois autres fonctions que vous pouvez utiliser à la place

de :regex()

 fixed(): correspond exactement à la séquence d’octets

spécifiée. Il ignore toutes les expressions régulières
spéciales et fonctionne à un niveau très bas. Cela vous
permet d’éviter les échappées complexes et peut être
beaucoup plus rapide que expressions régulières. Le
microbenchmark suivant montre qu’il s’agit de 3 fois plus
rapide pour un exemple simple.

 microbenchmark::microbenchmark(
 fixed = str_detect(sentences, fixed("the")),
 regex = str_detect(sentences, "the"),
 times = 20
 )
 #> Unit: microseconds
 #> expr min lq mean median uq max neval
 #> fixed 61.7 66.20 92.915 82.1 88.30 354.2 20
#> regex 272.5 279.85 293.130 283.3 288.65 476.1 20
 Attention à l’utilisation de données non anglaises. C’est
problématique parce que Il y a souvent plusieurs façons de
représenter le même personnage. Pour exemple, il y a deux
façons de définir « á » : soit comme un seul caractère, soit
comme sous la forme d’un « A » plus un accent : fixed()

a1 <- "\u00e1"
a2 <- "a\u0301"
c(a1, a2)
#> [1] "á" "á"
a1 == a2
#> [1] FALSE
Ils s’affichent de manière identique, mais comme ils sont
définis différemment, il ne trouve pas de correspondance. Au
lieu de cela, vous pouvez utiliser , défini Ensuite, pour
respecter les règles de comparaison des caractères
humains :fixed()coll()

str_detect(a1, fixed(a2))
#> [1] FALSE
str_detect(a1, coll(a2))
#> [1] TRUE
 coll(): comparer des chaînes à l’aide de règles
de compilationstandard. C’est utile pour effectuer des
correspondances insensibles à la casse. Notez que prend un
paramètre qui contrôle les règles utilisées pour comparer
caractères. Malheureusement, différentes parties du monde
utilisent des règles différentes !coll()locale

 # That means you also need to be aware of the difference

 # when doing case insensitive matches:
 i <- c("I", "İ", "i", "ı")
 i
 #> [1] "I" "İ" "i" "ı"

 str_subset(i, coll("i", ignore_case = TRUE))
 #> [1] "I" "i"
 str_subset(i, coll("i", ignore_case = TRUE, locale = "tr"))
#> [1] "İ" "i"
Les deux et ont des arguments, mais ils ne vous permettent
pas de choisir les paramètres régionaux : ils utilisent toujours
les paramètres régionaux par défaut. Vous pouvez voir ce
que c’est avec le code suivant ; En savoir plus sur Stringi
plus tard.fixed()regex()ignore_case

stringi::stri_locale_info()
#> $Language
#> [1] "c"
#>
#> $Country
#> [1] ""
 #>
#> $Variant
#> [1] ""
#>
#> $Name
#> [1] "c"
L’inconvénient est la vitesse ; parce que les règles de
reconnaissance Les caractères sont les mêmes sont
compliqués, est relativement lent par rapport à
et .coll()coll()regex()fixed()

 Comme vous l’avez vu, vous pouvez utiliser pour faire

correspondre les limites. Vous pouvez également l’utiliser
avec les autres fonctions :str_split()boundary()

 x <- "This is a sentence."

 str_view_all(x, boundary("word"))
 #> [1] │ <This> <is> <a> <sentence>.
 str_extract_all(x, boundary("word"))
 #> [[1]]
#> [1] "This" "is" "a" "sentence"

14.5.1 Exercices
1. Comment trouveriez-vous toutes les chaînes contenant avec
vs. avec?\regex()fixed()

2. Quels sont les cinq mots les plus courants dans ? sentences

14.6 Autres utilisations des expressions

régulières
Il existe deux fonctions utiles dans la base R qui utilisent
également des expressions régulières :

 apropos() Recherche tous les objets disponibles dans

l’environnement global. Ceci est utile si vous ne vous
souvenez pas tout à fait du nom de la fonction.

 apropos("replace")
 #> [1] "%+replace%" "replace" "replace_na"
"setReplaceMethod"
#> [5] "str_replace" "str_replace_all" "str_replace_na"
"theme_replace"
 dir() répertorie tous les fichiers d’un répertoire. L’argument
prend une expression régulière et ne renvoie que les noms
de fichiers qui correspondent au modèle. Par exemple, vous
pouvez trouver tous les fichiers R Markdown dans le fichier
répertoire avec :pattern
  head(dir(pattern = "\\.Rmd$"))
 #> [1] "communicate-plots.Rmd" "communicate.Rmd"
"datetimes.Rmd"
#> [4] "EDA.Rmd" "explore.Rmd" "factors.Rmd"
(Si vous êtes plus à l’aise avec les « globs » comme , vous
pouvez convertir en expressions régulières
avec :*.Rmdglob2rx()

14.7 Stringi
Stringr est construit sur le paquet Stringi. stringr est utile lorsque
vous apprenez car il expose un ensemble minimal de fonctions,
qui ont été soigneusement sélectionnées pour gérer les fonctions
de manipulation de chaînes les plus courantes. Stringi, en
revanche, est conçu pour être complet. Il contient presque toutes
les fonctions dont vous pourriez avoir besoin : stringi a 256
fonctions contre 59 pour stringr.

Si vous avez du mal à faire quelque chose en stringr, cela vaut la

peine de jeter un coup d’œil à stringi. Les packages fonctionnent
de manière très similaire, vous devriez donc être en mesure de
traduire vos connaissances de stringr de manière naturelle. La
principale différence est le préfixe : vs. .str_stri_

14.7.1 Exercices
1. Trouvez les fonctions stringi qui :

1. Comptez le nombre de mots.

2. Recherchez les chaînes dupliquées.
3. Générez du texte aléatoire.
2. Comment contrôlez-vous le langage qui utilise pour
classement?stri_sort()