Regex.Match Metoda
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Vyhledá vstupní řetězec pro podřetězce, který odpovídá vzoru regulárního výrazu, a vrátí první výskyt jako jeden Match objekt.
Přetížení
Match(String, String, RegexOptions) |
Vyhledá ve vstupním řetězci první výskyt zadaného regulárního výrazu pomocí zadaných odpovídajících možností. |
Match(String) |
Vyhledá v zadaném vstupním řetězci první výskyt regulárního výrazu zadaného v konstruktoru Regex . |
Match(String, Int32) |
Vyhledá ve vstupním řetězci první výskyt regulárního výrazu počínaje zadanou počáteční pozicí v řetězci. |
Match(String, String) |
Vyhledá v zadaném vstupním řetězci první výskyt zadaného regulárního výrazu. |
Match(String, Int32, Int32) |
Vyhledá ve vstupním řetězci první výskyt regulárního výrazu, počínaje zadanou počáteční pozicí a vyhledáváním pouze zadaného počtu znaků. |
Match(String, String, RegexOptions, TimeSpan) |
Vyhledá ve vstupním řetězci první výskyt zadaného regulárního výrazu pomocí zadaných odpovídajících možností a intervalu časového limitu. |
Match(String, String, RegexOptions)
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
Vyhledá ve vstupním řetězci první výskyt zadaného regulárního výrazu pomocí zadaných odpovídajících možností.
public:
static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);
static member Match : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Match
Public Shared Function Match (input As String, pattern As String, options As RegexOptions) As Match
Parametry
- input
- String
Řetězec, který hledá shodu.
- pattern
- String
Vzor regulárního výrazu, který se má shodovat.
- options
- RegexOptions
Bitové kombinace hodnot výčtu, které poskytují možnosti pro porovnávání.
Návraty
Objekt, který obsahuje informace o shodě.
Výjimky
Při analýze regulárního výrazu došlo k chybě.
input
nebo pattern
je null
.
options
není platná bitové kombinace RegexOptions hodnot.
Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.
Příklady
Následující příklad definuje regulární výraz, který porovnává slova začínající písmenem "a". Pomocí RegexOptions.IgnoreCase možnosti zajistí, že regulární výraz vyhledá slova začínající velkými písmeny "a" i malými písmeny "a".
using System;
using System.Text.RegularExpressions;
namespace Examples
{
public class Example2
{
public static void Main()
{
string pattern = @"\ba\w*\b";
string input = "An extraordinary day dawns with each new day.";
Match m = Regex.Match(input, pattern, RegexOptions.IgnoreCase);
if (m.Success)
Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index);
}
}
}
// The example displays the following output:
// Found 'An' at position 0.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\ba\w*\b"
Dim input As String = "An extraordinary day dawns with each new day."
Dim m As Match = Regex.Match(input, pattern, RegexOptions.IgnoreCase)
If m.Success Then
Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index)
End If
End Sub
End Module
' The example displays the following output:
' Found 'An' at position 0.
Vzor \ba\w*\b
regulárního výrazu je interpretován tak, jak je znázorněno v následující tabulce.
Vzor | Description |
---|---|
\b |
Začne porovnání na hranici slova. |
a |
Porovná znak "a". |
\w* |
Porovná žádný, jeden nebo více znaků slova. |
\b |
Ukončí porovnání na hranici slova. |
Poznámky
Metoda Match(String, String, RegexOptions) vrátí první podřetězce, který odpovídá vzoru regulárního výrazu ve vstupním řetězci. Informace o elementech jazyka použitých k vytvoření vzoru regulárního výrazu najdete v tématu Jazyk regulárních výrazů – stručná referenční příručka.
Statická Match(String, String, RegexOptions) metoda je ekvivalentní ke konstrukci objektu Regex pomocí konstruktoru Regex(String, RegexOptions) a volání metody instance Match(String) .
Parametr pattern
se skládá z elementů jazyka regulárních výrazů, které symbolicky popisují řetězec, který se má shodovat. Další informace o regulárních výrazech najdete v tématu Regulární výrazy .NET a jazyk regulárních výrazů – stručné referenční informace.
Pokud chcete zjistit, jestli byl ve vstupním řetězci nalezen vzor regulárního výrazu, zkontrolujte hodnotu vlastnosti vráceného Match objektu Success . Pokud se najde shoda, vlastnost vráceného Match objektu Value obsahuje podřetězenku, input
která odpovídá vzoru regulárního výrazu. Pokud se nenajde žádná shoda, jeho hodnota je String.Empty.
Tato metoda vrátí první podřetěžce nalezený v input
, který odpovídá vzoru regulárního výrazu. Následné shody můžete načíst opakovaným voláním metody vráceného Match objektu NextMatch . Voláním Regex.Matches(String, String, RegexOptions) metody můžete také načíst všechny shody v jednom volání metody .
Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění odpovídající operace překročí interval časového limitu zadaného pro doménu aplikace, ve které je metoda volána. Pokud není ve vlastnostech domény aplikace definován žádný časový limit nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , nevyvolá se žádná výjimka.
Poznámky pro volající
Tato metoda vyprší časový limit po intervalu, který se rovná výchozí hodnotě časového limitu domény aplikace, ve které je volána. Pokud pro doménu aplikace nebyla definována hodnota časového limitu, použije se hodnota InfiniteMatchTimeout, která brání vypršení časového limitu metody. Doporučená statická metoda pro načtení shody vzorů je Match(String, String), která umožňuje nastavit interval časového limitu.
Viz také
Platí pro
Match(String)
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
Vyhledá v zadaném vstupním řetězci první výskyt regulárního výrazu zadaného v konstruktoru Regex .
public:
System::Text::RegularExpressions::Match ^ Match(System::String ^ input);
public System.Text.RegularExpressions.Match Match (string input);
member this.Match : string -> System.Text.RegularExpressions.Match
Public Function Match (input As String) As Match
Parametry
- input
- String
Řetězec, který hledá shodu.
Návraty
Objekt, který obsahuje informace o shodě.
Výjimky
input
je null
.
Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.
Příklady
Následující příklad najde shody vzorů regulárních výrazů v řetězci a pak vypíše odpovídající skupiny, zachycení a pozice zachycení.
#using <System.dll>
using namespace System;
using namespace System::Text::RegularExpressions;
void main()
{
String^ text = "One car red car blue car";
String^ pat = "(\\w+)\\s+(car)";
// Compile the regular expression.
Regex^ r = gcnew Regex( pat,RegexOptions::IgnoreCase );
// Match the regular expression pattern against a text string.
Match^ m = r->Match(text);
int matchCount = 0;
while ( m->Success )
{
Console::WriteLine( "Match{0}", ++matchCount );
for ( int i = 1; i <= 2; i++ )
{
Group^ g = m->Groups[ i ];
Console::WriteLine( "Group{0}='{1}'", i, g );
CaptureCollection^ cc = g->Captures;
for ( int j = 0; j < cc->Count; j++ )
{
Capture^ c = cc[ j ];
System::Console::WriteLine( "Capture{0}='{1}', Position={2}", j, c, c->Index );
}
}
m = m->NextMatch();
}
}
// This example displays the following output:
// Match1
// Group1='One'
// Capture0='One', Position=0
// Group2='car'
// Capture0='car', Position=4
// Match2
// Group1='red'
// Capture0='red', Position=8
// Group2='car'
// Capture0='car', Position=12
// Match3
// Group1='blue'
// Capture0='blue', Position=16
// Group2='car'
// Capture0='car', Position=21
using System;
using System.Text.RegularExpressions;
class Example
{
static void Main()
{
string text = "One car red car blue car";
string pat = @"(\w+)\s+(car)";
// Instantiate the regular expression object.
Regex r = new Regex(pat, RegexOptions.IgnoreCase);
// Match the regular expression pattern against a text string.
Match m = r.Match(text);
int matchCount = 0;
while (m.Success)
{
Console.WriteLine("Match"+ (++matchCount));
for (int i = 1; i <= 2; i++)
{
Group g = m.Groups[i];
Console.WriteLine("Group"+i+"='" + g + "'");
CaptureCollection cc = g.Captures;
for (int j = 0; j < cc.Count; j++)
{
Capture c = cc[j];
System.Console.WriteLine("Capture"+j+"='" + c + "', Position="+c.Index);
}
}
m = m.NextMatch();
}
}
}
// This example displays the following output:
// Match1
// Group1='One'
// Capture0='One', Position=0
// Group2='car'
// Capture0='car', Position=4
// Match2
// Group1='red'
// Capture0='red', Position=8
// Group2='car'
// Capture0='car', Position=12
// Match3
// Group1='blue'
// Capture0='blue', Position=16
// Group2='car'
// Capture0='car', Position=21
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim text As String = "One car red car blue car"
Dim pattern As String = "(\w+)\s+(car)"
' Instantiate the regular expression object.
Dim r As Regex = new Regex(pattern, RegexOptions.IgnoreCase)
' Match the regular expression pattern against a text string.
Dim m As Match = r.Match(text)
Dim matchcount as Integer = 0
Do While m.Success
matchCount += 1
Console.WriteLine("Match" & (matchCount))
Dim i As Integer
For i = 1 to 2
Dim g as Group = m.Groups(i)
Console.WriteLine("Group" & i & "='" & g.ToString() & "'")
Dim cc As CaptureCollection = g.Captures
Dim j As Integer
For j = 0 to cc.Count - 1
Dim c As Capture = cc(j)
Console.WriteLine("Capture" & j & "='" & c.ToString() _
& "', Position=" & c.Index)
Next
Next
m = m.NextMatch()
Loop
End Sub
End Module
' This example displays the following output:
' Match1
' Group1='One'
' Capture0='One', Position=0
' Group2='car'
' Capture0='car', Position=4
' Match2
' Group1='red'
' Capture0='red', Position=8
' Group2='car'
' Capture0='car', Position=12
' Match3
' Group1='blue'
' Capture0='blue', Position=16
' Group2='car'
' Capture0='car', Position=21
Vzor (\w+)\s+(car)
regulárního výrazu odpovídá výskytům slova "car" spolu se slovem, které mu předchází. Interpretuje se tak, jak je znázorněno v následující tabulce.
Vzor | Description |
---|---|
(\w+) |
Porovná jeden nebo více znaků slova. Toto je první zachytávající skupina. |
\s+ |
Porovná jeden nebo více prázdných znaků. |
(auto) | Odpovídá řetězci literálu "car". Toto je druhá zachytávající skupina. |
Poznámky
Metoda Match(String) vrátí první podřetězce, který odpovídá vzoru regulárního výrazu ve vstupním řetězci. Informace o elementech jazyka použitých k vytvoření vzoru regulárního výrazu najdete v tématu Jazyk regulárních výrazů – stručná referenční příručka.
Pokud chcete zjistit, jestli byl ve vstupním řetězci nalezen vzor regulárního výrazu, zkontrolujte hodnotu vlastnosti vráceného Match objektu Success . Pokud se najde shoda, vlastnost vráceného Match objektu Value obsahuje podřetězenku, input
která odpovídá vzoru regulárního výrazu. Pokud se nenajde žádná shoda, jeho hodnota je String.Empty.
Tato metoda vrátí první podřetěžce, input
který odpovídá vzoru regulárního výrazu. Následné shody můžete načíst opakovaným voláním metody vráceného Match objektu Match.NextMatch . Voláním Regex.Matches(String) metody můžete také načíst všechny shody v jednom volání metody .
Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění odpovídající operace překročí interval časového limitu určeného konstruktorem Regex.Regex(String, RegexOptions, TimeSpan) . Pokud nenastavíte interval časového limitu při volání konstruktoru, je vyvolána výjimka, pokud operace překročí hodnotu časového limitu stanovenou pro doménu aplikace, ve které Regex je objekt vytvořen. Pokud není ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace definován žádný časový limit nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , nevyvolá se žádná výjimka.
Viz také
Platí pro
Match(String, Int32)
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
Vyhledá ve vstupním řetězci první výskyt regulárního výrazu počínaje zadanou počáteční pozicí v řetězci.
public:
System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int startat);
public System.Text.RegularExpressions.Match Match (string input, int startat);
member this.Match : string * int -> System.Text.RegularExpressions.Match
Public Function Match (input As String, startat As Integer) As Match
Parametry
- input
- String
Řetězec, který hledá shodu.
- startat
- Int32
Pozice znaku od nuly, na které se má zahájit hledání.
Návraty
Objekt, který obsahuje informace o shodě.
Výjimky
input
je null
.
startat
je menší než nula nebo větší než délka .input
Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.
Poznámky
Další informace o tomto rozhraní API najdete v tématu Doplňkové poznámky k rozhraní API pro Regex.Match.
Viz také
Platí pro
Match(String, String)
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
Vyhledá zadaný vstupní řetězec pro první výskyt zadaného regulárního výrazu.
public:
static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern);
public static System.Text.RegularExpressions.Match Match (string input, string pattern);
static member Match : string * string -> System.Text.RegularExpressions.Match
Public Shared Function Match (input As String, pattern As String) As Match
Parametry
- input
- String
Řetězec, který má vyhledat shodu.
- pattern
- String
Vzor regulárního výrazu, který se má shodovat.
Návraty
Objekt, který obsahuje informace o shodě.
Výjimky
Došlo k chybě parsování regulárního výrazu.
input
nebo pattern
je null
.
Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.
Příklady
Následující příklad volá metodu Match(String, String) k vyhledání prvního slova, které obsahuje alespoň jeden z
znak, a pak zavolá metodu Match.NextMatch k vyhledání dalších shod.
using System;
using System.Text.RegularExpressions;
namespace Examples
{
public class Example
{
public static void Main()
{
string input = "ablaze beagle choral dozen elementary fanatic " +
"glaze hunger inept jazz kitchen lemon minus " +
"night optical pizza quiz restoration stamina " +
"train unrest vertical whiz xray yellow zealous";
string pattern = @"\b\w*z+\w*\b";
Match m = Regex.Match(input, pattern);
while (m.Success)
{
Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index);
m = m.NextMatch();
}
}
}
}
// The example displays the following output:
// 'ablaze' found at position 0
// 'dozen' found at position 21
// 'glaze' found at position 46
// 'jazz' found at position 65
// 'pizza' found at position 104
// 'quiz' found at position 110
// 'whiz' found at position 157
// 'zealous' found at position 174
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "ablaze beagle choral dozen elementary fanatic " +
"glaze hunger inept jazz kitchen lemon minus " +
"night optical pizza quiz restoration stamina " +
"train unrest vertical whiz xray yellow zealous"
Dim pattern As String = "\b\w*z+\w*\b"
Dim m As Match = Regex.Match(input, pattern)
Do While m.Success
Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index)
m = m.NextMatch()
Loop
End Sub
End Module
' The example displays the following output:
'ablaze' found at position 0
'dozen' found at position 21
'glaze' found at position 46
'jazz' found at position 65
'pizza' found at position 104
'quiz' found at position 110
'whiz' found at position 157
'zealous' found at position 174
Vzor \b\w*z+\w*\b
regulárního výrazu je interpretován tak, jak je znázorněno v následující tabulce.
Vzor | Description |
---|---|
\b |
Začne porovnání na hranici slova. |
\w* |
Porovná žádný, jeden nebo více znaků slova. |
z+ |
Porovná jeden nebo více výskytů znaku z . |
\w* |
Porovná nula, jeden nebo více znaků slova. |
\b |
Ukončí porovnání na hranici slova. |
Poznámky
Metoda Match(String, String) vrátí první podřetězc, který odpovídá vzoru regulárního výrazu ve vstupním řetězci. Informace o elementech jazyka použitých k vytvoření vzoru regulárních výrazů najdete v tématu Jazyk regulárních výrazů – stručná referenční dokumentace.
Statická Match(String, String) metoda je ekvivalentní k vytvoření objektu Regex se zadaným vzorem regulárního výrazu a volání metody instance Match(String) . V tomto případě modul regulárních výrazů ukládá vzor regulárního výrazu do mezipaměti.
Parametr pattern
se skládá z elementů jazyka regulárních výrazů, které symbolicky popisují řetězec, který se má shodovat. Další informace o regulárních výrazech najdete v tématu Regulární výrazy .NET a Jazyk regulárních výrazů – stručná referenční příručka.
Můžete zjistit, zda byl vzor regulárního výrazu nalezen ve vstupním řetězci kontrolou hodnoty vlastnosti vráceného Match objektu Success . Pokud je nalezena shoda, vlastnost vráceného Match objektu Value obsahuje podřetěžce, input
který odpovídá vzoru regulárního výrazu. Pokud se nenajde žádná shoda, je její hodnota String.Empty.
Tato metoda vrátí první podřetěžce, input
který odpovídá vzoru regulárního výrazu. Následné shody můžete načíst opakovaným voláním metody vráceného Match objektu Match.NextMatch . Voláním metody můžete také načíst všechny shody v jediném Regex.Matches(String, String) volání metody.
Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění odpovídající operace překročí časový limit zadaný pro doménu aplikace, ve které je volána metoda. Pokud ve vlastnostech domény aplikace není definován žádný časový limit nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , nevyvolá se žádná výjimka.
Poznámky pro volající
Tato metoda vyprší časový limit po intervalu, který se rovná výchozí hodnotě časového limitu domény aplikace, ve které je volána. Pokud pro doménu aplikace nebyla definována hodnota časového limitu, použije se hodnota InfiniteMatchTimeout, která brání vypršení časového limitu metody. Doporučená statická metoda pro načtení shody vzorů je Match(String, String), která umožňuje nastavit interval časového limitu.
Viz také
Platí pro
Match(String, Int32, Int32)
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
Vyhledá ve vstupním řetězci první výskyt regulárního výrazu, počínaje zadanou počáteční pozicí a vyhledáváním pouze zadaného počtu znaků.
public:
System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int beginning, int length);
public System.Text.RegularExpressions.Match Match (string input, int beginning, int length);
member this.Match : string * int * int -> System.Text.RegularExpressions.Match
Public Function Match (input As String, beginning As Integer, length As Integer) As Match
Parametry
- input
- String
Řetězec, který má vyhledat shodu.
- beginning
- Int32
Pozice nulového znaku ve vstupním řetězci, která definuje pozici nejvíce vlevo, která má být prohledána.
- length
- Int32
Počet znaků v podřetěžci, který se má zahrnout do hledání.
Návraty
Objekt, který obsahuje informace o shodě.
Výjimky
input
je null
.
beginning
je menší než nula nebo větší než délka .input
-nebo-
length
je menší než nula nebo větší než délka .input
-nebo-
beginning
+
length
-1
identifikuje pozici, která je mimo rozsah .input
Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.
Poznámky
Metoda Match(String, Int32, Int32) vrátí první podřetězc, který odpovídá vzoru regulárního výrazu v části vstupního řetězce. Informace o elementech jazyka použitých k vytvoření vzoru regulárních výrazů najdete v tématu Jazyk regulárních výrazů – stručná referenční dokumentace.
Vzor regulárního výrazu Match(String, Int32, Int32) , pro který metoda hledá, je definován voláním jednoho z Regex konstruktorů třídy. Další informace o elementech, které mohou vytvořit vzor regulárního výrazu, najdete v tématu Jazyk regulárních výrazů – stručná referenční dokumentace.
Metoda Match(String, Int32, Int32) vyhledá část input
definovanou beginning
parametry a length
pro vzor regulárního výrazu. beginning
vždy definuje index znaku nejvíce vlevo, který se má zahrnout do hledání, a length
definuje maximální počet znaků, které se mají prohledávat. Společně definují rozsah hledání. Chování je přesně stejné, jako kdyby input
byl efektivně input.Substring(beginning, length)
, s tím rozdílem, že index jakékoli shody se počítá vzhledem k začátku .input
To znamená, že všechny ukotvení nebo kontrolní výrazy s nulovou šířkou na začátku nebo konci vzoru se chovají, jako by se mimo tento rozsah nechová input
. Například ukotvení , , a \A
budou spokojeny v beginning
a $
a \z
budou spokojeny v beginning + length - 1
. \G
^
Pokud hledání pokračuje zleva doprava (výchozí), modul regulárních výrazů hledá od znaku v indexu beginning
ke znaku v indexu beginning + length - 1
. Pokud byl modul regulárních výrazů vytvořený pomocí RegexOptions.RightToLeft možnosti tak, aby hledání probíhalo zprava doleva, prohledá modul regulárních výrazů od znaku v indexu beginning + length - 1
ke znaku v indexu beginning
.
Tato metoda vrátí první shodu, kterou najde v tomto rozsahu. Následné shody můžete načíst opakovaným voláním metody vráceného Match objektu Match.NextMatch .
Můžete zjistit, zda byl vzor regulárního výrazu nalezen ve vstupním řetězci kontrolou hodnoty vlastnosti vráceného Match objektu Success . Pokud je nalezena shoda, vlastnost vráceného Match objektu Value obsahuje podřetěžce, input
který odpovídá vzoru regulárního výrazu. Pokud se nenajde žádná shoda, je její hodnota String.Empty.
Výjimka RegexMatchTimeoutException je vyvolána, pokud doba provádění odpovídající operace překročí časový limit určený konstruktorem Regex.Regex(String, RegexOptions, TimeSpan) . Pokud při volání konstruktoru nenastavíte hodnotu časového limitu, vyvolá se výjimka, pokud operace překročí jakoukoli hodnotu časového limitu stanovenou pro doménu aplikace, ve které Regex je objekt vytvořen. Pokud není ve volání konstruktoru Regex nebo ve vlastnostech domény aplikace definován žádný časový limit nebo pokud je Regex.InfiniteMatchTimeouthodnota časového limitu , nevyvolá se žádná výjimka.
Viz také
Platí pro
Match(String, String, RegexOptions, TimeSpan)
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
Vyhledá vstupní řetězec pro první výskyt zadaného regulárního výrazu pomocí zadaných odpovídajících možností a intervalu časového limitu.
public:
static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Match : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Match
Public Shared Function Match (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As Match
Parametry
- input
- String
Řetězec, který má vyhledat shodu.
- pattern
- String
Vzor regulárního výrazu, který se má shodovat.
- options
- RegexOptions
Bitové kombinace hodnot výčtu, které poskytují možnosti pro porovnávání.
- matchTimeout
- TimeSpan
Interval časového limitu nebo InfiniteMatchTimeout označující, že by nemělo dojít k vypršení časového limitu metody.
Návraty
Objekt, který obsahuje informace o shodě.
Výjimky
Došlo k chybě parsování regulárního výrazu.
input
nebo pattern
je null
.
options
není platná bitové kombinace RegexOptions hodnot.
-nebo-
matchTimeout
je záporná, nulová nebo větší než přibližně 24 dnů.
Došlo k vypršení časového limitu. Další informace o časových limitech najdete v části Poznámky.
Poznámky
Metoda Match(String, String, RegexOptions, TimeSpan) vrátí první podřetězc, který odpovídá vzoru regulárního výrazu ve vstupním řetězci. Informace o elementech jazyka použitých k vytvoření vzoru regulárních výrazů najdete v tématu Jazyk regulárních výrazů – stručná referenční dokumentace.
Statická Match(String, String, RegexOptions, TimeSpan) metoda je ekvivalentní k vytvoření objektu Regex pomocí konstruktoru Regex(String, RegexOptions, TimeSpan) a volání metody instance Match(String) .
Parametr pattern
se skládá z elementů jazyka regulárních výrazů, které symbolicky popisují řetězec, který se má shodovat. Další informace o regulárních výrazech najdete v tématu Regulární výrazy .NET a Jazyk regulárních výrazů – stručná referenční příručka.
Můžete zjistit, zda byl vzor regulárního výrazu nalezen ve vstupním řetězci kontrolou hodnoty vlastnosti vráceného Match objektu Success . Pokud je nalezena shoda, vlastnost vráceného Match objektu Value obsahuje podřetěžce, input
který odpovídá vzoru regulárního výrazu. Pokud se nenajde žádná shoda, je její hodnota String.Empty.
Tato metoda vrátí první podřetěžce nalezený v input
, který odpovídá vzoru regulárního výrazu. Následné shody můžete načíst opakovaným voláním metody vráceného Match objektu NextMatch . Voláním metody můžete také načíst všechny shody v jediném Regex.Matches(String, String, RegexOptions) volání metody.
Parametr matchTimeout
určuje, jak dlouho by se metoda porovnávání vzorů měla pokusit najít shodu, než vyprší časový limit. Nastavení intervalu časového limitu zabrání tomu, aby regulární výrazy, které jsou závislé na nadměrném navracení, přestaly reagovat, když zpracovávají vstup, který obsahuje téměř shody. Další informace najdete v tématu Osvědčené postupy pro regulární výrazy a backtracking. Pokud se v daném časovém intervalu nenajde žádná shoda, metoda vyvolá RegexMatchTimeoutException výjimku. matchTimeout
přepíše všechny výchozí hodnoty časového limitu definované pro doménu aplikace, ve které se metoda spouští.
Poznámky pro volající
Doporučujeme nastavit matchTimeout
parametr na odpovídající hodnotu, například dvě sekundy. Pokud zakážete vypršení časových limitů zadáním InfiniteMatchTimeout, modul regulárních výrazů nabízí o něco lepší výkon. Vypršení časových limitů byste ale měli zakázat pouze za následujících podmínek:
Když je vstup zpracovaný regulárním výrazem odvozen ze známého a důvěryhodného zdroje nebo se skládá ze statického textu. Tím se vyloučí text, který uživatelé zadává dynamicky.
Když byl vzor regulárního výrazu důkladně otestován, aby se zajistilo, že efektivně zpracovává shody, neshody a blízké shody.
Když vzor regulárního výrazu neobsahuje žádné elementy jazyka, o kterých je známo, že způsobují nadměrné navracení při zpracování téměř shody.
Viz také
Platí pro
Váš názor
https://aka.ms/ContentUserFeedback.
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu:Odeslat a zobrazit názory pro