Reguláris kifejezés beállításai
Alapértelmezés szerint a beviteli sztringek és a reguláris kifejezésmintákban szereplő összes literális karakter összehasonlítása kis- és nagybetűkre érzékeny, a normál kifejezésmintában lévő üres térköz literális szóköz karakterként van értelmezve, a normál kifejezésben lévő csoportok rögzítése pedig implicit és explicit módon történik. Ezeket és az alapértelmezett reguláris kifejezések viselkedésének számos egyéb aspektusát módosíthatja a reguláris kifejezés beállításainak megadásával. Az alábbi táblázatban felsorolt lehetőségek némelyike a reguláris kifejezésminta részeként beágyazottan is szerepelhet, vagy megadható egy System.Text.RegularExpressions.Regex osztálykonstruktornak vagy statikus mintaegyező metódusnak enumerálási System.Text.RegularExpressions.RegexOptions értékként.
RegexOptions Tag |
Beágyazott karakter | Hatály | További információ |
|---|---|---|---|
| None | Nem elérhető | Használja az alapértelmezett viselkedést. | Alapértelmezett beállítások |
| IgnoreCase | i |
Használjon kis- és nagybetűket nem érzékelyítő egyezést. | Kis- és nagybetűk megkülönböztetése |
| Multiline | m |
Használjon többsoros módot, ahol ^ és $ jelezze az egyes sorok elejét és végét (a bemeneti sztring kezdete és vége helyett). |
Többsoros mód |
| Singleline | s |
Használjon egysoros módot, ahol a pont (.) minden karakternek megfelel (a karakterek kivételével).\n |
Egysoros mód |
| ExplicitCapture | n |
Ne rögzítsen névtelen csoportokat. Az egyetlen érvényes rögzítés az űrlapnév (?<>alexpressziójának) explicit neve vagy számozott csoportjai. |
Csak explicit rögzítések |
| Compiled | Nem elérhető | Állítsa össze a reguláris kifejezést egy szerelvényre. | Lefordított reguláris kifejezések |
| IgnorePatternWhitespace | x |
Zárjon ki üres szóközt a mintából, és engedélyezze a megjegyzéseket egy számjel (#) után. |
Üres terület figyelmen kívül hagyása |
| RightToLeft | Nem elérhető | Módosítsa a keresési irányt. A keresés jobbról balra halad ahelyett, hogy balról jobbra halad. | Jobbról balra mód |
| ECMAScript | Nem elérhető | Engedélyezze az ECMAScript-kompatibilis viselkedést a kifejezéshez. | ECMAScript-egyeztetési viselkedés |
| CultureInvariant | Nem elérhető | A nyelvi különbségek figyelmen kívül hagyása. | Összehasonlítás az invariáns kultúrával |
| NonBacktracking | Nem elérhető | Egyezzen egy olyan megközelítéssel, amely elkerüli a visszakövetést, és garantálja a lineáris idejű feldolgozást a bemenet hosszában. (.NET 7-ben és újabb verziókban érhető el.) | Visszalépési mód |
Beállítások megadása
A reguláris kifejezések beállításait háromféleképpen adhatja meg:
optionsOsztálykonstruktor vagy statikus (SharedVisual Basic) mintaegyeztetési módszer paraméterébenSystem.Text.RegularExpressions.Regex, például Regex(String, RegexOptions) vagy Regex.Match(String, String, RegexOptions). Aoptionsparaméter az enumerált értékek bitenkénti VAGY kombinációja System.Text.RegularExpressions.RegexOptions .Ha egy Regex példányhoz egy osztálykonstruktor paraméterével adja meg a
optionsbeállításokat, a beállítások a System.Text.RegularExpressions.RegexOptions tulajdonsághoz lesznek rendelve. A System.Text.RegularExpressions.RegexOptions tulajdonság azonban nem tükrözi magában a reguláris kifejezésmintában szereplő beágyazott beállításokat.Az alábbi példa egy illusztrációt tartalmaz. A metódus paraméterével engedélyezi a
optionsRegex.Match(String, String, RegexOptions) kis- és nagybetűk megkülönböztetését, és figyelmen kívül hagyja a minta üres területét a "d" betűvel kezdődő szavak azonosításakor.string pattern = @"d \w+ \s"; string input = "Dogs are decidedly good pets."; RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace; foreach (Match match in Regex.Matches(input, pattern, options)) Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index); // The example displays the following output: // 'Dogs // found at index 0. // 'decidedly // found at index 9.Dim pattern As String = "d \w+ \s" Dim input As String = "Dogs are decidedly good pets." Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.IgnorePatternWhitespace For Each match As Match In Regex.Matches(input, pattern, options) Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index) Next ' The example displays the following output: ' 'Dogs ' found at index 0. ' 'decidedly ' found at index 9.Ha beágyazott beállításokat alkalmaz egy reguláris kifejezési mintában a szintaxissal
(?imnsx-imnsx). A beállítás a mintára vonatkozik attól a ponttól kezdve, amelytől a beállítás a minta végéig vagy arra a pontra vonatkozik, ahol a beállítást egy másik beágyazott beállítás nem definiálja. Vegye figyelembe, hogy egy System.Text.RegularExpressions.RegexOptionsRegex példány tulajdonsága nem tükrözi ezeket a beágyazott beállításokat. További információ: Vegyes szerkezetek témakör.Az alábbi példa egy illusztrációt tartalmaz. Beágyazott beállításokkal teszi lehetővé a kis- és nagybetűk megkülönböztetését, és figyelmen kívül hagyja a minta üres területét a "d" betűvel kezdődő szavak azonosításakor.
string pattern = @"(?ix) d \w+ \s"; string input = "Dogs are decidedly good pets."; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index); // The example displays the following output: // 'Dogs // found at index 0. // 'decidedly // found at index 9.Dim pattern As String = "\b(?ix) d \w+ \s" Dim input As String = "Dogs are decidedly good pets." For Each match As Match In Regex.Matches(input, pattern) Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index) Next ' The example displays the following output: ' 'Dogs ' found at index 0. ' 'decidedly ' found at index 9.Ha beágyazott beállításokat alkalmaz egy adott csoportosítási szerkezetben egy reguláris kifejezési mintában a szintaxis
(?imnsx-imnsx:alexpressziójával). Nincs előjel, mielőtt egy beállításkészlet bekapcsolja a beállítást; egy mínuszjel, mielőtt egy beállításkészlet kikapcsolja a beállítást. (?a nyelvi szerkezet szintaxisának rögzített része, amely kötelező, függetlenül attól, hogy a beállítások engedélyezve vagy letiltva vannak-e.) A beállítás csak az adott csoportra vonatkozik. További információ: Csoportosítási szerkezetek.Az alábbi példa egy illusztrációt tartalmaz. Beágyazott beállításokat használ egy csoportosítási szerkezetben, hogy lehetővé tegye a kis- és nagybetűk megkülönböztetését, és figyelmen kívül hagyja a minta üres területét a "d" betűvel kezdődő szavak azonosításakor.
string pattern = @"\b(?ix: d \w+)\s"; string input = "Dogs are decidedly good pets."; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index); // The example displays the following output: // 'Dogs // found at index 0. // 'decidedly // found at index 9.Dim pattern As String = "\b(?ix: d \w+)\s" Dim input As String = "Dogs are decidedly good pets." For Each match As Match In Regex.Matches(input, pattern) Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index) Next ' The example displays the following output: ' 'Dogs ' found at index 0. ' 'decidedly ' found at index 9.
Ha a beállítások beágyazottan vannak megadva, egy mínuszjel (-) a beállítás vagy beállításkészlet előtt kikapcsolja ezeket a beállításokat. A beágyazott szerkezet (?ix-ms) például bekapcsolja a beállításokat és RegexOptions.IgnorePatternWhitespace a RegexOptions.IgnoreCase beállításokat, és RegexOptions.Singleline kikapcsolja a RegexOptions.Multiline beállításokat. Alapértelmezés szerint minden normál kifejezési beállítás ki van kapcsolva.
Feljegyzés
Ha egy konstruktor vagy metódushívás paraméterében options megadott reguláris kifejezési beállítások ütköznek a normál kifejezésmintában megadott beágyazott beállításokkal, a rendszer a beágyazott beállításokat használja.
A következő öt reguláris kifejezési beállítás adható meg a beállításparaméterrel és a beágyazott beállítással is:
A következő öt reguláris kifejezési beállítás adható meg a options paraméterrel, de nem állítható be beágyazott módon:
Beállítások meghatározása
Az írásvédett Regex.Options tulajdonság értékének beolvasásával meghatározhatja, hogy Regex az objektum mely beállításokat adta meg a példányosításkor. Ez a tulajdonság különösen hasznos a metódus által Regex.CompileToAssembly létrehozott lefordított reguláris kifejezéshez definiált beállítások meghatározásához.
Bármely lehetőség RegexOptions.Nonemeglétének ellenőrzéséhez végezze el az AND műveletet a Regex.Options tulajdonság értékével és az RegexOptions önt érdeklő értékkel. Ezután ellenőrizze, hogy az eredmény megegyezik-e ezzel az RegexOptions értékkel. Az alábbi példa azt ellenőrzi, hogy a RegexOptions.IgnoreCase beállítás be van-e állítva.
if ((rgx.Options & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase)
Console.WriteLine("Case-insensitive pattern comparison.");
else
Console.WriteLine("Case-sensitive pattern comparison.");
If (rgx.Options And RegexOptions.IgnoreCase) = RegexOptions.IgnoreCase Then
Console.WriteLine("Case-insensitive pattern comparison.")
Else
Console.WriteLine("Case-sensitive pattern comparison.")
End If
A teszteléshez RegexOptions.Noneállapítsa meg, hogy RegexOptions.Nonea Regex.Options tulajdonság értéke egyenlő-e az alábbi példával.
if (rgx.Options == RegexOptions.None)
Console.WriteLine("No options have been set.");
If rgx.Options = RegexOptions.None Then
Console.WriteLine("No options have been set.")
End If
Az alábbi szakaszok a .NET-ben a reguláris kifejezés által támogatott beállításokat sorolják fel.
Alapértelmezett beállítások
A RegexOptions.None beállítás azt jelzi, hogy nincs megadva beállítás, és a normál kifejezésmotor az alapértelmezett viselkedését használja. Ezek a következők lehetnek:
A minta ekmaScript-reguláris kifejezés helyett canonikusként értelmezendő.
A normál kifejezésminta balról jobbra illeszkedik a bemeneti sztringben.
Az összehasonlítások megkülönböztetik a kis- és nagybetűket.
$A^nyelvi elemek a bemeneti sztring elejét és végét jelölik. A bemeneti sztring vége lehet egy záró újvonalas\nkarakter.A
.nyelvi elem minden karakternek megfelel, kivéve\n.A reguláris kifejezésmintában lévő üres térközeket a rendszer literális szóköz karakterként értelmezi.
A rendszer az aktuális kultúra konvencióit használja a minta és a bemeneti sztring összehasonlításakor.
A csoportok rögzítése a reguláris kifejezési mintában implicit és explicit is.
Feljegyzés
A RegexOptions.None beállításnak nincs beágyazott megfelelője. Ha a normál kifejezési beállításokat beágyazott módon alkalmazza, az alapértelmezett viselkedés beállításonként lesz visszaállítva egy adott beállítás kikapcsolásával. Bekapcsolhatja például (?i) a kis- és nagybetűk közötti összehasonlítást, és visszaállítja az alapértelmezett kis- és (?-i) nagybetűket megkülönböztető összehasonlítást.
Mivel a RegexOptions.None beállítás a normál kifejezésmotor alapértelmezett viselkedését jelöli, a metódushívásokban ritkán van explicit módon megadva. Ehelyett egy konstruktort vagy statikus mintaegyeztetési metódust options hívunk meg paraméter nélkül.
Kis- és nagybetűk megkülönböztetése
A IgnoreCase beállítás vagy a i beágyazott beállítás megkülönbözteti a kis- és nagybetűket. Alapértelmezés szerint a rendszer az aktuális kultúra burkolati konvencióit használja.
Az alábbi példa egy reguláris kifejezésmintát határoz meg, \bthe\w*\bamely az "a" betűvel kezdődő összes szót egyezik. Mivel a metódus első hívása a Match kis- és nagybetűk alapértelmezett összehasonlítását használja, a kimenet azt jelzi, hogy a mondatot kezdő "The" sztring nem egyezik. A metódus akkor lesz megfeleltetve, ha a Match metódus a következőre van állítva IgnoreCase: .
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\bthe\w*\b";
string input = "The man then told them about that event.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
Console.WriteLine();
foreach (Match match in Regex.Matches(input, pattern,
RegexOptions.IgnoreCase))
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
}
}
// The example displays the following output:
// Found then at index 8.
// Found them at index 18.
//
// Found The at index 0.
// Found then at index 8.
// Found them at index 18.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\bthe\w*\b"
Dim input As String = "The man then told them about that event."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
Next
Console.WriteLine()
For Each match As Match In Regex.Matches(input, pattern, _
RegexOptions.IgnoreCase)
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' Found then at index 8.
' Found them at index 18.
'
' Found The at index 0.
' Found then at index 8.
' Found them at index 18.
Az alábbi példa módosítja az előző példában szereplő reguláris kifejezésmintát, hogy a paraméter helyett beágyazott beállításokat használjon a options kis- és nagybetűk közötti összehasonlításhoz. Az első minta határozza meg a kis- és nagybetűket érzéketlen beállítást egy csoportosítási szerkezetben, amely csak a "the" sztring "t" betűjére vonatkozik. Mivel a beállításszerkezet a minta elején történik, a második minta a kis- és nagybetűket érzéketlenként alkalmazza a teljes reguláris kifejezésre.
using System;
using System.Text.RegularExpressions;
public class CaseExample
{
public static void Main()
{
string pattern = @"\b(?i:t)he\w*\b";
string input = "The man then told them about that event.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
Console.WriteLine();
pattern = @"(?i)\bthe\w*\b";
foreach (Match match in Regex.Matches(input, pattern,
RegexOptions.IgnoreCase))
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
}
}
// The example displays the following output:
// Found The at index 0.
// Found then at index 8.
// Found them at index 18.
//
// Found The at index 0.
// Found then at index 8.
// Found them at index 18.
Imports System.Text.RegularExpressions
Module CaseExample
Public Sub Main()
Dim pattern As String = "\b(?i:t)he\w*\b"
Dim input As String = "The man then told them about that event."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
Next
Console.WriteLine()
pattern = "(?i)\bthe\w*\b"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' Found The at index 0.
' Found then at index 8.
' Found them at index 18.
'
' Found The at index 0.
' Found then at index 8.
' Found them at index 18.
Többsoros mód
A RegexOptions.Multiline beállítás vagy a m beágyazott beállítás lehetővé teszi, hogy a reguláris kifejezésmotor kezelje a több sorból álló bemeneti sztringet. Úgy módosítja a ^ nyelvi elemek $ értelmezését, hogy azok a bemeneti sztring kezdete és vége helyett egy sor elejét és végét jelölik.
Alapértelmezés szerint $ csak a bemeneti sztring végén lesz elégedett. Ha megadja a RegexOptions.Multiline beállítást, az új karakter (\n) vagy a bemeneti sztring vége elégedett lesz vele.
Egyik esetben sem $ ismeri fel a kocsi visszatérési/sorbetöltési karakterkombinációját (\r\n). $ mindig figyelmen kívül hagyja a kocsivissza (\r). Az egyezés \r\n\nbefejezéséhez használja a szubexpressziót \r?$ ahelyett, hogy csak $. Vegye figyelembe, hogy ez lesz a \r meccs része.
Az alábbi példa kinyeri a dobók nevét és pontszámait, és hozzáadja őket egy SortedList<TKey,TValue> gyűjteményhez, amely csökkenő sorrendben rendezi őket. A Matches metódust kétszer hívjuk meg. Az első metódushívásban a reguláris kifejezés van ^(\w+)\s(\d+)$ megadva, és nincsenek megadva beállítások. Ahogy a kimenet is mutatja, mivel a reguláris kifejezésmotor nem tud megegyezni a bemeneti mintával és a bemeneti sztring elejével és végén, nem található egyezés. A második metódushívásban a normál kifejezés ^(\w+)\s(\d+)\r?$ módosul, és a beállítások a következőre RegexOptions.Multilinevannak állítva: . Ahogy a kimenet is mutatja, a nevek és a pontszámok sikeresen megegyeznek, és a pontszámok csökkenő sorrendben jelennek meg.
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
public class Multiline1Example
{
public static void Main()
{
SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer1<int>());
string input = "Joe 164\n" +
"Sam 208\n" +
"Allison 211\n" +
"Gwen 171\n";
string pattern = @"^(\w+)\s(\d+)$";
bool matched = false;
Console.WriteLine("Without Multiline option:");
foreach (Match match in Regex.Matches(input, pattern))
{
scores.Add(Int32.Parse(match.Groups[2].Value), (string)match.Groups[1].Value);
matched = true;
}
if (!matched)
Console.WriteLine(" No matches.");
Console.WriteLine();
// Redefine pattern to handle multiple lines.
pattern = @"^(\w+)\s(\d+)\r*$";
Console.WriteLine("With multiline option:");
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
scores.Add(Int32.Parse(match.Groups[2].Value), (string)match.Groups[1].Value);
// List scores in descending order.
foreach (KeyValuePair<int, string> score in scores)
Console.WriteLine("{0}: {1}", score.Value, score.Key);
}
}
public class DescendingComparer1<T> : IComparer<T>
{
public int Compare(T x, T y)
{
return Comparer<T>.Default.Compare(x, y) * -1;
}
}
// The example displays the following output:
// Without Multiline option:
// No matches.
//
// With multiline option:
// Allison: 211
// Sam: 208
// Gwen: 171
// Joe: 164
Imports System.Collections.Generic
Imports System.Text.RegularExpressions
Module Multiline1Example
Public Sub Main()
Dim scores As New SortedList(Of Integer, String)(New DescendingComparer1(Of Integer)())
Dim input As String = "Joe 164" + vbCrLf +
"Sam 208" + vbCrLf +
"Allison 211" + vbCrLf +
"Gwen 171" + vbCrLf
Dim pattern As String = "^(\w+)\s(\d+)$"
Dim matched As Boolean = False
Console.WriteLine("Without Multiline option:")
For Each match As Match In Regex.Matches(input, pattern)
scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
matched = True
Next
If Not matched Then Console.WriteLine(" No matches.")
Console.WriteLine()
' Redefine pattern to handle multiple lines.
pattern = "^(\w+)\s(\d+)\r*$"
Console.WriteLine("With multiline option:")
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
Next
' List scores in descending order.
For Each score As KeyValuePair(Of Integer, String) In scores
Console.WriteLine("{0}: {1}", score.Value, score.Key)
Next
End Sub
End Module
Public Class DescendingComparer1(Of T) : Implements IComparer(Of T)
Public Function Compare(x As T, y As T) As Integer _
Implements IComparer(Of T).Compare
Return Comparer(Of T).Default.Compare(x, y) * -1
End Function
End Class
' The example displays the following output:
' Without Multiline option:
' No matches.
'
' With multiline option:
' Allison: 211
' Sam: 208
' Gwen: 171
' Joe: 164
A reguláris kifejezésminta ^(\w+)\s(\d+)\r*$ az alábbi táblázatban látható módon van definiálva.
| Minta | Leírás |
|---|---|
^ |
Kezdje a sor elején. |
(\w+) |
Egy vagy több szó karakterének egyeztetése. Ez az első rögzítési csoport. |
\s |
Egyezik egy szóköz karakterrel. |
(\d+) |
Egy vagy több tizedesjegy egyeztetése. Ez a második rögzítési csoport. |
\r? |
Nulla vagy egy kocsivissza karakterének egyeztetése. |
$ |
Vége a sor végén. |
Az alábbi példa egyenértékű az előző példával, azzal a különbséggel, hogy a beágyazott beállítással (?m) állítja be a többsoros beállítást.
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
public class Multiline2Example
{
public static void Main()
{
SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());
string input = "Joe 164\n" +
"Sam 208\n" +
"Allison 211\n" +
"Gwen 171\n";
string pattern = @"(?m)^(\w+)\s(\d+)\r*$";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
scores.Add(Convert.ToInt32(match.Groups[2].Value), match.Groups[1].Value);
// List scores in descending order.
foreach (KeyValuePair<int, string> score in scores)
Console.WriteLine("{0}: {1}", score.Value, score.Key);
}
}
public class DescendingComparer<T> : IComparer<T>
{
public int Compare(T x, T y)
{
return Comparer<T>.Default.Compare(x, y) * -1;
}
}
// The example displays the following output:
// Allison: 211
// Sam: 208
// Gwen: 171
// Joe: 164
Imports System.Collections.Generic
Imports System.Text.RegularExpressions
Module Multiline2Example
Public Sub Main()
Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())
Dim input As String = "Joe 164" + vbCrLf +
"Sam 208" + vbCrLf +
"Allison 211" + vbCrLf +
"Gwen 171" + vbCrLf
Dim pattern As String = "(?m)^(\w+)\s(\d+)\r*$"
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
Next
' List scores in descending order.
For Each score As KeyValuePair(Of Integer, String) In scores
Console.WriteLine("{0}: {1}", score.Value, score.Key)
Next
End Sub
End Module
Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
Public Function Compare(x As T, y As T) As Integer _
Implements IComparer(Of T).Compare
Return Comparer(Of T).Default.Compare(x, y) * -1
End Function
End Class
' The example displays the following output:
' Allison: 211
' Sam: 208
' Gwen: 171
' Joe: 164
Egysoros mód
A RegexOptions.Singleline beállítás vagy a s beágyazott beállítás miatt a reguláris kifejezésmotor úgy kezeli a bemeneti sztringet, mintha egyetlen sorból áll. Ezt úgy teszi, hogy módosítja a pont (.) nyelvi elem viselkedését úgy, hogy minden karakternek megfeleljen, ahelyett, hogy az új vonal karakterét leszámítva minden karaktert egyeztet \n.
Az alábbi példa bemutatja, hogyan változik a . nyelvi elem viselkedése a RegexOptions.Singleline beállítás használatakor. A reguláris kifejezés ^.+ a sztring elején kezdődik, és minden karakternek megfelel. Alapértelmezés szerint az egyezés az első sor végén ér véget; a reguláris kifejezésminta megegyezik a kocsi visszatérési karakterével \r, de nem egyezik \n. Mivel a RegexOptions.Singleline beállítás a teljes bemeneti sztringet egyetlen sorként értelmezi, megfelel a bemeneti sztring minden karakterének, beleértve a \n.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "^.+";
string input = "This is one line and" + Environment.NewLine + "this is the second.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(Regex.Escape(match.Value));
Console.WriteLine();
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
Console.WriteLine(Regex.Escape(match.Value));
}
}
// The example displays the following output:
// This\ is\ one\ line\ and\r
//
// This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "^.+"
Dim input As String = "This is one line and" + vbCrLf + "this is the second."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(Regex.Escape(match.Value))
Next
Console.WriteLine()
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
Console.WriteLine(Regex.Escape(match.Value))
Next
End Sub
End Module
' The example displays the following output:
' This\ is\ one\ line\ and\r
'
' This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Az alábbi példa egyenértékű az előző példával, azzal a különbséggel, hogy a beágyazott beállítással (?s) engedélyezi az egysoros módot.
using System;
using System.Text.RegularExpressions;
public class SingleLineExample
{
public static void Main()
{
string pattern = "(?s)^.+";
string input = "This is one line and" + Environment.NewLine + "this is the second.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(Regex.Escape(match.Value));
}
}
// The example displays the following output:
// This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Imports System.Text.RegularExpressions
Module SingleLineExample
Public Sub Main()
Dim pattern As String = "(?s)^.+"
Dim input As String = "This is one line and" + vbCrLf + "this is the second."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(Regex.Escape(match.Value))
Next
End Sub
End Module
' The example displays the following output:
' This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Csak explicit rögzítések
Alapértelmezés szerint a csoportok rögzítését zárójelek használata határozza meg a reguláris kifejezési mintában. Az elnevezett csoportok neve vagy száma a (?<név>alatti) nyelv beállítással van hozzárendelve, míg a névtelen csoportok indexelhetők. Az objektumban a GroupCollection névtelen csoportok megelőzik az elnevezett csoportokat.
A csoportosítási szerkezeteket gyakran csak kvantitátorok több nyelvi elemre való alkalmazására használják, és a rögzített részszűkítések nem érdekesek. Ha például a következő reguláris kifejezés:
\b\(?((\w+),?\s?)+[\.!?]\)?
csak olyan mondatok kinyerésére szolgál, amelyek ponttal, felkiáltójellel vagy kérdőjellel végződnek egy dokumentumból, csak az eredményül kapott mondat (amelyet az Match objektum jelöl) érdekes. A gyűjtemény egyes szavai nem.
A később nem használt csoportok rögzítése költséges lehet, mivel a normál kifejezésmotornak mind a gyűjteményobjektumokat, mind a GroupCollectionCaptureCollection gyűjteményobjektumokat fel kell töltenie. Másik lehetőségként a RegexOptions.ExplicitCapture beállítással vagy a n beágyazott beállítással megadhatja, hogy az egyetlen érvényes rögzítés kifejezetten elnevezett vagy számozott csoport legyen, amelyeket a (?<név>alexpressziós) szerkezete jelöl ki.
Az alábbi példa a reguláris kifejezésminta által \b\(?((\w+),?\s?)+[\.!?]\)? visszaadott egyezésekkel kapcsolatos információkat jeleníti meg, amikor a Match metódus meghívása lehetőséggel és lehetőség nélkül RegexOptions.ExplicitCapture történik. Ahogy az első metódushívás kimenete is mutatja, a reguláris kifejezésmotor teljes mértékben kitölti az és CaptureCollection a gyűjtemény objektumait a GroupCollection rögzített részszűkítésekre vonatkozó információkkal. Mivel a második metódus meghívása a következőre RegexOptions.ExplicitCapturevan options állítva, nem rögzíti a csoportok adatait.
using System;
using System.Text.RegularExpressions;
public class Explicit1Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"\b\(?((?>\w+),?\s?)+[\.!?]\)?";
Console.WriteLine("With implicit captures:");
foreach (Match match in Regex.Matches(input, pattern))
{
Console.WriteLine("The match: {0}", match.Value);
int groupCtr = 0;
foreach (Group group in match.Groups)
{
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value);
groupCtr++;
int captureCtr = 0;
foreach (Capture capture in group.Captures)
{
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value);
captureCtr++;
}
}
}
Console.WriteLine();
Console.WriteLine("With explicit captures only:");
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.ExplicitCapture))
{
Console.WriteLine("The match: {0}", match.Value);
int groupCtr = 0;
foreach (Group group in match.Groups)
{
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value);
groupCtr++;
int captureCtr = 0;
foreach (Capture capture in group.Captures)
{
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value);
captureCtr++;
}
}
}
}
}
// The example displays the following output:
// With implicit captures:
// The match: This is the first sentence.
// Group 0: This is the first sentence.
// Capture 0: This is the first sentence.
// Group 1: sentence
// Capture 0: This
// Capture 1: is
// Capture 2: the
// Capture 3: first
// Capture 4: sentence
// Group 2: sentence
// Capture 0: This
// Capture 1: is
// Capture 2: the
// Capture 3: first
// Capture 4: sentence
// The match: Is it the beginning of a literary masterpiece?
// Group 0: Is it the beginning of a literary masterpiece?
// Capture 0: Is it the beginning of a literary masterpiece?
// Group 1: masterpiece
// Capture 0: Is
// Capture 1: it
// Capture 2: the
// Capture 3: beginning
// Capture 4: of
// Capture 5: a
// Capture 6: literary
// Capture 7: masterpiece
// Group 2: masterpiece
// Capture 0: Is
// Capture 1: it
// Capture 2: the
// Capture 3: beginning
// Capture 4: of
// Capture 5: a
// Capture 6: literary
// Capture 7: masterpiece
// The match: I think not.
// Group 0: I think not.
// Capture 0: I think not.
// Group 1: not
// Capture 0: I
// Capture 1: think
// Capture 2: not
// Group 2: not
// Capture 0: I
// Capture 1: think
// Capture 2: not
// The match: Instead, it is a nonsensical paragraph.
// Group 0: Instead, it is a nonsensical paragraph.
// Capture 0: Instead, it is a nonsensical paragraph.
// Group 1: paragraph
// Capture 0: Instead,
// Capture 1: it
// Capture 2: is
// Capture 3: a
// Capture 4: nonsensical
// Capture 5: paragraph
// Group 2: paragraph
// Capture 0: Instead
// Capture 1: it
// Capture 2: is
// Capture 3: a
// Capture 4: nonsensical
// Capture 5: paragraph
//
// With explicit captures only:
// The match: This is the first sentence.
// Group 0: This is the first sentence.
// Capture 0: This is the first sentence.
// The match: Is it the beginning of a literary masterpiece?
// Group 0: Is it the beginning of a literary masterpiece?
// Capture 0: Is it the beginning of a literary masterpiece?
// The match: I think not.
// Group 0: I think not.
// Capture 0: I think not.
// The match: Instead, it is a nonsensical paragraph.
// Group 0: Instead, it is a nonsensical paragraph.
// Capture 0: Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions
Module Explicit1Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph."
Dim pattern As String = "\b\(?((?>\w+),?\s?)+[\.!?]\)?"
Console.WriteLine("With implicit captures:")
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("The match: {0}", match.Value)
Dim groupCtr As Integer = 0
For Each group As Group In match.Groups
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value)
groupCtr += 1
Dim captureCtr As Integer = 0
For Each capture As Capture In group.Captures
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value)
captureCtr += 1
Next
Next
Next
Console.WriteLine()
Console.WriteLine("With explicit captures only:")
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.ExplicitCapture)
Console.WriteLine("The match: {0}", match.Value)
Dim groupCtr As Integer = 0
For Each group As Group In match.Groups
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value)
groupCtr += 1
Dim captureCtr As Integer = 0
For Each capture As Capture In group.Captures
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value)
captureCtr += 1
Next
Next
Next
End Sub
End Module
' The example displays the following output:
' With implicit captures:
' The match: This is the first sentence.
' Group 0: This is the first sentence.
' Capture 0: This is the first sentence.
' Group 1: sentence
' Capture 0: This
' Capture 1: is
' Capture 2: the
' Capture 3: first
' Capture 4: sentence
' Group 2: sentence
' Capture 0: This
' Capture 1: is
' Capture 2: the
' Capture 3: first
' Capture 4: sentence
' The match: Is it the beginning of a literary masterpiece?
' Group 0: Is it the beginning of a literary masterpiece?
' Capture 0: Is it the beginning of a literary masterpiece?
' Group 1: masterpiece
' Capture 0: Is
' Capture 1: it
' Capture 2: the
' Capture 3: beginning
' Capture 4: of
' Capture 5: a
' Capture 6: literary
' Capture 7: masterpiece
' Group 2: masterpiece
' Capture 0: Is
' Capture 1: it
' Capture 2: the
' Capture 3: beginning
' Capture 4: of
' Capture 5: a
' Capture 6: literary
' Capture 7: masterpiece
' The match: I think not.
' Group 0: I think not.
' Capture 0: I think not.
' Group 1: not
' Capture 0: I
' Capture 1: think
' Capture 2: not
' Group 2: not
' Capture 0: I
' Capture 1: think
' Capture 2: not
' The match: Instead, it is a nonsensical paragraph.
' Group 0: Instead, it is a nonsensical paragraph.
' Capture 0: Instead, it is a nonsensical paragraph.
' Group 1: paragraph
' Capture 0: Instead,
' Capture 1: it
' Capture 2: is
' Capture 3: a
' Capture 4: nonsensical
' Capture 5: paragraph
' Group 2: paragraph
' Capture 0: Instead
' Capture 1: it
' Capture 2: is
' Capture 3: a
' Capture 4: nonsensical
' Capture 5: paragraph
'
' With explicit captures only:
' The match: This is the first sentence.
' Group 0: This is the first sentence.
' Capture 0: This is the first sentence.
' The match: Is it the beginning of a literary masterpiece?
' Group 0: Is it the beginning of a literary masterpiece?
' Capture 0: Is it the beginning of a literary masterpiece?
' The match: I think not.
' Group 0: I think not.
' Capture 0: I think not.
' The match: Instead, it is a nonsensical paragraph.
' Group 0: Instead, it is a nonsensical paragraph.
' Capture 0: Instead, it is a nonsensical paragraph.
A reguláris kifejezésminta\b\(?((?>\w+),?\s?)+[\.!?]\)? az alábbi táblázatban látható módon van definiálva.
| Minta | Leírás |
|---|---|
\b |
Kezdje egy szóhatáron. |
\(? |
A nyitó zárójel nullájának vagy egy előfordulásának egyezése ("("). |
(?>\w+),? |
Egy vagy több szó karakterének egyezése, amelyet nulla vagy egy vessző követ. Ne vonja vissza a műveletet, ha egyezik a szavak karakterei. |
\s? |
Nulla vagy egy szóköz karakter egyezése. |
((\w+),?\s?)+ |
Egy vagy több szókarakter, nulla vagy egy vessző, valamint egy vagy több üres szóköz karakter kombinációjának felel meg. |
[\.!?]\)? |
Egyezzen a három írásjel bármelyikével, amelyet nulla vagy egy záró zárójel (")) követ. |
A beágyazott elem használatával is letilthatja az (?n) automatikus rögzítéseket. Az alábbi példa úgy módosítja az előző reguláris kifejezésmintát, hogy a (?n) beágyazott elemet használja a RegexOptions.ExplicitCapture beállítás helyett.
using System;
using System.Text.RegularExpressions;
public class Explicit2Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?";
foreach (Match match in Regex.Matches(input, pattern))
{
Console.WriteLine("The match: {0}", match.Value);
int groupCtr = 0;
foreach (Group group in match.Groups)
{
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value);
groupCtr++;
int captureCtr = 0;
foreach (Capture capture in group.Captures)
{
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value);
captureCtr++;
}
}
}
}
}
// The example displays the following output:
// The match: This is the first sentence.
// Group 0: This is the first sentence.
// Capture 0: This is the first sentence.
// The match: Is it the beginning of a literary masterpiece?
// Group 0: Is it the beginning of a literary masterpiece?
// Capture 0: Is it the beginning of a literary masterpiece?
// The match: I think not.
// Group 0: I think not.
// Capture 0: I think not.
// The match: Instead, it is a nonsensical paragraph.
// Group 0: Instead, it is a nonsensical paragraph.
// Capture 0: Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions
Module Explicit2Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph."
Dim pattern As String = "(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("The match: {0}", match.Value)
Dim groupCtr As Integer = 0
For Each group As Group In match.Groups
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value)
groupCtr += 1
Dim captureCtr As Integer = 0
For Each capture As Capture In group.Captures
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value)
captureCtr += 1
Next
Next
Next
End Sub
End Module
' The example displays the following output:
' The match: This is the first sentence.
' Group 0: This is the first sentence.
' Capture 0: This is the first sentence.
' The match: Is it the beginning of a literary masterpiece?
' Group 0: Is it the beginning of a literary masterpiece?
' Capture 0: Is it the beginning of a literary masterpiece?
' The match: I think not.
' Group 0: I think not.
' Capture 0: I think not.
' The match: Instead, it is a nonsensical paragraph.
' Group 0: Instead, it is a nonsensical paragraph.
' Capture 0: Instead, it is a nonsensical paragraph.
Végül a beágyazott csoportelem (?n:) használatával csoportonként letilthatja az automatikus rögzítéseket. Az alábbi példa módosítja az előző mintát, hogy letiltsa a névtelen rögzítéseket a külső csoportban. ((?>\w+),?\s?) Vegye figyelembe, hogy ez a belső csoportban is letiltja a névtelen rögzítéseket.
using System;
using System.Text.RegularExpressions;
public class Explicit3Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?";
foreach (Match match in Regex.Matches(input, pattern))
{
Console.WriteLine("The match: {0}", match.Value);
int groupCtr = 0;
foreach (Group group in match.Groups)
{
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value);
groupCtr++;
int captureCtr = 0;
foreach (Capture capture in group.Captures)
{
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value);
captureCtr++;
}
}
}
}
}
// The example displays the following output:
// The match: This is the first sentence.
// Group 0: This is the first sentence.
// Capture 0: This is the first sentence.
// The match: Is it the beginning of a literary masterpiece?
// Group 0: Is it the beginning of a literary masterpiece?
// Capture 0: Is it the beginning of a literary masterpiece?
// The match: I think not.
// Group 0: I think not.
// Capture 0: I think not.
// The match: Instead, it is a nonsensical paragraph.
// Group 0: Instead, it is a nonsensical paragraph.
// Capture 0: Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions
Module Explicit3Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph."
Dim pattern As String = "\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("The match: {0}", match.Value)
Dim groupCtr As Integer = 0
For Each group As Group In match.Groups
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value)
groupCtr += 1
Dim captureCtr As Integer = 0
For Each capture As Capture In group.Captures
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value)
captureCtr += 1
Next
Next
Next
End Sub
End Module
' The example displays the following output:
' The match: This is the first sentence.
' Group 0: This is the first sentence.
' Capture 0: This is the first sentence.
' The match: Is it the beginning of a literary masterpiece?
' Group 0: Is it the beginning of a literary masterpiece?
' Capture 0: Is it the beginning of a literary masterpiece?
' The match: I think not.
' Group 0: I think not.
' Capture 0: I think not.
' The match: Instead, it is a nonsensical paragraph.
' Group 0: Instead, it is a nonsensical paragraph.
' Capture 0: Instead, it is a nonsensical paragraph.
Lefordított reguláris kifejezések
Feljegyzés
Ha lehetséges, használja a forrás által létrehozott reguláris kifejezéseket ahelyett, hogy reguláris kifejezéseket állít össze a RegexOptions.Compiled beállítás használatával. A forráslétrehozás segíthet az alkalmazás gyorsabb elindításában, gyorsabb futtatásában és a vágásban. A forráslétrehozás lehetőségének megismeréséhez lásd : Mikor érdemes használni.
Alapértelmezés szerint a rendszer a .NET-ben lévő reguláris kifejezéseket értelmezi. Amikor egy Regex objektumot példányosít vagy statikus Regex metódust hív meg, a rendszer egyéni opkódok készletébe elemzi a reguláris kifejezésmintát, és egy értelmező ezeket az opkódokat használja a reguláris kifejezés futtatásához. Ez kompromisszumot jelent: A normál kifejezésmotor inicializálásának költsége a futásidejű teljesítmény rovására minimálisra csökken.
A hagyományos kifejezések értelmezése helyett fordítva is használhatja a RegexOptions.Compiled beállítást. Ebben az esetben, amikor egy mintát átadnak a normál kifejezésmotornak, a rendszer opkódok készletében elemzi, majd közös köztes nyelvre (CIL) konvertálja, amelyet közvetlenül a közös nyelvi futtatókörnyezetbe továbbíthat. A lefordított reguláris kifejezések maximalizálják a futásidejű teljesítményt az inicializálási idő rovására.
Feljegyzés
A reguláris kifejezések csak úgy állíthatók össze, ha options az RegexOptions.Compiled értéket egy Regex osztálykonstruktor paraméterének vagy egy statikus mintaegyeztetési módszernek adja meg. Beágyazott beállításként nem érhető el.
A lefordított reguláris kifejezéseket statikus és példány reguláris kifejezések hívásaiban is használhatja. Statikus reguláris kifejezésekben a rendszer átadja a RegexOptions.Compiled beállítást a options reguláris kifejezésminta-egyeztetési módszer paraméterének. Például a reguláris kifejezések az osztálykonstruktor paraméterének Regex lesznek átadvaoptions. Mindkét esetben jobb teljesítményt eredményez.
Ez a teljesítménybeli javulás azonban csak a következő feltételek mellett történik:
Egy Regex adott reguláris kifejezést jelképező objektumot a rendszer több, a reguláris kifejezésminta-egyeztetési metódusokra irányuló hívásban is használ.
Az Regex objektum nem hagyható ki a hatókörből, így újra felhasználható.
A rendszer statikus reguláris kifejezést használ a reguláris kifejezésminta-egyeztetési metódusok több hívásában. (A teljesítmény javítása azért lehetséges, mert a statikus metódushívásokban használt reguláris kifejezéseket a normál kifejezésmotor gyorsítótárazza.)
Feljegyzés
A RegexOptions.Compiled beállítás nem kapcsolódik a Regex.CompileToAssembly metódushoz, amely egy speciális célú szerelvényt hoz létre, amely előre meghatározott, lefordított reguláris kifejezéseket tartalmaz.
Üres terület figyelmen kívül hagyása
Alapértelmezés szerint a normál kifejezési mintában a szabad terület jelentős; a normál kifejezésmotort arra kényszeríti, hogy egyezzen a bemeneti sztring egy szóköz karakterével. Emiatt a "\b\w+\s" és ""\b\w+ reguláris kifejezés nagyjából egyenértékű reguláris kifejezések. Emellett, ha a számjel (#) egy reguláris kifejezési mintában jelentkezik, akkor a rendszer konstans karakterként értelmezi, amelyet egyeztetni kell.
A RegexOptions.IgnorePatternWhitespace beállítás vagy a x beágyazott beállítás az alábbiak szerint módosítja ezt az alapértelmezett viselkedést:
A rendszer figyelmen kívül hagyja a normál kifejezésmintában lévő üres szóközt. Ahhoz, hogy egy reguláris kifejezésminta része legyen, a szóköz karaktereket meg kell szökni (például mint vagy
\s"\").A számjel (#) a megjegyzés kezdeteként van értelmezve, nem pedig literális karakterként. A normál kifejezésmintában szereplő összes szöveg a
#karaktertől a következő\nkarakterig vagy a sztring végéig megjegyzésként lesz értelmezve.
A következő esetekben azonban a normál kifejezésben lévő szóköz karaktereket a rendszer nem hagyja figyelmen kívül, még akkor sem, ha a RegexOptions.IgnorePatternWhitespace beállítást használja:
A karakterosztályon belüli szóköz mindig szó szerint értelmezve van. A reguláris kifejezésminta
[ .,;:]például egyezik az egyetlen szóközzel, ponttal, vesszőből, pontosvesszőből vagy kettőspontból álló karakterrel.A szögletes kvantálón belül nem engedélyezett a térköz, például
{n},{n,}és{n,m.}A reguláris kifejezésminta\d{1, 3}például nem felel meg az egy-három számjegyből álló számjegysorozatoknak, mert üres szóköz karaktert tartalmaz.A nyelvi elemet tartalmazó karaktersorozatokban nem engedélyezett a szóköz. Példa:
A nyelvi elem
(?:részexpressziója)nem összetartó csoportot jelöl, és az(?:elem része nem tartalmazhat beágyazott szóközöket. A minta(? :alexpressziója)futásidőben ad vissza egy ArgumentException hibát, mert a normál kifejezésmotor nem tudja elemezni a mintát, és a minta( ?:alexpressziója)nem egyezik meg a szubexpresszióval.A Unicode-kategóriát vagy elnevezett blokkot jelképező nyelvi elemnév
\p{}nem tartalmazhat beágyazott szóközöket az\p{elem részébe. Ha szóközt is tartalmaz, az elem futásidőben dob ArgumentException egy helyet.
Ennek a beállításnak a engedélyezése leegyszerűsíti a gyakran nehezen elemezni és értelmezni kívánt reguláris kifejezéseket. Javítja az olvashatóságot, és lehetővé teszi egy reguláris kifejezés dokumentálására.
Az alábbi példa a következő reguláris kifejezésmintát határozza meg:
\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence.
Ez a minta hasonló az Explicit rögzítések csak szakaszában definiált mintához, azzal a kivételrel, hogy figyelmen kívül hagyja a RegexOptions.IgnorePatternWhitespace minta üres területét.
using System;
using System.Text.RegularExpressions;
public class Whitespace1Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence.";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// This is the first sentence.
// Is it the beginning of a literary masterpiece?
// I think not.
// Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions
Module Whitespace1Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph."
Dim pattern As String = "\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence."
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)
Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' This is the first sentence.
' Is it the beginning of a literary masterpiece?
' I think not.
' Instead, it is a nonsensical paragraph.
Az alábbi példa a beágyazott beállítással (?x) figyelmen kívül hagyja a minta üres területét.
using System;
using System.Text.RegularExpressions;
public class Whitespace2Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"(?x)\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// This is the first sentence.
// Is it the beginning of a literary masterpiece?
// I think not.
// Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions
Module Whitespace2Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph."
Dim pattern As String = "(?x)\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' This is the first sentence.
' Is it the beginning of a literary masterpiece?
' I think not.
' Instead, it is a nonsensical paragraph.
Jobbról balra mód
Alapértelmezés szerint a normál kifejezésmotor balról jobbra keres. A keresési irányt a beállítással RegexOptions.RightToLeft megfordíthatja. A jobbról balra történő keresés automatikusan elindul a sztring utolsó karakterpozíciójában. Olyan mintaegyeztetési metódusok esetében, amelyek egy kezdő pozícióparamétert tartalmaznak, például Regex.Match(String, Int32)a megadott kezdő pozíció annak a jobb szélső karakterpozíciónak az indexe, amelyen a keresés elkezdődik.
Feljegyzés
A jobbról balra minta mód csak az osztálykonstruktor vagy a options statikus mintaegyező metódus paraméterének Regex megadásával RegexOptions.RightToLeft érhető el. Beágyazott beállításként nem érhető el.
Példa
A reguláris kifejezés \bb\w+\s két vagy több karakterből álló szavakkal egyezik, amelyek a "b" betűvel kezdődnek, és egy szóköz karakter követi őket. A következő példában a bemeneti sztring három olyan szóból áll, amelyek egy vagy több "b" karaktert tartalmaznak. Az első és a második szó a "b" betűvel kezdődik, a harmadik pedig a "b" betűvel végződik. Ahogy a jobbról balra keresési példa kimenete mutatja, csak az első és a második szó egyezik meg a reguláris kifejezésmintával, és a második szó lesz az első.
using System;
using System.Text.RegularExpressions;
public class RTL1Example
{
public static void Main()
{
string pattern = @"\bb\w+\s";
string input = "build band tab";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.RightToLeft))
Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
}
}
// The example displays the following output:
// 'band ' found at position 6.
// 'build ' found at position 0.
Imports System.Text.RegularExpressions
Module RTL1Example
Public Sub Main()
Dim pattern As String = "\bb\w+\s"
Dim input As String = "build band tab"
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.RightToLeft)
Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' 'band ' found at position 6.
' 'build ' found at position 0.
Kiértékelési sorrend
A RegexOptions.RightToLeft beállítás megváltoztatja a keresési irányt, és megfordítja a reguláris kifejezésminta kiértékelésének sorrendjét is. Jobbról balra történő keresés esetén a keresési minta jobbról balra olvasható. Ez a megkülönböztetés azért fontos, mert hatással lehet például a rögzítési csoportokra és a háttérrendszerekre. A kifejezés Regex.Match("abcabc", @"\1(abc)", RegexOptions.RightToLeft) például talál egyezést abcabc, de a balról jobbra irányuló keresésben (Regex.Match("abcabc", @"\1(abc)", RegexOptions.None)) nem található egyezés. Ennek az az oka, hogy az (abc) elemet a számozott rögzítési csoport () elem (\1) előtt kell kiértékelni egy egyezés megtalálása érdekében.
Lookahead és lookbehind állítások
A lookahead ((?=subexpression)) vagy a lookbehind ((?<=subexpression)) állítás egyezésének helye nem változik a jobbról balra történő keresésben. A lookahead-állítások az aktuális egyezés helyétől jobbra jelennek meg; a lookbehind állítások az aktuális egyezés helyétől balra jelennek meg.
Tipp.
Akár jobbról balra keres, akár nem, a keresések az aktuális egyezés helyétől kezdve jobbról balra történő kereséssel implementálhatók.
A reguláris kifejezés (?<=\d{1,2}\s)\w+,\s\d{4} például a lookbehind állítással tesztel egy hónapnevet megelőző dátumot. A reguláris kifejezés ezután megegyezik a hónap és az év. A lookahead és a lookbehind állításokkal kapcsolatos információkért lásd a csoportosítási szerkezeteket.
using System;
using System.Text.RegularExpressions;
public class RTL2Example
{
public static void Main()
{
string[] inputs = { "1 May, 1917", "June 16, 2003" };
string pattern = @"(?<=\d{1,2}\s)\w+,\s\d{4}";
foreach (string input in inputs)
{
Match match = Regex.Match(input, pattern, RegexOptions.RightToLeft);
if (match.Success)
Console.WriteLine("The date occurs in {0}.", match.Value);
else
Console.WriteLine("{0} does not match.", input);
}
}
}
// The example displays the following output:
// The date occurs in May, 1917.
// June 16, 2003 does not match.
Imports System.Text.RegularExpressions
Module RTL2Example
Public Sub Main()
Dim inputs() As String = {"1 May, 1917", "June 16, 2003"}
Dim pattern As String = "(?<=\d{1,2}\s)\w+,\s\d{4}"
For Each input As String In inputs
Dim match As Match = Regex.Match(input, pattern, RegexOptions.RightToLeft)
If match.Success Then
Console.WriteLine("The date occurs in {0}.", match.Value)
Else
Console.WriteLine("{0} does not match.", input)
End If
Next
End Sub
End Module
' The example displays the following output:
' The date occurs in May, 1917.
' June 16, 2003 does not match.
A reguláris kifejezésminta az alábbi táblázatban látható módon van definiálva.
| Minta | Leírás |
|---|---|
(?<=\d{1,2}\s) |
Az egyezés elejét egy vagy két tizedesjegynek kell megelőznie, amelyet szóköz követ. |
\w+ |
Egy vagy több szó karakterének egyeztetése. |
, |
Egyezik egy vessző karakter. |
\s |
Egyezik egy szóköz karakterrel. |
\d{4} |
Négy tizedesjegy egyeztetése. |
ECMAScript-egyeztetési viselkedés
Alapértelmezés szerint a reguláris kifejezésmotor a szokásos kifejezésminta beviteli szöveghez való illesztésekor a canonical viselkedést használja. A beállítás megadásával azonban utasíthatja a reguláris kifejezésmotort az ECMAScript-megfeleltetési RegexOptions.ECMAScript viselkedés használatára.
Feljegyzés
Az ECMAScript-kompatibilis viselkedés csak egy RegexOptions.ECMAScript osztálykonstruktor vagy statikus mintaegyező metódus paraméterének Regex megadásával options érhető el. Beágyazott beállításként nem érhető el.
A RegexOptions.ECMAScript beállítás csak a RegexOptions.IgnoreCase beállításokkal kombinálható RegexOptions.Multiline . A reguláris kifejezések ArgumentOutOfRangeExceptionbármely más lehetőségének használata egy .
Az ECMAScript és a canonical reguláris kifejezések viselkedése három területen különbözik: a karakterosztály szintaxisa, a csoportok önhivatkozása és az oktális és a háttérbeli értelmezés.
Karakterosztály szintaxisa. Mivel a canonical reguláris kifejezések támogatják a Unicode-t, míg az ECMAScript nem, az ECMAScript karakterosztályai korlátozottabb szintaxissal rendelkeznek, és néhány karakterosztály nyelvi eleme más jelentéssel rendelkezik. Az ECMAScript például nem támogatja a nyelvi elemeket, például a Unicode-kategóriát vagy a blokkelemeket
\pés\Pa . Hasonlóképpen, a\wszó karakterével egyező elem egyenértékű az ECMAScript használatakor és[\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]a[a-zA-Z_0-9]canonikus viselkedés használatakor használt karakterosztálysal. További információ: Karakterosztályok.Az alábbi példa a canonical és az ECMAScript mintaegyezés közötti különbséget mutatja be. Egy reguláris kifejezést határoz meg, amely egyezik a szavakkal,
\b(\w+\s*)+majd a szóközzel. A bemenet két sztringből áll, az egyik a latin karakterkészletet, a másik a cirill karakterkészletet használja. Ahogy a kimenet is mutatja, az Regex.IsMatch(String, String, RegexOptions) ECMAScript-egyeztetést használó metódus hívása nem egyezik a cirill szavakkal, míg a canonical matching metódushívása megfelel ezeknek a szavaknak.using System; using System.Text.RegularExpressions; public class EcmaScriptExample { public static void Main() { string[] values = { "целый мир", "the whole world" }; string pattern = @"\b(\w+\s*)+"; foreach (var value in values) { Console.Write("Canonical matching: "); if (Regex.IsMatch(value, pattern)) Console.WriteLine("'{0}' matches the pattern.", value); else Console.WriteLine("{0} does not match the pattern.", value); Console.Write("ECMAScript matching: "); if (Regex.IsMatch(value, pattern, RegexOptions.ECMAScript)) Console.WriteLine("'{0}' matches the pattern.", value); else Console.WriteLine("{0} does not match the pattern.", value); Console.WriteLine(); } } } // The example displays the following output: // Canonical matching: 'целый мир' matches the pattern. // ECMAScript matching: целый мир does not match the pattern. // // Canonical matching: 'the whole world' matches the pattern. // ECMAScript matching: 'the whole world' matches the pattern.Imports System.Text.RegularExpressions Module Ecma1Example Public Sub Main() Dim values() As String = {"целый мир", "the whole world"} Dim pattern As String = "\b(\w+\s*)+" For Each value In values Console.Write("Canonical matching: ") If Regex.IsMatch(value, pattern) Then Console.WriteLine("'{0}' matches the pattern.", value) Else Console.WriteLine("{0} does not match the pattern.", value) End If Console.Write("ECMAScript matching: ") If Regex.IsMatch(value, pattern, RegexOptions.ECMAScript) Then Console.WriteLine("'{0}' matches the pattern.", value) Else Console.WriteLine("{0} does not match the pattern.", value) End If Console.WriteLine() Next End Sub End Module ' The example displays the following output: ' Canonical matching: 'целый мир' matches the pattern. ' ECMAScript matching: целый мир does not match the pattern. ' ' Canonical matching: 'the whole world' matches the pattern. ' ECMAScript matching: 'the whole world' matches the pattern.Csoportok önhivatkozása. Minden rögzítési iterációval frissíteni kell a reguláris kifejezésrögzítési osztályt, amely háttérrendszerrel rendelkezik. Ahogy az alábbi példa is mutatja, ez a funkció lehetővé teszi, hogy a reguláris kifejezés
((a+)(\1) ?)+megfeleljen az "aa aaaa a" bemeneti sztringnek ECMAScript használatakor, de a canonical matching használata esetén nem.using System; using System.Text.RegularExpressions; public class EcmaScript2Example { static string pattern; public static void Main() { string input = "aa aaaa aaaaaa "; pattern = @"((a+)(\1) ?)+"; // Match input using canonical matching. AnalyzeMatch(Regex.Match(input, pattern)); // Match input using ECMAScript. AnalyzeMatch(Regex.Match(input, pattern, RegexOptions.ECMAScript)); } private static void AnalyzeMatch(Match m) { if (m.Success) { Console.WriteLine("'{0}' matches {1} at position {2}.", pattern, m.Value, m.Index); int grpCtr = 0; foreach (Group grp in m.Groups) { Console.WriteLine(" {0}: '{1}'", grpCtr, grp.Value); grpCtr++; int capCtr = 0; foreach (Capture cap in grp.Captures) { Console.WriteLine(" {0}: '{1}'", capCtr, cap.Value); capCtr++; } } } else { Console.WriteLine("No match found."); } Console.WriteLine(); } } // The example displays the following output: // No match found. // // '((a+)(\1) ?)+' matches aa aaaa aaaaaa at position 0. // 0: 'aa aaaa aaaaaa ' // 0: 'aa aaaa aaaaaa ' // 1: 'aaaaaa ' // 0: 'aa ' // 1: 'aaaa ' // 2: 'aaaaaa ' // 2: 'aa' // 0: 'aa' // 1: 'aa' // 2: 'aa' // 3: 'aaaa ' // 0: '' // 1: 'aa ' // 2: 'aaaa 'Imports System.Text.RegularExpressions Module Ecma2Example Dim pattern As String Public Sub Main() Dim input As String = "aa aaaa aaaaaa " pattern = "((a+)(\1) ?)+" ' Match input using canonical matching. AnalyzeMatch(Regex.Match(input, pattern)) ' Match input using ECMAScript. AnalyzeMatch(Regex.Match(input, pattern, RegexOptions.ECMAScript)) End Sub Private Sub AnalyzeMatch(m As Match) If m.Success Then Console.WriteLine("'{0}' matches {1} at position {2}.", pattern, m.Value, m.Index) Dim grpCtr As Integer = 0 For Each grp As Group In m.Groups Console.WriteLine(" {0}: '{1}'", grpCtr, grp.Value) grpCtr += 1 Dim capCtr As Integer = 0 For Each cap As Capture In grp.Captures Console.WriteLine(" {0}: '{1}'", capCtr, cap.Value) capCtr += 1 Next Next Else Console.WriteLine("No match found.") End If Console.WriteLine() End Sub End Module ' The example displays the following output: ' No match found. ' ' '((a+)(\1) ?)+' matches aa aaaa aaaaaa at position 0. ' 0: 'aa aaaa aaaaaa ' ' 0: 'aa aaaa aaaaaa ' ' 1: 'aaaaaa ' ' 0: 'aa ' ' 1: 'aaaa ' ' 2: 'aaaaaa ' ' 2: 'aa' ' 0: 'aa' ' 1: 'aa' ' 2: 'aa' ' 3: 'aaaa ' ' 0: '' ' 1: 'aa ' ' 2: 'aaaa 'A reguláris kifejezés az alábbi táblázatban látható módon van definiálva.
Minta Leírás (a+) Egy vagy több alkalommal egyezzen az "a" betűvel. Ez a második rögzítési csoport. (\1) Egyezzen az első rögzítési csoport által rögzített részszűréssel. Ez a harmadik rögzítési csoport. ? Nulla vagy egy szóköz karakter egyezése. ((a+)(\1) ?) + Egyezik egy vagy több "a" karakter mintájával, majd egy sztringgel, amely megfelel az első rögzítési csoportnak, majd egy vagy több szóköz karakterrel. Ez az első rögzítési csoport. Az oktális menekülések és a háttérrendszerek közötti kétértelműségek megoldása. Az alábbi táblázat az oktális és a háttérbeli értelmezés különbségeit foglalja össze a canonical és ECMAScript reguláris kifejezések alapján.
Reguláris kifejezés Canonical behavior ECMAScript-viselkedés \0majd 0–2 oktális számjegyÉrtelmezze oktálisként. A rendszer például mindig oktális értékként értelmezi, és azt jelenti, \044hogy "$".Ugyanaz a viselkedés. \1-től 9-ig egy számjegy követi, amelyet további tizedesjegyek nélkül követnek,Értelmezze háttérrendszerként. Például \9mindig 9-es háttérrendszert jelent, még akkor is, ha egy kilencedik rögzítési csoport nem létezik. Ha a rögzítési csoport nem létezik, a reguláris kifejezéselemző egy ArgumentException.Ha egyetlen tizedesjegy-rögzítési csoport létezik, az adott számjegyre való visszakövetkeztetés. Ellenkező esetben az értéket literálként értelmezze. \1 és 9 közötti számjegy, majd további tizedesjegyekA számjegyeket decimális értékként értelmezze. Ha a rögzítési csoport létezik, értelmezze a kifejezést háttérrendszerként.
Ellenkező esetben értelmezze a kezdő oktális számjegyeket a 377-ig; azaz csak az érték alacsony 8 bites értékeit vegye figyelembe. A fennmaradó számjegyeket literálként értelmezze. Ha például a kifejezésben\3000a 300-as csoport rögzítése létezik, akkor a 300-as háttérrendszerként kell értelmezni; ha a 300-as csoport rögzítése nem létezik, akkor az oktális 300- as, majd a 0-ás.Értelmezze háttérként, ha a lehető legtöbb számjegyet decimális értékké konvertálja, amely egy rögzítésre hivatkozhat. Ha nem konvertálható számjegy, akkor oktálisként értelmezze a 377-ig vezető oktális számjegyeket; a fennmaradó számjegyeket literálként értelmezi.
Összehasonlítás az invariáns kultúra használatával
Alapértelmezés szerint, amikor a reguláris kifejezésmotor kis- és nagybetűk érzéketlen összehasonlítását hajtja végre, az aktuális kultúra burkolati konvencióit használja az egyenértékű nagybetűk és kisbetűk meghatározásához.
Ez a viselkedés azonban bizonyos típusú összehasonlítások esetében nem kívánatos, különösen akkor, ha a felhasználói bemenetet a rendszererőforrások nevével, például jelszavakkal, fájlokkal vagy URL-címekkel hasonlítja össze. Az alábbi példa egy ilyen forgatókönyvet mutat be. A kód célja, hogy letiltsa a hozzáférést minden olyan erőforráshoz, amelynek URL-címe előtaggal rendelkezik FILE://. A reguláris kifejezés kis- és nagybetűket nem érzékelyítő egyezést kísérel meg a sztringgel a reguláris kifejezés $FILE://használatával. Ha azonban a jelenlegi rendszerkultúra tr-TR (Turkish-Türkiye), az "I" nem az "i" nagybetűs megfelelője. Ennek eredményeképpen a Regex.IsMatch metódus hívása visszatér false, és a fájlhoz való hozzáférés engedélyezett.
CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");
string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";
Console.WriteLine("Culture-sensitive matching ({0} culture)...",
Thread.CurrentThread.CurrentCulture.Name);
if (Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase))
Console.WriteLine("URLs that access files are not allowed.");
else
Console.WriteLine("Access to {0} is allowed.", input);
Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
// Culture-sensitive matching (tr-TR culture)...
// Access to file://c:/Documents.MyReport.doc is allowed.
Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")
Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"
Console.WriteLine("Culture-sensitive matching ({0} culture)...",
Thread.CurrentThread.CurrentCulture.Name)
If Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase) Then
Console.WriteLine("URLs that access files are not allowed.")
Else
Console.WriteLine("Access to {0} is allowed.", input)
End If
Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
' Culture-sensitive matching (tr-TR culture)...
' Access to file://c:/Documents.MyReport.doc is allowed.
Feljegyzés
A kis- és nagybetűk megkülönböztetésével és az invariáns kultúrát használó sztring-összehasonlításokkal kapcsolatos további információkért tekintse meg a sztringek használatának ajánlott eljárásait.
A jelenlegi kultúra kis- és nagybetűs összehasonlítása helyett megadhatja a RegexOptions.CultureInvariant nyelvi különbségek figyelmen kívül hagyását és az invariáns kultúra konvenciók használatát.
Feljegyzés
Az invariáns kultúra összehasonlítása csak az osztálykonstruktor vagy a options statikus mintaegyeztetési RegexOptions.CultureInvariant módszer paraméterének Regex megadásával érhető el. Beágyazott beállításként nem érhető el.
Az alábbi példa megegyezik az előző példával, azzal a kivétellel, hogy a statikus Regex.IsMatch(String, String, RegexOptions) metódust olyan beállításokkal hívja meg, amelyek tartalmazzák a következőket RegexOptions.CultureInvariant: . Még akkor is, ha a jelenlegi kultúra török (Türkiye) értékre van állítva, a reguláris kifejezésmotor sikeresen megfelel a "FILE" és a "file" értéknek, és letiltja a fájlerőforráshoz való hozzáférést.
CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");
string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";
Console.WriteLine("Culture-insensitive matching...");
if (Regex.IsMatch(input, pattern,
RegexOptions.IgnoreCase | RegexOptions.CultureInvariant))
Console.WriteLine("URLs that access files are not allowed.");
else
Console.WriteLine("Access to {0} is allowed.", input);
Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
// Culture-insensitive matching...
// URLs that access files are not allowed.
Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")
Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"
Console.WriteLine("Culture-insensitive matching...")
If Regex.IsMatch(input, pattern,
RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant) Then
Console.WriteLine("URLs that access files are not allowed.")
Else
Console.WriteLine("Access to {0} is allowed.", input)
End If
Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
' Culture-insensitive matching...
' URLs that access files are not allowed.
Visszalépési mód
Alapértelmezés szerint. A NET regex motorja visszakövetést használ a minta egyezések kereséséhez. A visszakövetési motor egy olyan motor, amely megpróbál megegyezni egy mintával, és ha ez nem sikerül, visszalép, és megpróbál megegyezni egy másik mintával, és így tovább. A visszakövetési motor nagyon gyors a tipikus esetekhez, de lelassul a minta váltakozásainak számának növekedésével, ami katasztrofális visszakövetéshez vezethet. A RegexOptions.NonBacktracking .NET 7-ben bevezetett lehetőség nem használ visszakövetést, és elkerüli ezt a legrosszabb esetet. Célja, hogy következetesen jó viselkedést biztosítson, függetlenül a keresett bemenettől.
Ez RegexOptions.NonBacktracking a lehetőség nem támogat mindent, amit a többi beépített motor támogat. A beállítás nem használható például a következővel RegexOptions.RightToLeft együtt: vagy RegexOptions.ECMAScript. Nem engedélyezi a következő szerkezeteket a mintában:
- Atomi csoportok
- Háttérrendszerek
- Csoportok kiegyensúlyozása
- Feltételesek
- Megkerülő megoldások
- Horgonyok indítása (
\G)
RegexOptions.NonBacktracking a végrehajtás tekintetében is van egy apró különbség. Ha egy rögzítési csoport hurokban van, a legtöbb (non-.NET) regex motor csak az utolsó egyeztetett értéket adja meg a rögzítéshez. Azonban. A NET regex motorja nyomon követi a hurokban rögzített összes értéket, és hozzáférést biztosít azokhoz. Ez RegexOptions.NonBacktracking a lehetőség a legtöbb regex-implementációhoz hasonlóan csak a végleges rögzítést támogatja.
A visszakövetéssel kapcsolatos további információkért lásd : Visszakövetés reguláris kifejezésekben.
Lásd még
Visszajelzés
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ: https://aka.ms/ContentUserFeedback.
Visszajelzés küldése és megtekintése a következőhöz: