Chatbot con expresiones regulares

Expresiones regulares

Las expresiones regulares (regexes) son secuencias de caracteres que especifican un patrón de búsqueda en un texto.

Aprender la sintaxis de las expresiones regulares queda fuera del alcance de este tema. Nos centraremos en las expresiones que jq ofrece para usar regexes.

Variante de regex

Distintas herramientas implementan distintas versiones de las expresiones regulares. jq incorpora la librería de regex Oniguruma, que es en gran medida compatible con las regexes de Perl v5.8.

La sintaxis específica que usa jq se puede encontrar en el repositorio de GitHub de Oniguruma.

Funciones de regex

Las expresiones regulares en jq se limitan a un conjunto de filtros.

Coincidencia simple

Cuando necesitas saber si un string coincide con un patrón, usa el filtro test.

STRING | test(REGEX)
STRING | test(REGEX; FLAGS)
STRING | test([REGEX, FLAGS])

Este filtro devuelve un resultado Boolean.

"Hello World!" | test("W")    # => true
"Goodbye Mars" | test("W")    # => false

Información sobre la coincidencia

Cuando necesitas extraer el substring que realmente coincidió con el patrón, usa el filtro match.

STRING | match(REGEX)
STRING | match(REGEX; FLAGS)
STRING | match([REGEX, FLAGS])

Este filtro devuelve:

• nada si no hubo coincidencia, o
• un objeto con varias propiedades si hubo coincidencia.

Este ejemplo busca dos vocales idénticas consecutivas usando la sintaxis de referencia inversa, \1.

"Hello World!" | match("([aeiou])\\1")
# => empty

"Goodbye Mars" | match("([aeiou])\\1")
# => {
#      "offset": 1,
#      "length": 2,
#      "string": "oo",
#      "captures": [
#        {
#          "offset": 1,
#          "length": 1,
#          "string": "o",
#          "name": null
#        }
#      ]
#    }

El filtro match devuelve un objeto por cada coincidencia. Este ejemplo muestra el flag "g" en acción para encontrar todas las vocales.

"Goodbye Mars" | match("[aeiou]"; "g")
# => { "offset": 1, "length": 1, "string": "o", "captures": [] }
#    { "offset": 2, "length": 1, "string": "o", "captures": [] }
#    { "offset": 6, "length": 1, "string": "e", "captures": [] }
#    { "offset": 9, "length": 1, "string": "a", "captures": [] }

Substrings capturados

De forma similar al filtro match, el filtro capture devuelve un objeto si hubo coincidencia.

STRING | capture(REGEX)
STRING | capture(REGEX; FLAGS)
STRING | capture([REGEX, FLAGS])

El objeto devuelto es un mapeo de las capturas con nombre.

"JIRAISSUE-1234" | capture("(?<project>\\w+)-(?<issue_num>\\d+)")
# => {
#      "project": "JIRAISSUE",
#      "issue_num": "1234"
#    }

Solo los substrings

El filtro scan es similar a match con el flag "g".

STRING | scan(REGEX)
STRING | scan(REGEX; FLAGS)

scan emite un flujo de substrings.

"Goodbye Mars" | scan("[aeiou]")
# => "o"
#    "o"
#    "e"
#    "a"

Usa el constructor de array [...] para capturar los substrings.

"Goodbye Mars" | [ scan("[aeiou]") ]
# => ["o", "o", "e", "a"]

Dividir un string

Si conoces las partes del string que quieres conservar, usa match o scan. Si conoces las partes que quieres descartar, usa split.

STRING | split(REGEX; FLAGS)

Un ejemplo que divide un string por espacios en blanco arbitrarios.

"first   second           third fourth" | split("\\s+"; "")
# => ["first", "second", "third", "fourth"]

Sustituciones

Los filtros sub y gsub pueden transformar el string de entrada, reemplazando las partes del string que coinciden con un string de reemplazo.

Para reemplazar solo la primera coincidencia, usa sub. Para reemplazar todas las coincidencias, usa gsub.

STRING | sub(REGEX; REPLACEMENT)
STRING | sub(REGEX; REPLACEMENT; FLAGS)
STRING | gsub(REGEX; REPLACEMENT)
STRING | gsub(REGEX; REPLACEMENT; FLAGS)

"Goodnight kittens. Goodnight mittens." | sub("night"; " morning")
# => "Good morning kittens. Goodnight mittens."

"Goodnight kittens. Goodnight mittens." | gsub("night"; " morning")
# => "Good morning kittens. Good morning mittens."

El texto de reemplazo puede referirse a los substrings que coinciden; usa capturas con nombre e interpolación de strings.

"Some 3-letter acronyms: gnu, csv, png"
| gsub( "\\b(?<tla>[[:alpha:]]{3})\\b";     # find words 3 letters long
        "\(.tla | ascii_upcase)" )          # upper-case the match
# => "Some 3-letter acronyms: GNU, CSV, PNG"

Flags

En todos los filtros anteriores, FLAGS es un string formado por cero o más de los flags admitidos.

• g - Búsqueda global (encuentra todas las coincidencias, no solo la primera)
• i - Búsqueda sin distinguir mayúsculas y minúsculas
• m - Modo multilínea ('.' coincide con los saltos de línea)
• n - Ignora las coincidencias vacías
• p - Se activan los modos s y m a la vez
• s - Modo de una sola línea ('^' -> '\A', '$' -> '\Z')
• l - Encuentra las coincidencias más largas posibles
• x - Formato de regex extendido (ignora los espacios en blanco y los comentarios)

Por ejemplo

"JIRAISSUE-1234" | capture("(?<project>\\w+)-(?<issue_num>\\d+)")

# or with Extended formatting

"JIRAISSUE-1234" | capture("
                     (?<project>   \\w+ )  # the Jira project
                     -                     # followed by a hyphen
                     (?<issue_num> \\d+ )  # followed by digits
                   "; "x")