Možnosti regulárních výrazů
Ve výchozím případě bere porovnání vstupního řetězce s jakýmikoli literálními znaky ve vzorku regulárního výrazu ohled na malá a velká písmena. Prázdný znak ve vzorku regulárního výrazu je interpretován jako literální znak prázdného místa. Zachytávající skupiny jsou pojmenovány implicitně a také explicitně. Je možné změnit tyto a několik jiných aspektů výchozího chování regulárních výrazů zadáním možností regulárních výrazů. Tyto možnosti, které jsou uvedeny v následující tabulce, mohou být zahrnuty vložené jako součást vzorku regulárního výrazu nebo mohou být poskytnuty konstruktoru třídy System.Text.RegularExpressions.Regex nebo statické metodě porovnávání vzorků jako hodnota výčtu System.Text.RegularExpressions.RegexOptions.
Člen RegexOptions |
Vložený znak |
Účinek |
|---|---|---|
Není k dispozici |
Použije výchozí chování. Další informace naleznete v tématu Výchozí možnosti. |
|
i |
Použije porovnávání, které nebere ohled na velká a malá písmena. Další informace naleznete v tématu Porovnávání bez ohledu na velká a malá písmena. |
|
m |
Použije víceřádkový režim, kde ^ a $ odpovídají začátku a konci každého řádku (místo začátku a konce vstupního řetězce). Další informace naleznete v tématu Víceřádkový mód. |
|
s |
Použije jednořádkový mód, kde tečka (.) odpovídá každému znaku (namísto každého znaku s výjimkou \n). Další informace naleznete v tématu Jednořákový režim. |
|
n |
Nezachytí nepojmenované skupiny. Jediné platné zachycení jsou explicitně pojmenované nebo číslované skupiny formuláře (?<name> subexpression). Další informace naleznete v tématu Pouze explicitní zachycení. |
|
Není k dispozici |
Kompiluje regulární výraz do sestavení. Další informace naleznete v tématu Kompilované regulární výrazy. |
|
x |
Vyloučí prázdné znaky bez řídících znaků ze vzorku a povolí komentáře po znaku (#). Další informace naleznete v tématu Ignorování prázdných znaků. |
|
Není k dispozici |
Změní směr hledání. Vyhledávání se přesunuje zprava doleva namísto zleva doprava. Další informace naleznete v tématu Režim zprava doleva. |
|
Není k dispozici |
Povolí pro výraz chování standardu ECMAScript. Další informace naleznete v tématu Chování odpovídající ECMAScript. |
|
Není k dispozici |
Ignoruje kulturní rozdíly v jazyce. Další informace naleznete v tématu Porovnání s použitím invariantní jazykové verze. |
Určení možnosti
Můžete určit možnosti pro regulární výrazy jedním ze tří způsobů:
V parametru options konstruktoru třídy System.Text.RegularExpressions.Regex nebo statické (Shared v jazyce Visual Basic) metody pro porovnávání vzorků, jako jsou například Regex.Regex(String, RegexOptions) nebo Regex.Match(String, String, RegexOptions). Parametr options je bitová kombinace OR výčtových hodnot System.Text.RegularExpressions.RegexOptions.
Následující příklad uvádí ukázku. Používá parametr options metody Regex.Match(String, String, RegexOptions) pro povolení porovnávání bez rozlišování velkých a malých písmen a ignorování vzorků prázdných znaků při identifikaci slov začínajících na písmeno d.
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.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.Použitím vložené možnosti ve vzorku regulárního výrazu se syntaxí (?imnsx-imnsx). Možnost se vztahuje na vzorek od bodu, kdy je možnost definována buď do konce vzorku nebo do bodu, kdy je možnost zrušena definicí jiné vložené možnosti. Další informace získáte v tématu Rozdílné konstrukce.
Následující příklad uvádí ukázku. Používá vložené možnosti pro povolení porovnávání bez ohledu na velikost písmen a pro ignorování vzorků prázdných znaků při identifikaci slov začínajících na písmeno d.
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.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.Použitím vložených možností v konkrétní konstrukci skupiny ve vzorku regulárního výrazu se syntaxí (?imnsx-imnsx:subexpression). Žádné znaménko před sadou možností zapne sadu; znaménko minus před sadou možností sadu vypne. (? je pevnou součástí konstrukce jazyka syntaxi, která je požadována, zda jsou povoleny možnosti nebo zakázáno.) Možnost se vztahuje pouze na tuto skupinu. Další informace naleznete v tématu Seskupovací konstrukce.
Následující příklad uvádí ukázku. Použije vložené možnosti v konstrukci seskupení pro povolení porovnávání bez rozlišování velkých a malých písmen a pro ignorování prázdných znaků při identifikaci slov začínajících na písmeno d.
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.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.
Pokud jsou možnosti zadány jako vložené, symbol mínus (-) před možností nebo sadou možností vypne tyto možnosti. Například vložená konstrukce (?ix-ms) zapne možnosti RegexOptions.IgnoreCase a RegexOptions.IgnorePatternWhitespace a vypne možnosti RegexOptions.Multiline a RegexOptions.Singleline. Všechny možnosti regulárních výrazů jsou ve výchozím nastavení vypnuty.
.gif "Poznámka") Poznámka |
|---|
Jestliže jsou možnosti regulárních výrazů zadané v parametru options konstruktoru nebo volání metody v konfliktu s vloženými možnostmi ve vzorku regulárního výrazu, jsou použity vložené možnosti. |
Následujících pět možností regulárních výrazů lze nastavit jak pomocí parametru, tak s pomocí vložených možností:
Následujících pět možností regulárních výrazu lze nastavit pomocí parametru options, ale nelze je nastavit pomocí vložených možností:
Určení nastavení
Můžete určit, které možnosti byly poskytnuty objektu Regex, když byla vytvořena jeho instance načtením hodnoty vlastnosti jen pro čtení Regex.Options. Tato vlastnost je zvláště užitečná pro určení možností, které jsou definovány pro kompilované regulární výrazy vytvořené metodou Regex.CompileToAssembly.
Chcete-li testovat přítomnost jakýchkoli možností kromě RegexOptions.None, proveďte operaci AND s hodnotou vlastnosti Regex.Options a hodnotou RegexOptions, o kterou se zajímáte. Poté testujte, zda se výsledek rovná hodnotě RegexOptions. Následující příklad testuje, zda byla nastavena možnost RegexOptions.IgnoreCase.
If (rgx.Options And RegexOptions.IgnoreCase) = RegexOptions.IgnoreCase Then
Console.WriteLine("Case-insensitive pattern comparison.")
Else
Console.WriteLine("Case-sensitive pattern comparison.")
End If
if ((rgx.Options & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase)
Console.WriteLine("Case-insensitive pattern comparison.");
else
Console.WriteLine("Case-sensitive pattern comparison.");
Pro testování RegexOptions.None, zjistěte, zda se hodnota vlastnosti Regex.Options rovná RegexOptions.None, jak ukazuje následující příklad.
If rgx.Options = RegexOptions.None Then
Console.WriteLine("No options have been set.")
End If
if (rgx.Options == RegexOptions.None)
Console.WriteLine("No options have been set.");
V následujících oddílech jsou uvedeny možnosti podporované regulárními výrazy v rozhraní .NET Framework.
Výchozí možnosti
Možnost RegexOptions.None označuje, že nebyly zadány žádné možnosti a že modul regulárních výrazů používá jeho výchozí chování. To zahrnuje následující:
Vzorek je interpretován jako kanonický spíše než regulární výraz ECMAScript.
Vzorek regulárního výrazu je porovnán se vstupním řetězcem zleva doprava.
Porovnávání rozlišuje malá a velká písmena.
Prvky jazyka ^ a $ odpovídají začátku a konci vstupního řetězce.
Prvek jazyka . odpovídá každému znaku s výjimkou \n.
Jakékoli prázdné znaky ve vzorku regulárního výrazu jsou interpretovány jako literální znaky mezery.
Konvence aktuální jazykové verze se používají v případě, že se porovnává vzorek se vstupním řetězcem.
Zachycující skupiny ve vzorku regulárních výrazů jsou implicitní i explicitní.
| Poznámka |
|---|
Možnost RegexOptions.None nemá žádný vložený ekvivalent. Když jsou možnosti regulárních výrazů uplatňovány jako vložené, je obnoveno výchozí chování na základě option-by-option vypnutím určité možnosti.Například (?i) zapne porovnávání bez rozlišení velkých a malých písmen, a (?-i) obnoví výchozí porovnávání s rozlišováním velkých a malých písmen. |
Protože možnost RegexOptions.None představuje výchozí chování modulu regulárních výrazů, je zřídka explicitně zadána ve volání metody. Konstruktor nebo statická metoda porovnávání vzorků bez parametru options je použita místo ní.
Zpět na začátek
Porovnávání, které bere ohled na velká a malá písmena
Možnost IgnoreCase nebo vložená možnost i, poskytuje porovnávání, které nebere ohled na velká a malá písmena. Ve výchozím nastavení se používají konvence pro změnu velikosti písmen podle aktuální jazykové verze.
Následující příklad definuje vzorek regulárního výrazu \bthe\w*\b, který odpovídá všem slovům začínajícím na the. Protože první volání metody Match používá výchozí porovnání s rozlišováním velkých a malých písmen, výstup označuje, že řetězec The, kterým začíná věta se neshoduje. Shoduje se, když je metoda Match je volána s možnostmi nastavenými na IgnoreCase.
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.
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.
Následující příklad upravuje vzorek regulárního výrazu z předchozího příkladu pro použití vložených možnosti místo parametru options pro poskytnutí porovnávání bez rozlišování velkých a malých písmen. První vzorek definuje možnost pro nerozlišování velkých a malých písmen v seskupující konstrukci, která se týká pouze písmena t v řetězci the. Protože se konstrukce možnosti vyskytuje na začátku vzorku, druhý vzorek použije možnost pro nerozlišování velkých a malých písmen na celý regulární výraz.
Imports System.Text.RegularExpressions
Module Example
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.
using System;
using System.Text.RegularExpressions;
public class Example
{
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.
Zpět na začátek
Víceřádkový režim.
Možnost RegexOptions.Multiline nebo vložená možnost m, umožňuje modulu regulárních výrazů zpracovat vstupní řetězec, který se skládá z více řádků. Změní výklad jazykových prvků ^ a $ tak, aby odpovídaly začátku a konci řádku, místo začátku a konce vstupního řetězce.
Ve výchozím nastavení $ odpovídá pouze konci vstupního řetězce. Pokud zadáte možnost RegexOptions.Multiline, odpovídá buď znaku nového řádku \n nebo konci vstupního řetězce. Avšak neodpovídá kombinaci znaků pro návrat na začátek řádku a nového řádku. Chcete-li je úspěšně porovnávat, použijte dílčí výraz \r?$ namísto pouze $.
Následující příklad extrahuje jména a skóre nadhazovačů a přidá je do kolekce SortedList<TKey, TValue>, která je seřadí v sestupném pořadí. Metoda Matches je volána dvakrát. V prvním volání metody je regulární výraz ^(\w+)\s(\d+)$ a nejsou nastaveny žádné možnosti. Jak ukazuje výstup, vzhledem k tomu, že modul regulárních výrazů nemůže porovnat vstupní vzorek spolu s začátkem a koncem vstupního řetězce, nejsou nalezeny žádné shody. Ve druhém volání metody, regulární výraz je změněn na ^(\w+)\s(\d+)\r?$ a možnosti jsou nastaveny na RegexOptions.Multiline. Jak ukazuje výstup, jména a hodnoty skóre jsou úspěšně porovnány a skóre jsou zobrazeny v sestupném pořadí.
Imports System.Collections.Generic
Imports System.Text.RegularExpressions
Module Example
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 = "^(\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 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:
' Without Multiline option:
' No matches.
'
' With multiline option:
' Allison: 211
' Sam: 208
' Gwen: 171
' Joe: 164
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
public class Example
{
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 = @"^(\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 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:
// Without Multiline option:
// No matches.
//
// With multiline option:
// Allison: 211
// Sam: 208
// Gwen: 171
// Joe: 164
Vzorce regulárního výrazu ^(\w+)\s(\d+)\r*$ je definován podle následující tabulky.
Maska |
Popis |
|---|---|
^ |
Začíná na začátku řádku. |
(\w+) |
Porovná jeden nebo více slovních znaků. Toto je první zachytávající skupina. |
\s |
Porovnává prázdný znak. |
(\d+) |
Porovná jednu nebo více desítkových číslic. Toto je druhá zachytávající skupina. |
\r? |
Porovná nula nebo jeden znak pro návrat na začátek řádku. |
$ |
Skončí na konci řádku. |
Následující příklad je ekvivalentní předchozímu, s tím rozdílem, že používá vloženou možnost (?m) pro nastavení víceřádkové možnosti.
Imports System.Collections.Generic
Imports System.Text.RegularExpressions
Module Example
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
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
public class Example
{
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
Zpět na začátek
Jednořádkový režim
Možnost RegexOptions.Singleline nebo vložená možnost s způsobí, že modul regulárních výrazů zachází se vstupním řetězcem, jako by se skládal z jednoho řádku. Dosahuje toho změnou chování jazykového prvku tečka (.) tak, že odpovídá každému znaku, namísto toho, že odpovídá každému znaku s výjimkou znaku nového řádku \n nebo \u000A.
Následující příklad ukazuje, jak se chování jazykového prvku . změní, když použijete možnost RegexOptions.Singleline. Regulární výraz ^.+ začíná na začátku řetězce a porovnává s každým znakem. Standardně je porovnávání ukončeno na konci prvního řádku. Vzorek regulárního výrazu porovnává znak pro návrat na začátek řádku, \r nebo \u000D, ale ten neodpovídá \n. Protože možnost RegexOptions.Singleline interpretuje celý vstupní řetězec jako jediný řádek, porovnává každý znak ve vstupním řetězci včetně \n.
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\.
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\.
Následující příklad je ekvivalentní předchozímu, s tím rozdílem, že používá vloženou možnost (?s) pro nastavení jednořádkového režimu.
Imports System.Text.RegularExpressions
Module Example
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\.
using System;
using System.Text.RegularExpressions;
public class Example
{
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\.
Zpět na začátek
Pouze explicitní zachycení
Ve výchozím nastavení jsou zachycující skupiny definovány pomocí závorek ve vzorku regulárního výrazu. Pojmenovaným skupinám jsou přiřazovány názvy nebo čísla podle možnosti jazyka (?<name> subexpression). Nepojmenované skupiny jsou přístupné pomocí indexů. V objektu GroupCollection nepojmenované skupiny předcházejí pojmenované skupiny.
Konstrukce seskupení jsou často používány pouze k aplikaci kvantifikátorů pro násobení prvků jazyka a zachycené podřetězce nejsou podstatné. Například pokud následující regulární výraz:
\b\(?((\w+),?\s?)+[\.!?]\)?
je určen pouze k extrahování vět, které končí tečkou, vykřičníkem nebo otazníkem z dokumentu, pouze výsledná věta (která je reprezentována objektem Match) je podstatná. Jednotlivá slova nejsou v kolekci.
Zachycující skupiny, které se nepoužívají následně, mohou být nákladné, protože modul regulárních výrazů musí naplnit obě kolekce objektů GroupCollection a CaptureCollection. Alternativně můžete použít buď možnost RegexOptions.ExplicitCapture nebo vloženou možnost n pro nastavení, aby byly pouze platná zachycení explicitně pojmenovanými nebo číslovanými skupinami, které jsou označeny konstrukcí (?<name> subexpression).
V následujícím příkladu zobrazí informace o shod vrácené \b\(?((\w+),?\s?)+[\.!?]\)? vzorek regulárního výrazu, kdy Match Metoda je volána s a bez RegexOptions.ExplicitCapture možnost. Jak ukazuje výstup z prvního volání metody, modul regulárních výrazů plně naplní objekty kolekce GroupCollection and CaptureCollection informacemi o zachycených podřetězcích. Protože je druhá metoda volána s options nastaveným na RegexOptions.ExplicitCapture, nezachycuje informace o skupinách.
Imports System.Text.RegularExpressions
Module Example
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.
using System;
using System.Text.RegularExpressions;
public class Example
{
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.
Vzorce regulárního výrazu \b\(?((?>\w+),?\s?)+[\.!?]\)? je definován podle následující tabulky.
Maska |
Popis |
|---|---|
\b |
Začne na hranici slova. |
\(? |
Porovná nula nebo jeden výskyt levé závorky (. |
(?>\w+),? |
Porovná jeden nebo více znaků slova, následované nula nebo jednou tečkou. Zpětné není trasování při porovnávání znaků slova. |
\s? |
Porovná nula nebo jeden prázdný znak. |
((\w+),? \s?)+ |
Porovná kombinaci jednoho nebo více znaků slova, nula nebo jednu čárku a nula nebo jeden prázdný znake jednou nebo vícekrát. |
[\.!?]\)? |
Porovná jakékoli ze tří interpunkčních znamének, následované nula nebo jednou pravou závorkou ). |
Můžete také použít (?n) vložený prvek potlačit automatické otisků. Následující příklad upravuje předchozí vzorku regulárního výrazu použít (?n) vložený prvek místo RegexOptions.ExplicitCapture možnost.
Imports System.Text.RegularExpressions
Module Example
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.
using System;
using System.Text.RegularExpressions;
public class Example
{
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.
Nakonec můžete použít vložený prvek skupiny (?n:) potlačit automatické sběr dat na základě-skupina. Následující příklad upravuje předchozí vzorek potlačit nepojmenované otisků vnější skupiny ((?>\w+),?\s?). Všimněte si, že toto potlačí nepojmenované zachycení také ve vnitřních skupinách.
Imports System.Text.RegularExpressions
Module Example
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.
using System;
using System.Text.RegularExpressions;
public class Example
{
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.
Zpět na začátek
Kompilované regulární výrazy
Ve výchozím nastavení jsou regulární výrazy v rozhraní .NET Framework interpretovány. Když je vytvořena instance objektu Regex nebo je volána statická metoda Regex, vzorek regulárního výrazu je analyzován do sady vlastních operačních kódů a překladač používá tyto operační kódy ke spuštění regulárního výrazu. To vyžaduje kompromis: Náklady na inicializaci modulu regulárních výrazů jsou minimalizovány na úkor výkonu provádění.
Můžete namísto toho použít interpretované regulární výrazy použitím možnosti RegexOptions.Compiled. V tomto případě, když je vzorek předán modulu regulárních výrazů, tak je analyzován na sadu operačních kódů a poté převeden na jazyk MSIL (Microsoft Intermediate Language), který může být přímo předán modulu CLR. Kompilované regulární výrazy maximalizují výkon na úkor doby inicializace.
| Poznámka |
|---|
Regulární výraz lze kompilovat pouze zadáním hodnoty RegexOptions.Compiled parametru options konstruktoru třídy Regex nebo metodě statického porovnávání vzorků.Není k dispozici jako vložená možnost. |
Můžete použít kompilované regulární výrazy ve voláních statických i instančních regulárních výrazů. Ve statickém regulárním výrazu je možnost RegexOptions.Compiled předána parametru options metody porovnávání vzorků regulárních výrazů. V instančních regulárních výrazech je předána parametru options konstruktoru třídy Regex. V obou případech je výsledkem lepší výkon.
K tomuto zlepšení výkonu však dochází pouze za následujících podmínek:
Objekt Regex představující konkrétní regulární výraz je používán ve více voláních metody porovnávání vzorků regulárních výrazů.
Objektu Regex není povoleno přejít mimo rozsah, tak aby jej bylo možno znovu použít.
Statický regulární výraz je používán ve více voláních metody porovnávání vzorků regulárních výrazů. (Zlepšení výkonu je možné, protože regulární výrazy použité ve volání statické metody jsou ukládány do mezipaměti modulem regulárních výrazů.)
| Poznámka |
|---|
Možnost RegexOptions.Compiled je nezávislá na metodě Regex.CompileToAssembly, která vytvoří sestavení se speciálním učelem, které obsahuje předdefinované kompilované regulární výrazy. |
Zpět na začátek
Ignorování prázdných znaků
Ve výchozím nastavení jsou prázdné znaky ve vzorcích regulárních výrazů významné. Nutí modul regulárních výrazů, aby porovnával prázdné znaky ve vstupním řetězci. Z toho důvodu regulární výrazy \b\w+\s a \b\w+ jsou zhruba ekvivalentní. Kromě toho v případě, že se narazí ve vzorku regulárního výrazu na znak křížku #, je interpretován jako literální znak pro porovnání.
Možnost RegexOptions.IgnorePatternWhitespace nebo vložená možnost x, změní toto výchozí chování následujícím způsobem:
Prázdný znak bez řídícího znaku ve vzorku regulárního výrazu je ignorován. Aby byly prázdné znaky součástí vzorku regulárního výrazu, musí být uvozeny řídícími znaky (například jako \s nebo \ ).
.gif "Důležitá poznámka")
DůležitéPrázdné znaky v rámci třídy znaků jsou interpretovány literálně bez ohledu na používání možnosti RegexOptions.IgnorePatternWhitespace. Například vzorek regulárního výrazu [ .,;:] odpovídá jakémukoli jednomu prázdnému znaku, tečce, čárce, středníku nebo dvojtečce.
Znak křížku # je interpretován jako začátek komentáře, nikoli jako literální znak. Veškerý text ve vzorku regulárního výrazu od znaku # na konec řetězce je interpretován jako komentář.
Povolení této možnosti pomáhá zjednodušit regulární výrazy, které je často obtížné analyzovat a pochopit. Zlepšují čitelnost a umožňují dokumentovat regulární výrazy.
Následující příklad definuje následující vzorek regulárního výrazu:
\b \(? ( (?>\w+) ,? \s? )+ [\.!?] \)? # Matches an entire sentence.
Tento vzorek je podobný vzorku definovaném v oddílu Pouze explicitní zachycení s výjimkou, že používá možnost RegexOptions.IgnorePatternWhitespace, pro ignorování prázdných znaků.
Imports System.Text.RegularExpressions
Module Example
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.
using System;
using System.Text.RegularExpressions;
public class Example
{
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?)+[\.!?]\)?";
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.
Následující příklad používá vloženou možnost (?x) pro ignorování prázdných znaků.
Imports System.Text.RegularExpressions
Module Example
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.
using System;
using System.Text.RegularExpressions;
public class Example
{
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.
Zpět na začátek
Režim zprava doleva
Ve výchozím nastavení modul regulárních výrazů vyhledává zleva doprava. Můžete obrátit směr vyhledávání použitím možnosti RegexOptions.RightToLeft. Vyhledávání automaticky začne na pozicí posledního znaku řetězce. Pro metody porovnávání vzorků, které obsahují parametr počáteční pozice, jako například Regex.Match(String, Int32), je počáteční pozice indexem znaku zcela vpravo, na které má vyhledávání začít.
| Poznámka |
|---|
Režim vzorku zprava doleva je k dispozici pouze zadáním hodnoty RegexOptions.RightToLeft parametru options konstruktoru třídy Regex nebo statické metodě porovnávání vzorků. Není k dispozici jako vložená možnost. |
Možnost RegexOptions.RightToLeft změní pouze směr vyhledávání. Nezpůsobí interpretování vzorku regulárního výrazu zprava doleva. Například regulární výraz \bb\w+\s odpovídá slovům, která začínají písmenem b a jsou následovana prázdným znakem. V následujícím příkladu se vstupní řetězec skládá ze tří slov, která obsahují jeden nebo více znaků b. První slovo začíná písmenem b, druhé končí b a třetí obsahuje dva znaky b uprostřed slova. Jak ukazuje výstup z příkladu, pouze první slovo odpovídá vzorku regulárního výrazu.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\bb\w+\s"
Dim input As String = "builder rob rabble"
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:
' 'builder ' found at position 0.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\bb\w+\s";
string input = "builder rob rabble";
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:
// 'builder ' found at position 0.
Všimněte si také, že dopředné vyhledávání (prvek jazyka (?=subexpression)) a zpětné vyhledávání (prvek jazyka (?<=subexpression)) nemění směr. Dopředné vyhledávání hledá zprava. Zpětné vyhledávání hledá zleva. Například regulární výraz (?<=\d{1,2}\s)\w+,*\s\d{4} používá zpětné hledání pro testování data, které předchází název měsíce. Regulární výraz poté porovnává měsíc a rok. Informace o dopředných a zpětných hledáních naleznete v tématu Seskupovací konstrukce.
Imports System.Text.RegularExpressions
Module Example
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.
using System;
using System.Text.RegularExpressions;
public class Example
{
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.
Vzorek regulárního výrazu je definován tak, jak je uvedeno v následující tabulce.
Maska |
Popis |
|---|---|
(?<=\d{1,2}\s) |
Začátek porovnávání musí být předcházen jednou nebo dvěma desítkovými číslicemi následované mezerou. |
\w+ |
Porovná jeden nebo více slovních znaků. |
,* |
Porovná nula nebo jeden znak čárky. |
\s |
Porovná prázdný znak. |
\d{4} |
Porovná čtyři desítkové číslice. |
Zpět na začátek
Chování porovnávání ECMAScript
Ve výchozím nastavením modul regulárních výrazů používá kanonické chování při porovnávání vzorku regulárního výrazu se vstupním textem. Můžete však určit, aby modul regulárních výrazů používal chování porovnávání ECMAScript zadáním možnosti RegexOptions.ECMAScript.
| Poznámka |
|---|
Chování ECMAScript je k dispozici pouze prostřednictvím zadání hodnoty RegexOptions.ECMAScript parametru options konstruktoru třídy Regex nebo statické metodě porovnávání vzorků. Není k dispozici jako vložená možnost. |
Parametr RegexOptions.ECMAScript lze kombinovat jen s možnostmi RegexOptions.IgnoreCase a RegexOptions.Multiline. Použití jakékoli jiné možnosti v regulárním výrazu způsobí ArgumentOutOfRangeException.
Chování ECMAScript a kanonické regulární výrazy se liší ve třech oblastech: syntaxe třídy znaků, zachycující skupiny odkazující samy na sebe a interpretace osmičková versus intepretace prostřednictvím zpětných odkazů.
Syntaxe třídy znaků. Vzhledem k tomu, že kanonické regulární výrazy podporují Unicode, zatímco ECMAScript jej nepodporuje, třídy znaků v ECMAScript mají omezenější syntaxi a některé jazykové prvky třídy znaků mají různý význam. Například ECMAScript nepodporuje jazykové prvky, jako je například kategorie Unicode nebo blok prvků \p a \P. Podobně jazykový prvek \w, který odpovídá znaku slova, je ekvivalentní třídě znaků [a-zA-Z_0-9] při použití ECMAScript a [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] při použití kanonického chování. Další informace naleznete v tématu Třídy znaků.
Následující příklad ukazuje rozdíl mezi kanonickým a ECMAScript porovnáváním vzorků. Definuje regulární výraz \b(\w+\s*)+, který odpovídá slovům, následovaným prázdnými znaky. Vstupní řetězec se skládá ze dvou řetězců, jeden používá sadu znaků Latinky, druhý používá znakovou sadu Cyrilice. Jak ukazuje výstup, volání metody Regex.IsMatch(String, String, RegexOptions), které používá porovnávání ECMAScript selže při porovnávání slov ve znakové sadě Cyrilice, zatímco, volání metody, které používá kanonické porovnávání vyhodnotí tuto shodu úspěšně.
Imports System.Text.RegularExpressions Module Example 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) 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) 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.using System; using System.Text.RegularExpressions; public class Example { 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.Zachytávající skupiny odkazující samy na sebe. Třída zachycení regulárních výrazů se zpětným odkazem na sama sebe musí být aktualizována při každé iteraci zachycení. Jak ukazuje následující příklad, tato funkce umožňuje regulárnímu výrazu ((a+)(\1) ?)+ porovnávat vstupní řetězec " aa aaaa aaaaaa " s použitím ECMAScript, ale ne v případě, že se používá kanonické porovnávání.
Regulární výraz je definován tak, jak je uvedeno v následující tabulce.
Maska
Popis
(a+)
Porovná písmeno a jednou nebo vícekrát. Toto je druhá zachytávající skupina.
(\1)
Porovná podřetězec zachycený první zachycující skupinou. Toto je třetí zachytávající skupina.
?
Porovná nula nebo jeden znak mezery.
((a+)(\1) ?)+
Porovná vzorek jednoho nebo více znaků a, za nimiž následuje řetězec, který odpovídá zachycující skupině následované nula nebo jedním znakem mezery jednou nebo vícekrát. Toto je první zachytávající skupina.
Rozlišení nejasnosti mezi osmičkovými řídícími znaky a zpětnými odkazy. Následující tabulka shrnuje rozdíly v intepretaci osmičkové a zpětných odkazů podle regulárních výrazů v kanonické a ECMAScript formě.
Regulární výraz
Kanonické chování
Chování ECMAScript
\0 následované 0 až 2 osmičkovými číslicemi
Interpretováno jako osmičkové. Například \044 je vždy interpretováno jako osmičková hodnota a znamená $.
Stejné chování.
\ následované číslicí od 1 do 9, následované bez dalších desítkových číslic,
Interpretováno jako zpětný odkaz. Například \9 vždy znamená zpětný odkaz na 9, i když devátá zachycující skupina neexistuje. Pokud zachycující skupina neexistuje, vyvolá analyzátor regulárních výrazů ArgumentException.
Pokud existuje zachycující skupina pro jednociferné desítkové číslo, jedná se o zpětný odkaz na tuto číslici. V jiném případě interpretujte hodnotu jako literální.
\ následované číslicí od 1 do 9, následované bez dalších desítkových číslic,
Interpretuje číslice, jako desítkovou hodnotu. Pokud existuje zachycující skupina, interpretuje výraz jako zpětný odkaz.
V jiném případě interpretuje počáteční osmičkové číslice až do osmičkové hodnoty 377. To znamená, že záleží pouze na 8 bitech s nižší hodnotou. Interpretuje zbývající číslice jako literální. Například ve výrazu \3000, pokud existuje zachycující skupina 300, je interpretována jako zpětný odkaz 300, pokud zachycující skupina 300 neexistuje, je interpretována jako osmičková hodnota 300 následována 0.
Interpretována jako zpětný odkaz převedením tolika číslic, kolik je možné na desítkovou hodnotu, která může odkazovat zachycení. Pokud nemohou být převedeny žádné číslice, interpretujte jako osmičkovou hodnotu pomocí počáteční osmičkové hodnoty 377. Zbývající číslice interpretujte jako literální.
Zpět na začátek
Porovnávání s použitím invariantní jazykové verze
Ve výchozím nastavení, když modul regulárních výrazů provádí porovnávání bez rozlišení velkých a malých písmen, používá konvence pro převod velikosti písmen aktuální jazykové verze k určení ekvivalentních znaků velkých a malých písmen.
Toto chování je však nežádoucí u některých typů porovnávání, zejména při porovnání vstupu uživatele s názvy systémových prostředků, jako například hesla, soubory nebo adresy URL. Následující příklad ukazuje takovýto scénář. Kód je určen k blokování přístupu k jakémukoli prostředku, jehož adresa URL začíná FILE://. Regulární výraz zkusí porovnávání bez ohledu na velikost písmen s řetězcem s použitím regulárního výrazu $FILE://. Avšak pokud je aktuální jazyková verze systému tr-TR (Turkish-Turkey), tak znak I není velkým ekvivalentem znaku i. Ve výsledku tedy volání metody Regex.IsMatch vrátí false, a přístup k souboru je povolen.
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.
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.
| Poznámka |
|---|
Další informace o porovnávání řetězců, které rozlišují a které používají výchozí kultury Doporučené postupy pro použití řetězců v rozhraní .NET Framework. |
Namísto použití porovnávání bez ohledu na velká a malá písmena aktuální jazykové verze, můžete určit možnost RegexOptions.CultureInvariant, chcete-li ignorovat rozdíly jazykové verze v jazyce a použít konvence pro invariantní jazykovou verzi.
| Poznámka |
|---|
Porovnávání pomocí invariantní jazykové verze je k dispozici pouze prostřednictvím zadání hodnoty RegexOptions.CultureInvariant parametru options konstruktoru třídy Regex nebo statické metodě porovnávání vzoreků.Není k dispozici jako vložená možnost. |
Následující příklad je stejný jako předchozí příklad s výjimkou, že statická metoda Regex.IsMatch(String, String, RegexOptions) je volána s možností, která zahrnuje RegexOptions.CultureInvariant. I když je nastaven aktuální prostředí turečtina (Turecko), motor regulární výraz je schopen úspěšně odpovídají "Soubor" a "soubor" a blokovat přístup k prostředku souboru.
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.
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.
Zpět na začátek