Capture.Value Właściwość

Odwołanie

Definicja

Przestrzeń nazw:: System.Text.RegularExpressions

Zestaw:: System.Text.RegularExpressions.dll

Zestaw:: System.dll

Zestaw:: netstandard.dll

Źródło:: Capture.cs

Źródło:: Capture.cs

Źródło:: Capture.cs

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Pobiera przechwycony podciąg z ciągu wejściowego.

public:
 property System::String ^ Value { System::String ^ get(); };

public string Value { get; }

member this.Value : string

Public ReadOnly Property Value As String

Wartość właściwości

String

Podciąg przechwycony przez dopasowanie.

Przykłady

W poniższym przykładzie zdefiniowano wyrażenie regularne, które pasuje do zdań, które nie zawierają znaków interpunkcyjnych z wyjątkiem kropki ("."). Właściwość Match.Value wyświetla ciąg wyniku, który składa się z dopasowanego zdania dla każdego dopasowania. Właściwość Group.Value wyświetla ciąg wyniku dla każdej grupy przechwytywania; składa się z ostatniego ciągu przechwyconego przez grupę przechwytywania. Właściwość Capture.Value wyświetla ciąg wyniku dla każdego przechwytywania.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Yes. This dog is very friendly.";
      string pattern = @"((\w+)[\s.])+";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("Match: {0}", match.Value);
         for (int groupCtr = 0; groupCtr < match.Groups.Count; groupCtr++)
         {
            Group group = match.Groups[groupCtr];
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            for (int captureCtr = 0; captureCtr < group.Captures.Count; captureCtr++)
               Console.WriteLine("      Capture {0}: {1}", captureCtr, 
                                 group.Captures[captureCtr].Value);
         }                      
      }
   }
}
// The example displays the following output:
//       Match: Yes.
//          Group 0: Yes.
//             Capture 0: Yes.
//          Group 1: Yes.
//             Capture 0: Yes.
//          Group 2: Yes
//             Capture 0: Yes
//       Match: This dog is very friendly.
//          Group 0: This dog is very friendly.
//             Capture 0: This dog is very friendly.
//          Group 1: friendly.
//             Capture 0: This
//             Capture 1: dog
//             Capture 2: is
//             Capture 3: very
//             Capture 4: friendly.
//          Group 2: friendly
//             Capture 0: This
//             Capture 1: dog
//             Capture 2: is
//             Capture 3: very
//             Capture 4: friendly

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Yes. This dog is very friendly."
      Dim pattern As String = "((\w+)[\s.])+"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Match: {0}", match.Value)
         For groupCtr As Integer = 0 To match.Groups.Count - 1
            Dim group As Group = match.Groups(groupCtr)
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            For captureCtr As Integer = 0 To group.Captures.Count - 1
               Console.WriteLine("      Capture {0}: {1}", captureCtr, _
                                 group.Captures(captureCtr).Value)
            Next
         Next                      
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: Yes.
'          Group 0: Yes.
'             Capture 0: Yes.
'          Group 1: Yes.
'             Capture 0: Yes.
'          Group 2: Yes
'             Capture 0: Yes
'       Match: This dog is very friendly.
'          Group 0: This dog is very friendly.
'             Capture 0: This dog is very friendly.
'          Group 1: friendly.
'             Capture 0: This
'             Capture 1: dog
'             Capture 2: is
'             Capture 3: very
'             Capture 4: friendly.
'          Group 2: friendly
'             Capture 0: This
'             Capture 1: dog
'             Capture 2: is
'             Capture 3: very
'             Capture 4: friendly

Wzorzec ((\w+)[\s.])+ wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli. Należy pamiętać, że w tym wyrażeniu regularnym do całego wyrażenia regularnego jest stosowany kwantyfikator (+).

Wzorce	Opis
`(\w+)`	Dopasowuje co najmniej jeden znak słowa. Jest to druga grupa przechwytywania.
`[\s.])`	Dopasuj znak lub kropkę (".").
`((\w+)[\s.])`	Dopasuj co najmniej jeden znak wyrazu, po którym następuje znak lub kropka ("."). Jest to pierwsza grupa przechwytywania.
`((\w+)[\s.])+`	Dopasuj co najmniej jedno wystąpienie znaku lub znaków wyrazu, po którym następuje znak lub kropka (".").

W tym przykładzie ciąg wejściowy składa się z dwóch zdań. Jak pokazano w danych wyjściowych, pierwsze zdanie składa się tylko z jednego wyrazu, więc CaptureCollection obiekt ma jeden Capture obiekt, który reprezentuje to samo przechwytywanie co Group obiekt. Drugie zdanie składa się z wielu wyrazów, więc Group obiekty zawierają tylko informacje o ostatnim dopasowanym podrażeniu. Grupa 1, która reprezentuje pierwsze przechwytywanie, zawiera ostatnie słowo w zdaniu, które ma okres zamknięcia. Grupa 2, która reprezentuje drugie przechwytywanie, zawiera ostatnie słowo w zdaniu. Capture Jednak obiekty w obiekcie grupy CaptureCollection przechwytują każde dopasowanie podwyrażenia. Obiekty Capture w pierwszej grupie przechwytywania kolekcji przechwytywania zawierają informacje o każdym przechwyconym słowie i białym znaku lub kropki. Obiekty Capture w drugiej grupie przechwytywania kolekcji przechwytywania zawierają informacje o każdym przechwyconym słowie.

W poniższym przykładzie użyto wzorca wyrażenia regularnego , ^([a-z]+)(\d+)*\.([a-z]+(\d)*)$aby dopasować liczbę produktu składającą się z dwóch części rozdzielonych kropką. Obie części składają się z znaków alfabetycznych, po których następują opcjonalne cyfry. Ponieważ pierwszy ciąg wejściowy nie jest zgodny ze wzorcem, wartość właściwości zwracanego System.Text.RegularExpressions.Match obiektu Value to String.Empty. Podobnie, gdy wzorzec wyrażenia regularnego nie może dopasować grupy przechwytywania, wartość właściwości odpowiedniego Group obiektu Value to String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      String pattern = @"^([a-z]+)(\d+)?\.([a-z]+(\d)*)$";
      String[] values = { "AC10", "Za203.CYM", "XYZ.CoA", "ABC.x170" };   
      foreach (var value in values) {
         Match m = Regex.Match(value, pattern, RegexOptions.IgnoreCase);
         if (m.Success) {
            Console.WriteLine("Match: '{0}'", m.Value);
            Console.WriteLine("   Number of Capturing Groups: {0}", 
                              m.Groups.Count);
            for (int gCtr = 0; gCtr < m.Groups.Count; gCtr++) {
               Group group = m.Groups[gCtr];
               Console.WriteLine("      Group {0}: {1}", gCtr, 
                                 group.Value == "" ? "<empty>" : "'" + group.Value + "'");   
               Console.WriteLine("         Number of Captures: {0}", 
                                 group.Captures.Count);
           
               for (int cCtr = 0; cCtr < group.Captures.Count; cCtr++) 
                  Console.WriteLine("            Capture {0}: {1}", 
                                    cCtr, group.Captures[cCtr].Value);
            }
         } 
         else {
            Console.WriteLine("No match for {0}: Match.Value is {1}", 
                              value, m.Value == String.Empty ? "<empty>" : m.Value);
         }
      }
   }
}
// The example displays the following output:
//       No match for AC10: Match.Value is <empty>
//       Match: 'Za203.CYM'
//          Number of Capturing Groups: 5
//             Group 0: 'Za203.CYM'
//                Number of Captures: 1
//                   Capture 0: Za203.CYM
//             Group 1: 'Za'
//                Number of Captures: 1
//                   Capture 0: Za
//             Group 2: '203'
//                Number of Captures: 1
//                   Capture 0: 203
//             Group 3: 'CYM'
//                Number of Captures: 1
//                   Capture 0: CYM
//             Group 4: <empty>
//                Number of Captures: 0
//       Match: 'XYZ.CoA'
//          Number of Capturing Groups: 5
//             Group 0: 'XYZ.CoA'
//                Number of Captures: 1
//                   Capture 0: XYZ.CoA
//             Group 1: 'XYZ'
//                Number of Captures: 1
//                   Capture 0: XYZ
//             Group 2: <empty>
//                Number of Captures: 0
//             Group 3: 'CoA'
//                Number of Captures: 1
//                   Capture 0: CoA
//             Group 4: <empty>
//                Number of Captures: 0
//       Match: 'ABC.x170'
//          Number of Capturing Groups: 5
//             Group 0: 'ABC.x170'
//                Number of Captures: 1
//                   Capture 0: ABC.x170
//             Group 1: 'ABC'
//                Number of Captures: 1
//                   Capture 0: ABC
//             Group 2: <empty>
//                Number of Captures: 0
//             Group 3: 'x170'
//                Number of Captures: 1
//                   Capture 0: x170
//             Group 4: '0'
//                Number of Captures: 3
//                   Capture 0: 1
//                   Capture 1: 7
//                   Capture 2: 0

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^([a-z]+)(\d+)?\.([a-z]+(\d)*)$"
      Dim values() As String = { "AC10", "Za203.CYM", "XYZ.CoA", "ABC.x170" }   
      For Each value In values
         Dim m As Match = Regex.Match(value, pattern, RegexOptions.IgnoreCase)
         If m.Success Then
            Console.WriteLine("Match: '{0}'", m.Value)
            Console.WriteLine("   Number of Capturing Groups: {0}", 
                              m.Groups.Count)
            For gCtr As Integer = 0 To m.Groups.Count - 1
               Dim group As Group = m.Groups(gCtr)
               Console.WriteLine("      Group {0}: {1}", gCtr, 
                                 If(group.Value = "", "<empty>", "'" + group.Value + "'"))   
               Console.WriteLine("         Number of Captures: {0}", 
                                 group.Captures.Count)
           
               For cCtr As Integer = 0 To group.Captures.Count - 1
                  Console.WriteLine("            Capture {0}: {1}", 
                                    cCtr, group.Captures(cCtr).Value)
               Next
            Next
         Else
            Console.WriteLine("No match for {0}: Match.Value is {1}", 
                              value, If(m.Value = String.Empty, "<empty>", m.Value))
         End If
      Next    
   End Sub
End Module
' The example displays the following output:
'       No match for AC10: Match.Value is <empty>
'       Match: 'Za203.CYM'
'          Number of Capturing Groups: 5
'             Group 0: 'Za203.CYM'
'                Number of Captures: 1
'                   Capture 0: Za203.CYM
'             Group 1: 'Za'
'                Number of Captures: 1
'                   Capture 0: Za
'             Group 2: '203'
'                Number of Captures: 1
'                   Capture 0: 203
'             Group 3: 'CYM'
'                Number of Captures: 1
'                   Capture 0: CYM
'             Group 4: <empty>
'                Number of Captures: 0
'       Match: 'XYZ.CoA'
'          Number of Capturing Groups: 5
'             Group 0: 'XYZ.CoA'
'                Number of Captures: 1
'                   Capture 0: XYZ.CoA
'             Group 1: 'XYZ'
'                Number of Captures: 1
'                   Capture 0: XYZ
'             Group 2: <empty>
'                Number of Captures: 0
'             Group 3: 'CoA'
'                Number of Captures: 1
'                   Capture 0: CoA
'             Group 4: <empty>
'                Number of Captures: 0
'       Match: 'ABC.x170'
'          Number of Capturing Groups: 5
'             Group 0: 'ABC.x170'
'                Number of Captures: 1
'                   Capture 0: ABC.x170
'             Group 1: 'ABC'
'                Number of Captures: 1
'                   Capture 0: ABC
'             Group 2: <empty>
'                Number of Captures: 0
'             Group 3: 'x170'
'                Number of Captures: 1
'                   Capture 0: x170
'             Group 4: '0'
'                Number of Captures: 3
'                   Capture 0: 1
'                   Capture 1: 7
'                   Capture 2: 0

Wzorzec wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli:

Wzorce	Opis
`^`	Rozpocznij dopasowanie na początku ciągu.
`([a-z]+)`	Dopasuj co najmniej jedno wystąpienie dowolnego znaku z na z. Ponieważ aparat wyrażeń regularnych jest przekazywany RegexOptions.IgnoreCase , to porównanie jest bez uwzględniania wielkości liter. Jest to pierwsza grupa przechwytywania.
`(\d+)?`	Dopasuj zero lub jedno wystąpienie co najmniej jednej cyfry dziesiętnej. Jest to druga grupa przechwytywania.
`\.`	Dopasuj znak kropki literału.
`([a-z]+`	Dopasuj co najmniej jedno wystąpienie dowolnego znaku z na z. Porównanie jest bez uwzględniania wielkości liter.
`(\d)*`	Dopasowanie do zera lub większej liczby cyfr dziesiętnych. Pojedyncza dopasowana cyfra to czwarta grupa przechwytywania.
`([a-z]+(\d)*)`	Dopasuj co najmniej jeden znak alfabetyczny od z do z, po którym następuje zero, co najmniej jedna cyfra dziesiętna. Jest to czwarta grupa przechwytywania.
`$`	Zakończ dopasowanie na końcu ciągu.

Uwagi

Jeśli wywołanie metody Regex.Match lub Match.NextMatch nie może znaleźć dopasowania, wartość zwróconej Match.Value właściwości to String.Empty. Jeśli aparat wyrażeń regularnych nie może dopasować grupy przechwytywania. wartość zwróconej Group.Value właściwości to String.Empty. Zobacz drugi przykład ilustracji.

Dotyczy

Udostępnij za pośrednictwem