Espressioni regolari

Le funzioni IsMatch, Match e MatchAll vengono utilizzate per estrarre e convalidare modelli nel testo. Il modello che utilizzano è chiamato espressione regolare. ...

Le espressioni regolari sono potenti e versatili. A volte, tuttavia, possono apparire come una sequenza casuale di segni di punteggiatura. Questo articolo non descrive tutti gli aspetti delle espressioni regolari, ma online sono disponibili numerose informazioni, tutorial e strumenti.

Le espressioni regolari hanno una lunga storia e sono disponibili in molti linguaggi di programmazione. Ogni linguaggio di programmazione ha il suo dialetto di espressioni regolari e gli standard sono pochi. Ci impegniamo il più possibile affinché la stessa espressione regolare dia lo stesso risultato in tutte le implementazioni. Power Fx La compatibilità non è facile da ottenere poiché viene eseguito su JavaScript e .NET, che presentano differenze significative. Power Fx Per funzionare su piattaforme diverse, le espressioni regolari utilizzano un sottoinsieme di funzionalità ampiamente supportate nel settore. Power Fx

Di conseguenza, alcune espressioni regolari che funzionano in altri ambienti potrebbero essere bloccate o richiedere modifiche in Power Fx. Vengono segnalati errori durante la creazione quando vengono rilevate funzionalità non supportate. Ecco perché l'espressione regolare e le opzioni devono essere una costante al momento della creazione e non dinamiche, ad esempio fornite in una variabile.

Nota

Power Apps utilizza una versione precedente delle espressioni regolari, che presenta meno limitazioni ma anche meno funzionalità. Power Fx MatchOptions.DotAll e MatchOptions.FreeSpacing non sono disponibili e le definizioni di Match.Email e Match.Hyphen sono diverse. Le coppie di surrogati Unicode non vengono trattate come un singolo carattere. MatchOptions.NumberedSubMatches è l'impostazione predefinita. La versione delle espressioni regolari descritta qui sarà disponibile a breve, con l'opzione " Power Apps compatibilità V1.0".Power Fx

Funzionalità supportate

Power Fx supporta le seguenti funzionalità di espressioni regolari, con note su come il comportamento potrebbe differire da quello di altri sistemi. Power Fx

L'espressione regolare deve essere costante e non calcolata o memorizzata in una variabile. Sono supportati l'operatore & , l'interpolazione di stringhe $"{...}" e le funzioni Concatenate, Char e UniChar con argomenti costanti.

Caratteri letterali

Funzionalità di	Descrzione
Caratteri letterali	È possibile inserire direttamente qualsiasi carattere Unicode, eccetto \, [, ], ^, $, ., |, ?, *, +, (, ), { e }. Quando si utilizzano MatchOptions.FreeSpacing, #, e altri \s caratteri spazio, è necessario eseguire l'escape poiché hanno un significato diverso.
Caratteri letterali sfuggiti	\ (barra rovesciata) seguito da uno dei caratteri letterali diretti, ad esempio \? per inserire un punto interrogativo. \# e \ può essere utilizzato anche quando MatchOptions.FreeSpacing è disabilitato per coerenza.
Codici dei caratteri esadecimali e Unicode	\x20 con esattamente due cifre esadecimali, \u2028 con esattamente quattro cifre esadecimali e può essere utilizzato per surrogati alti e bassi.
Punto di codice Unicode	\u{01F47B} con un massimo di otto cifre esadecimali. Deve essere compreso tra 0 e U+10FFFF e non può essere utilizzato né per un surrogato alto né per uno basso. Può generare una coppia surrogata (due caratteri) se maggiore di U+FFFF.
Ritorno a capo	\r, lo stesso di Char(13).
Carattere di nuova riga	\n, lo stesso di Char(10).
Avanzamento modulo	\f, lo stesso di Char(12).
Scheda orizzontale	\t, lo stesso di Char(9).

Utilizza \x o \u invece. I codici ottali per i caratteri, come \044 o \o{044} , non sono consentiti, perché possono risultare ambigui con riferimenti retronumerati.

\v non è supportato perché è ambiguo nei linguaggi di espressioni regolari. Utilizzare \x0b per una tabulazione verticale o [\x0b\f\r\n\x85\u2028\u2029] per uno spazio vuoto verticale.

Affermazioni

Le asserzioni corrispondono a una posizione specifica nel testo ma non occupano alcun carattere.

Funzionalità di	Descrzione
Inizio della linea	^, corrisponde all'inizio del testo o di una riga se viene utilizzato MatchOptions.Multiline .
Fine della linea	$, corrisponde alla fine del testo o di una riga se viene utilizzato MatchOptions.Multiline .
Guardare avanti	(?=a) e (?!a), corrispondenze in anticipo per un modello.
Guardare dietro	(?<=b) e (?<!b), corrispondenze dietro per un pattern.
Le parole si interrompono	\b e \B, utilizzando la definizione Unicode delle lettere [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}].

$ corrisponde alla fine di una riga, inclusi eventuali caratteri finali \r\n, \r o \n.

Le asserzioni lookahead e lookbehind non possono contenere sottocorrispondenze o quantificatori illimitati al loro interno e non possono essere utilizzate con un quantificatore all'esterno.

Classi di personaggi

Funzionalità di	Descrzione
Punto	., corrisponde a tutto tranne \r e \n a meno che non venga utilizzato MatchOptions.DotAll .
Classe di caratteri	[abc] elenco di caratteri, [a-fA-f0-9] intervallo di caratteri, [^a-z] tutto tranne questi caratteri. Le classi di caratteri non possono essere annidate, sottratte o intersecate e molti segni di punteggiatura non possono apparire due volte di seguito (@@, %%, !!, ecc.).
Caratteri di parole	\w e \W utilizzando la definizione Unicode delle lettere [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]. \W non può essere utilizzato in una classe di caratteri negativa.
Caratteri numerici	\d include le cifre da 0 a9 e \p{Nd}, \D corrisponde a tutto tranne ai caratteri corrispondenti a \d. \D non può essere utilizzato in una classe di caratteri negativa.
Personaggi spaziali	\s include caratteri di spaziatura [ \t\n\x0b\f\r\x85\u2028\u2029\p{Z}], \S che corrispondono a tutto tranne ai caratteri corrispondenti a \s. \S non può essere utilizzato in una classe di caratteri negativa.
Categoria di caratteri Unicode	\p{Ll} corrisponde a tutte le lettere minuscole Unicode, mentre \P{Ll} corrisponde a tutto ciò che non è una lettera minuscola Unicode. \P{} non può essere utilizzato in una classe di caratteri negativa.

Per aumentare la chiarezza ed evitare ambiguità, le classi di caratteri delle parentesi quadre sono più restrittive rispetto ad altri linguaggi di espressioni regolari:

• I caratteri trattino letterali devono essere preceduti da escape. Utilizzare [\-a] invece di [-a] per abbinare - o a.
• Le parentesi quadre iniziali devono essere precedute da un carattere di escape. Utilizzare [\[a] invece di [[] per abbinare [ o a.
• A meno che non sia il primo carattere e indichi una negazione, il carattere deve essere preceduto da un carattere di escape. Utilizzare [a\^] invece di [a^] per abbinare ^ o a.
• Le parentesi graffe devono essere separate. Utilizza [\{\}] per abbinare { o }.
• Le classi di caratteri vuote [] non sono supportate. Per includere una parentesi quadra di chiusura in una classe di caratteri, occorre eseguirne l'escape.

Categorie di caratteri Unicode supportate da \p{} e \P{}:

• Lettere: L, Lu, Ll, Lt, Lm, Lo
• Voti: M, Mn, Mc, Me
• Numeri: N, Nd, Nl, No
• Punteggiatura: P, Pc, Pd, Ps, Pe, Pi, Pf, Po
• Simboli: S, Sm, Sc, Sk, So
• Separatori: Z, Zs, Zl, Zp
• Controllo e formato: Cc, Cf, mentre altre C categorie di prefisso non sono supportate.

\W, \D, \S e \P{} non possono essere utilizzati all'interno di una classe di caratteri negata [^...]. Per essere implementate su alcune piattaforme, queste classi di caratteri negativi vengono tradotte nei loro equivalenti Unicode, il che potrebbe risultare difficile se anch'esse venissero negate.

I caratteri Unicode compresi tra U+10000 e U+10FFFF, che richiedono coppie surrogate, non sono supportati nelle classi di caratteri.

Quantificatori

Funzionalità di	Descrzione
Avido zero o uno	? corrisponde a zero o una volta, con la corrispondenza più ampia possibile.
Avido zero o più	* corrisponde a zero o più volte, con la corrispondenza più ampia possibile.
Avido uno o più	+ corrisponde una o più volte, con la corrispondenza più ampia possibile.
Avido almeno n	{n,} corrisponde almeno n volte, con la più corrispondenza ampia possibile. Ad esempio, a{3,} corrisponde a tutti i caratteri in aaaaa.
Avido tra n e m	{n,m} corrispondenze tra n e m volte, con la più ampia corrispondenza possibile. Ad esempio, a{1,3} corrisponde ai primi tre caratteri di aaaaa.
Pigro zero o uno	?? corrisponde a zero o una volta, con la corrispondenza più piccola possibile.
Pigro zero o più	*? corrisponde a zero o più volte, con la corrispondenza più piccola possibile.
Uno o più pigri	+? corrisponde una o più volte, con la corrispondenza più piccola possibile.
Pigro almeno n	{n,}? corrispondenze almeno n volte, con la corrispondenza più piccola possibile. Ad esempio, a{3,}? corrisponde solo ai primi tre caratteri di aaaaa.
Pigro tra n e m	{n,m}? partite tra n e m volte, con una corrispondenza il più piccola possibile. Ad esempio, a{1,3}? corrisponde solo al primo carattere di aaaaa.
Esatto n	{n} corrisponde n volte, esattamente. Ad esempio, a{3} corrisponde esattamente a tre caratteri di aaaaa.

I quantificatori possessivi non sono supportati.

La combinazione di sottocorrispondenze e quantificatori presenta dei limiti. Per ulteriori informazioni, vedere Possibili sottocorrispondenze vuote.

Gruppi

Funzionalità di	Descrzione
Raggruppa	( e ) vengono utilizzati per raggruppare gli elementi ai quali applicare i quantificatori. Ad esempio, (abc)+ corrisponde abcabc.
Alternanza	a|b corrisponde ad "a" o "b", spesso usato in gruppo.
Sottocorrispondenza nominata e riferimento inverso	(?<name>chars) cattura una sottocorrispondenza con il nome name, referenziata con \k<name>. Non può essere utilizzato se MatchOptions.NumberedSubMatches è abilitato.
Sottopartita numerata e riferimento posteriore	Quando MatchOptions.NumberedSubMatches è abilitato, (a) cattura una sottocorrispondenza a cui si fa riferimento con \1.
Gruppo non catturato	(?:a), crea un gruppo senza catturare il risultato come sottocorrispondenza denominata o numerata. Tutti i gruppi non vengono acquisiti a meno che non sia abilitato MatchOptions.NumberedSubMatches .

Le sottopartite denominate e numerate non possono essere utilizzate insieme. Per impostazione predefinita, le sottocorrispondenze denominate sono abilitate e sono preferite per chiarezza e manutenibilità, mentre i gruppi di acquisizione standard diventano gruppi non di acquisizione con prestazioni migliorate. Questo comportamento può essere modificato con MatchOptions.NumberedSubMatches , che fornisce gruppi di cattura tradizionali ma disabilita i gruppi di cattura denominati. Alcune implementazioni trattano in modo diverso un mix di gruppi di cattura numerati e denominati, motivo per cui Power Fx non lo consentono.

I gruppi di cattura autoreferenziali non sono supportati, ad esempio l'espressione regolare (a\1).

Due gruppi di acquisizione non possono condividere lo stesso nome, ad esempio l'espressione regolare (?<id>\w+)|(?<id>\d+) non è supportata.

Il nome di una sottocorrispondenza denominata deve iniziare con un \p{L} carattere o _ e può continuare con tali caratteri più \p{Nd}. La lunghezza dei nomi è limitata a 62 unità di codice UTF-16.

Non sono supportati nemmeno i riferimenti retroattivi a possibili sottocorrispondenze vuote e a sottocorrispondenze all'interno di un look backward o look ahead.

Alcune implementazioni offrono un'opzione di "cattura esplicita" per migliorare le prestazioni, il che è superfluo in quanto è l'impostazione predefinita. Power Fx MatchOptions.NumberedSubMatches lo disabilita e abilita le catture numerate implicitamente.

La combinazione di sottocorrispondenze e quantificatori presenta dei limiti. Per ulteriori informazioni, vedere Sottocorrispondenze eventualmente vuote .

Commenti

Funzionalità di	Descrzione
Commenti in linea	(?# comment here), che viene ignorato come commento. Il commento termina con la parentesi chiusa successiva, anche se nel commento è presente una parentesi aperta.

Per un'alternativa per la formattazione e il commento delle espressioni regolari, vedere MatchOptions.FreeSpacing .

Opzioni in linea

Funzionalità di	Descrzione
Opzioni in linea	(?im) è lo stesso che usare MatchOptions.IgnoreCase e MatchOptions.Multiline. Deve essere impostato all'inizio dell'espressione regolare.

Le modalità inline supportate sono [imsx]. Questi corrispondono rispettivamente a MatchOptions.IgnoreCase, MatchOptions.Multiline, MatchOptions.DotAll e MatchOptions.FreeSpacing. n è accettato anche per compatibilità ma non ha effetto in quanto è l'impostazione predefinita ed è incompatibile con MatchOptions.NumberedSubMatches.

Le opzioni in linea non possono essere utilizzate per disabilitare un'opzione o impostarne una per una sottoespressione.

Opzioni

Le opzioni di corrispondenza modificano il comportamento della corrispondenza delle espressioni regolari. Esistono due modi per abilitare le opzioni, che possono essere combinati purché non ci siano conflitti:

• MatchOptions valore enum passato come terzo argomento a Match, MatchAll e IsMatch. Le opzioni possono essere combinate con l' & operatore o la Concatenate funzione, ad esempio MatchOptions.DotAll & MatchOptions.FreeSpacing. Tutte le funzioni di espressione regolare richiedono che MatchOptions sia un valore costante; non può essere calcolato o memorizzato in una variabile.
• (?...) prefisso all'inizio dell'espressione regolare. Le opzioni possono essere combinate con più lettere nel costrutto (?...) , ad esempio (?sx). Alcune opzioni non hanno un (?...) equivalente, ma possono avere altri modi per ottenere lo stesso effetto, ad esempio MatchOptions.BeginsWith è l'equivalente di ^ all'inizio dell'espressione regolare.

Contiene

Abilitato con MatchOptions.Contains senza un equivalente testuale di espressione regolare. MatchOptions.Contains è l'impostazione predefinita per tutte le funzioni al di fuori di Power Apps; all'interno di Power Apps MatchOptions.Complete è l'impostazione predefinita per IsMatch.

Completamento

Abilitato con MatchOptions.Complete oppure utilizzare ^ e $ rispettivamente all'inizio e all'inizio dell'espressione regolare.

BeginsWith

Abilitato con MatchOptions.BeginsWith oppure utilizzato ^ all'inizio e dell'espressione regolare.

EndsWith

Abilitato con MatchOptions.EndsWith o utilizzato $ alla fine dell'espressione regolare.

DotAll

Abilitato con MatchOptions.DotAll o (?s) all'inizio dell'espressione regolare.

Normalmente l'operatore punto . corrisponde a tutti i caratteri eccetto i caratteri di nuova riga [\n\x0b\f\r\x85\u2028\u2029]. Con il modificatore DotAll vengono trovati tutti i caratteri, comprese le nuove righe.

In questo esempio, viene trovato solo "Hello" poiché per impostazione predefinita . non corrisponde alla nuova riga:

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

Ma se aggiungiamo il modificatore DotAll , la nuova riga e tutti i caratteri successivi vengono abbinati:

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

Spaziatura libera

Abilitato con MatchOptions.FreeSpacing o (?x) all'inizio di un'espressione regolare.

La spaziatura libera semplifica la lettura e la gestione di un'espressione regolare complessa. Le regole sono semplici:

• Gli spazi vengono ignorati nell'espressione regolare, compresi tutti i caratteri che corrisponderebbero a \s. Se si desidera trovare uno spazio corrispondente, utilizzare \s, \ , \t, \r o \n.
• # inizia un commento che prosegue fino alla fine della riga. Questo e tutti i caratteri che seguono il carattere di nuova riga successivo (caratteri non corrispondenti a . senza MatchOptions.DotAll) vengono ignorati.
• Le classi dei personaggi non sono incluse in queste modifiche. I caratteri spaziano e # si comportano come al solito. Ad esempio, IsMatch( "a#b c", "(?x)a[ #]b[ #]c" ) restituisce true. Alcuni linguaggi di espressioni regolari includono classi di caratteri con spaziatura libera o forniscono un'opzione per includerle, ma Power Fx non lo fanno.

Ad esempio, ecco un'espressione regolare complessa per la corrispondenza di una data e ora 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

Ed ecco l'identica espressione regolare con spaziatura libera che utilizza più righe, rientro per i gruppi e commenti di espressione regolare, rendendo questa versione più facile da comprendere, convalidare e gestire.

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

Ignora maiuscole/minuscole

Abilitato con MatchOptions.IgnoreCase o (?i) all'inizio di un'espressione regolare.

Corrisponde al testo in una lettera senza distinzione tra maiuscole e minuscole: le lettere maiuscole corrispondono a quelle minuscole e le lettere minuscole corrispondono a quelle maiuscole.

Ad esempio:

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

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

La maggior parte delle parti è consapevole della cultura locale, ma non qui. Power Fx L'utilizzo della corrispondenza invariante rispetto alla cultura è lo standard del settore per le espressioni regolari, anche in JavaScript e Perl. È utile nel secondo esempio, quando viene confrontata una risorsa di sistema, ad esempio nella tr-TR cultura dove I non è l'equivalente in maiuscolo di i.

Se è necessaria una corrispondenza consapevole della cultura e senza distinzione tra maiuscole e minuscole, utilizzare invece la classe di caratteri con i caratteri corrispondenti, ad esempio [Hh][Ee][Ll][Ll][Oo] per il primo esempio.

Multiriga

Abilitato con MatchOptions.Multiline o (?m) all'inizio di un'espressione regolare.

Normalmente, le ancore ^ e $ corrispondono all'inizio e al punto del testo di input. Con il modificatore Multiline , queste ancore corrispondono all'inizio e alla fine delle righe nel testo di input, dove ogni riga termina con \r, \n, \r\n o con la fine dell'input. Ad esempio:

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

Modelli predefiniti

I modelli predefiniti consentono di abbinare uno o più caratteri di un set o una sequenza di più caratteri. Utilizza l' operatore di concatenazione di stringhe & per combinare le stringhe di testo con i membri dell'enum Match :

Enumerazione Match	Descrzione	Espressione regolare
Qualunque	Corrisponde a qualsiasi carattere.	.
Virgola	Corrisponde a una virgola ,.	,
Cifra	Corrisponde a una singola cifra (da 0 a 9 e altri membri di \p{Nd}).	\d
E-mail	Corrisponde a un indirizzo email che contiene il simbolo "at" (@) e un nome di dominio che contiene almeno un punto (.), delimitato da spazi e caratteri di punteggiatura.	vedi nota
Trattino	Corrisponde a un trattino.	- vedi nota
Parente sinistro	Corrisponde a una parentesi aperta (.	\(
Lettera	Corrisponde a una lettera.	\p{L}
MultipleDigits	Corrisponde a una o più cifre.	\d+
Lettere multiple	Corrisponde a una o più lettere.	\p{L}+
MultipleNonSpaces	Corrisponde a uno o più caratteri che non aggiungono uno spazio vuoto (non spazio, tabulazione, nuova riga).	\S+
Spazi multipli	Corrisponde a uno o più caratteri che aggiungono uno spazio vuoto (spazio, tabulazione o nuova riga).	\s+
NonSpazio	Corrisponde a un singolo carattere che non aggiunge uno spazio vuoto.	\S
Cifre facoltative	Corrisponde a zero, a una o a più cifre.	\d*
Lettere facoltative	Corrisponde a zero, a una o a più lettere.	\p{L}*
OptionalNonSpaces	Corrisponde a zero, a uno o a più caratteri che non aggiungono uno spazio vuoto.	\S*
Spazi facoltativi	Corrisponde a zero, a uno o a più caratteri che aggiungono uno spazio vuoto.	\s*
Period	Corrisponde a un punto o a un punto ..").	\.
Parente destro	Corrisponde a una parentesi chiusa ).	\)
Spazio	Corrisponde a un carattere che aggiunge uno spazio vuoto.	\s
Tab	Corrisponde a un carattere della scheda.	\t

Ad esempio, il modello "A" & Match.MultipleDigits corrisponde alla lettera "A" seguita da una o più cifre.

Il modello Match.Email è più complesso degli altri. Rileva ed estrae gli indirizzi email più comuni nel formato local@hostname.tld, anche da lunghi passaggi di testo, e supporta caratteri internazionali ed emoji. Utilizzalo per convalidare un modulo che accetta un indirizzo email come input, per verificare rapidamente che l'input sia in un modulo email. Se non si esegue l'estrazione, utilizzare MatchOptions.Complete per rilevare un indirizzo e-mail, ad esempio in un controllo di immissione di testo.

Tuttavia, Match.Email non convalida che l'indirizzo email sia conforme a tutti i numerosi standard in continua evoluzione per indirizzi email, nomi di dominio e domini di primo livello, che richiederebbero un'espressione regolare complicata che dovrebbe essere aggiornata di volta in volta. Sebbene la maggior parte degli indirizzi email venga trattata come previsto, Match.Email corrisponde ad alcuni casi non validi, come un trattino basso nel nome host, e non corrisponde ad alcuni casi validi, come indirizzi email tra virgolette o indirizzi IP. Se necessario, sul web si trovano numerose espressioni regolari che consentono di individuare un indirizzo email realmente legale. Prima di utilizzare l'espressione regolare in produzione, testala sempre in base alle tue esigenze specifiche.

Per vedere l'espressione regolare utilizzata, valutare la formula Text( Match.Email ). La prima parte corrisponde ai caratteri prima di @ ed esclude la punteggiatura ASCII comune secondo RFC 822 e revisioni e la punteggiatura iniziale e finale Unicode per un'estrazione più semplice, come (, [, “, « e 「. Non supporta l'uso insolito e sconsigliato di stringhe o commenti tra virgolette. Dopo @, la seconda e la terza parte dell'espressione regolare sono uguali e separate da ., assicurando che nell'indirizzo ci sia sempre almeno un . . Queste parti escludono tutta la punteggiatura Unicode, ad eccezione di ., - e _. Gli indirizzi IP non sono supportati. In tutto l'indirizzo email sono supportati caratteri internazionali ed emoji.

Nella Power Apps, quando non si utilizza la Power Fx versione 1.0, Match.Email e Match.Hyphen hanno definizioni leggermente diverse. Match.Email è più semplice, ma non è adatto per estrarre un indirizzo email perché cattura gli spazi. In precedenza, Match.Hyphen veniva eseguito l'escape all'esterno di una classe di caratteri, il che ora è illegale.

Sottopartite numerate

Abilitato con MatchOptions.NumberedSubMatches senza opzione in linea. (?n) è supportato come opposto di questa opzione per motivi di compatibilità ed è l'impostazione predefinita.

Per impostazione predefinita, (...) non acquisisce, l'equivalente di ciò che la maggior parte dei sistemi chiama "acquisizione esplicita". Per acquisire, utilizzare un'acquisizione denominata con (?<name>...) con backreference \k<name>. L'utilizzo di acquisizioni denominate migliora le prestazioni evitando di acquisire gruppi non necessari, migliorando la chiarezza mediante l'utilizzo di nomi e non essendo soggetto a errori se la posizione delle acquisizioni cambia.

Se si dispone di un'espressione regolare esistente, questa potrebbe dipendere dall'acquisizione automatica e dalla numerazione dei gruppi, inclusi i riferimenti retrostanti numerati. Questo comportamento è disponibile utilizzando l'opzione MatchOptions.NumberedSubMatches .

Le sottopartite denominate e numerate non possono essere utilizzate insieme. Poiché alcune implementazioni trattano in modo diverso un mix di gruppi di cattura numerati e denominati, Power Fx non lo consente.

Possibili sottocorrispondenze vuote

Come affermato nell'introduzione, le espressioni regolari di Power Fx sono intenzionalmente limitate alle funzionalità che possono essere implementate in modo coerente sui motori di espressioni regolari di .NET, JavaScript e altri linguaggi di programmazione. Gli errori in fase di creazione impediscono l'utilizzo di funzionalità che non fanno parte di questo set.

Un aspetto che può variare tra le implementazioni è il modo in cui vengono gestite le sottocorrispondenze vuote. Ad esempio, si consideri l'espressione regolare (?<submatch>a*)+ a cui viene chiesto di trovare la corrispondenza con il testo a. Su .NET, la sottocorrispondenza produce una stringa di testo vuota, mentre su JavaScript produce a. Entrambe possono essere considerate implementazioni corrette, poiché il quantificatore può essere soddisfatto con una stringa vuota poiché il contenuto del gruppo ha un quantificatore. +*

Per evitare risultati diversi nelle diverse implementazioni, le sottocorrispondenze che potrebbero essere vuote non possono essere utilizzate con un quantificatore. Power Fx Ecco alcuni esempi di come una sottocorrispondenza potrebbe essere vuota:

Esempi	Descrzione
(?<submatch>a{0,}b*)+	Tutto il contenuto della sottocorrispondenza è facoltativo, quindi l'intera sottocorrispondenza potrebbe essere vuota.
((<submatch>a)?b)+	A causa dell' ? esterno della sottocorrispondenza, la sottocorrispondenza nel suo complesso è facoltativa.
(?<submatch>a|b*)+	L'alternanza all'interno della sottopartita con qualcosa che potrebbe essere vuoto potrebbe rendere l'intera sottopartita vuota.
((?<submatch>a)|b)+	Un'alternanza al di fuori della sottocorrispondenza potrebbe corrispondere b , nel qual caso la sottocorrispondenza sarebbe vuota.

La sottocorrispondenza in (?<submatch>a+)+ non può essere vuota perché deve essercene almeno una a nella sottocorrispondenza, ed è supportata.

Unicode

Power Fx le espressioni regolari utilizzano le categorie Unicode per definire \w, \d e \s, con categorie specifiche disponibili tramite \p{..}.

Queste definizioni potrebbero variare a seconda della piattaforma. Ad esempio, lo standard Unicode viene aggiornato periodicamente con nuovi caratteri che verranno poi implementati dalle piattaforme secondo i propri ritmi. Si prevedono variazioni nei risultati tra le piattaforme finché non saranno aggiornate tutte.

Power Fx le espressioni regolari garantiscono che le informazioni sulla categoria siano sempre disponibili per il Basic Multilingual Plane (caratteri da U+0 a U+ffff). Alcune piattaforme non implementano le categorie per i personaggi del Piano Multilingue Supplementare e oltre (da U+10000 a U+10ffff). Questa limitazione solitamente non rappresenta un problema, poiché i caratteri del Basic Multilingual Plane sono quelli più comunemente utilizzati. Se il tuo scenario include personaggi pari o superiori a U+10000, utilizza direttamente i valori dei caratteri anziché le categorie. Prova le tue espressioni regolari sulle piattaforme che intendi utilizzare.

Potrebbero esserci piccole differenze nei casi limite tra le piattaforme. Ad esempio, alcune piattaforme potrebbero non rilevare ſ come corrispondente s quando viene richiamato MatchOptions.IgnoreCase . Se questi caratteri sono importanti per il tuo scenario, usa una classe di caratteri come [ſsS] per abbinare senza distinzione tra maiuscole e minuscole e includere esplicitamente i caratteri desiderati.