Alternation Constructs in Regular Expressions

  • Cikk

Az alternation szerkezetek módosítanak egy reguláris kifejezést, hogy lehetővé tegyék vagy/vagy feltételes egyeztetést tegyenek lehetővé. A .NET három váltakozó szerkezetet támogat:

Mintaegyezés |

A függőleges sáv (|) karakterrel egyező mintázatok bármelyikét használhatja, ahol a karakter elválasztja az | egyes mintákat.

A pozitív karakterosztályhoz hasonlóan a | karakter használható egyetlen karakter bármelyikének egyezésére. Az alábbi példa a karakterrel egyező pozitív karakterosztályt és/vagy mintát használ a | "szürke" vagy a "szürke" szavak előfordulásának kereséséhez egy sztringben. Ebben az esetben a | karakter egy olyan reguláris kifejezést hoz létre, amely részletesebb.

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

A karaktert |\bgr(a|e)y\bhasználó reguláris kifejezés az alábbi táblázatban látható módon lesz értelmezve:

Minta Leírás
\b Kezdje egy szóhatáron.
gr Egyezik a "gr" karakterekkel.
(a|e) Egyezik az "a" vagy az "e" értékkel.
y\b Egyezik egy "y" szóval egy szóhatáron.

A | karakter használható egy vagy több karakterrel vagy alkifejezéssel való egyeztetésre is, amely a karakterkonstansok és a reguláris kifejezés nyelvi elemeinek bármilyen kombinációját tartalmazhatja. (A karakterosztály nem biztosítja ezt a funkciót.) Az alábbi példa egy amerikai társadalombiztosítási szám (SSN) kinyerésére használja a | karaktert, amely egy 9 jegyű szám, ddd-dd- formátumban, vagy egy egyesült államokbeli munkáltatói azonosítószám (EIN), amely egy 9 jegyű szám, dddddddd- formátumban.

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

A rendszer a reguláris kifejezést \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b az alábbi táblázatban látható módon értelmezi:

Minta Leírás
\b Kezdje egy szóhatáron.
(\d{2}-\d{7}|\d{3}-\d{2}-\d{4}) Egyezzen a következők valamelyikével: két tizedesjegy, majd egy kötőjel, majd hét tizedesjegy; vagy három tizedesjegy, egy kötőjel, két tizedesjegy, egy másik kötőjel és négy tizedesjegy.
\b Egy szóhatáron fejezd be az egyezést.

Feltételes egyeztetés kifejezéssel

Ez a nyelvi elem megkísérli egyezni a két minta egyikét attól függően, hogy megfelel-e egy kezdeti mintának. Szintaxisa:

(?(kifejezés)igen)

vagy

(?(kifejezés)igen|nem)

ahol a kifejezés a kezdeti egyeztetendő minta, igen az a minta, amelyet egyezni kell, ha a kifejezés megfeleltetve van, és nem az a választható minta, amelyet akkor kell egyezni, ha a kifejezés nem egyezik (ha nincs megadva minta, akkor az üres nemnek felel meg). A reguláris kifejezésmotor nulla szélességű állításként kezeli a kifejezést, vagyis a reguláris kifejezésmotor nem lép előre a bemeneti adatfolyamban a kifejezés kiértékelése után. Ezért ez a szerkezet egyenértékű a következő konstrukcióval:

(?(?=kifejezés)igen|nem)

ahol (?=a kifejezés) nulla szélességű helyességi szerkezet. (További információ:Csoportosítási szerkezetek.) Mivel a reguláris kifejezésmotor a kifejezést horgonyként (nulla szélességű állításként) értelmezi, a kifejezésnek nullaszélességű helyességi feltételnek kell lennie (további információ: Horgonyok) vagy az igenben is található alkifejezés. Ellenkező esetben az igen minta nem egyeztethető.

Feljegyzés

Ha a kifejezés névvel ellátott vagy számozott rögzítési csoport, a váltakozó szerkezetet a rendszer rögzítési tesztként értelmezi. További információt a következő, Feltételes egyeztetés érvényes rögzítési csoporton alapuló szakaszában talál. Más szóval a reguláris kifejezésmotor nem a rögzített részstringnek próbál megfelelni, hanem a csoport jelenlétére vagy hiányára vonatkozó teszteket.

Az alábbi példa a példa egyik változata, amely a (z) | szakaszban látható Vagy mintaegyeztetés | szakaszában jelenik meg. Feltételes egyeztetéssel állapítja meg, hogy a szóhatár utáni első három karakter két számjegyből áll-e, amelyet kötőjel követ. Ha így van, az egyesült államokbeli munkáltatói azonosító számmal (EIN) próbál megegyezni. Ha nem, egy amerikai társadalombiztosítási számmal (SSN) próbál megegyezni.

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

A rendszer a reguláris kifejezésmintát \b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b az alábbi táblázatban látható módon értelmezi:

Minta Leírás
\b Kezdje egy szóhatáron.
(?(\d{2}-) Határozza meg, hogy a következő három karakter két számjegyből és egy kötőjelből áll-e.
\d{2}-\d{7} Ha az előző minta egyezik, egyezzen két számjegyből, majd egy kötőjelből, majd hét számjegyből.
\d{3}-\d{2}-\d{4} Ha az előző minta nem egyezik, egyezik három tizedesjegy, egy kötőjel, két tizedesjegy, egy másik kötőjel és négy tizedesjegy.
\b Egy szóhatár egyeztetése.

Feltételes egyeztetés érvényes rögzített csoport alapján

Ez a nyelvi elem két minta egyikét próbálja meg egyezni attól függően, hogy megfelelt-e egy adott rögzítési csoportnak. Szintaxisa:

(?(név)igen)

vagy

(?(név)igen|nem)

vagy

(?(szám)igen)

vagy

(?(szám)igen|nem)

ahol a név a név és a szám egy rögzítési csoport száma, igen, ha a név vagy szám megegyezik, és nem az opcionális kifejezés, amelyet egyezni kell, ha nem (ha nincs megadva minta, akkor az üres nemnek felel meg).

Ha a név nem felel meg a reguláris kifejezésmintában használt rögzítési csoport nevének, a rendszer kifejezéstesztként értelmezi az alternation szerkezetet az előző szakaszban leírtak szerint. Ez általában azt jelenti, hogy a kifejezés kiértékelése a következőre történik false: . Ha a szám nem felel meg a reguláris kifejezésmintában használt számozott rögzítési csoportnak, a reguláris kifejezésmotor egy ArgumentException.

Az alábbi példa a példa egyik változata, amely a (z) | szakaszban látható Vagy mintaegyeztetés | szakaszában jelenik meg. Egy két számjegyből és egy kötőjelből álló rögzítési csoportot n2 használ. A váltakozó szerkezet ellenőrzi, hogy a rögzítési csoport megfelel-e a bemeneti sztringnek. Ha így van, a váltakozó szerkezet megpróbál megegyezni egy kilencjegyű egyesült államokbeli munkáltatói azonosító szám (EIN) utolsó hét számjegyével. Ha nem, megpróbál megegyezni egy kilencjegyű amerikai társadalombiztosítási számmal (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

A rendszer a reguláris kifejezésmintát \b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b az alábbi táblázatban látható módon értelmezi:

Minta Leírás
\b Kezdje egy szóhatáron.
(?<n2>\d{2}-)? Egyezik két számjegy nullával vagy egy előfordulásával, amelyet kötőjel követ. Nevezze el ezt a rögzítési csoportot n2.
(?(n2) Ellenőrizze, hogy a bemeneti sztring megfelelt-e n2 .
\d{7} Ha n2 megfelelt, hét tizedesjegyet kell egyeznie.
|\d{3}-\d{2}-\d{4} Ha n2 nem egyezett, egyezik három tizedesjegy, egy kötőjel, két tizedesjegy, egy másik kötőjel és négy tizedesjegy.
\b Egy szóhatár egyeztetése.

Az alábbi példában látható a példában az a változat, amely számozott csoportot használ elnevezett csoport helyett. A reguláris kifejezési minta a \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

Lásd még