Expresiones regulares

Este tema describe qué expresiones son expresiones regulares y cómo utilizarlas para buscar texto. Las expresiones regulares son flexibles y potentes, aunque utilicen una sintaxis compleja. Una alternativa a las expresiones regulares es un pattern (desde la versión R2020b), que es más sencilla de definir y resulta en un código que es más sencillo de leer. Para obtener más información, consulte Build Pattern Expressions.

¿Qué es una expresión regular?

Una expresión regular es una secuencia de caracteres que define un patrón determinado. Habitualmente, utiliza una expresión regular para buscar texto de un grupo de palabras que coinciden con el patrón, por ejemplo, al analizar la entrada de un programa o durante el procesamiento de un bloque de texto.

El vector de caracteres 'Joh?n\w*' es un ejemplo de expresión regular. Define un patrón que comienza con las letras Jo, va seguido de manera opcional por la letra h (indicada por 'h?'), después por la letra n y termina con cualquier número de caracteres de palabra, es decir, caracteres alfabéticos, numéricos o guiones bajos (indicado por '\w*'). Este patrón coincide con cualquiera de lo siguiente:

Jon, John, Jonathan, Johnny

Las expresiones regulares ofrecen una forma única de buscar un volumen de texto para un subconjunto determinado de caracteres en dicho texto. En lugar de buscar una coincidencia exacta de caracteres como haría con una función como strfind, las expresiones regulares le ofrecen la posibilidad de buscar un patrón de caracteres en concreto.

Por ejemplo, algunas formas de expresar una velocidad en el sistema métrico son:

km/h
km/hr
km/hour
kilometers/hour
kilometers per hour

Puede localizar cualquiera de los términos anteriores en el texto enviando cinco comandos de búsqueda distintos:

strfind(text, 'km/h');
strfind(text, 'km/hour');
% etc.

Sin embargo, para ser más eficiente, puede crear una única frase que se aplique a todos estos términos de búsqueda:

Flow-chart describing logic of example regular expression.

Traduzca esta frase en una expresión regular (se explicará más adelante en esta sección) y tiene:

pattern = 'k(ilo)?m(eters)?(/|\sper\s)h(r|our)?';

Ahora localice un término o varios con un único comando:

text = ['The high-speed train traveled at 250 ', ...
   'kilometers per hour alongside the automobile ', ...
   'travelling at 120 km/h.'];
regexp(text, pattern, 'match')

ans =

  1×2 cell array

    {'kilometers per hour'}    {'km/h'}

Existen cuatro funciones de MATLAB^® compatibles con la búsqueda y el reemplazo de caracteres con expresiones regulares. Las tres primeras son similares en los valores de entrada que aceptan y los valores de salida que devuelven. Para obtener más información, haga clic en los enlaces de las páginas de referencia de la función.

Función	Descripción
`regexp`	Hacer coincidir expresiones regulares.
`regexpi`	Hacer coincidir expresiones regulares ignorando mayúsculas y minúsculas.
`regexprep`	Sustituir parte del texto utilizando expresiones regulares.
`regexptranslate`	Traducir el texto en expresiones regulares.

Cuando llame a cualquiera de las tres primeras funciones, pase el texto que desea analizar y la expresión regular como los dos primeros argumentos de entrada. Cuando llame a regexprep, pase una entrada adicional que es una expresión que especifica un patrón para el reemplazo.

Pasos para la formación de expresiones

Hay tres pasos implicados en el uso de expresiones regulares para buscar un elemento específico en un texto:

Identificar los patrones únicos de la cadena
Esto implica dividir el texto que desea buscar en grupos de tipos de caracteres similares. Estos tipos de caracteres pueden ser una serie de letras en minúscula, el símbolo de dólar seguido por tres números y un separador decimal, etc.
Expresar cada patrón como una expresión regular
Utilice los metacaracteres y los operadores que se describen en esta documentación para expresar cada segmento del patrón de búsqueda como una expresión regular. Después, combine estos segmentos de expresiones en una única expresión para utilizarla en la búsqueda.
Llamar a la función de búsqueda adecuada
Pase el texto que desea analizar a una de las funciones de búsqueda, como regexp o regexpi, o a la función de reemplazo de texto, regexprep.

El ejemplo que se muestra en esta sección busca un registro que contenga la información de contacto que pertenece a un grupo de cinco amigos. Esta información incluye el nombre, el número de teléfono, el lugar de residencia y la dirección de correo electrónico de cada persona. El objetivo es extraer información específica del texto.

contacts = { ...
'Harry  287-625-7315  Columbus, OH  hparker@hmail.com'; ...
'Janice  529-882-1759  Fresno, CA  jan_stephens@horizon.net'; ...
'Mike  793-136-0975  Richmond, VA  sue_and_mike@hmail.net'; ...
'Nadine  648-427-9947  Tampa, FL  nadine_berry@horizon.net'; ...
'Jason  697-336-7728  Montrose, CO  jason_blake@mymail.com'};

La primera parte del ejemplo forma una expresión regular que representa el formato común de una dirección de correo electrónico. Utilizando esta expresión, el ejemplo busca la información de la dirección de correo electrónico de un componente del grupo de amigos. La información de contacto de Janice se encuentra en la fila 2 del arreglo de celda contacts:

contacts{2}

ans =

    'Janice  529-882-1759  Fresno, CA  jan_stephens@horizon.net'

Paso 1 — Identificar los patrones únicos del texto

Una dirección de correo electrónico está formada por componentes estándar: el nombre de cuenta del usuario, seguido del símbolo @, el nombre del proveedor de servicios de Internet (PSI) del usuario, un punto y el dominio al que pertenece el PSI. La tabla que aparece a continuación enumera estos componentes en la columna de la izquierda y generaliza el formato de cada componente en la columna de la derecha.

Patrones únicos de una dirección de correo electrónico	Descripción general de cada patrón
En primer lugar, escriba el nombre de la cuenta `jan_stephens` . . .	Una o varias letras en minúscula con guiones bajos
Añada “`@`” `jan_stephens@` . . .	Símbolo `@`
Añada el PSI `jan_stephens@horizon` . . .	Una o varias letras en minúscula sin guiones bajos
Añada un punto `jan_stephens@horizon.` . . .	Carácter de punto
Finalmente, añada el dominio `jan_stephens@horizon.net`	`com` o `net`

Paso 2 — Expresar cada patrón como una expresión regular

En este paso, traduce los formatos generales derivados del paso 1 en segmentos de una expresión regular. Después, combina estos segmentos para formar la expresión completa.

La tabla que aparece a continuación muestra las descripciones de los formatos generalizados de cada patrón de caracteres en la columna de la izquierda. (Estos patrones se han extraído de la columna de la derecha de la tabla del paso 1). La segunda columna muestra los operadores o metacaracteres que representan el patrón de caracteres.

Descripción de cada segmento	Patrón
Una o varias letras en minúscula con guiones bajos	`[a-z_]+`
Símbolo `@`	`@`
Una o varias letras en minúscula sin guiones bajos	`[a-z]+`
Carácter de punto	`\.`
`com` o `net`	`(com\|net)`

Si combina estos patrones en un vector de caracteres, obtendrá la expresión completa:

email = '[a-z_]+@[a-z]+\.(com|net)';

Paso 3 — Llamar a la función de búsqueda adecuada

En este paso, utiliza la expresión regular derivada del paso 2 para obtener una dirección de correo electrónico de uno de los amigos del grupo. Utilice la función regexp para llevar a cabo la búsqueda.

A continuación se muestra la lista de información de contacto que ha aparecido anteriormente en esta sección. El registro de cada persona ocupa una fila del arreglo de celdas contacts:

contacts = { ...
'Harry  287-625-7315  Columbus, OH  hparker@hmail.com'; ...
'Janice  529-882-1759  Fresno, CA  jan_stephens@horizon.net'; ...
'Mike  793-136-0975  Richmond, VA  sue_and_mike@hmail.net'; ...
'Nadine  648-427-9947  Tampa, FL  nadine_berry@horizon.net'; ...
'Jason  697-336-7728  Montrose, CO  jason_blake@mymail.com'};

Esta es la expresión regular que representa una dirección de correo electrónico, tal y como se ha derivado en el paso 2:

email = '[a-z_]+@[a-z]+\.(com|net)';

Llame a la función regexp y pase la fila 2 del arreglo de celdas contacts y la expresión regular email. Este proceso devuelve la dirección de correo electrónico de Janice.

regexp(contacts{2}, email, 'match')

ans =

  1×1 cell array

    {'jan_stephens@horizon.net'}

MATLAB analiza un vector de caracteres de izquierda a derecha y "consume" el vector a medida que avanza. Si se encuentran caracteres que coincidan, regexp registra la ubicación y reanuda el análisis del vector de caracteres, comenzando justo después del final de la coincidencia más reciente.

Realice la misma llamada, pero esta vez para la quinta persona de la lista:

regexp(contacts{5}, email, 'match')

ans =

  1×1 cell array

    {'jason_blake@mymail.com'}

También puede buscar la dirección de correo electrónico de todas las personas de la lista utilizando el arreglo de celdas completo en el argumento de entrada:

regexp(contacts, email, 'match');

Operadores y caracteres

Las expresiones regulares pueden contener caracteres, metacaracteres, operadores, tokens e indicadores que especifican los patrones que deben coincidir, como se describe en estas secciones:

Metacaracteres
Representación de caracteres
Cuantificadores
Operadores de agrupación
Delimitadores
Aserciones de búsqueda de ancho cero
Operadores condicionales y lógicos
Operadores de token
Expresiones dinámicas
Comentarios
Indicadores de búsqueda

Metacaracteres

Los metacaracteres representan letras, intervalos de letras, dígitos y caracteres de espacio. Utilícelos para formar un patrón de caracteres generalizado.

Metacarácter	Descripción	Ejemplo
`.`	Cualquier carácter individual, incluido un espacio en blanco.	`'..ain'` coincide con las secuencias de cinco caracteres consecutivos que terminan en `'ain'`.
`[c₁c₂c₃]`	Cualquier carácter que se encuentre dentro de corchetes. Los siguientes caracteres se tratan de forma literal: `$ \| . * + ?` y `-` cuando no se utiliza para indicar un intervalo.	`'[rp.]ain'` coincide con `'rain'`, `'pain'` o `'.ain'`.
`[^c₁c₂c₃]`	Cualquier carácter que no se encuentre dentro de corchetes. Los siguientes caracteres se tratan de forma literal: `$ \| . * + ?` y `-` cuando no se utiliza para indicar un intervalo.	`'[^rp]ain'` coincide con todas las secuencias de cuatro letras que terminan en `'ain'`, excepto `'rain'`, `'pain'` y `'ain'`. Por ejemplo, coincide con `'gain'`, `'lain'` o `'vain'`.
`[c`₁`-c`₂`]`	Cualquier carácter que se encuentre en el intervalo de `c`₁ a `c`₂.	`'[A-G]'` coincide con cualquier carácter del intervalo de `A` a `G`.
`\w`	Cualquier carácter alfabético, numérico o de guion bajo. Para los conjuntos de caracteres en inglés, `\w` es equivalente a `[a-zA-Z_0-9]`.	`'\w*'` identifica una palabra compuesta de cualquier grupo de caracteres alfabético, numérico o de guion bajo.
`\W`	Cualquier carácter que no sea alfabético, numérico o de guion bajo. Para los conjuntos de caracteres en inglés, `\W` es equivalente a `[^a-zA-Z_0-9]`.	`'\W*'` identifica un término que no es una palabra compuesta de cualquier grupo de caracteres alfabético, numérico o de guion bajo.
`\s`	Cualquier carácter de espacio en blanco, equivalente a `[ \f\n\r\t\v]`.	`'\w*n\s'` coincide con las palabras que terminan en la letra `n` seguida de un carácter de espacio en blanco.
`\S`	Cualquier carácter que no sea de espacio en blanco, equivalente a `[^ \f\n\r\t\v]`.	`'\d\S'` coincide con un dígito numérico seguido de cualquier carácter que no sea de espacio en blanco.
`\d`	Cualquier dígito numérico, equivalente a `[0-9]`.	`'\d*'` coincide con cualquier número de dígitos consecutivos.
`\D`	Cualquier carácter que no sea un dígito, equivalente a `[^0-9]`.	`'\w*\D\>'` coincide con las palabras que no terminan con un dígito numérico.
`\oN` o `\o{N}`	Carácter de valor octal `N`.	`'\o{40}'` coincide con el carácter de espacio que define el octal `40`.
`\xN` o `\x{N}`	Carácter de valor hexadecimal `N`.	`'\x2C'` coincide con el carácter de coma que define el hexadecimal `2C`.

Representación de caracteres

Operador	Descripción
`\a`	Alarma (pitido)
`\b`	Retroceso
`\f`	Salto de impresión
`\n`	Nueva línea
`\r`	Retorno de carro
`\t`	Tabulación horizontal
`\v`	Tabulación vertical
`\char`	Cualquier carácter con significado especial en las expresiones regulares que desea hacer que coincida de forma literal (por ejemplo, utilice `\\` para que una barra invertida simple coincida)

Cuantificadores

Los cuantificadores especifican el número de veces que un patrón se debe producir en el texto que coincide.

Cuantificador	Número de veces que se produce la expresión	Ejemplo
`expr*`	0 o más veces consecutivas.	`'\w*'` coincide con una palabra de cualquier longitud.
`expr?`	0 o 1 vez.	`'\w*(\.m)?'` coincide con palabras que pueden acabar en la extensión `.m`.
`expr+`	1 o más veces consecutivas.	`'<img src="\w+\.gif">'` coincide con una etiqueta HTML `<img>` cuando el nombre del archivo contiene uno o varios caracteres.
`expr{m,n}`	Al menos `m` veces, pero no más de `n` veces consecutivas. `{0,1}` equivale a `?`.	`'\S{4,8}'` coincide con entre cuatro y ocho caracteres que no sean de espacio en blanco.
`expr{m,}`	Al menos `m` veces consecutivas. `{0,}` y `{1,}` equivalen a `*` y `+`, respectivamente.	`'<a href="\w{1,}\.html">'` coincide con una etiqueta HTML `<a>` cuando el nombre del archivo contiene uno o varios caracteres.
`expr{n}`	Exactamente `n` veces consecutivas. Equivale a `{n,n}`.	`'\d{4}'` coincide con cuatro dígitos consecutivos.

Los cuantificadores pueden aparecer en tres modos, según se describe en la tabla que aparece a continuación. q representa a cualquiera de los cuantificadores de la tabla anterior.

Modo	Descripción	Ejemplo
`expr`q	Expresión avariciosa: coincide con tantos caracteres como sea posible.	Dado el texto `'<tr><td><p>text</p></td>'`, la expresión `'</?t.*>'` coincide con todos los caracteres que se encuentran entre `<tr` y `/td>`: `'<tr><td><p>text</p></td>'`
`expr`q`?`	Expresión perezosa: coincide con tan pocos caracteres como sea posible.	Dado el texto `'<tr><td><p>text</p></td>'`, la expresión `'</?t.*?>'` finaliza cada coincidencia con la primera ocurrencia de una comilla angular de cierre (`>`): `'<tr>' '<td>' '</td>'`
`expr`q+	Expresión posesiva: coincide con tantos caracteres como sea posible, pero no vuelve a buscar ninguna parte del texto.	Dado el texto `'<tr><td><p>text</p></td>'`, la expresión `'</?t.+>'` no devuelve ninguna coincidencia, puesto que la comilla angular de cierre se ha captado mediante `.` y no se vuelve a detectar.

Modo

Descripción

Ejemplo

exprq

Expresión avariciosa: coincide con tantos caracteres como sea posible.

Dado el texto '<tr><td>text</td>', la expresión '</?t.*>' coincide con todos los caracteres que se encuentran entre <tr y /td>:

'<tr><td><p>text</p></td>'

exprq?

Expresión perezosa: coincide con tan pocos caracteres como sea posible.

Dado el texto '<tr><td>text</td>', la expresión '</?t.*?>' finaliza cada coincidencia con la primera ocurrencia de una comilla angular de cierre (>):

'<tr>' '<td>' '</td>'

exprq+

Expresión posesiva: coincide con tantos caracteres como sea posible, pero no vuelve a buscar ninguna parte del texto.

Dado el texto '<tr><td>text</td>', la expresión '</?t.*+>' no devuelve ninguna coincidencia, puesto que la comilla angular de cierre se ha captado mediante .* y no se vuelve a detectar.

Operadores de agrupación

Los operadores de agrupación le permiten capturar tokens, aplicar un operador a varios elementos o desactivar la búsqueda hacia atrás en un grupo específico.

Operador de agrupación	Descripción	Ejemplo
`(expr)`	Agrupa los elementos de la expresión y captura tokens.	`'Joh?n\s(\w*)'` captura un token que contiene el apellido de cualquier persona con el nombre `John` o `Jon`.
`(?:expr)`	Agrupa, pero no captura tokens.	`'(?:[aeiou][^aeiou]){2}'` coincide con dos patrones consecutivos de una vocal seguida de una consonante, por ejemplo, `'anon'`. Sin la agrupación, `'[aeiou][^aeiou]{2}'` coincide con una vocal seguida de dos consonantes.
`(?>expr)`	Agrupa de forma atómica. No realiza búsquedas hacia atrás dentro del grupo para completar la coincidencia y no captura tokens.	`'A(?>.)Z'` no coincide con `'AtoZ'`, aunque `'A(?:.)Z'` sí lo haga. Con el grupo atómico, `Z` se captura utilizando `.*` y no se vuelve a detectar.
`(expr1\|expr2)`	Coincide con la expresión `expr1` o con la expresión `expr2`. Si se produce una coincidencia con `expr1`, `expr2` se ignora. Puede incluir `?:` o `?>` después del paréntesis de apertura para suprimir los tokens o el grupo de forma atómica.	`'(let\|tel)\w+'` coincide con palabras que contienen, pero no terminan, en `let` o `tel`.

Delimitadores

Los delimitadores de una expresión coinciden con el comienzo o el final de una palabra o vector de caracteres.

Delimitador	Coincide con…	Ejemplo
`^expr`	El comienzo del texto de entrada.	`'^M\w*'` coincide con una palabra que comienza por `M` al principio del texto.
`expr$`	El final del texto de entrada.	`'\w*m$'` coincide con palabras que terminan en `m` al final del texto.
`\<expr`	El principio de una palabra.	`'\<n\w*'` coincide con cualquier palabra que comienza por `n`.
`expr\>`	El final de una palabra.	`'\w*e\>'` coincide con cualquier palabra que termina en `e`.

Aserciones de búsqueda de ancho cero

Las aserciones de búsqueda de ancho cero buscan patrones que preceden o siguen de forma inmediata a la coincidencia prevista, pero no forman parte de la coincidencia.

El puntero permanece en la ubicación actual y los caracteres que corresponden a la expresión test no se capturan ni descartan. Por lo tanto, las aserciones de búsqueda anticipada pueden coincidir con grupos de caracteres que se superponen.

Aserción de búsqueda de ancho cero	Descripción	Ejemplo
`expr(?=test)`	Busca caracteres hacia adelante que coinciden con `test`.	`'\w*(?=ing)'` coincide con los términos que van seguidos de `ing`, como `'Fly'` y `'fall'`, del texto de entrada `'Flying, not falling.'`
`expr(?!test)`	Busca caracteres hacia adelante que no coinciden con `test`.	`'i(?!ng)'` coincide con las instancias de la letra `i` que no van seguidas de `ng`.
`(?<=test)expr`	Busca hacia atrás los caracteres que coinciden con `test`.	`'(?<=re)\w*'` coincide con los términos que siguen a `'re'`, como `'new'`, `'use'` y `'cycle'`, del texto de entrada `'renew, reuse, recycle'`
`(?<!test)expr`	Busca hacia atrás los caracteres que no coinciden con `test`.	`'(?<!\d)(\d)(?!\d)'` coincide con los números de un solo dígito (dígitos que no preceden ni siguen a otros dígitos).

Si especifica una aserción de búsqueda anticipada antes de una expresión, la operación equivale a un AND lógico.

Operación	Descripción	Ejemplo
`(?=test)expr`	Coincide con `test` y `expr`.	`'(?=[a-z])[^aeiou]'` coincide con consonantes.
`(?!test)expr`	Coincide con `expr`, pero no con `test`.	`'(?![aeiou])[a-z]'` coincide con consonantes.

Para obtener más información, consulte Aserciones de búsqueda anticipada en expresiones regulares.

Operadores condicionales y lógicos

Los operadores condicionales y lógicos le permiten realizar una prueba del estado de una condición determinada y después utilizar la salida para determinar qué patrón, si existe, coincide después. Estos operadores admiten los operadores lógicos OR e if o las condiciones if/else. (Para las condiciones AND, consulte Aserciones de búsqueda de ancho cero).

Las condiciones pueden ser tokens, aserciones de búsqueda de ancho cero o expresiones dinámicas con la forma (?@cmd). Las expresiones dinámicas deben devolver un valor numérico o lógico.

Operador condicional	Descripción	Ejemplo
`expr1\|expr2`	Coincide con la expresión `expr1` o con la expresión `expr2`. Si se produce una coincidencia con `expr1`, `expr2` se ignora.	`'(let\|tel)\w+'` coincide con palabras que comienzan por `let` o `tel`.
`(?(cond)expr)`	Si la condición `cond` es `true`, coincide con `expr`.	`'(?(?@ispc)[A-Z]:\\)'` coincide con un nombre de unidad, como `C:\`, cuando se ejecuta en un sistema Windows^®.
`(?(cond)expr1\|expr2)`	Si la condición `cond` es `true`, coincide con `expr1`. De lo contrario, coincide con `expr2`.	`'Mr(s?)\..?(?(1)her\|his) \w'` coincide con el texto que incluye `her` cuando el texto comienza con `Mrs` o que incluye `his` cuando el texto comienza con `Mr`.

Operador condicional

Descripción

Ejemplo

expr1|expr2

Coincide con la expresión expr1 o con la expresión expr2.

Si se produce una coincidencia con expr1, expr2 se ignora.

'(let|tel)\w+' coincide con palabras que comienzan por let o tel.

(?(cond)expr)

Si la condición cond es true, coincide con expr.

'(?(?@ispc)[A-Z]:\\)' coincide con un nombre de unidad, como C:\, cuando se ejecuta en un sistema Windows^®.

(?(cond)expr1|expr2)

Si la condición cond es true, coincide con expr1. De lo contrario, coincide con expr2.

'Mr(s?)\..*?(?(1)her|his) \w*' coincide con el texto que incluye her cuando el texto comienza con Mrs o que incluye his cuando el texto comienza con Mr.

Operadores de token

Los tokens son partes del texto que coincide que usted define englobando una parte de la expresión regular entre paréntesis. Puede referirse a un token mediante su secuencia en el texto (un token ordinal) o asignar nombres a los tokens para facilitar el mantenimiento del código y una salida legible.

Operador de token ordinal	Descripción	Ejemplo
`(expr)`	Captura en un token los caracteres que se corresponden con la expresión delimitada.	`'Joh?n\s(\w*)'` captura un token que contiene el apellido de cualquier persona con el nombre `John` o `Jon`.
`\N`	Hace coincidir el `N`.º token.	`'<(\w+).>.</\1>'` captura tokens para etiquetas HTML, como `'title'` del texto `'<title>Some text</title>'`.
`(?(N)expr1\|expr2)`	Si se encuentra el `N`.º token, coincide con `expr1`. De lo contrario, coincide con `expr2`.	`'Mr(s?)\..?(?(1)her\|his) \w'` coincide con el texto que incluye `her` cuando el texto comienza con `Mrs` o que incluye `his` cuando el texto comienza con `Mr`.

Operador de token denominado	Descripción	Ejemplo
`(?<name>expr)`	Captura en un token denominado los caracteres que coinciden con la expresión delimitada.	`'(?<month>\d+)-(?<day>\d+)-(?<yr>\d+)'` crea tokens denominados para el mes, el día y el año en una fecha de entrada con formato `mm-dd-yy`.
`\k<name>`	Hace coincidir el token al que se hace referencia mediante `name`.	`'<(?<tag>\w+).>.</\k<tag>>'` captura tokens para etiquetas HTML, como `'title'` del texto `'<title>Some text</title>'`.
`(?(name)expr1\|expr2)`	Si se encuentra el token denominado, coincide con `expr1`. De lo contrario, coincide con `expr2`.	`'Mr(?<sex>s?)\..?(?(sex)her\|his) \w'` coincide con el texto que incluye `her` cuando el texto comienza con `Mrs` o que incluye `his` cuando el texto comienza con `Mr`.

Nota

Si una expresión tiene paréntesis anidados, MATLAB captura los tokens que corresponden con el conjunto de paréntesis exterior. Por ejemplo, dado el patrón de búsqueda '(and(y|rew))', MATLAB crea un token para 'andrew', pero no para 'y' o 'rew'.

Para obtener más información, consulte Tokens en expresiones regulares.

Expresiones dinámicas

Las expresiones dinámicas le permiten ejecutar un comando de MATLAB o una expresión regular para determinar el texto que debe coincidir.

Los paréntesis que delimitan expresiones dinámicas no crean un grupo de captura.

Operador	Descripción	Ejemplo
`(??expr)`	Analiza `expr` e incluye el término resultante en la expresión que coincide. Al analizarse, `expr` debe corresponderse con una expresión regular válida y completa. Las expresiones dinámicas que utilizan el carácter de escape de barra invertida (`\`) necesitan dos barras invertidas: una para el análisis inicial de `expr` y una para la coincidencia completa.	`'^(\d+)((??\\w{$1}))'` determina cuántos caracteres coinciden leyendo un dígito al comienzo de la coincidencia. La expresión dinámica está delimitada en un segundo conjunto de paréntesis para que la coincidencia resultante se capture en un token. Por ejemplo, hacer coincidir `'5XXXXX'` captura tokens para `'5'` y `'XXXXX'`.
`(??@cmd)`	Ejecuta el comando de MATLAB representado por `cmd` e incluye el resultado devuelto por el comando en la expresión de la coincidencia.	`'(.{2,}).?(??@fliplr($1))'` encuentra palíndromos que tienen al menos cuatro caracteres, como `'abba'`.
`(?@cmd)`	Ejecuta el comando MATLAB representado por `cmd`, pero descarta cualquier resultado que devuelva el comando. (Útil para el diagnóstico de expresiones regulares).	`'\w?(\w)(?@disp($1))\1\w'` hace coincidir palabras que incluyen letras dobles (como `pp`) y muestra resultados intermedios.

Operador

Descripción

Ejemplo

(??expr)

Analiza expr e incluye el término resultante en la expresión que coincide.

Al analizarse, expr debe corresponderse con una expresión regular válida y completa. Las expresiones dinámicas que utilizan el carácter de escape de barra invertida (\) necesitan dos barras invertidas: una para el análisis inicial de expr y una para la coincidencia completa.

'^(\d+)((??\\w{$1}))' determina cuántos caracteres coinciden leyendo un dígito al comienzo de la coincidencia. La expresión dinámica está delimitada en un segundo conjunto de paréntesis para que la coincidencia resultante se capture en un token. Por ejemplo, hacer coincidir '5XXXXX' captura tokens para '5' y 'XXXXX'.

(??@cmd)

Ejecuta el comando de MATLAB representado por cmd e incluye el resultado devuelto por el comando en la expresión de la coincidencia.

'(.{2,}).?(??@fliplr($1))' encuentra palíndromos que tienen al menos cuatro caracteres, como 'abba'.

(?@cmd)

Ejecuta el comando MATLAB representado por cmd, pero descarta cualquier resultado que devuelva el comando. (Útil para el diagnóstico de expresiones regulares).

'\w*?(\w)(?@disp($1))\1\w*' hace coincidir palabras que incluyen letras dobles (como pp) y muestra resultados intermedios.

En expresiones dinámicas, utilice los siguientes operadores para definir los términos de sustitución.

Operador de sustitución	Descripción
`$&` o `$0`	Parte del texto de entrada que actualmente forma parte de una coincidencia
$`	Parte del texto de entrada que precede a la coincidencia actual
`$'`	Parte del texto de entrada que sigue a la coincidencia actual (utilice `$''` para representar `$'`)
`$N`	`N`.º token
`$<name>`	Token denominado
`${cmd}`	Resultado devuelto cuando MATLAB ejecuta el comando, `cmd`

Para obtener más información, consulte Expresiones regulares dinámicas.

Comentarios

El operador comment le permite insertar comentarios en el código para hacerlo más fácil de mantener. MATLAB ignora el texto del comentario cuando coincide con el texto de entrada.

Caracteres	Descripción	Ejemplo
`(?#comment)`	Inserta un comentario en la expresión regular. El texto del comentario se ignora cuando coincide con la entrada.	`'(?# Initial digit)\<\d\w+'` incluye un comentario y hace coincidir palabras que comienzan con un número.

Indicadores de búsqueda

Los indicadores de búsqueda modifican el comportamiento para las expresiones que coinciden.

Indicador	Descripción
`(?-i)`	Hace coincidir mayúsculas y minúsculas (opción predeterminada para `regexp` y `regexprep`).
`(?i)`	No hace coincidir mayúsculas y minúsculas (opción predeterminada para `regexpi`).
`(?s)`	Hace coincidir el punto (`.`) en el patrón con cualquier otro carácter (opción predeterminada).
`(?-s)`	Hace coincidir el punto en el patrón con cualquier otro carácter que no sea un carácter de línea nueva.
`(?-m)`	Hace coincidir los metacaracteres `^` y `$` al principio y al final del texto (opción predeterminada).
`(?m)`	Hace coincidir los metacaracteres `^` y `$` al principio y al final de una línea.
`(?-x)`	Incluye los caracteres de espacio y los comentarios cuando coinciden (opción predeterminada).
`(?x)`	Ignora los caracteres de espacio y los comentarios cuando coinciden. Utiliza `'\ '` y `'\#'` para hacer coincidir los caracteres de espacio y `#`.

La expresión que modifica el indicador puede aparecer antes de los paréntesis, como

(?i)\w*

o dentro de los paréntesis y separada del indicador con dos puntos (:), como

(?i:\w*)

La última sintaxis le permite cambiar el comportamiento para una parte de una expresión mayor.

Consulte también

regexp | regexpi | regexprep | regexptranslate | pattern