Capture.Value Propiedad

Referencia

Definición

Espacio de nombres:: System.Text.RegularExpressions

Ensamblado:: System.Text.RegularExpressions.dll

Ensamblado:: System.dll

Ensamblado:: netstandard.dll

Source:: Capture.cs

Source:: Capture.cs

Source:: Capture.cs

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Obtiene la subcadena capturada desde la cadena de entrada.

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

public string Value { get; }

member this.Value : string

Public ReadOnly Property Value As String

Valor de propiedad

String

Subcadena capturada por la coincidencia.

Ejemplos

En el ejemplo siguiente se define una expresión regular que coincide con las oraciones que no contienen signos de puntuación excepto un punto ("."). La Match.Value propiedad muestra la cadena de resultado, que consta de una oración coincidente, para cada coincidencia. La Group.Value propiedad muestra la cadena de resultado de cada grupo de captura; consta de la última cadena capturada por ese grupo de captura. La Capture.Value propiedad muestra la cadena de resultado de cada captura.

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

El patrón de expresión regular ((\w+)[\s.])+ se define como se muestra en la tabla siguiente. Tenga en cuenta que, en esta expresión regular, se aplica un cuantificador (+) a toda la expresión regular.

Modelo	Descripción
`(\w+)`	Buscar coincidencias con uno o más caracteres alfabéticos. Este es el segundo grupo de captura.
`[\s.])`	Coincide con un carácter de espacio en blanco o un punto (".").
`((\w+)[\s.])`	Coincide con uno o varios caracteres de palabra seguidos de un carácter de espacio en blanco o un punto ("."). Este es el primer grupo de captura.
`((\w+)[\s.])+`	Coincide con una o varias apariciones de un carácter de palabra o caracteres seguidos de un carácter de espacio en blanco o un punto (".").

En este ejemplo, la cadena de entrada consta de dos oraciones. Como se muestra en la salida, la primera oración consta de una sola palabra, por lo que el CaptureCollection objeto tiene un solo Capture objeto que representa la misma captura que el Group objeto . La segunda oración consta de varias palabras, por lo que los Group objetos solo contienen información sobre la última subexpresión coincidente. El grupo 1, que representa la primera captura, contiene la última palabra de la frase que tiene un período de cierre. El grupo 2, que representa la segunda captura, contiene la última palabra de la oración. Sin embargo, los Capture objetos del objeto del CaptureCollection grupo capturan cada coincidencia de subexpresión. Los Capture objetos de la primera colección de capturas del grupo de capturas contienen información sobre cada palabra capturada y el carácter o punto de espacio en blanco. Los Capture objetos de la segunda colección de capturas del grupo de capturas contienen información sobre cada palabra capturada.

En el ejemplo siguiente se usa un patrón de expresión regular, ^([a-z]+)(\d+)*\.([a-z]+(\d)*)$, para que coincida con un número de producto que consta de dos partes separadas por un punto. Ambas partes constan de caracteres alfabéticos seguidos de números opcionales. Dado que la primera cadena de entrada no coincide con el patrón, el valor de la propiedad del Value objeto devuelto System.Text.RegularExpressions.Match es String.Empty. De forma similar, cuando el patrón de expresión regular no puede coincidir con un grupo de captura, el valor de la propiedad del Value objeto correspondiente Group es 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

El patrón de expresión regular se define como se muestra en la tabla siguiente:

Modelo	Descripción
`^`	Empieza la búsqueda de coincidencias en el principio de la cadena.
`([a-z]+)`	Coincide con una o varias apariciones de cualquier carácter de a a z. Dado que el motor de expresiones regulares se pasa a la RegexOptions.IgnoreCase opción , esta comparación no distingue mayúsculas de minúsculas. Este es el primer grupo de captura.
`(\d+)?`	Coincide con cero o una aparición de uno o varios dígitos decimales. Este es el segundo grupo de captura.
`\.`	Coincide con un carácter de punto literal.
`([a-z]+`	Coincide con una o varias apariciones de cualquier carácter de a a z. La comparación distingue entre mayúsculas y minúsculas.
`(\d)*`	Busca cero o más dígitos decimales. Un único dígito coincidente es el cuarto grupo de captura.
`([a-z]+(\d)*)`	Coincide con uno o varios caracteres alfabéticos de a z seguidos de cero, uno o más dígitos decimales. Este es el cuarto grupo de captura.
`$`	Concluir la coincidencia al final de la cadena.

Comentarios

Si una llamada al Regex.Match método o Match.NextMatch no encuentra una coincidencia, el valor de la propiedad devuelta Match.Value es String.Empty. Si el motor de expresiones regulares no puede coincidir con un grupo de captura. el valor de la propiedad devuelta Group.Value es String.Empty. Vea el segundo ejemplo para obtener una ilustración.

Se aplica a

Compartir a través de