regex - test - expresiones regulares tutorial

¿Cómo trato con caracteres especiales como / ^ $.?*|+()[{En mi expresión regular?

Question

Quiero hacer coincidir un carácter especial de expresión regular , /^$.?*|+()[{ . Lo intenté:

x <- "a[b"
grepl("[", x)
## Error: invalid regular expression ''['', reason ''Missing '']''''

(Equivalentemente stringr::str_detect(x, "[") o stringi::stri_detect_regex(x, "[") .)

Duplicar el valor para escapar no funciona:

grepl("[[", x)
## Error: invalid regular expression ''[['', reason ''Missing '']''''

Tampoco el uso de una barra invertida:

grepl("/[", x)
## Error: ''/['' is an unrecognized escape in character string starting ""/["

¿Cómo hago coincidir caracteres especiales?

Algunos casos especiales de esto en preguntas que son antiguas y están bien escritas para que sea descarado cerrar como duplicados de esto:
Períodos escapados en expresiones regulares R
¿Cómo escapar de un signo de interrogación en R?
tubería de escape ("|") en una expresión regular

Answer 1

Escapar con una barra invertida doble

R trata las barras invertidas como valores de escape para las constantes de caracteres . (... y también lo hacen las expresiones regulares. De ahí la necesidad de dos barras invertidas al proporcionar un argumento de carácter para un patrón. El primero no es en realidad un carácter, sino que convierte al segundo en un carácter.) Puede ver cómo se procesan con cat .

y <- "double quote: /", tab: /t, newline: /n, unicode point: /u20AC"
print(y)
## [1] "double quote: /", tab: /t, newline: /n, unicode point: €"
cat(y)
## double quote: ", tab: , newline:
## , unicode point: €

Lectura adicional: escapar de una barra diagonal inversa con una barra diagonal inversa en R produce 2 barras diagonales inversas en una cadena, no 1

Para usar caracteres especiales en una expresión regular, el método más simple suele ser escapar de ellos con una barra diagonal inversa, pero como se señaló anteriormente, la barra diagonal inversa en sí misma debe escapar.

grepl("//[", "a[b")
## [1] TRUE

Para hacer coincidir las barras invertidas, debe doble escape, lo que resulta en cuatro barras invertidas.

grepl("////", c("a//b", "a/nb"))
## [1] TRUE FALSE

El paquete rebus contiene constantes para cada uno de los caracteres especiales para ahorrarle barras diagonales.

library(rebus)
OPEN_BRACKET
## [1] "//["
BACKSLASH
## [1] "////"

Para más ejemplos ver:

?SpecialCharacters

Su problema se puede resolver de esta manera:

library(rebus)
grepl(OPEN_BRACKET, "a[b")

Formar una clase de personaje

También puede ajustar los caracteres especiales entre corchetes para formar una clase de caracteres .

grepl("[?]", "a?b")
## [1] TRUE

Dos de los caracteres especiales tienen un significado especial dentro de las clases de caracteres: / y ^ .

La barra invertida aún debe escaparse incluso si está dentro de una clase de personaje.

grepl("[////]", c("a//b", "a/nb"))
## [1] TRUE FALSE

Caret solo necesita escapar si es directamente después del corchete de apertura.

grepl("[ ^]", "a^b") # matches spaces as well.
## [1] TRUE
grepl("[//^]", "a^b")
## [1] TRUE

rebus también te permite formar una clase de personaje.

char_class("?")
## <regex> [?]

Usa una clase de personaje preexistente

Si desea hacer coincidir todos los signos de puntuación, puede usar la clase de carácter [:punct:] .

grepl("[[:punct:]]", c("//", "[", "(", "{", "?", "^", "$"))
## [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE

stringi asigna esto a la Categoría general Unicode para la puntuación, por lo que su comportamiento es ligeramente diferente.

stri_detect_regex(c("//", "[", "(", "{", "?", "^", "$"), "[[:punct:]]")
## [1] TRUE TRUE TRUE TRUE TRUE FALSE FALSE

También puede usar la sintaxis multiplataforma para acceder a un UGC.

stri_detect_regex(c("//", "[", "(", "{", "?", "^", "$"), "//p{P}")
## [1] TRUE TRUE TRUE TRUE TRUE FALSE FALSE

Use escapes / Q / E

Al colocar caracteres entre //Q y //E el motor de expresiones regulares los trata literalmente en lugar de como expresiones regulares.

grepl("//Q.//E", "a.b")
## [1] TRUE

rebus te permite escribir bloques literales de expresiones regulares.

literal(".")
## <regex> /Q./E

No uses expresiones regulares

Las expresiones regulares no siempre son la respuesta. Si desea hacer coincidir una cadena fija, puede hacer, por ejemplo:

grepl("[", "a[b", fixed = TRUE)
stringr::str_detect("a[b", fixed("["))
stringi::stri_detect_fixed("a[b", "[")

Answer 2

Creo que la forma más fácil de unir los personajes como

/^$.?*|+()[

están utilizando clases de caracteres desde R. Considere lo siguiente para limpiar los encabezados de columna de un archivo de datos, que podría contener espacios y caracteres de puntuación:

> library(stringr)
> colnames(order_table) <- str_replace_all(colnames(order_table),"[:punct:]|[:space:]","")

Este enfoque nos permite encadenar las clases de caracteres para que coincidan con los caracteres de puntuación, además de los espacios en blanco, algo de lo que normalmente tendrías que escapar con // para detectar. Puede obtener más información sobre las clases de personajes en esta hoja de trucos a continuación, y también puede escribir ?regexp para ver más información sobre esto.

https://www.rstudio.com/wp-content/uploads/2016/09/RegExCheatsheet.pdf