Capture.Value Eigenschaft
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Ruft die erfasste Teilzeichenfolge aus der Eingabezeichenfolge ab.
public:
property System::String ^ Value { System::String ^ get(); };public string Value { get; }member this.Value : stringPublic ReadOnly Property Value As StringEigenschaftswert
Die Teilzeichenfolge, die von der Übereinstimmung erfasst wird.
Beispiele
Im folgenden Beispiel wird ein regulärer Ausdruck definiert, der mit Sätzen übereinstimmt, die keine Interpunktion mit Ausnahme eines Punkts (".") enthalten. Die Match.Value Eigenschaft zeigt die Ergebniszeichenfolge an, die aus einem übereinstimmenden Satz für jede Übereinstimmung besteht. Die Group.Value Eigenschaft zeigt die Ergebniszeichenfolge für jede Aufnahmegruppe an. Sie besteht aus der letzten Zeichenfolge, die von dieser Aufnahmegruppe erfasst wird. Die Capture.Value Eigenschaft zeigt die Ergebniszeichenfolge für jede Aufnahme an.
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
Das Muster ((\w+)[\s.])+ für reguläre Ausdrücke ist wie in der folgenden Tabelle dargestellt definiert. Beachten Sie, dass in diesem regulären Ausdruck ein Quantifizierer (+) auf den gesamten regulären Ausdruck angewendet wird.
| Schema | Beschreibung |
|---|---|
(\w+) |
Übereinstimmung mit mindestens einem Wortzeichen. Dies ist die zweite Erfassungsgruppe. |
[\s.]) |
Entspricht einem Leerzeichen oder Punkt ("."). |
((\w+)[\s.]) |
Entspricht einem oder mehreren Wortzeichen, gefolgt von einem Leerzeichen oder Punkt ("."). Dies ist die erste Erfassungsgruppe. |
((\w+)[\s.])+ |
Entspricht einem oder mehreren Vorkommen eines Wortzeichens oder Zeichens gefolgt von einem Leerzeichen oder Punkt ("."). |
In diesem Beispiel besteht die Eingabezeichenfolge aus zwei Sätzen. Wie die Ausgabe zeigt, besteht der erste Satz aus nur einem Wort, sodass das CaptureCollection Objekt über ein einzelnes Capture Objekt verfügt, das dieselbe Aufnahme wie das Group Objekt darstellt. Der zweite Satz besteht aus mehreren Wörtern, sodass die Group Objekte nur Informationen über den letzten übereinstimmenen Unterausdruck enthalten. Gruppe 1, die die erste Erfassung darstellt, enthält das letzte Wort im Satz mit einem Abschlusszeitraum. Gruppe 2, die die zweite Aufnahme darstellt, enthält das letzte Wort im Satz. Capture Die Objekte im Objekt der Gruppe CaptureCollection erfassen jedoch jede Teilausdruckübereinstimmung. Die Capture Objekte in der Sammlung der Erfassungsgruppen enthalten Informationen zu den einzelnen erfassten Wörtern und Leerzeichen oder Punkt. Die Capture Objekte in der Sammlung der Erfassungsgruppen enthalten Informationen zu jedem erfassten Wort.
Im folgenden Beispiel wird ein Muster für reguläre Ausdrücke verwendet, um eine Produktnummer abzugleichen, ^([a-z]+)(\d+)*\.([a-z]+(\d)*)$die aus zwei Teilen besteht, die durch einen Punkt getrennt sind. Beide Teile bestehen aus alphabetischen Zeichen, gefolgt von optionalen Zahlen. Da die erste Eingabezeichenfolge nicht mit dem Muster übereinstimmt, lautet String.Emptyder Wert der Eigenschaft des zurückgegebenen System.Text.RegularExpressions.MatchValue Objekts. Wenn das Muster für reguläre Ausdrücke nicht mit einer Aufnahmegruppe übereinstimmen kann, lautet String.Emptyder Wert der Eigenschaft des entsprechenden Group ObjektsValue.
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
Das Muster für reguläre Ausdrücke wird entsprechend der folgenden Tabelle definiert:
| Schema | Beschreibung |
|---|---|
^ |
Beginnt die Suche am Anfang der Zeichenfolge. |
([a-z]+) |
Entspricht einem oder mehreren Vorkommen eines beliebigen Zeichens von a bis z. Da das Modul für reguläre Ausdrücke die RegexOptions.IgnoreCase Option übergeben wird, wird bei diesem Vergleich die Groß-/Kleinschreibung nicht beachtet. Dies ist die erste Erfassungsgruppe. |
(\d+)? |
Entspricht null oder einem Vorkommen einer oder mehrerer Dezimalstellen. Dies ist die zweite Erfassungsgruppe. |
\. |
Entspricht einem Literalperiodenzeichen. |
([a-z]+ |
Entspricht einem oder mehreren Vorkommen eines beliebigen Zeichens von a bis z. Bei dem Vergleich wird Groß- und Kleinschreibung nicht unterschieden. |
(\d)* |
Übereinstimmung mit null oder mehr Dezimalziffern. Eine einzelne übereinstimmende Ziffer ist die vierte Erfassungsgruppe. |
([a-z]+(\d)*) |
Entspricht einem oder mehreren alphabetischen Zeichen von a bis z gefolgt von Null, einer oder mehreren Dezimalziffern. Dies ist die vierte Erfassungsgruppe. |
$ |
Schließen Sie die Übereinstimmung am Ende der Zeichenfolge ab. |
Hinweise
Wenn ein Aufruf der Regex.Match Oder-Methode Match.NextMatch keine Übereinstimmung findet, lautet String.Emptyder Wert der zurückgegebenen Match.Value Eigenschaft . Wenn das Modul für reguläre Ausdrücke keine Übereinstimmung mit einer Aufnahmegruppe herstellen kann. der Wert der zurückgegebenen Group.Value Eigenschaft lautet String.Empty. Eine Abbildung finden Sie im zweiten Beispiel.
