Capture.Value Propriété

Référence

Définition

Espace de noms:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Source:: Capture.cs

Source:: Capture.cs

Source:: Capture.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Obtient la sous-chaîne capturée à partir de la chaîne d'entrée.

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

public string Value { get; }

member this.Value : string

Public ReadOnly Property Value As String

Valeur de propriété

String

Sous-chaîne qui est capturée par la correspondance.

Exemples

L’exemple suivant définit une expression régulière qui correspond à des phrases qui ne contiennent aucune ponctuation à l’exception d’un point (« . »). La Match.Value propriété affiche la chaîne de résultat, qui se compose d’une phrase correspondante, pour chaque correspondance. La Group.Value propriété affiche la chaîne de résultat pour chaque groupe de capture ; elle se compose de la dernière chaîne capturée par ce groupe de capture. La Capture.Value propriété affiche la chaîne de résultat pour chaque 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

Le modèle d'expression régulière ((\w+)[\s.])+ est défini comme indiqué dans le tableau suivant. Notez que dans cette expression régulière, un quantificateur (+) est appliqué à l’expression régulière entière.

Modèle	Description
`(\w+)`	Mettre en correspondance un ou plusieurs caractères alphabétiques. Il s'agit du deuxième groupe de capture.
`[\s.])`	Faire correspondre un espace blanc ou un point (« . »).
`((\w+)[\s.])`	Faire correspondre un ou plusieurs caractères de mot suivis d’un espace blanc ou d’un point (« . »). Il s'agit du premier groupe de capture.
`((\w+)[\s.])+`	Faire correspondre une ou plusieurs occurrences d’un ou plusieurs caractères de mot suivis d’un espace blanc ou d’un point (« . »).

Dans cet exemple, la chaîne d’entrée se compose de deux phrases. Comme le montre la sortie, la première phrase se compose d’un seul mot, de sorte que l’objet CaptureCollection a un seul Capture objet qui représente la même capture que l’objet Group . La deuxième phrase se compose de plusieurs mots, de sorte que les Group objets contiennent uniquement des informations sur la dernière sous-expression correspondante. Le groupe 1, qui représente la première capture, contient le dernier mot de la phrase qui a un point de fermeture. Le groupe 2, qui représente la deuxième capture, contient le dernier mot de la phrase. Toutefois, les Capture objets dans l’objet du CaptureCollection groupe capturent chaque correspondance de sous-expression. Les Capture objets de la collection de captures du premier groupe de captures contiennent des informations sur chaque mot et chaque point ou caractère d’espace blanc capturés. Les Capture objets du deuxième groupe de captures contiennent des informations sur chaque mot capturé.

L’exemple suivant utilise un modèle d’expression régulière, ^([a-z]+)(\d+)*\.([a-z]+(\d)*)$, pour faire correspondre un numéro de produit qui se compose de deux parties séparées par un point. Les deux parties se composent de caractères alphabétiques suivis de nombres facultatifs. Étant donné que la première chaîne d’entrée ne correspond pas au modèle, la valeur de la propriété de Value l’objet retourné System.Text.RegularExpressions.Match est String.Empty. De même, lorsque le modèle d’expression régulière ne peut pas correspondre à un groupe de capture, la valeur de la propriété de Value l’objet correspondant Group est 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

Le modèle d’expression régulière est défini comme indiqué dans le tableau suivant :

Modèle	Description
`^`	Commencer la correspondance au début de la chaîne.
`([a-z]+)`	Faire correspondre une ou plusieurs occurrences d’un caractère de a à z. Étant donné que l’option est transmise RegexOptions.IgnoreCase au moteur d’expression régulière, cette comparaison ne respecte pas la casse. Il s'agit du premier groupe de capture.
`(\d+)?`	Mettre en correspondance zéro ou une occurrence d’un ou plusieurs chiffres décimaux. Il s'agit du deuxième groupe de capture.
`\.`	Correspond à un caractère de période littéral.
`([a-z]+`	Faire correspondre une ou plusieurs occurrences d’un caractère de a à z. La comparaison respecte la casse.
`(\d)*`	Met en correspondance zéro ou plusieurs chiffres décimaux. Un seul chiffre correspondant est le quatrième groupe de capture.
`([a-z]+(\d)*)`	Faire correspondre un ou plusieurs caractères alphabétiques de a à z suivis de zéro, un ou plusieurs chiffres décimaux. Il s'agit du quatrième groupe de capture.
`$`	Terminez la correspondance à la fin de la chaîne.

Remarques

Si un appel à la Regex.Match méthode ou Match.NextMatch ne parvient pas à trouver une correspondance, la valeur de la propriété retournée Match.Value est String.Empty. Si le moteur d’expressions régulières ne peut pas correspondre à un groupe de capture. la valeur de la propriété retournée Group.Value est String.Empty. Pour obtenir une illustration, consultez le deuxième exemple.

S’applique à

Partager via