Expressões regulares

As funçõesIsMatch , Match e MatchAll são usadas para extrair e validar padrões no texto. O padrão que eles usam é chamado de expressão regular.

As expressões regulares são poderosas e versáteis. No entanto, por vezes podem aparecer como uma sequência aleatória de sinais de pontuação. Este artigo não descreve todos os aspetos das expressões regulares, mas uma grande variedade de informações, tutoriais e ferramentas estão disponíveis online.

As expressões regulares têm uma longa história e estão disponíveis em muitas linguagens de programação. Cada linguagem de programação tem seu próprio dialeto de expressões regulares, e há poucos padrões. Na medida do possível, estamos nos esforçando para que a mesma expressão regular dê o mesmo resultado em todas as Power Fx implementações. A compatibilidade não é fácil de realizar, pois Power Fx é executada em cima do JavaScript e do .NET, que têm diferenças significativas. Para serem executadas em diferentes plataformas, Power Fx as expressões regulares usam um subconjunto de recursos amplamente suportados em toda a indústria.

Como resultado, algumas expressões regulares que funcionam em outros ambientes podem ser bloqueadas ou precisar de ajustes Power Fx. Os erros de tempo de criação são relatados à medida que recursos sem suporte são encontrados. É por isso que a expressão regular e as opções devem ser uma constante de tempo de criação e não dinâmica, como ser fornecida em uma variável.

Nota

Power Apps usa uma versão anterior de Power Fx expressões regulares, que tem menos limitações, mas também menos recursos. MatchOptions.DotAll e MatchOptions.FreeSpacing não estão disponíveis e as definições de Match.Email e Match.Hyphen são diferentes. Os pares substitutos Unicode não são tratados como um único caráter. MatchOptions.NumberedSubMatches é o padrão. A versão de expressões regulares descrita aqui estará disponível em Power Apps breve, sob uma opção "Power Fx Compatibilidade V1.0".

Funcionalidades suportadas

Power Fx suporta os seguintes recursos de expressão regular, com notas sobre como Power Fx o comportamento pode diferir de outros sistemas.

A expressão regular deve ser constante e não calculada ou armazenada em uma variável. O operador, a & interpolação $"{...}" de cadeia de caracteres e o Concatenate, Char, e UniChar funções com argumentos constantes são suportados.

Caracteres literais

Caraterística	Description
Caracteres literais	Qualquer caráter Unicode pode ser inserido diretamente, exceto,,,,, \, [, ]^$.|?* e. +(){} Ao usar MatchOptions.FreeSpacing, #, , e outros \s caracteres de espaço devem ser escapados, pois eles têm um significado diferente.
Caracteres literais escapados	\ (barra invertida) seguido por um dos caracteres literais diretos, como \? para inserir um ponto de interrogação. \# e \ também pode ser usado mesmo quando MatchOptions.FreeSpacing está desativado para consistência.
Códigos de caracteres hexadecimais e Unicode	\x20 com exatamente dois dígitos hexadecimais, \u2028 com exatamente quatro dígitos hexadecimais e pode ser usado para substitutos altos e baixos.
Ponto de código Unicode	\u{01F47B} com até oito dígitos hexadecimais. Deve estar na faixa de 0 a U+10FFFF e não pode ser usado para um substituto alto ou baixo. Pode resultar em um par substituto (dois caracteres) se maior que U + FFFF.
Retorno de automóvel	\r, o mesmo que Char(13).
Caractere de nova linha	\n, o mesmo que Char(10).
Feed de formulários	\f, o mesmo que Char(12).
Guia Horizontal	\t, o mesmo que Char(9).

Use \x ou \u em vez disso. Códigos octais para caracteres, como \044 ou \o{044} não são permitidos, porque podem ser ambíguos com referências de volta numeradas.

\v não é suportado porque é ambíguo em linguagens de expressão regular. Use \x0b para uma guia vertical ou [\x0b\f\r\n\x85\u2028\u2029] para espaço em branco vertical.

Afirmações

As asserções correspondem a uma posição específica no texto, mas não consomem nenhum caráter.

Caraterística	Description
Início da linha	^, corresponde ao início do texto ou de uma linha se MatchOptions.Multiline for usado.
Fim da linha	$, corresponde ao final do texto ou de uma linha se MatchOptions.Multiline for usado.
Olhar em frente	(?=a) e (?!a), corresponde à frente para um padrão.
Olhar para trás	(?<=b) e (?<!b), corresponde atrás para um padrão.
Quebras de palavras	\b e \B, usando a definição Unicode de letras [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}].

$ corresponde ao fim de uma linha, incluindo qualquer trailing \r\n, \r, ou \n.

As asserções lookahead e lookbehind não podem conter subcorrespondências ou quantificadores ilimitados dentro e não podem ser usadas com um quantificador externo.

Classes de personagens

Caraterística	Description
Ponto	., corresponde a tudo, exceto \r e \n a menos que MatchOptions.DotAll seja usado.
Classe de caráter	[abc] lista de caracteres, [a-fA-f0-9] variedade de caracteres, tudo, [^a-z] menos esses caracteres. As classes de caracteres não podem ser aninhadas, subtraídas ou interseccionadas, e muitos sinais de pontuação podem não aparecer duas vezes seguidas (@@, %%, !!, etc).
Caracteres do Word	\w e \W usando a definição Unicode de letras [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]. \W não pode ser usado em uma classe de caráter negativa.
Caracteres de dígitos	\d inclui os dígitos 0 para e9 , corresponde a tudo, \p{Nd} exceto caracteres correspondidos \D por \d. \D não pode ser usado em uma classe de caráter negativa.
Caracteres espaciais	\s inclui caracteres [ \t\n\x0b\f\r\x85\u2028\u2029\p{Z}] de espaçamento, que corresponde a tudo, \S exceto caracteres correspondidos por \s. \S não pode ser usado em uma classe de caráter negativa.
Categoria de caráter Unicode	\p{Ll} corresponde a todas as letras minúsculas Unicode, enquanto \P{Ll} corresponde a tudo o que não é uma letra minúscula Unicode. \P{} não pode ser usado em uma classe de caráter negativa.

Para aumentar a clareza e evitar ambiguidade, as classes de caracteres entre colchetes são mais restritivas do que em outras linguagens de expressão regular:

• Caracteres de hífen literais devem ser escapados. Use [\-a] em vez de [-a] corresponder -a ou.
• Os colchetes iniciais devem ser evitados. Use [\[a] em vez de [[] corresponder [a ou.
• A menos que seja o primeiro caráter e indique negação, o personagem deve ser escapado. Use [a\^] em vez de [a^] corresponder ^a ou.
• Os suportes encaracolados devem ser escapados. Use [\{\}] para corresponder { ou }.
• Não há suporte para a classe [] de caráter vazia. Para incluir um colchete de fecho em uma classe de caracteres, escape-o.

Categorias de caracteres Unicode suportadas por \p{} e \P{}:

• Letras: L, Lu, Ll, Lt,, LmLo
• Marcas: M, Mn, Mc, Me
• Números: N, Nd, Nl, No
• Pontuação: P, Pc, Pd, Ps, Pe,, Pi, PfPo
• Símbolos: S, Sm, Sc,, SkSo
• Separadores: Z, Zs, Zl, Zp
• Control e Format: Cc, Cf, enquanto outras C categorias de prefixo não são suportadas.

\W, \D, \S, e \P{} não pode ser usado dentro de uma classe [^...] de caracteres negada. Para serem implementadas em algumas plataformas, essas classes de caracteres negativos são traduzidas para seus equivalentes Unicode, o que pode ser difícil de fazer se também for negado.

Caracteres Unicode entre U+10000 e U+10FFFF, que exigem pares substitutos, não são suportados em classes de caracteres.

Quantificadores

Caraterística	Description
Ganancioso zero ou um	? corresponde a zero ou uma vez, com uma partida tão grande quanto possível.
Ganancioso zero ou mais	* corresponde zero ou mais vezes, com uma partida tão grande quanto possível.
Ganancioso um ou mais	+ corresponde uma ou mais vezes, com uma partida tão grande quanto possível.
Ganancioso pelo menos n	{n,} corresponde pelo menos n vezes, com uma partida tão grande quanto possível. Por exemplo, a{3,} corresponde a todos os caracteres em aaaaa.
Ganancioso entre n e m	{n,m} Partidas entre n e m tempos, com uma partida tão grande quanto possível. Por exemplo, a{1,3} corresponde aos três primeiros caracteres de aaaaa.
Zero preguiçoso ou um	?? corresponde a zero ou uma vez, com uma correspondência tão pequena quanto possível.
Preguiçoso zero ou mais	*? corresponde zero ou mais vezes, com o menor número possível de correspondências.
Preguiçoso um ou mais	+? corresponde uma ou mais vezes, com o menor número possível de jogos.
Preguiçoso pelo menos n	{n,}? corresponde pelo menos n vezes, com o menor número possível de jogos. Por exemplo, a{3,}? corresponde apenas aos três primeiros caracteres em aaaaa.
Preguiçoso entre n e m	{n,m}? Partidas entre n e m tempos, com uma partida tão pequena quanto possível. Por exemplo, a{1,3}? corresponde apenas ao primeiro caráter de aaaaa.
Exato n	{n} corresponde a n vezes, exatamente. Por exemplo, a{3} corresponde exatamente a três caracteres de aaaaa.

Quantificadores possessivos não são suportados.

A mistura de subcorrespondências e quantificadores tem limitações. Para obter mais informações, consulte Possivelmente subcorrespondências vazias.

Grupos

Caraterística	Description
Agrupar	( e ) são usados para agrupar elementos para quantificadores a serem aplicados. Por exemplo, (abc)+ correspondências abcabc.
Alternância	a|b corresponde a "a" ou "b", frequentemente usado em grupo.
Subcorrespondência nomeada e referência posterior	(?<name>chars) captura uma subcorrespondência com o nome name, referenciado com \k<name>. Não pode ser usado se MatchOptions.NumberedSubMatches estiver habilitado.
Subcorrespondência numerada e referência posterior	Quando MatchOptions.NumberedSubMatches está habilitado, (a) captura uma subcorrespondência referenciada com \1.
Grupo sem captura	(?:a), cria grupo sem capturar o resultado como uma subcorrespondência nomeada ou numerada. Todos os grupos não são capturados, a menos que MatchOptions.NumberedSubMatches esteja habilitado.

Subcorrespondências nomeadas e numeradas não podem ser usadas juntas. Por padrão, as subcorrespondências nomeadas são habilitadas e preferidas para clareza e manutenção, enquanto os grupos de captura padrão se tornam grupos sem captura com desempenho aprimorado. Esse comportamento pode ser alterado com MatchOptions.NumberedSubMatchs , que fornece grupos de captura tradicionais, mas desabilita grupos de captura nomeados. Algumas implementações tratam uma mistura de grupos de captura numerados e nomeados de forma diferente, e é por isso que Power Fx não a permite.

Não há suporte para grupos de captura de autorreferência, por exemplo, a expressão (a\1) regular.

Dois grupos de captura não podem compartilhar o mesmo nome, por exemplo, a expressão (?<id>\w+)|(?<id>\d+) regular não é suportada.

O nome de uma subcorrespondência nomeada deve começar com um \p{L} caráter ou _, e pode continuar com esses caracteres mais \p{Nd}. Os nomes são limitados em comprimento a 62 unidades de código UTF-16.

Também não há suporte para referências a subcorrespondências possivelmente vazias e a subcorrespondências dentro de um olhar para trás ou olhar para frente.

Algumas implementações oferecem uma opção de "captura explícita" para melhorar o desempenho, o que é desnecessário Power Fx , pois é o padrão. MatchOptions.NumberedSubMatches desativa-o e permite capturas numeradas implicitamente.

Misturar subcorrespondências e quantificadores tem limitações. Consulte Possivelmente subcorrespondências vazias para obter mais informações.

Comentários

Caraterística	Description
Comentários embutidos	(?# comment here), que é ignorado como um comentário. O comentário termina com o próximo parêntese próximo, mesmo que um parêntese de abertura esteja no comentário.

Consulte MatchOptions.FreeSpacing para obter uma alternativa para formatar e comentar expressões regulares.

Opções em linha

Caraterística	Description
Opções em linha	(?im) é o mesmo que usar MatchOptions.IgnoreCase e MatchOptions.Multiline. Deve ser definido no início da expressão regular.

Os modos em linha suportados são [imsx]. Estes correspondem a MatchOptions.IgnoreCase, MatchOptions.Multiline, MatchOptions.DotAll e MatchOptions.FreeSpacing, respectivamente. n também é aceito para compatibilidade, mas não tem efeito, pois é o padrão e é incompatível com MatchOptions.NumberedSubMatches.

As opções embutidas não podem ser usadas para desabilitar uma opção ou definir uma opção para uma subexpressão.

Opções

As opções de correspondência alteram o comportamento da correspondência de expressão regular. Há duas maneiras de habilitar opções, que podem ser misturadas desde que não haja conflito:

• O valor do enum MatchOptions passou como o terceiro argumento para Match, MatchAll e IsMatch. As opções podem ser combinadas com o & operador ou Concatenate função, por exemplo MatchOptions.DotAll & MatchOptions.FreeSpacing. Todas as funções de expressão regular requerem que MatchOptions seja um valor constante, não pode ser calculado ou armazenado em uma variável.
• (?...) prefixo no início da expressão regular. As opções podem ser combinadas com várias letras na (?...) construção, por exemplo (?sx). Algumas opções não têm um (?...) equivalente, mas podem ter outras maneiras de obter o mesmo efeito, por exemplo , MatchOptions.BeginsWith é o equivalente ^ a no início da expressão regular.

Contém

Ativado com MatchOptions.Contains sem um equivalente de texto de expressão regular. MatchOptions.Contains é o padrão para todas as funções fora de Power Apps; dentro Power Apps de MatchOptions.Complete é o padrão para IsMatch.

Concluir

Ativado com MatchOptions.Complete ou use ^ e $ no início e da expressão regular, respectivamente.

BeginsWith

Ativado com MatchOptions.BeginsWith ou use ^ no início e da expressão regular.

EndsWith

Ativado com MatchOptions.EndsWith ou use $ no final da expressão regular.

DotAll

Ativado com MatchOptions.DotAll ou (?s) no início da expressão regular.

Normalmente, o operador de pontos . corresponde a todos os caracteres, exceto os caracteres [\n\x0b\f\r\x85\u2028\u2029] de nova linha. Com o modificador DotAll , todos os caracteres são correspondidos, incluindo novas linhas.

Neste exemplo, apenas o "Olá" é correspondido, pois por padrão o . não corresponderá à nova linha:

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

Mas se adicionarmos o modificador DotAll , a nova linha e todos os caracteres subsequentes serão correspondidos:

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

Espaçamento Livre

Ativado com MatchOptions.FreeSpacing ou (?x) no início de uma expressão regular.

O espaçamento livre facilita a leitura e a manutenção de uma expressão regular complexa. As regras são simples:

• Os caracteres de espaço são ignorados na expressão regular, incluindo todos os caracteres que corresponderiam \s. Se a correspondência de um espaço for desejada, use \s, \ , \t,, \r ou \n.
• # inicia um comentário que vai até o final da linha. Ele e todos os caracteres que seguem até o próximo caráter de nova linha (caracteres não correspondidos sem .MatchOptions.DotAll) são ignorados.
• As classes de caracteres não estão incluídas nessas alterações. Personagens espaciais e # agem como normalmente fazem. Por exemplo, IsMatch( "a#b c", "(?x)a[ #]b[ #]c" ) retorna true. Algumas linguagens de expressão regular incluem classes de caracteres no espaçamento livre ou fornecem uma opção para incluí-las, mas Power Fx não o fazem.

Por exemplo, aqui está uma expressão regular complexa para corresponder a uma hora de data ISO8601:

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 aqui está a expressão regular idêntica com espaçamento livre utilizando várias linhas, recuo para grupos e comentários de expressão regular, tornando esta versão mais fácil 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

IgnorarCaso

Ativado com MatchOptions.IgnoreCase ou (?i) no início de uma expressão regular.

Corresponde ao texto em letras maiúsculas e minúsculas: letras maiúsculas correspondem a letras minúsculas e letras minúsculas correspondem a letras maiúsculas.

Por exemplo:

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

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

A maioria das partes ou Power Fx são conscientes da cultura, mas não aqui. O uso da correspondência invariante de cultura é o padrão do setor para expressões regulares, inclusive em JavaScript e Perl. É útil no segundo exemplo em que um recurso do sistema está a ser correspondido, por exemplo, na tr-TR cultura em que I não é o equivalente em maiúsculas i.

Se for necessária uma correspondência consciente de cultura e sem distinção entre maiúsculas e minúsculas, use a classe de caracteres com os caracteres correspondentes, por exemplo [Hh][Ee][Ll][Ll][Oo] , para o primeiro exemplo.

Multilinha

Ativado com MatchOptions.Multiline ou (?m) no início de uma expressão regular.

Normalmente, ^ e $ as âncoras correspondem ao início e ao texto de entrada. Com o modificador Multiline , essas âncoras correspondem ao início e ao fim das linhas no texto de entrada, onde cada linha termina com \r, \n, \r\n, ou o final da entrada. Por exemplo:

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

Padrões predefinidos

Os padrões predefinidos permitem que você corresponda a um de um conjunto de caracteres ou a uma sequência de vários caracteres. Use o operador string-concatenation& para combinar suas cadeias de texto com membros do enum Match :

Enumeração de correspondência	Description	Expressão regular
Qualquer	Corresponde a qualquer caráter.	.
Vírgula	Corresponde a uma vírgula ,.	,
Algarismo	Corresponde a um único dígito (0 através 9 e outros membros de \p{Nd}).	\d
E-mail	Corresponde a um endereço de e-mail que contém um símbolo "at" (@) e um nome de domínio que contém pelo menos um ponto (.), delimitado por espaço em branco e caracteres de pontuação.	ver nota
Hífen	Corresponde a um hífen.	- ver nota
LeftParen	Corresponde a um parêntese ( esquerdo.	\(
Carta	Corresponde a uma letra.	\p{L}
Dígitos múltiplos	Corresponde a um ou mais dígitos.	\d+
Letras Múltiplas	Corresponde a uma ou mais letras.	\p{L}+
MultipleNonSpaces	Corresponde a um ou mais carateres que não adicionam espaços em branco (não espaço, separador ou nova linha).	\S+
Espaços Múltiplos	Corresponde a um ou mais carateres que adicionam espaços em branco (espaço, separador ou nova linha).	\s+
Não-Espaço	Corresponde a um único caráter que não adiciona espaço em branco.	\S
OpcionalDígitos	Corresponde a zero, um ou mais dígitos.	\d*
Cartas Opcionais	Corresponde a zero, uma ou mais letras.	\p{L}*
OptionalNonSpaces	Corresponde a zero, um ou mais carateres que não adicionam espaços em branco.	\S*
Espaços Opcionais	Corresponde a zero, um ou mais carateres que adicionam espaços em branco.	\s*
Period	Corresponde a um ponto ou ponto ..").	\.
DireitaParen	Corresponde a um parêntese ) certo.	\)
Espaço	Corresponde a um caráter que adiciona espaço em branco.	\s
Tab	Corresponde um caráter de separador.	\t

Por exemplo, o padrão "A" & Match.MultipleDigits corresponde à letra "A" seguida por um ou mais dígitos.

O padrão Match.Email é mais complexo do que o resto. Ele deteta e extrai endereços de e-mail comuns no formulário local@hostname.tld, possivelmente de longas passagens de texto, e suporta caracteres internacionais e emojis. Use-o para validar um formulário que usa um endereço de e-mail como entrada, como um teste rápido de que a entrada está em um formulário de e-mail. Se você não estiver a extrair, use MatchOptions.Complete para detetar um endereço de e-mail, por exemplo, em um controle de entrada de texto.

No entanto, Match.Email não valida que o endereço de e-mail esteja em conformidade com todos os muitos padrões em evolução para endereços de e-mail, nomes de domínio e domínios de nível superior, o que exigiria uma expressão regular complicada que precisaria ser atualizada de tempos em tempos. Embora a maioria dos endereços de e-mail seja tratada como esperado,Match.Email corresponde a alguns casos inválidos, como um sublinhado no nome do host, e não corresponde a alguns casos válidos, como endereços de e-mail citados ou endereços IP. Se necessário, existem muitas expressões regulares na Web para detetar um endereço de e-mail verdadeiramente legal. Teste sempre a sua expressão regular para as suas necessidades específicas antes de utilizar na produção.

Se quiser ver a expressão regular usada, avalie a fórmula Text( Match.Email ). A primeira parte corresponde aos carateres antes de @ e exclui a pontuação ASCII comum, de acordo com RFC 822 e revisões, bem como pontuação inicial e final Unicode para facilitar a extração, como (, [, “, « e 「. Ele não suporta o uso incomum e desencorajado de strings ou comentários citados. Após a @, a segunda e terceira partes da expressão regular são as mesmas e separadas por a ., garantindo que haja sempre pelo menos uma . no endereço. Essas partes excluem toda a pontuação Unicode, exceto para ., -, e _. Os endereços IP não são suportados. Em todo o endereço de e-mail, personagens internacionais e emojis são suportados.

Em Power Apps, quando não estiver a usar Power Fx 1.0,Match.Email e Match.Hyphen têm definições ligeiramente diferentes. Match.Email é mais simples, mas não é adequado para extrair um endereço de e-mail, pois captura espaços. Anteriormente, Match.Hyphen foi escapado fora de uma classe de caracteres que agora é ilegal.

Subcorrespondências numeradas

Ativado com MatchOptions.NumberedSubMatches sem opção embutida. (?n) é suportado como o oposto desta opção para compatibilidade e é o padrão.

Por padrão, (...) não captura, o equivalente ao que a maioria dos sistemas chama de "captura explícita". Para capturar, use uma captura nomeada com (?<name>...) backreference \k<name>. O uso de capturas nomeadas melhora o desempenho ao não capturar grupos que não são necessários, melhorando a clareza usando nomes e não propenso a erros se a posição das capturas mudar.

Se você tiver uma expressão regular existente, ela pode depender de grupos sendo capturados automaticamente e numerados, incluindo referências de volta numeradas. Esse comportamento está disponível usando a opção MatchOptions.NumberedSubMatchs .

Subcorrespondências nomeadas e numeradas não podem ser usadas juntas. Como algumas implementações tratam uma mistura de grupos de captura numerados e nomeados de forma diferente, Power Fx não permite isso.

Subcorrespondências possivelmente vazias

Como dito na introdução, Power Fx as expressões regulares são intencionalmente limitadas a recursos que podem ser implementados consistentemente em .NET, JavaScript e outros mecanismos de expressão regular de linguagem de programação. Os erros de tempo de criação impedem o uso de recursos que não fazem parte desse conjunto.

Uma área que pode ser diferente entre implementações é como as subcorrespondências vazias são tratadas. Por exemplo, considere a expressão (?<submatch>a*)+ regular solicitada a corresponder ao texto a. No .NET, a subcorrespondência resulta em uma cadeia de texto vazia, enquanto no JavaScript ela resulta a. Ambos podem ser argumentados como implementações corretas, pois o + quantificador pode ser satisfeito com uma cadeia de caracteres vazia, uma vez que o conteúdo do grupo tem um * quantificador.

Para evitar resultados diferentes entre Power Fx implementações, as subcorrespondências que podem estar vazias não podem ser usadas com um quantificador. Aqui estão exemplos de como uma subcorrespondência pode estar vazia:

Exemplos	Description
(?<submatch>a{0,}b*)+	Todo o conteúdo da subcorrespondência é opcional, portanto, toda a subcorrespondência pode estar vazia.
((<submatch>a)?b)+	Devido ao ? exterior da subcorrespondência, a subcorrespondência como um todo é opcional.
(?<submatch>a|b*)+	A alternância dentro da subcorrespondência com algo que poderia estar vazio poderia resultar em toda a subcorrespondência vazia.
((?<submatch>a)|b)+	A alternância fora da subcorrespondência poderia corresponder b , caso em que a subcorrespondência estaria vazia.

A subcorrespondência não (?<submatch>a+)+ pode estar vazia porque deve haver pelo menos uma a na subcorrespondência, e ela é suportada.

Unicode

Power Fx expressões regulares usam categorias Unicode para definir \w, \d e \s, com categorias específicas disponíveis através \p{..}.

Essas definições podem variar entre plataformas. Por exemplo, o padrão Unicode é atualizado de tempos em tempos com novos caracteres que serão posteriormente implementados pelas plataformas em seu próprio ritmo. Espere variações nos resultados entre plataformas até que todas as plataformas sejam atualizadas.

Power Fx expressões regulares garantem que as informações de categoria estejam sempre disponíveis para o Plano Multilingue Básico (caracteres U+0 a U+ffff). Algumas plataformas não implementam categorias para caracteres no Plano Multilingue Suplementar e mais além (U+10000 a U+10ffff). Esta limitação geralmente não é uma preocupação, pois os caracteres no Plano Multilíngue Básico são os mais comumente usados. Use valores de caracteres diretamente em vez de categorias se o cenário envolver caracteres em ou além de U+10000. Teste as suas expressões regulares nas plataformas que pretende utilizar.

Pequenas diferenças de casos de borda podem existir entre plataformas. Por exemplo, algumas plataformas podem não ver ſ como correspondente s quando MatchOptions.IgnoreCase é invocado. Se esses caracteres forem importantes para o seu cenário, use uma classe de caráter como [ſsS] para corresponder maiúsculas e minúsculas sem distinção e inclua explicitamente os caracteres desejados.