Konstrukce alternace v regulárních výrazech
Konstrukce alternace upravují regulární výraz tak, aby povolily nebo podmíněné porovnávání. .NET podporuje tři konstrukce alternace:
- Porovnávání vzorů s |
- Podmíněné porovnávání s (?( výraz)ano|ne)
- Podmíněné porovnávání na základě platné zachycené skupiny
Porovnávání vzorů s |
Svislý znak pruhu (|) můžete použít ke spárování libovolné řady vzorů, kde | jednotlivé vzory odděluje.
Stejně jako u kladné třídy | znaků lze znak použít ke shodě s libovolným počtem jednotlivých znaků. V následujícím příkladu se k vyhledání výskytů slov "šedá" nebo "šedá" v řetězci používá třída kladného znaku i třída nebo vzor | odpovídající tomuto znaku. V tomto případě | znak vytvoří regulární výraz, který je více podrobný.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
// Regular expression using character class.
string pattern1 = @"\bgr[ae]y\b";
// Regular expression using either/or.
string pattern2 = @"\bgr(a|e)y\b";
string input = "The gray wolf blended in among the grey rocks.";
foreach (Match match in Regex.Matches(input, pattern1))
Console.WriteLine("'{0}' found at position {1}",
match.Value, match.Index);
Console.WriteLine();
foreach (Match match in Regex.Matches(input, pattern2))
Console.WriteLine("'{0}' found at position {1}",
match.Value, match.Index);
}
}
// The example displays the following output:
// 'gray' found at position 4
// 'grey' found at position 35
//
// 'gray' found at position 4
// 'grey' found at position 35
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
' Regular expression using character class.
Dim pattern1 As String = "\bgr[ae]y\b"
' Regular expression using either/or.
Dim pattern2 As String = "\bgr(a|e)y\b"
Dim input As String = "The gray wolf blended in among the grey rocks."
For Each match As Match In Regex.Matches(input, pattern1)
Console.WriteLine("'{0}' found at position {1}", _
match.Value, match.Index)
Next
Console.WriteLine()
For Each match As Match In Regex.Matches(input, pattern2)
Console.WriteLine("'{0}' found at position {1}", _
match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' 'gray' found at position 4
' 'grey' found at position 35
'
' 'gray' found at position 4
' 'grey' found at position 35
Regulární výraz, který používá | znak , \bgr(a|e)y\bje interpretován, jak je znázorněno v následující tabulce:
| Vzor | Popis |
|---|---|
\b |
Začne na hranici slova. |
gr |
Porovná znaky "gr". |
(a|e) |
Porovná buď se znakem „a“, nebo s „e“. |
y\b |
Porovná "y" na hranici slova. |
Znak | lze také použít k provedení nebo shody s více znaky nebo dílčí výrazy, které mohou zahrnovat libovolnou kombinaci literálů znaků a elementů jazyka regulárních výrazů. (Třída znaků neposkytuje tuto funkci.) Následující příklad používá | znak k extrahování čísla sociálního pojištění USA (SSN), což je 9místné číslo s formátem ddd ddd dddd--, nebo identifikační číslo zaměstnavatele (EIN), což je 9místné číslo s formátem dd.-
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b";
string input = "01-9999999 020-333333 777-88-9999";
Console.WriteLine("Matches for {0}:", pattern);
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(" {0} at position {1}", match.Value, match.Index);
}
}
// The example displays the following output:
// Matches for \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b:
// 01-9999999 at position 0
// 777-88-9999 at position 22
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b"
Dim input As String = "01-9999999 020-333333 777-88-9999"
Console.WriteLine("Matches for {0}:", pattern)
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(" {0} at position {1}", match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' Matches for \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b:
' 01-9999999 at position 0
' 777-88-9999 at position 22
Regulární výraz \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b se interpretuje, jak je znázorněno v následující tabulce:
| Vzor | Popis |
|---|---|
\b |
Začne na hranici slova. |
(\d{2}-\d{7}|\d{3}-\d{2}-\d{4}) |
Porovná jednu z následujících hodnot: dvě desetinné číslice následované pomlčkou následovanou sedmi desetinnými číslicemi; nebo tři desetinná číslice, spojovník, dvě desetinné číslice, další spojovník a čtyři desetinné číslice. |
\b |
Ukončí porovnání na hranici slova. |
Podmíněné porovnávání s výrazem
Tento prvek jazyka se pokouší shodovat s jedním ze dvou vzorů v závislosti na tom, jestli se může shodovat s počátečním vzorem. Jeho syntaxe je:
(?(výraz ) Ano )
nebo
(?(výraz ) Ano | Ne )
where expression is the initial pattern to match, yes is the pattern to match if expression is matched, and no is the optional pattern to match if expression is not matched (if a no pattern is not provided, it's equivalent to an empty no). Modul regulárních výrazů považuje výraz za kontrolní výraz s nulovou šířkou. To znamená, že modul regulárních výrazů nepochází ve vstupním streamu po vyhodnocení výrazu. Proto je tento konstruktor ekvivalentní následujícímu:
(?(?=výraz ) Ano | Ne )
where (?=výraz je konstruktor kontrolního výrazu) s nulovou šířkou. (Další informace najdete v tématu Seskupování konstruktorů.) Vzhledem k tomu, že modul regulárních výrazů interpretuje výraz jako ukotvení (kontrolní výraz s nulovou šířkou), musí být výraz buď kontrolní výraz s nulovou šířkou (další informace, viz Anchors) nebo dílčí výraz, který je také obsažen v ano. V opačném případě nelze vzor ano spárovat.
Poznámka:
Pokud je výraz pojmenovanou nebo číslovaný zachytávací skupinou, konstruktor alternace se interpretuje jako test zachycení. Další informace najdete v další části Podmíněné porovnávání na základě platné skupiny zachycení. Jinými slovy, modul regulárních výrazů se nepokoušá spárovat zachycený podřetěc, ale místo toho testuje přítomnost nebo nepřítomnost skupiny.
Následující příklad je varianta příkladu, který se zobrazí v oddílu Buď/nebo Porovnávání vzorů s | . Používá podmíněné porovnávání k určení, zda první tři znaky za hranicí slova jsou dvě číslice následované pomlčkou. Pokud ano, pokusí se shodovat s identifikačním číslem zaměstnavatele (EIN). Pokud ne, pokusí se shodovat s číslem sociálního pojištění USA (SSN).
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b";
string input = "01-9999999 020-333333 777-88-9999";
Console.WriteLine("Matches for {0}:", pattern);
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(" {0} at position {1}", match.Value, match.Index);
}
}
// The example displays the following output:
// Matches for \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b:
// 01-9999999 at position 0
// 777-88-9999 at position 22
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b"
Dim input As String = "01-9999999 020-333333 777-88-9999"
Console.WriteLine("Matches for {0}:", pattern)
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(" {0} at position {1}", match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' Matches for \b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b:
' 01-9999999 at position 0
' 777-88-9999 at position 22
Vzor \b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b regulárního výrazu se interpretuje, jak je znázorněno v následující tabulce:
| Vzor | Popis |
|---|---|
\b |
Začne na hranici slova. |
(?(\d{2}-) |
Určete, jestli se další tři znaky skládají ze dvou číslic následovaných pomlčkou. |
\d{2}-\d{7} |
Pokud předchozí vzor odpovídá, spárujte dvě číslice následované spojovníkem následovaným sedmi číslicemi. |
\d{3}-\d{2}-\d{4} |
Pokud se předchozí vzor neshoduje, porovná tři desetinná čísla, spojovník, dvě desetinné číslice, další spojovník a čtyři desetinné číslice. |
\b |
Porovná hranici slova. |
Podmíněné porovnávání na základě platné zachycené skupiny
Tento prvek jazyka se pokusí shodovat s jedním ze dvou vzorů v závislosti na tom, jestli se shodovala se zadanou skupinou zachycení. Jeho syntaxe je:
(?(Jméno ) Ano )
nebo
(?(Jméno ) Ano | Ne )
nebo
(?(číslo ) Ano )
nebo
(?(číslo ) Ano | Ne )
where name is the name and number is the number of a capturing group, yes is the expression to match if name or number has a no is the optional expression to match if it if it not (if a no pattern is not provided, it's equivalent to an empty no).
Pokud název neodpovídá názvu zachytávání skupiny, která se používá ve vzoru regulárního výrazu, je konstrukce alternace interpretována jako test výrazu, jak je vysvětleno v předchozí části. Obvykle to znamená, že výraz se vyhodnotí jako false. Pokud číslo neodpovídá číslované zachycené skupině, která se používá ve vzoru regulárního výrazu, vyvolá modul regulárních výrazů hodnotu ArgumentException.
Následující příklad je varianta příkladu, který se zobrazí v oddílu Buď/nebo Porovnávání vzorů s | . Používá zachytávání pojmenovanou n2 skupinu, která se skládá ze dvou číslic následovaných pomlčkou. Konstruktor alternace testuje, zda byla tato zachytávání skupina spárována ve vstupním řetězci. Pokud ano, konstrukce alternace se pokusí shodovat s posledních sedmi číslicemi devítimístného amerického identifikačního čísla zaměstnavatele (EIN). Pokud tomu tak není, pokusí se shodovat s devíticiferným číslem amerického sociálního pojištění (SSN).
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b";
string input = "01-9999999 020-333333 777-88-9999";
Console.WriteLine("Matches for {0}:", pattern);
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(" {0} at position {1}", match.Value, match.Index);
}
}
// The example displays the following output:
// Matches for \b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b:
// 01-9999999 at position 0
// 777-88-9999 at position 22
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b"
Dim input As String = "01-9999999 020-333333 777-88-9999"
Console.WriteLine("Matches for {0}:", pattern)
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(" {0} at position {1}", match.Value, match.Index)
Next
End Sub
End Module
Vzor \b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b regulárního výrazu se interpretuje, jak je znázorněno v následující tabulce:
| Vzor | Popis |
|---|---|
\b |
Začne na hranici slova. |
(?<n2>\d{2}-)? |
Porovná žádný nebo jeden výskyt dvou číslic následovaných pomlčkou. Pojmenujte tuto zachytávání skupiny n2. |
(?(n2) |
Otestujte, jestli n2 se ve vstupním řetězci shodoval. |
\d{7} |
Pokud n2 byl shodný, shodný se sedmi desetinnými číslicemi. |
|\d{3}-\d{2}-\d{4} |
Pokud n2 se neshoduje, porovná se třemi desetinnými číslicemi, spojovníkem, dvěma desetinnými číslicemi, dalším spojovníkem a čtyřmi desetinnými číslicemi. |
\b |
Porovná hranici slova. |
Variace tohoto příkladu, která místo pojmenované skupiny používá číslovaný skupinu, je znázorněna v následujícím příkladu. Vzor regulárního výrazu je \b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b";
string input = "01-9999999 020-333333 777-88-9999";
Console.WriteLine("Matches for {0}:", pattern);
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(" {0} at position {1}", match.Value, match.Index);
}
}
// The example display the following output:
// Matches for \b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b:
// 01-9999999 at position 0
// 777-88-9999 at position 22
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b"
Dim input As String = "01-9999999 020-333333 777-88-9999"
Console.WriteLine("Matches for {0}:", pattern)
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(" {0} at position {1}", match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' Matches for \b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b:
' 01-9999999 at position 0
' 777-88-9999 at position 22
