Capture.Value Propriedade

Definição

Obtém a subcadeia de caracteres capturada da cadeia de caracteres de entrada.Gets the captured substring from the input string.

public:
 property System::String ^ Value { System::String ^ get(); };
public string Value { get; }
member this.Value : string
Public ReadOnly Property Value As String

Valor da propriedade

A subcadeia de caracteres capturada pela correspondência.The substring that is captured by the match.

Exemplos

O exemplo a seguir define uma expressão regular que corresponde a frases que não contêm nenhuma pontuação, exceto por um ponto (".").The following example defines a regular expression that matches sentences that contain no punctuation except for a period ("."). A propriedade Match.Value exibe a cadeia de caracteres de resultado, que consiste em uma frase correspondente, para cada correspondência.The Match.Value property displays the result string, which consists of a matched sentence, for each match. A propriedade Group.Value exibe a cadeia de caracteres de resultado para cada grupo de captura; Ele consiste na última cadeia de caracteres capturada por esse grupo de captura.The Group.Value property displays the result string for each capturing group; it consists of the last string captured by that capturing group. A propriedade Capture.Value exibe a cadeia de caracteres de resultado para cada captura.The Capture.Value property displays the result string for each capture.

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

O padrão de expressão regular ((\w+)[\s.])+ é definido conforme mostrado na tabela a seguir.The regular expression pattern ((\w+)[\s.])+ is defined as shown in the following table. Observe que nessa expressão regular, um quantificador (+) é aplicado à expressão regular inteira.Note that in this regular expression, a quantifier (+) is applied to the entire regular expression.

PadrãoPattern DescriçãoDescription
(\w+) Corresponde a um ou mais caracteres de palavra.Match one or more word characters. Este é o segundo grupo de captura.This is the second capturing group.
[\s.]) Corresponder a um caractere de espaço em branco ou ponto (".").Match a white-space character or period (".").
((\w+)[\s.]) Corresponder um ou mais caracteres de palavra seguidos por um caractere de espaço em branco ou ponto (".").Match one or more word characters followed by a white-space character or period ("."). Este é o primeiro grupo de captura.This is the first capturing group.
((\w+)[\s.])+ Corresponder uma ou mais ocorrências de um caractere ou caracteres de palavra seguidos por um caractere de espaço em branco ou ponto (".").Match one or more occurrences of a word character or characters followed by a white-space character or period (".").

Neste exemplo, a cadeia de caracteres de entrada consiste em duas frases.In this example, the input string consists of two sentences. Como mostra a saída, a primeira sentença consiste em apenas uma palavra, portanto, o objeto CaptureCollection tem um único objeto Capture que representa a mesma captura que o objeto Group.As the output shows, the first sentence consists of only one word, so the CaptureCollection object has a single Capture object that represents the same capture as the Group object. A segunda sentença consiste em várias palavras, portanto, os objetos Group contêm apenas informações sobre a última subexpressão correspondida.The second sentence consists of multiple words, so the Group objects only contain information about the last matched subexpression. O grupo 1, que representa a primeira captura, contém a última palavra na frase que tem um período de fechamento.Group 1, which represents the first capture, contains the last word in the sentence that has a closing period. O grupo 2, que representa a segunda captura, contém a última palavra da sentença.Group 2, which represents the second capture, contains the last word in the sentence. No entanto, os objetos Capture no objeto CaptureCollection do grupo capturam cada subexpressão correspondente.However, the Capture objects in the group's CaptureCollection object capture each subexpression match. Os objetos Capture na primeira coleção de capturas do grupo de captura contêm informações sobre cada palavra capturada e o caractere de espaço em branco ou o ponto.The Capture objects in the first capturing group's collection of captures contain information about each captured word and white-space character or period. O Capture objetos na coleção de capturas do segundo grupo de captura contêm informações sobre cada palavra capturada.The Capture objects in the second capturing group's collection of captures contain information about each captured word.

O exemplo a seguir usa um padrão de expressão regular, ^([a-z]+)(\d+)*\.([a-z]+(\d)*)$, para corresponder a um número de produto que consiste em duas partes separadas por um ponto.The following example uses a regular expression pattern, ^([a-z]+)(\d+)*\.([a-z]+(\d)*)$, to match a product number that consists of two parts separated by a period. Ambas as partes consistem em caracteres alfabéticos seguidos por números opcionais.Both parts consist of alphabetic characters followed by optional numbers. Como a primeira cadeia de caracteres de entrada não corresponde ao padrão, o valor da propriedade Value do objeto de System.Text.RegularExpressions.Match retornado é String.Empty.Because the first input string does not match the pattern, the value of the returned System.Text.RegularExpressions.Match object's Value property is String.Empty. Da mesma forma, quando o padrão de expressão regular não é capaz de corresponder a um grupo de captura, o valor da propriedade Value do objeto de Group correspondente é String.Empty.Similarly, when the regular expression pattern is unable to match a capturing group, the value of the corresponding Group object's Value property is 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

O padrão de expressão regular é definido como mostrado na tabela a seguir:The regular expression pattern is defined as shown in the following table:

PadrãoPattern DescriçãoDescription
^ Começar a correspondência no início da cadeia de caracteres.Begin the match at the beginning of the string.
([a-z]+) Corresponder uma ou mais ocorrências de qualquer caractere de a a z.Match one or more occurrences of any character from a to z. Como o mecanismo de expressão regular passa a opção RegexOptions.IgnoreCase, essa comparação não diferencia maiúsculas de minúsculas.Because the regular expression engine is passed the RegexOptions.IgnoreCase option, this comparison is case-insensitive. Este é o primeiro grupo de captura.This is the first capturing group.
(\d+)? Corresponder a zero ou uma ocorrência de um ou mais dígitos decimais.Match zero or one occurrence of one or more decimal digits. Este é o segundo grupo de captura.This is the second capturing group.
\. Corresponde a um caractere de período literal.Match a literal period character.
([a-z]+ Corresponder uma ou mais ocorrências de qualquer caractere de a a z.Match one or more occurrences of any character from a to z. A comparação não diferencia maiúsculas de minúsculas.The comparison is case-insensitive.
(\d)* Corresponde a zero ou mais dígitos decimais.Match zero or more decimal digits. Um único dígito correspondente é o quarto grupo de captura.A single matched digit is the fourth capturing group.
([a-z]+(\d)*) Corresponder um ou mais caracteres alfabéticos de a a z seguidos por zero, um ou mais dígitos decimais.Match one or more alphabetic characters from a to z followed by zero, one, or more decimal digits. Este é o quarto grupo de captura.This is the fourth capturing group.
$ Conclua a correspondência no final da cadeia de caracteres.Conclude the match at the end of the string.

Comentários

Se uma chamada para o método Regex.Match ou Match.NextMatch falhar ao localizar uma correspondência, o valor da propriedade Match.Value retornada será String.Empty.If a call to the Regex.Match or Match.NextMatch method fails to find a match, the value of the returned Match.Value property is String.Empty. Se o mecanismo de expressões regulares não puder corresponder a um grupo de captura.If the regular expression engine is unable to match a capturing group. o valor da propriedade Group.Value retornada é String.Empty.the value of the returned Group.Value property is String.Empty. Consulte o segundo exemplo para uma ilustração.See the second example for an illustration.

Aplica-se a