Not
Åtkomst till den här sidan kräver auktorisering. Du kan prova att logga in eller ändra kataloger.
Åtkomst till den här sidan kräver auktorisering. Du kan prova att ändra kataloger.
Funktionerna IsMatch , Match och MatchAll används för att extrahera och validera mönster i text. Mönstret de använder kallas för ett reguljärt uttryck.
Reguljära uttryck är kraftfulla och mångsidiga. De kan dock ibland visas som en slumpmässig sekvens av skiljetecken. Den här artikeln beskriver inte alla aspekter av reguljära uttryck, men det finns en mängd information, självstudier och verktyg online.
Reguljära uttryck har en lång historia och är tillgängliga i många programmeringsspråk. Varje programmeringsspråk har sin egen dialekt av reguljära uttryck, och det finns få standarder. Så mycket som möjligt strävar vi efter att samma reguljära uttryck ska ge samma resultat i alla Power Fx implementeringar. Kompatibilitet är inte lätt att uppnå eftersom Power Fx den körs ovanpå JavaScript och .NET som har betydande skillnader. För att köras på olika plattformar Power Fx använder reguljära uttryck en delmängd av funktioner som har brett stöd i branschen.
Det innebär att vissa reguljära uttryck som fungerar i andra miljöer kan blockeras eller behöva justeras Power Fx. Fel vid redigering rapporteras när funktioner som inte stöds påträffas. Det är därför det reguljära uttrycket och alternativen måste vara en konstant för redigering och inte dynamiska, till exempel i en variabel.
Obs
Power Apps Använder en tidigare version av Power Fx reguljära uttryck, som har färre begränsningar men också färre funktioner. MatchOptions.DotAll och MatchOptions.FreeSpacing är inte tillgängliga och definitionerna av Match.Email och Match.Hyphen skiljer sig åt. Unicode-surrogatpar behandlas inte som ett enda tecken. MatchOptions.NumberedSubMatches är standard. Den version av reguljära uttryck som beskrivs här är tillgänglig i Power Apps snart, under en växel för "Power Fx V1.0-kompatibilitet".
Funktioner som stöds
Power Fx Stöder följande funktioner för reguljära uttryck, med anteckningar om hur Power Fx beteendet kan skilja sig från andra system.
Det reguljära uttrycket måste vara konstant och får inte beräknas eller lagras i en variabel. Operatorn & , stränginterpolationen $"{...}" och funktionerna, ConcatenateChar, och UniChar med konstanta argument stöds.
Literala tecken
| Egenskap | Description |
|---|---|
| Literala tecken | Alla Unicode-tecken kan infogas direkt, förutom \, []^$.|?*+(){ och. } När du använder MatchOptions.FreeSpacing, #, , och andra \s blankstegstecken måste vara undantagna eftersom de har en annan betydelse. |
| Undantagna literaltecken |
\ (omvänt snedstreck) följt av ett av de direkta bokstavliga tecknen, till exempel \? för att infoga ett frågetecken.
\# och \ kan också användas även när MatchOptions.FreeSpacing är inaktiverat för konsekvens. |
| Hexadecimala teckenkoder och Unicode-teckenkoder |
\x20 med exakt två hexadecimala siffror, \u2028 med exakt fyra hexadecimala siffror och kan användas för höga och låga surrogatmammor. |
| Unicode-kodpunkt |
\u{01F47B} med upp till åtta hexadecimala siffror. Måste vara i intervallet 0 till U+10FFFF och kan inte användas för vare sig en hög eller låg surrogatmamma. Kan resultera i ett surrogatpar (två tecken) om det är större än U+FFFF. |
| Vagnretur |
\r, samma som Char(13). |
| Tecken för ny rad |
\n, samma som Char(10). |
| Inmatning av formulär |
\f, samma som Char(12). |
| Vågrät flik |
\t, samma som Char(9). |
Använd \x or \u i stället. Oktala koder för tecken, till exempel \044 eller \o{044} är otillåtna, eftersom de kan vara tvetydiga med numrerade bakåtreferenser.
\v stöds inte eftersom det är tvetydigt i språk med reguljära uttryck. Används \x0b för en lodrät flik eller [\x0b\f\r\n\x85\u2028\u2029] för lodräta blanksteg.
Påståenden
Påståenden matchar en viss position i texten men förbrukar inga tecken.
| Egenskap | Description |
|---|---|
| Början av raden |
^, matchar början av texten eller av en rad om MatchOptions.Multiline används. |
| Slut på rad |
$, matchar slutet av texten eller av en rad om MatchOptions.Multiline används. |
| Framåtblickande |
(?=a) Och (?!a) matchar framåt för ett mönster. |
| Blick bakom |
(?<=b) och (?<!b) matchar bakom för ett mönster. |
| Ordbrytningar |
\b och \B med hjälp av Unicode-definitionen av bokstäver [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]. |
$ matchar slutet på en rad, inklusive eventuella efterföljande \r\n, \r, eller \n.
Lookahead- och lookbehind-kontroller kan inte innehålla delmatchningar eller obegränsade kvantifierare i och kan inte användas med en kvantifierare utanför.
Teckenklasser
| Egenskap | Description |
|---|---|
| Punkt |
., matchar allt utom \r och \n om inte MatchOptions.DotAll används. |
| Klass Tecken |
[abc] lista över tecken, [a-fA-f0-9] teckenomfång, [^a-z] allt utom dessa tecken. Teckenklasser kan inte kapslas, subtraheras eller korsas, och många skiljetecken kanske inte visas två gånger i rad (@@, %%, !!, osv.). |
| Word-tecken |
\w och \W med hjälp av Unicode-definitionen av bokstäver [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}].
\W Kan inte användas i en klass med negativa tecken. |
| Siffriga tecken |
\d Inkluderar siffrorna 0 till9 och \p{Nd}, \D matchar allt utom tecken som matchas av \d.
\D Kan inte användas i en klass med negativa tecken. |
| Blankstegstecken |
\s Inkluderar avståndstecken [ \t\n\x0b\f\r\x85\u2028\u2029\p{Z}], \S som matchar allt utom tecken som matchas av \s.
\S Kan inte användas i en klass med negativa tecken. |
| Kategori av Unicode-tecken |
\p{Ll} matchar alla gemener i Unicode, medan allt \P{Ll} som inte är en gemener i Unicode matchar.
\P{} Kan inte användas i en klass med negativa tecken. |
För att öka tydligheten och undvika tvetydighet är hakparenteser mer restriktiva än i andra språk med reguljära uttryck:
- Literala bindestreck måste vara undantagna. Använd
[\-a]i stället för[-a]att matcha-ellera. - Inledande hakparenteser måste vara undantagna. Använd
[\[a]i stället för[[]att matcha[ellera. - Om det inte är det första tecknet och anger negation måste tecknet undantas. Använd
[a\^]i stället för[a^]att matcha^ellera. - Lockiga hängslen måste undvikas. Används
[\{\}]för att matcha{eller}. - Klassen med tomma tecken
[]stöds inte. Om du vill inkludera en avslutande hakparentes i en teckenklass måste du undvika den.
Unicode-teckenkategorier som stöds av \p{} och \P{}:
- Bokstäver:
L,Lu,Ll,Lt,,LmLo - Märken:
M,Mn,,McMe - Nummer:
N,Nd,,NlNo - Skiljetecken:,,,
P,,Pc,,PdPsPePiPfPo - Symboler:
S,Sm,Sc,,SkSo - Avgränsare:
Z,Zs,Zl,Zp - Control och Format:
Cc,Cf, medan andraCprefixkategorier inte stöds.
\W, \D, \S, och \P{} kan inte användas i en negerad teckenklass [^...]. För att kunna implementeras på vissa plattformar översätts dessa negativa teckenklasser till deras Unicode-motsvarigheter, vilket kan vara svårt att göra om det också förnekas.
Unicode-tecken mellan U+10000 och U+10FFFF, som kräver surrogatpar, stöds inte i teckenklasser.
Kvantifierare
| Egenskap | Description |
|---|---|
| Girig nolla eller en |
? matchar noll eller en gång, med en så stor matchning som möjligt. |
| Girig noll eller mer |
* matchar noll eller flera gånger, med en så stor matchning som möjligt. |
| Girig en eller flera |
+ matchar en eller flera gånger, med en så stor matchning som möjligt. |
| Girig minst n |
{n,} matchar minst n gånger, med en så stor matchning som möjligt. Till exempel,matchar a{3,} alla tecken i aaaaa. |
| Girig mellan n och m |
{n,m} matchningar mellan n och m tider, med en så stor matchning som möjligt. Till exempel, a{1,3} matchar de tre första tecknen i aaaaa. |
| Lata noll eller ett |
?? matchar noll eller en gång, med en så liten matchning som möjligt. |
| Lata noll eller mer |
*? matchar noll eller flera gånger, med en så liten matchning som möjligt. |
| Lata en eller flera |
+? matchar en eller flera gånger, med en så liten matchning som möjligt. |
| Lata minst n |
{n,}? matchningar minst n gånger, med en så liten matchning som möjligt. Matchar till exempel a{3,}? bara de tre första tecknen i aaaaa. |
| Lata mellan n och m |
{n,m}? Matchningar mellan n och m tider, med en så liten matchning som möjligt. Matchar till exempel a{1,3}? bara det första tecknet aaaaa i. |
| Exakt n |
{n} matchar n gånger, exakt. Till exempel, a{3} matchar exakt tre tecken i aaaaa. |
Possessiva kvantifierare stöds inte.
Att blanda delmatchningar och kvantifierare har begränsningar. Mer information finns i Eventuellt tomma delmatchningar.
Grupper
| Egenskap | Description |
|---|---|
| Grupp |
( och ) används för att gruppera element för kvantifierare som ska tillämpas. Till exempel, (abc)+ tändstickor abcabc. |
| Avljud |
a|b matchar "A" eller "B", som ofta används i en grupp. |
| Namngiven undermatchning och bakåtreferens |
(?<name>chars) Samlar in en undermatchning med namnet name som refereras till \k<name>. Kan inte användas om MatchOptions.NumberedSubMatches är aktiverat. |
| Numrerad undermatchning och bakåtreferens | När MatchOptions.NumberedSubMatches är aktiverat (a) avbildar en undermatchning som refereras till \1. |
| Icke-avbildningsgrupp |
(?:a)skapar en grupp utan att resultatet registreras som en namngiven eller numrerad delmatchning. Alla grupper avbildas inte om inte MatchOptions.NumberedSubMatches är aktiverat. |
Namngivna och numrerade delmatchningar kan inte användas tillsammans. Som standard är namngivna undermatchningar aktiverade och föredras för tydlighet och underhåll, medan standardinfångningsgrupper blir icke-avbildningsgrupper med förbättrad prestanda. Det här beteendet kan ändras med MatchOptions.NumberedSubMatches , som tillhandahåller traditionella avbildningsgrupper men inaktiverar namngivna avbildningsgrupper. Vissa implementeringar behandlar en blandning av numrerade och namngivna avbildningsgrupper på olika sätt, vilket är anledningen till att Power Fx det inte tillåts.
Självrefererande avbildningsgrupper stöds inte, till exempel det reguljära uttrycket (a\1).
Två avbildningsgrupper kan inte dela samma namn, till exempel stöds inte det reguljära uttrycket (?<id>\w+)|(?<id>\d+) .
Namnet på en namngiven undermatchning måste börja med ett \p{L} tecken eller _, och kan fortsätta med dessa tecken plus \p{Nd}. Namnen är begränsade till 62 UTF-16 kodenheter.
Bakåtreferenser till eventuellt tomma undermatchningar och till undermatchningar inom en blick bakåt eller blick framåt stöds inte heller.
Vissa implementeringar erbjuder ett alternativ för "explicit avbildning" för att förbättra prestandan, vilket är onödigt eftersom Power Fx det är standard. MatchOptions.NumberedSubMatches inaktiverar det och aktiverar implicit numrerade avbildningar.
Att blanda delmatchningar och kvantifierare har begränsningar. Mer information finns i Eventuellt tomma delmatchningar .
Kommentarer
| Egenskap | Description |
|---|---|
| Infogade kommentarer |
(?# comment here), som ignoreras som en kommentar. Kommentaren slutar med nästa avslutande parentes, även om det finns en inledande parentes i kommentaren. |
Se MatchOptions.FreeSpacing för ett alternativ för att formatera och kommentera reguljära uttryck.
Infogade alternativ
| Egenskap | Description |
|---|---|
| Infogade alternativ |
(?im) är detsamma som att använda MatchOptions.IgnoreCase och MatchOptions.Multiline. Måste anges i början av det reguljära uttrycket. |
Infogade lägen som stöds är [imsx]. Dessa motsvarar MatchOptions.IgnoreCase , MatchOptions.Multiline , MatchOptions.DotAll respektiveMatchOptions.FreeSpacing .
n accepteras också för kompatibilitet men har ingen effekt eftersom det är standard och inte är kompatibelt med MatchOptions.NumberedSubMatches.
Infogade alternativ kan inte användas för att inaktivera ett alternativ eller ange ett alternativ för ett underuttryck.
Alternativ
Matchningsalternativ ändrar beteendet för matchning av reguljära uttryck. Det finns två sätt att aktivera alternativ, som kan blandas så länge det inte finns någon konflikt:
-
MatchOptions räknar upp värdet som skickas som det tredje argumentet till Match, MatchAll och IsMatch. Alternativen kan till exempel
&kombineras med operatörenConcatenateellerMatchOptions.DotAll & MatchOptions.FreeSpacingfunktionen. Alla funktioner för reguljära uttryck kräver att MatchOptions är ett konstant värde, det kan inte beräknas eller lagras i en variabel. -
(?...)prefixet i början av det reguljära uttrycket. Alternativen kan till exempel(?...)kombineras med flera bokstäver i konstruktionen(?sx). Vissa alternativ har ingen(?...)motsvarighet men kan ha andra sätt att få samma effekt, till exempel MatchOptions.BeginsWith motsvarar^i början av det reguljära uttrycket.
innehåller
Aktiverad med MatchOptions.Contains utan en textmotsvarighet med reguljärt uttryck. MatchOptions.Contains är standard för alla funktioner utanför Power Apps MatchOptions.Complete Power Apps är standard för IsMatch.
Slutförd
Aktiverad med MatchOptions.Complete eller use ^ och $ i början respektive det reguljära uttrycket.
BeginsWith
Aktiverad med MatchOptions.BeginsWith eller använd ^ i början och av det reguljära uttrycket.
EndsWith
Aktiverad med MatchOptions.EndsWith eller använd $ i slutet av det reguljära uttrycket.
DotAll (DotAll)
Aktiverad med MatchOptions.DotAll eller (?s) i början av det reguljära uttrycket.
Normalt matchar punktoperatorn . alla tecken utom nyradstecken [\n\x0b\f\r\x85\u2028\u2029]. Med modifieraren DotAll matchas alla tecken, inklusive nya rader.
I det här exemplet matchas endast "Hej" som standard matchar inte . den nya raden:
Trim( Match( "Hello
World", ".*" ).FullMatch )
// returns
// "Hello"
Men om vi lägger till DotAll modifieraren matchas den nya raden och alla efterföljande tecken:
Trim( Match( "Hello
World", ".*", MatchOptions.DotAll ).FullMatch )
// returns
// "Hello
// World"
Fritt avstånd
Aktiverad med MatchOptions.FreeSpacing eller i början av ett reguljärt (?x) uttryck.
Fritt mellanrum gör det enklare att läsa och underhålla ett komplext reguljärt uttryck. Reglerna är enkla:
- Blanksteg ignoreras i det reguljära uttrycket, inklusive alla tecken som skulle matcha
\s. Om du vill matcha ett mellanslag använder du\s,\,\t,\r, eller\n. -
#Börjar en kommentar som löper till slutet av raden. Den och alla tecken som följer upp till nästa nyradstecken (tecken som inte matchas av.utan MatchOptions.DotAll) ignoreras. - Teckenklasser ingår inte i dessa ändringar. Mellanslag och
#fungerar som vanligt. Returnerar till exempelIsMatch( "a#b c", "(?x)a[ #]b[ #]c" )true. Vissa språk med reguljära uttryck innehåller teckenklasser med fritt mellanrum eller ger ett alternativ för att inkludera dem, men Power Fx gör det inte.
Här är till exempel ett komplext reguljärt uttryck för att matcha ett ISO 8601-datum och tid:
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
Och här är det identiska reguljära uttrycket med fritt mellanrum som använder flera rader, indrag för grupper och kommentarer till reguljära uttryck, vilket gör den här versionen lättare att förstå, validera och underhålla.
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
Ignorera Fall
Aktiverad med MatchOptions.IgnoreCase eller (?i) i början av ett reguljärt uttryck.
Matchar text i en bokstav Skiftlägeskänsligt: versaler matchar gemener och gemener matchar versaler.
Till exempel: '
IsMatch( "HELLO!", "hello", MatchOptions.IgnoreCase )
// returns true
IsMatch( "file://c:/temp/info.txt", "^FILE://", MatchOptions.IgnoreCase )
// returns true
De flesta delar eller Power Fx är kulturmedvetna, men inte här. Att använda invariant kulturmatchning är branschstandard för reguljära uttryck, inklusive i JavaScript och Perl. Det är användbart i det andra exemplet där en systemresurs matchas, tr-TR till exempel kulturen där I inte är den versala motsvarigheten till i.
Om en kulturmedveten, skiftlägesokänslig matchning behövs använder du teckenklassen med matchande tecken i stället, till exempel [Hh][Ee][Ll][Ll][Oo] för det första exemplet.
Multiline
Aktiverad med MatchOptions.Multiline eller (?m) i början av ett reguljärt uttryck.
Normalt ^ matchar $ och fästpunkter början och indatatexten.
Med Multiline modifieraren matchar dessa fästpunkter början och slutet av rader i indatatexten, där varje rad slutar med \r, \n, \r\n, eller slutet av indata. Till exempel: '
MatchAll( "Hello" & Char(13) & Char(10) & "World", "^.+$" )
// returns
// "Hello"
Fördefinierade mönster
Med fördefinierade mönster kan du matcha antingen en av en uppsättning tecken eller en sekvens med flera tecken. Använd operatorn string-concatenation för att kombinera dina textsträngar med medlemmar i Match enum:
| Uppräkningen Match | Description | Reguljärt uttryck |
|---|---|---|
| Någon | Matchar alla tecken. | . |
| Komma | Matchar ett kommatecken ,. |
, |
| Siffra | Matchar en enda siffra (0 genom 9 och andra medlemmar i \p{Nd}). |
\d |
| E-postmeddelande | Matchar en e-postadress som innehåller symbolen "snabel-at" (@) och ett domännamn som innehåller minst en punkt (.), avgränsad med blanksteg och skiljetecken. |
Se anteckning |
| Bindestreck | Matchar ett bindestreck. |
-
Se anteckning |
| LeftParen | Matchar en vänsterparentes (. |
\( |
| Brev | Matchar en bokstav. | \p{L} |
| Flera siffror | Matchar en eller flera siffror. | \d+ |
| MultipleLetters (flera bokstäver) | Matchar en eller flera bokstäver. | \p{L}+ |
| MultipleNonSpaces | Matchar ett eller flera tecken som inte lägger till blanksteg (inget mellanslag, tabb, ny rad). | \S+ |
| MultipleSpaces | Matchar ett eller flera tecken som lägger till blanksteg (mellanslag, tabb, ny rad). | \s+ |
| Icke-mellanslag | Matchar ett enskilt tecken som inte lägger till blanksteg. | \S |
| Valfria siffror | Matchar ingen, en eller flera siffror. | \d* |
| OptionalLetters (valfria) | Matchar ingen, en eller flera bokstäver. | \p{L}* |
| OptionalNonSpaces (Valfritt) | Matchar inget, ett eller flera tecken som inte lägger till blanksteg. | \S* |
| OptionalSpaces (Valfritt) | Matchar inget, ett eller flera tecken som lägger till blanksteg. | \s* |
| Period | Matchar en punkt eller punkt .."). |
\. |
| RightParen | Matchar en högerparentes ). |
\) |
| Rymd | Matchar ett tecken som lägger till blanksteg. | \s |
| Tab | Matchar en flikkaraktär. | \t |
Mönstret "A" och Match.MultipleDigits matchar till exempel bokstaven "A" följt av en eller flera siffror.
Det Match.Email mönstret är mer komplext än de andra. Den upptäcker och extraherar vanliga e-postadresser i formuläret local@hostname.tld, eventuellt från långa textstycken, och stöder internationella tecken och emojis. Använd den för att validera ett formulär som tar en e-postadress som indata, som ett snabbtest att indata finns i ett e-postformulär. Om du inte extraherar använder du MatchOptions.Complete för att identifiera en e-postadress, till exempel i en textinmatningskontroll.
Match.Email validerar dock inte att e-postadressen överensstämmer med alla de många nya standarderna för e-postadresser, domännamn och toppdomäner, vilket skulle kräva ett komplicerat reguljärt uttryck som skulle behöva uppdateras då och då. Även om de flesta e-postadresser behandlas som förväntat matchar Match.Email vissa ogiltiga fall, till exempel ett understreck i värdnamnet, och matchar inte vissa giltiga fall, till exempel citerade e-postadresser eller IP-adresser. Om det behövs finns det många reguljära uttryck på webben för att upptäcka en verkligt laglig e-postadress. Testa alltid ditt reguljära uttryck för dina specifika behov innan du använder det i produktion.
Om du vill se det reguljära uttrycket som används utvärderar du formeln Text( Match.Email ). Den första delen matchar tecknen före @ och utesluter vanlig ASCII-interpunktion enligt RFC 822 och revisioner och Unicode början och slut skiljetecken för enklare extrahering, till exempel (, [, “, « och 「. Det stöder inte den ovanliga och avrådda användningen av citerade strängar eller kommentarer.
@Efter den andra och tredje delen av det reguljära uttrycket är de samma och avgränsade med a ., vilket säkerställer att det alltid finns minst en . i adressen. Dessa delar utesluter all Unicode-interpunktion utom ., -, och _. IP-adresser stöds inte. I hela e-postadressen stöds internationella tecken och emojis.
I Power Apps, när du inte använder Power Fx 1.0,Match.Email och Match.Hyphen har något olika definitioner. Match.Email är enklare, men är inte lämpligt för att extrahera en e-postadress eftersom den fångar upp utrymmen. Tidigare undantogs Match.Hyphen utanför en teckenklass som nu är olaglig.
NumberedSubMatches (NumberedSubMatcher)
Aktiverad med MatchOptions.NumberedSubMatches utan infogade alternativ.
(?n) stöds som motsatsen till det här alternativet för kompatibilitet och är standard.
Som standard (...) avbildar den inte, vilket motsvarar vad de flesta system kallar "explicit infångning". Om du vill avbilda använder du en namngiven avbildning med (?<name>...) med backreference \k<name>. Om du använder namngivna avbildningar förbättras prestanda genom att inte samla in grupper som inte behövs, förbättra tydligheten med hjälp av namn och inte vara benägna att göra fel om avbildningens position ändras.
Om du har ett befintligt reguljärt uttryck kan det bero på att grupper avbildas automatiskt och numreras, inklusive numrerade bakåtreferenser. Det här beteendet är tillgängligt med hjälp av alternativet MatchOptions.NumberedSubMatches .
Namngivna och numrerade undermatchningar kan inte användas tillsammans. Eftersom vissa implementeringar behandlar en blandning av numrerade och namngivna avbildningsgrupper på olika sätt Power Fx tillåts det inte.
Eventuellt tomma delmatchningar
Som vi nämnde i inledningen Power Fx är reguljära uttryck avsiktligt begränsade till funktioner som konsekvent kan implementeras på .NET, JavaScript och andra programmeringsspråkmotorer för reguljära uttryck. Redigeringsfel förhindrar användning av funktioner som inte ingår i den här uppsättningen.
Ett område som kan skilja sig åt mellan implementeringar är hur tomma delmatchningar hanteras. Tänk dig till exempel att det reguljära uttrycket (?<submatch>a*)+ ska matcha texten a. På .NET resulterar undermatchningen i en tom textsträng, medan den i JavaScript resulterar i a. Båda kan argumenteras som korrekta implementeringar, eftersom kvantifieraren + kan nöja sig med en tom sträng eftersom innehållet i gruppen har en * kvantifierare.
För att undvika olika resultat mellan Power Fx implementeringar kan delmatchningar som kan vara tomma inte användas med en kvantifierare. Här är exempel på hur en undermatchning kan vara tom:
| Exempel | Description |
|---|---|
(?<submatch>a{0,}b*)+ |
Allt innehåll i undermatchningen är valfritt, så hela undermatchningen kan vara tom. |
((<submatch>a)?b)+ |
På grund av att undermatchningen ? är utanför matchningen är den som helhet valfri. |
(?<submatch>a|b*)+ |
Växling inom undermatchningen med något som kan vara tomt kan resultera i att hela undermatchningen är tom. |
((?<submatch>a)|b)+ |
Växling utanför delmatchen skulle kunna matcha b i så fall skulle delmatchningen vara tom. |
Undermatchningen i (?<submatch>a+)+ kan inte vara tom eftersom det måste finnas minst en i undermatchningen a och den stöds.
Unicode
Power Fx reguljära uttryck använder Unicode-kategorier för att definiera \w,, och \d, med specifika kategorier tillgängliga via \s\p{..}.
Dessa definitioner kan variera mellan olika plattformar. Till exempel uppdateras Unicode-standarden då och då med nya tecken som senare kommer att implementeras av plattformar i sin egen takt. Förvänta dig variationer i resultat mellan plattformar tills alla plattformar är uppdaterade.
Power Fx reguljära uttryck säkerställer att kategoriinformation alltid är tillgänglig för det grundläggande flerspråkiga planet (tecken U+0 till U+ffff). Vissa plattformar implementerar inte kategorier för tecken i det kompletterande flerspråkiga planet och därefter (U+10000 till U+10ffff). Den här begränsningen är vanligtvis inte ett problem eftersom tecken i det grundläggande flerspråkiga planet är de vanligaste. Använd teckenvärden direkt i stället för kategorier om ditt scenario omfattar tecken på eller bortom U+10000. Testa dina reguljära uttryck på de plattformar som du tänker använda.
Det kan finnas små skillnader mellan olika gränsfall. Vissa plattformar kanske till exempel inte ser ſ som matchning s när MatchOptions.IgnoreCase anropas. Om dessa tecken är viktiga för ditt scenario använder du en teckenklass som [ſsS] att matcha skiftläge okänsligt och uttryckligen inkludera önskade tecken.