Capture.Value Vlastnost

Reference

Definice

Obor názvů:: System.Text.RegularExpressions

Sestavení:: System.Text.RegularExpressions.dll

Sestavení:: System.dll

Sestavení:: netstandard.dll

Zdroj:: Capture.cs

Zdroj:: Capture.cs

Zdroj:: Capture.cs

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í.

Získá zachycený podřetězcec ze vstupního řetězce.

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

public string Value { get; }

member this.Value : string

Public ReadOnly Property Value As String

Hodnota vlastnosti

String

Podřetěc, který je zachycen pomocí shody.

Příklady

Následující příklad definuje regulární výraz, který odpovídá větám, které neobsahují žádnou interpunkci kromě tečky ("."). Vlastnost Match.Value zobrazí výsledný řetězec, který se skládá z odpovídající věty, pro každou shodu. Vlastnost Group.Value zobrazuje výsledný řetězec pro každou zachytávající skupinu; skládá se z posledního řetězce zachyceného zachytávající skupinou. Vlastnost Capture.Value zobrazí výsledný řetězec pro každý záznam.

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

Vzor ((\w+)[\s.])+ regulárního výrazu je definovaný tak, jak je znázorněno v následující tabulce. Všimněte si, že v tomto regulárním výrazu se na celý regulární výraz použije kvantifikátor (+).

Vzor	Description
`(\w+)`	Porovná jeden nebo více znaků slova. Toto je druhá zachytávající skupina.
`[\s.])`	Spárovat prázdný znak nebo tečku (".").
`((\w+)[\s.])`	Porovná jeden nebo více znaků slova následovaných prázdným znakem nebo tečkou ("."). Toto je první zachytávající skupina.
`((\w+)[\s.])+`	Porovná jeden nebo více výskytů znaku slova nebo znaků následovaných prázdným znakem nebo tečkou (".").

V tomto příkladu se vstupní řetězec skládá ze dvou vět. Jak ukazuje výstup, první věta se skládá pouze z jednoho slova, takže CaptureCollection objekt má jeden Capture objekt, který představuje stejný záznam jako Group objekt. Druhá věta se skládá z více slov, takže Group objekty obsahují pouze informace o posledním odpovídajícím dílčím výrazu. Skupina 1, která představuje první záznam, obsahuje poslední slovo ve větě, která má uzavírací období. Skupina 2, která představuje druhý záznam, obsahuje poslední slovo ve větě. Capture Objekty v objektu skupiny CaptureCollection však zachytávají jednotlivé dílčí výrazy. Objekty Capture v kolekci zachycení první zachytávající skupiny obsahují informace o jednotlivých zachycených slovech a prázdných znacích nebo tečkách. Objekty Capture v kolekci zachytávání druhé skupiny obsahují informace o jednotlivých zachycených slovech.

Následující příklad používá vzor regulárního výrazu , ^([a-z]+)(\d+)*\.([a-z]+(\d)*)$který odpovídá číslu výrobku, který se skládá ze dvou částí oddělených tečkou. Obě části se skládají z abecedních znaků následovaných volitelnými čísly. Vzhledem k tomu, že první vstupní řetězec neodpovídá vzoru, hodnota vlastnosti vráceného System.Text.RegularExpressions.Match objektu Value je String.Empty. Podobně platí, že pokud se vzor regulárního výrazu nemůže shodovat se zachytávající skupinou, hodnota vlastnosti odpovídajícího Group objektu Value je 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

Vzor regulárního výrazu je definovaný tak, jak je znázorněno v následující tabulce:

Vzor	Description
`^`	Zahajte shodu na začátku řetězce.
`([a-z]+)`	Porovná jeden nebo více výskytů libovolného znaku od a do z. Vzhledem k tomu, že modul regulárních výrazů je předán RegexOptions.IgnoreCase možnost, toto porovnání nerozlišuje velká a malá písmena. Toto je první zachytávající skupina.
`(\d+)?`	Porovná nula nebo jeden výskyt jedné nebo více desetinných číslic. Toto je druhá zachytávající skupina.
`\.`	Porovná znak literálu tečky.
`([a-z]+`	Porovná jeden nebo více výskytů libovolného znaku od a do z. Při porovnání se nerozlišují malá a velká písmena.
`(\d)*`	Porovná žádnou nebo několik desítkových číslic. Jedna shodná číslice je čtvrtá zachytácí skupina.
`([a-z]+(\d)*)`	Porovná jeden nebo více abecedních znaků od a do z následovaných nulou, jednou nebo více desetinnými číslicemi. Toto je čtvrtá zachycená skupina.
`$`	Na konci řetězce uzavřete shodu.

Poznámky

Pokud se Regex.Match volání metody nebo Match.NextMatch nepodaří najít shodu, hodnota vrácené Match.Value vlastnosti je String.Empty. Pokud modul regulárních výrazů nemůže odpovídat zachytávající skupině. hodnota vrácené Group.Value vlastnosti je String.Empty. Podívejte se na druhý příklad pro ilustraci.

Platí pro

Sdílet prostřednictvím