Compartir por

Expresións regulares

As funcións IsMatch, Match e MatchAll úsanse para extraer e validar patróns no texto. O patrón que empregan chámase expresión regular.

As expresións regulares son potentes e versátiles. Non obstante, ás veces poden aparecer como unha secuencia aleatoria de signos de puntuación. Este artigo non describe todos os aspectos das expresións regulares, pero hai moita información, titoriais e ferramentas dispoñibles en liña.

As expresións regulares teñen unha longa historia e están dispoñibles en moitas linguaxes de programación. Cada linguaxe de programación ten o seu propio dialecto de expresións regulares e existen poucos estándares. Na medida do posible, esforzámonos por que a mesma expresión regular dea o mesmo resultado en todas as implementacións. Power Fx A compatibilidade non é doada de conseguir xa que Power Fx se executa sobre JavaScript e .NET, que teñen diferenzas significativas. Para executarse en diferentes plataformas, as expresións regulares Power Fx empregan un subconxunto de funcionalidades amplamente compatibles en toda a industria.

Como resultado, algunhas expresións regulares que funcionan noutros entornos poden estar bloqueadas ou precisar axustes en Power Fx. Os erros de tempo de creación infórmanse cando se atopan funcionalidades non compatibles. É por iso que a expresión regular e as opcións deben ser unha constante de tempo de creación e non dinámicas, como se se proporcionasen nunha variable.

Nota

Power Apps usa unha versión anterior das expresións regulares Power Fx , que ten menos limitacións pero tamén menos funcionalidades. MatchOptions.DotAll e MatchOptions.FreeSpacing non están dispoñibles e as definicións de Match.Email e Match.Hyphen son diferentes. Os pares de substitutos Unicode non se tratan como un só carácter. MatchOptions.NumberedSubMatches é o valor predeterminado. A versión das expresións regulares descrita aquí estará dispoñible en breve, baixo a opción de "compatibilidade coa V1.0". Power Apps Power Fx

Funcionalidades compatibles

Power Fx admite as seguintes características de expresións regulares, con notas sobre como o comportamento pode diferir do doutros sistemas. Power Fx

A expresión regular debe ser constante e non calcularse nin almacenarse nunha variable. Admítense o operador & , a interpolación de cadeas $"{...}" e as funcións Concatenate, Char e UniChar con argumentos constantes.

Caracteres literais

Funcionalidade Descripción
Caracteres literais Pódese inserir directamente calquera carácter Unicode, agás \, [, ], ^, $, ., |, ?, *, +, (, ), { e }. Ao usar MatchOptions.FreeSpacing, #, e outros \s espazos, débense usar caracteres de escape, xa que teñen un significado diferente.
Caracteres literais de escape \ (barra invertida) seguida dun dos caracteres literais directos, como por exemplo \? para inserir un signo de interrogación. \# e \ tamén se pode usar mesmo cando MatchOptions.FreeSpacing está desactivado para manter a coherencia.
Códigos de caracteres hexadecimais e Unicode \x20 con exactamente dous díxitos hexadecimais, \u2028 con exactamente catro díxitos hexadecimais e pódese usar para substitutos altos e baixos.
Punto de código Unicode \u{01F47B} con ata oito díxitos hexadecimais. Debe estar no rango de 0 a U+10FFFF e non se pode usar nin para un substituto alto nin para un substituto baixo. Pode resultar nun par suplente (dous caracteres) se é maior que U+FFFF.
Retorno de carro \r, o mesmo que Char(13).
Carácter de nova liña \n, o mesmo que Char(10).
Avance de formulario \f, o mesmo que Char(12).
Pestana horizontal \t, o mesmo que Char(9).

No seu lugar, utiliza \x ou \u . Os códigos octais para caracteres, como \044 ou \o{044} , non están permitidos porque poden ser ambiguos con referencias inversas numeradas.

\v non é compatible porque é ambiguo en todas as linguaxes de expresións regulares. Usar \x0b para unha tabulación vertical ou [\x0b\f\r\n\x85\u2028\u2029] para espazos en branco verticais.

Afirmacións

As afirmacións coinciden cunha posición particular no texto pero non consomen ningún caractere.

Funcionalidade Descripción
Inicio da liña ^, coincide co comezo do texto ou dunha liña se se usa MatchOptions.Multiline .
Fin da liña $, coincide co final do texto ou dunha liña se se usa MatchOptions.Multiline .
Anticipa (?=a) e (?!a), coincide con antelación para un patrón.
Mirar cara atrás (?<=b) e (?<!b), coincide co patrón que hai detrás.
Saltos de palabras \b e \B, usando a definición Unicode de letras [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}].

$ coincide co final dunha liña, incluíndo calquera \r\n, \r ou \n final.

As asercións anticipadas e retrospectivas non poden conter subcoincidencias nin cuantificadores ilimitados no seu interior e non se poden usar cun cuantificador exterior.

Clases de personaxes

Funcionalidade Descripción
Punto ., coincide con todo excepto con \r e \n a non ser que se use MatchOptions.DotAll .
Clase de personaxe [abc] lista de caracteres, [a-fA-f0-9] intervalo de caracteres, [^a-z] todo menos estes caracteres. As clases de caracteres non se poden aniñar, restar nin intersecar, e moitos signos de puntuación non poden aparecer dúas veces seguidas (@@, %%, !!, etc.).
Caracteres de palabras \w e \W usando a definición Unicode de letras [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]. \W Non se pode usar nunha clase de caracteres negativos.
Caracteres dixitais \d inclúe os díxitos 0 ata9 e \p{Nd}, \D coincide con todo excepto cos caracteres que coinciden con \d. \D Non se pode usar nunha clase de caracteres negativos.
Personaxes espaciais \s inclúe caracteres de espazado [ \t\n\x0b\f\r\x85\u2028\u2029\p{Z}], \S que coincide con todo excepto os caracteres que coinciden con \s. \S Non se pode usar nunha clase de caracteres negativos.
Categoría de caracteres Unicode \p{Ll} coincide con todas as letras minúsculas de Unicode, mentres que \P{Ll} coincide con todo o que non sexa unha letra minúscula de Unicode. \P{} Non se pode usar nunha clase de caracteres negativos.

Para aumentar a claridade e evitar ambigüidades, as clases de caracteres entre corchetes son máis restritivas que noutras linguaxes de expresións regulares:

  • Os caracteres de guión literais deben ter un símbolo de escape. Usar [\-a] en lugar de [-a] para coincidir con - ou a.
  • Os corchetes iniciais deben ser de tipo "escapado". Usar [\[a] en lugar de [[] para coincidir con [ ou a.
  • A non ser que sexa o primeiro carácter e indique negación, o carácter debe ter un caractere de escape. Usar [a\^] en lugar de [a^] para coincidir con ^ ou a.
  • As chaves rizadas deben ter un símbolo de escape. Usa [\{\}] para coincidir { ou }.
  • Non se admite a clase de caracteres baleira [] . Para incluír unha corchete de peche nunha clase de caracteres, cómpre usar o símbolo de escape.

Categorías de caracteres Unicode compatibles con \p{} e \P{}:

  • Letras: L, Lu, Ll, Lt, Lm, Lo
  • Marcas: M, Mn, Mc, Me
  • Números: N, Nd, Nl, No
  • Puntuación: P, Pc, Pd, Ps, Pe, Pi, Pf, Po
  • Símbolos: S, Sm, Sc, Sk, So
  • Separadores: Z, Zs, Zl, Zp
  • Control e formato: Cc, Cf, mentres que outras categorías de prefixos C non son compatibles.

\W, \D, \S e \P{} non se poden usar dentro dunha clase de caracteres negada [^...]. Para seren implementadas nalgunhas plataformas, estas clases de caracteres negativos tradúcense aos seus equivalentes Unicode, o que podería ser difícil de facer se tamén se negasen.

Os caracteres Unicode entre U+10000 e U+10FFFF, que requiren pares substitutos, non son compatibles nas clases de caracteres.

Cuantificadores

Funcionalidade Descripción
Cobicioso cero ou un ? coincide con cero ou unha vez, cunha coincidencia o máis grande posible.
Cobicioso cero ou máis * coincide cero ou máis veces, cunha coincidencia o máis grande posible.
Un ou máis avariciosos + coincide unha ou máis veces, cunha coincidencia o máis grande posible.
Cobicioso polo menos n {n,} coincide polo menos n veces, cunha coincidencia o máis grande posible. Por exemplo, a{3,} coincide con todos os caracteres de aaaaa.
Cobicioso entre n e m {n,m} coincidencias entre n e m veces, cunha coincidencia o máis grande posible. Por exemplo, a{1,3} coincide cos tres primeiros caracteres de aaaaa.
Preguiceiro cero ou un ?? coincide con cero ou unha vez, cunha coincidencia o máis pequena posible.
Cero preguiceiro ou máis *? coincide cero ou máis veces, cunha coincidencia tan pequena como sexa posible.
Un ou máis preguiceiros +? coincide unha ou máis veces, cunha coincidencia o máis pequena posible.
Preguiceiro polo menos n {n,}? coincide polo menos n veces, cunha coincidencia o máis pequena posible. Por exemplo, a{3,}? só coincide cos tres primeiros caracteres de aaaaa.
Preguiceiro entre n e m {n,m}? coincidencias entre n e m veces, cunha coincidencia o pequena máis posible. Por exemplo, a{1,3}? só coincide co primeiro carácter de aaaaa.
N exacto {n} coincide exactamente n veces. Por exemplo, a{3} coincide exactamente con tres caracteres de aaaaa.

Non se admiten cuantificadores posesivos.

Mesturar subcoincidencias e cuantificadores ten limitacións. Para obter máis información, consulte Subcoincidencias posiblemente baleiras.

Grupos

Funcionalidade Descripción
Agrupar ( e ) úsanse para agrupar elementos para aplicar os cuantificadores. Por exemplo, (abc)+ coincidencia abcabc.
Alternancia a|b coincide con "a" ou "b", que se emprega a miúdo nun grupo.
Subcoincidencia nomeada e referencia anterior (?<name>chars) captura unha subcoincidencia co nome name, referenciada con \k<name>. Non se pode usar se MatchOptions.NumberedSubMatches está activado.
Subcoincidencia numerada e referencia anterior Cando MatchOptions.NumberedSubMatches está activado, (a) captura unha subcoincidencia á que se fai referencia con \1.
Grupo sen captura (?:a), crea un grupo sen capturar o resultado como unha subcoincidencia con nome ou numerada. Non se captura ningún grupo a menos que MatchOptions.NumberedSubMatches estea activado.

As subcoincidencias con nome e numeradas non se poden usar xuntas. Por defecto, as subcoincidencias con nome están activadas e son as preferidas por claridade e mantemento, mentres que os grupos de captura estándar convértense en grupos que non son de captura e teñen un rendemento mellorado. Este comportamento pódese cambiar con MatchOptions.NumberedSubMatches que proporciona grupos de captura tradicionais pero desactiva os grupos de captura con nome. Algunhas implementacións tratan unha mestura de grupos de captura numerados e nomeados de forma diferente, polo que Power Fx o desactiva.

Non se admiten os grupos de captura autorreferenciados, por exemplo, a expresión regular (a\1).

Dous grupos de captura non poden compartir o mesmo nome; por exemplo, a expresión regular (?<id>\w+)|(?<id>\d+) non é compatible.

O nome dunha subcoincidencia con nome debe comezar cun carácter \p{L} ou _ e pode continuar con eses caracteres máis \p{Nd}. Os nomes teñen unha lonxitude limitada a 62 unidades de código UTF-16.

Tampouco se admiten as referencias retroactivas a posibles subcoincidencias baleiras nin a subcoincidencias dentro dunha busca atrás ou unha busca adiante.

Algunhas implementacións ofrecen unha opción de "captura explícita" para mellorar o rendemento, que é innecesaria xa que é a predeterminada. Power Fx MatchOptions.NumberedSubMatches desactívao e activa as capturas numeradas implicitamente.

Mesturar subcoincidencias e cuantificadores ten limitacións. Consulta Subcoincidencias posiblemente baleiras para obter máis información.

Comentarios

Funcionalidade Descripción
Comentarios en liña (?# comment here), que se ignora como comentario. O comentario remata coa seguinte paréntese de peche, mesmo se o comentario inclúe unha paréntese de apertura.

Consulta MatchOptions.FreeSpacing para obter unha alternativa para formatar e comentar expresións regulares.

Opcións en liña

Funcionalidade Descripción
Opcións en liña (?im) é o mesmo que usar MatchOptions.IgnoreCase e MatchOptions.Multiline. Debe definirse ao comezo da expresión regular.

Os modos en liña compatibles son [imsx]. Estes correspóndense con MatchOptions.IgnoreCase, MatchOptions.Multiline, MatchOptions.DotAll e MatchOptions.FreeSpacing, respectivamente. n tamén se acepta por compatibilidade pero non ten ningún efecto xa que é o valor predeterminado e é incompatible con MatchOptions.NumberedSubMatches.

As opcións en liña non se poden usar para desactivar unha opción nin definir unha opción para unha subexpresión.

Opcións

As opcións de coincidencia cambian o comportamento da coincidencia de expresións regulares. Hai dúas maneiras de activar as opcións, que se poden combinar sempre que non haxa conflitos:

  • Valor da enumeración MatchOptions pasado como terceiro argumento a Match, MatchAll e IsMatch. As opcións pódense combinar co operador & ou a función Concatenate , por exemplo MatchOptions.DotAll & MatchOptions.FreeSpacing. Todas as funcións de expresión regular requiren que MatchOptions sexa un valor constante, non se pode calcular nin almacenar nunha variable.
  • (?...) prefixo ao comezo da expresión regular. As opcións pódense combinar con varias letras na construción (?...) , por exemplo (?sx). Algunhas opcións non teñen un equivalente (?...) pero poden ter outras maneiras de obter o mesmo efecto, por exemplo MatchOptions.BeginsWith é o equivalente a ^ ao comezo da expresión regular.

Contén

Activado con MatchOptions.Contén sen unha expresión regular de texto equivalente. MatchOptions.Contains é o valor predeterminado para todas as funcións fóra de Power Apps; dentro de Power Apps MatchOptions.Complete é o valor predeterminado para IsMatch.

Concluída

Activado con MatchOptions.Complete ou usando ^ e $ ao comezo e da expresión regular, respectivamente.

BeginsWith

Activado con MatchOptions.BeginsWith ou usado ^ ao comezo e da expresión regular.

EndsWith

Activado con MatchOptions.EndsWith ou usado $ ao final da expresión regular.

DotAll

Activado con MatchOptions.DotAll ou (?s) ao comezo da expresión regular.

Normalmente, o operador punto . coincide con todos os caracteres excepto os caracteres de nova liña [\n\x0b\f\r\x85\u2028\u2029]. Co modificador DotAll , coinciden todos os caracteres, incluídos os saltos de liña.

Neste exemplo, só coincide "Ola" xa que, por defecto, . non coincidirá co salto de liña:

Trim( Match( "Hello
              World", ".*" ).FullMatch )
// returns 
// "Hello"

Pero se engadimos o modificador DotAll , entón a nova liña e todos os caracteres posteriores coinciden:

Trim( Match( "Hello
              World", ".*", MatchOptions.DotAll ).FullMatch )
// returns 
// "Hello
// World"

Espazado libre

Activado con MatchOptions.FreeSpacing ou (?x) ao comezo dunha expresión regular.

O espazado libre facilita a leitura e o mantemento dunha expresión regular complexa. As regras son sinxelas:

  • Os espazos ignóranse na expresión regular, incluídos todos os caracteres que coincidan con \s. Se desexa que coincida un espazo, use \s, \ , \t, \r ou \n.
  • # comeza un comentario que se estende ata o final da liña. Ignóranse tanto el como todos os caracteres que seguen ao seguinte carácter de nova liña (caracteres que non coinciden con . sen MatchOptions.DotAll).
  • As clases de personaxes non están incluídas nestes cambios. Personaxes espaciais e # actúan como o fan normalmente. Por exemplo, IsMatch( "a#b c", "(?x)a[ #]b[ #]c" ) devolve verdadeiro. Algunhas linguaxes de expresións regulares inclúen clases de caracteres con espazo libre ou ofrecen unha opción para incluílas, pero Power Fx non o fan.

Por exemplo, aquí tes unha expresión regular complexa para atopar unha data e hora ISO 8601:

IsMatch( 
    "2025-01-17T19:38:49+0000",
    "^\d{4}-(0\d|1[012])-([012]\d|3[01])(T([01]\d|2[0123]):[0-5]\d(:[0-5]\d(\.\d{3})?)?(Z|[\-+]\d{4}))?$"
)
// returns true

E aquí está a expresión regular idéntica con espazado libre utilizando varias liñas, sangría para grupos e comentarios de expresións regulares, o que fai que esta versión sexa máis doada de entender, validar e manter.

IsMatch( "2025-01-17T19:38:49+0000", 
    "(?x)                 # enables free spacing, must be very first
    ^                     # matches from beginning of text
    \d{4}                 # year (0000-9999)
    -(0\d|1[012])         # month (00-12)
    -([012]\d|3[01])      # day (00-31, range not checked against month)
    (T([01]\d|2[0123])    # optional time, starting with hours (00-23)
      :[0-5]\d            # minutes (00-59)
      (:[0-5]\d           # optional seconds (00-59)
        (\.\d{3})?        # optional milliseconds (000-999)
      )?
      (Z|[\-+]\d{4})      # time zone
    )?
    $                     # matches to end of text
    "
)
// returns true

Ignorar maiúsculas e minúsculas

Activado con MatchOptions.IgnoreCase ou (?i) ao comezo dunha expresión regular.

Coincide co texto nunha letra sen distinción entre maiúsculas e minúsculas: as maiúsculas coinciden coas minúsculas e as minúsculas coinciden coas maiúsculas.

Por exemplo:

IsMatch( "HELLO!", "hello", MatchOptions.IgnoreCase )
// returns true

IsMatch( "file://c:/temp/info.txt", "^FILE://", MatchOptions.IgnoreCase )
// returns true

A maior parte das partes ou Power Fx son culturais, pero non aquí. O uso da coincidencia invariante cultural é o estándar da industria para as expresións regulares, incluíndo en JavaScript e Perl. É útil no segundo exemplo onde se coincide cun recurso do sistema, por exemplo, na cultura tr-TR onde I non é o equivalente en maiúsculas de i.

Se se precisa unha coincidencia que teña en conta a cultura e que non distinga entre maiúsculas e minúsculas, use a clase characters cos caracteres coincidentes, por exemplo [Hh][Ee][Ll][Ll][Oo] para o primeiro exemplo.

Multiliña

Activado con MatchOptions.Multiline ou (?m) ao comezo dunha expresión regular.

Normalmente, as áncoras ^ e $ coinciden co inicio e co texto de entrada. Co modificador Multiline , estas áncoras coinciden co comezo e o final das liñas no texto de entrada, onde cada liña remata con \r, \n, \r\n ou o final da entrada. Por exemplo:

MatchAll( "Hello" & Char(13) & Char(10) & "World", "^.+$" )
// returns 
// "Hello"

Padróns predefinidos

Os patróns predefinidos permítenche atopar coincidencias entre un conxunto de caracteres ou unha secuencia de varios caracteres. Usa o operador de concatenación de cadeas & para combinar as túas cadeas de texto cos membros da enumeración Match :

Enumeración Match Descripción Expresión regular
Calquera Busca coincidencias con calquera carácter. .
Coma Coincide cunha coma ,. ,
Díxito Coincide cun só díxito (0 ata 9 e outros membros de \p{Nd}). \d
Correo electrónico Coincide cun enderezo de correo electrónico que contén un símbolo "arroba" (@) e un nome de dominio que contén polo menos un punto (.), delimitado por espazos en branco e caracteres de puntuación. ver nota
Guión Busca coincidencias cun guión. - ver nota
Paréntese Esquerda Coincide cunha paréntese esquerda (. \(
Carta Busca coincidencias cunha letra. \p{L}
Varios díxitos Busca coincidencias cun ou máis díxitos. \d+
Varias letras Busca coincidencias cunha ou máis letras. \p{L}+
Múltiples non espazos Busca coincidencias cun ou máis caracteres que non engaden espazo en branco (non espazo, separador ou liña nova). \S+
Espazos Múltiples Busca coincidencias cun ou máis caracteres que engaden espazo en branco (espazo, separador ou liña nova). \s+
NonSpace Busca coincidencias cun único carácter que non engade espazo en branco. \S
Díxitos opcionais Busca coincidencias con cero, un ou máis díxitos. \d*
Letras opcionais Busca coincidencias con cero, unha ou máis letras. \p{L}*
Espazos sen espazos opcionais Busca coincidencias con cero, un ou máis caracteres que non engaden espazo en branco. \S*
Espazos opcionais Busca coincidencias con cero, un ou máis caracteres que engaden espazo en branco. \s*
Período Coincide cun punto ou punto .."). \.
Paréntese dereita Coincide cunha paréntese dereita ). \)
Espazo Busca coincidencias cun carácter que engade espazo en branco. \s
Pestana Coincide cun carácter de tabulación. \t

Por exemplo, o patrón "A" & Match.MultipleDigits coincide coa letra "A" seguida dun ou máis díxitos.

O patrón Match.Email é máis complexo que os demais. Detecta e extrae enderezos de correo electrónico comúns co formato local@hostname.tld, posiblemente de longas pasaxes de texto, e admite caracteres internacionais e emojis. Úsao para validar un formulario que acepta un enderezo de correo electrónico como entrada, como unha proba rápida de que a entrada está nun formulario de correo electrónico. Se non estás a extraer, usa MatchOptions.Complete para detectar un enderezo de correo electrónico, por exemplo, nun control de entrada de texto.

Non obstante, Match.Email non valida que o enderezo de correo electrónico se axuste aos moitos estándares en evolución para enderezos de correo electrónico, nomes de dominio e dominios de nivel superior, que requirirían unha expresión regular complicada que tería que actualizarse de cando en vez. Aínda que a maioría dos enderezos de correo electrónico se tratan como se espera, Match.Email coincide con algunhas maiúsculas e minúsculas non válidas, como un guión baixo no nome do host, e non coincide con algunhas maiúsculas e minúsculas válidas, como os enderezos de correo electrónico entre comiñas ou os enderezos IP. Se é necesario, hai moitas expresións regulares na web para detectar un enderezo de correo electrónico verdadeiramente legal. Proba sempre a túa expresión regular para as túas necesidades específicas antes de usala en produción.

Se queres ver a expresión regular empregada, avalía a fórmula Text( Match.Email ). A primeira parte coincide cos caracteres anteriores á @ e exclúe a puntuación ASCII común segundo a RFC 822 e as revisións e a puntuación inicial e final de Unicode para facilitar a extracción, como (, [, “, « e 「. Non admite o uso pouco común e desaconsellado de cadeas ou comentarios entre comiñas. Seguindo o @, a segunda e a terceira parte da expresión regular son iguais e están separadas por un ., o que garante que sempre haxa polo menos un . no enderezo. Estas partes exclúen toda a puntuación Unicode agás ., - e _. Non se admiten enderezos IP. Admítense caracteres e emojis internacionais en todo o enderezo de correo electrónico.

En Power Apps, cando non se usa Power Fx 1.0, Match.Email e Match.Hyphen teñen definicións lixeiramente diferentes. Match.Email é máis sinxelo, pero non é axeitado para extraer un enderezo de correo electrónico xa que captura espazos. Anteriormente, Match.Hyphen escapaba fóra dunha clase de caracteres, o que agora é ilegal.

Subcoincidencias numeradas

Activado con MatchOptions.NumberedSubMatches sen opción en liña. (?n) admítese como o contrario desta opción por compatibilidade e é a predeterminada.

Por defecto, (...) non captura, o equivalente ao que a maioría dos sistemas chaman "captura explícita". Para capturar, use unha captura nomeada con (?<name>...) con referencia inversa \k<name>. O uso de capturas con nome mellora o rendemento ao non capturar grupos que non son necesarios, mellora a claridade ao usar nomes e non é propenso a erros se cambia a posición das capturas.

Se xa tes unha expresión regular, pode depender de que os grupos se capturen automaticamente e se numeren, incluídas as referencias retroactivas numeradas. Este comportamento está dispoñible usando a opción MatchOptions.NumberedSubMatches .

As subcoincidencias con nome e numeradas non se poden usar xuntas. Dado que algunhas implementacións tratan de forma diferente unha mestura de grupos de captura numerados e nomeados, Power Fx non o permite.

Posibles subcoincidencias baleiras

Como se indicou na introdución, as expresións regulares de Power Fx están intencionadamente limitadas a funcionalidades que se poden implementar de forma consistente en .NET, JavaScript e outros motores de expresións regulares de linguaxes de programación. Os erros no momento da creación impiden o uso de funcionalidades que non forman parte deste conxunto.

Un aspecto que pode variar entre as implementacións é como se xestionan as subcoincidencia baleiras. Por exemplo, considere a expresión regular (?<submatch>a*)+ á que se lle pide que coincida co texto a. En .NET, a subcoincidencia dá como resultado unha cadea de texto baleira, mentres que en JavaScript dá como resultado a. Pódese argumentar que ambas as dúas son implementacións correctas, xa que o cuantificador pode satisfacerse cunha cadea baleira xa que o contido do grupo ten un cuantificador. +*

Para evitar resultados diferentes entre as implementacións, as subcoincidencias que poidan estar baleiras non se poden usar cun cuantificador. Power Fx Aquí tes exemplos de como unha subcoincidencia podería estar baleira:

Exemplos Descripción
(?<submatch>a{0,}b*)+ Todo o contido da subcoincidencia é opcional, polo que é posible que esta estea baleira.
((<submatch>a)?b)+ Debido ao ? fóra da subcoincidencia, a subcoincidencia no seu conxunto é opcional.
(?<submatch>a|b*)+ A alternancia dentro da subcoincidencia con algo que podería estar baleiro podería resultar en que toda a subcoincidencia estea baleira.
((?<submatch>a)|b)+ A alternancia fóra da subcoincidencia podería coincidir b nese caso a subcoincidencia estaría baleira.

A subcoincidencia en (?<submatch>a+)+ non pode estar baleira porque debe haber polo menos unha a na subcoincidencia e é compatible.

Unicode

Power Fx As expresións regulares empregan categorías Unicode para definir \w, \d e \s, con categorías específicas dispoñibles a través de \p{..}.

Estas definicións poden variar segundo as plataformas. Por exemplo, o estándar Unicode actualízase de cando en vez con novos caracteres que posteriormente serán implementados polas plataformas ao seu propio ritmo. Agarda variacións nos resultados entre as plataformas ata que todas as plataformas estean actualizadas.

Power Fx As expresións regulares garanten que a información da categoría estea sempre dispoñible para o plano multilingüe básico (caracteres U+0 a U+ffff). Algunhas plataformas non implementan categorías para os caracteres no plano multilingüe suplementario e posteriores (de U+10000 a U+10ffff). Esta limitación non adoita ser un problema, xa que os caracteres do plano multilingüe básico son os que se usan con máis frecuencia. Emprega valores de caracteres directamente en lugar de categorías se o teu escenario inclúe caracteres en ou por riba de U+10000. Proba as túas expresións regulares nas plataformas que pretendes usar.

Poderían existir pequenas diferenzas nos casos límite entre as plataformas. Por exemplo, algunhas plataformas poden non ver ſ como coincidente s cando se invoca MatchOptions.IgnoreCase . Se estes caracteres son importantes para o teu escenario, usa unha clase de caracteres como [ſsS] para que a comparación sexa indistinguible entre maiúsculas e minúsculas e inclúa explicitamente os caracteres desexados.

  • Last updated on