Clases de expresiones regulares
En las siguientes secciones se describen las clases de expresiones regulares de .NET Framework.
Regex
La clase Regex representa una expresión regular inmutable (de sólo lectura). Contiene también métodos estáticos que permiten utilizar otras clases de expresiones regulares sin crear explícitamente instancias de objetos de las otras clases.
En el siguiente ejemplo de código se crea una instancia de la clase Regex y se define una expresión regular simple cuando se inicializa el objeto. Observe que se utiliza una barra diagonal inversa adicional como carácter de escape para indicar que la barra diagonal inversa de la clase de caracteres de coincidencia \\s debe interpretarse como un literal de cadena.
' Declare object variable of type Regex.
Dim r As Regex
' Create a Regex object and define its regular expression.
r = New Regex("\s2000")
// Declare object variable of type Regex.
Regex r;
// Create a Regex object and define its regular expression.
r = new Regex("\\s2000");
Match
La clase Match representa el resultado de una operación de búsqueda de coincidencias de expresiones regulares. En el ejemplo siguiente se utiliza el método Match de la clase Regex para devolver un objeto de tipo Match con el fin de buscar la primera coincidencia de la cadena de entrada. En el ejemplo se utiliza la propiedad Match.Success de la clase Match para indicar si se ha encontrado alguna coincidencia.
' cCreate a new Regex object.
Dim r As New Regex("abc")
' Find a single match in the input string.
Dim m As Match = r.Match("123abc456")
If m.Success Then
' Print out the character position where a match was found.
' (Character position 3 in this case.)
Console.WriteLine("Found match at position " & m.Index.ToString())
End If
// Create a new Regex object.
Regex r = new Regex("abc");
// Find a single match in the string.
Match m = r.Match("123abc456");
if (m.Success)
{
// Print out the character position where a match was found.
// (Character position 3 in this case.)
Console.WriteLine("Found match at position " + m.Index);
}
MatchCollection
La clase MatchCollection representa una secuencia de coincidencias correctas no solapadas. La colección es inmutable (de sólo lectura) y no tiene constructor público. El método Regex.Matches devuelve instancias de MatchCollection.
En el siguiente ejemplo se utiliza el método Matches de la clase Regex para rellenar MatchCollection con todas las coincidencias encontradas en la cadena de entrada. En este ejemplo se copia la colección en una matriz de cadenas que almacena las coincidencias y en una matriz de enteros que indica la posición de cada una de ellas.
Dim mc As MatchCollection
Dim results(20) As String
Dim matchposition(20) As Integer
' Create a new Regex object and define the regular expression.
Dim r As New Regex("abc")
' Use the Matches method to find all matches in the input string.
mc = r.Matches("123abc4abcd")
' Loop through the match collection to retrieve all
' matches and positions.
Dim i As Integer
For i = 0 To mc.Count - 1
' Add the match string to the string array.
results(i) = mc(i).Value
' Record the character position where the match was found.
matchposition(i) = mc(i).Index
Next i
MatchCollection mc;
String[] results = new String[20];
int[] matchposition = new int[20];
// Create a new Regex object and define the regular expression.
Regex r = new Regex("abc");
// Use the Matches method to find all matches in the input string.
mc = r.Matches("123abc4abcd");
// Loop through the match collection to retrieve all
// matches and positions.
for (int i = 0; i < mc.Count; i++)
{
// Add the match string to the string array.
results[i] = mc[i].Value;
// Record the character position where the match was found.
matchposition[i] = mc[i].Index;
}
GroupCollection
La clase GroupCollection representa una colección de grupos capturados y devuelve el conjunto de grupos capturados en una única coincidencia. La colección es inmutable (de sólo lectura) y no tiene constructor público. Las instancias de GroupCollection se devuelven en la colección que devuelve la propiedad Match.Groups.
En el siguiente ejemplo de aplicación de consola se busca e imprime el número de grupos capturados por una expresión regular. Para ver la forma en que se extraen las capturas individuales en cada miembro de una colección de grupos, vea el ejemplo Capture Collection de la siguiente sección.
Imports System
Imports System.Text.RegularExpressions
Public Class RegexTest
Public Shared Sub RunTest()
' Define groups "abc", "ab", and "b".
Dim r As New Regex("(a(b))c")
Dim m As Match = r.Match("abdabc")
Console.WriteLine("Number of groups found = " _
& m.Groups.Count.ToString())
End Sub
Public Shared Sub Main()
RunTest()
End Sub
End Class
using System;
using System.Text.RegularExpressions;
public class RegexTest
{
public static void RunTest()
{
// Define groups "abc", "ab", and "b".
Regex r = new Regex("(a(b))c");
Match m = r.Match("abdabc");
Console.WriteLine("Number of groups found = " + m.Groups.Count);
}
public static void Main()
{
RunTest();
}
}
Este ejemplo produce el siguiente resultado.
Number of groups found = 3
Number of groups found = 3
CaptureCollection
La clase CaptureCollection representa una secuencia de subcadenas capturadas y devuelve el conjunto de capturas realizadas por un único grupo de capturas. Un grupo de capturas puede capturar más de una cadena en una única coincidencia gracias a los cuantificadores. La propiedad Captures, que es un objeto de la clase CaptureCollection, se proporciona como miembro de las clases Match y Group para facilitar el acceso al conjunto de subcadenas capturadas.
Si utiliza, por ejemplo, la expresión regular ((a(b))c)+ (en la que el cuantificador + indica una o varias coincidencias) para capturar coincidencias de la cadena abcabcabc, la CaptureCollection de cada Group coincidente de subcadenas contendrá tres miembros.
En el siguiente ejemplo de aplicación de consola se utiliza la expresión regular (Abc)+ para buscar una o más coincidencias de la cadena XYZAbcAbcAbcXYZAbcAb. El ejemplo ilustra la forma en que se utiliza la propiedad Captures para que devuelva varios grupos de subcadenas capturadas.
Imports System
Imports System.Text.RegularExpressions
Public Class RegexTest
Public Shared Sub RunTest()
Dim counter As Integer
Dim m As Match
Dim cc As CaptureCollection
Dim gc As GroupCollection
' Look for groupings of "Abc".
Dim r As New Regex("(Abc)+")
' Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb")
gc = m.Groups
' Print the number of groups.
Console.WriteLine("Captured groups = " & gc.Count.ToString())
' Loop through each group.
Dim i, ii As Integer
For i = 0 To gc.Count - 1
cc = gc(i).Captures
counter = cc.Count
' Print number of captures in this group.
Console.WriteLine("Captures count = " & counter.ToString())
' Loop through each capture in group.
For ii = 0 To counter - 1
' Print capture and position.
Console.WriteLine(cc(ii).ToString() _
& " Starts at character " & cc(ii).Index.ToString())
Next ii
Next i
End Sub
Public Shared Sub Main()
RunTest()
End Sub
End Class
using System;
using System.Text.RegularExpressions;
public class RegexTest
{
public static void RunTest()
{
int counter;
Match m;
CaptureCollection cc;
GroupCollection gc;
// Look for groupings of "Abc".
Regex r = new Regex("(Abc)+");
// Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb");
gc = m.Groups;
// Print the number of groups.
Console.WriteLine("Captured groups = " + gc.Count.ToString());
// Loop through each group.
for (int i=0; i < gc.Count; i++)
{
cc = gc[i].Captures;
counter = cc.Count;
// Print number of captures in this group.
Console.WriteLine("Captures count = " + counter.ToString());
// Loop through each capture in group.
for (int ii = 0; ii < counter; ii++)
{
// Print capture and position.
Console.WriteLine(cc[ii] + " Starts at character " +
cc[ii].Index);
}
}
}
public static void Main() {
RunTest();
}
}
Este ejemplo devuelve el siguiente resultado.
Captured groups = 2
Captures count = 1
AbcAbcAbc Starts at character 3
Captures count = 3
Abc Starts at character 3
Abc Starts at character 6
Abc Starts at character 9
Captured groups = 2
Captures count = 1
AbcAbcAbc Starts at character 3
Captures count = 3
Abc Starts at character 3
Abc Starts at character 6
Abc Starts at character 9
Grupo
La clase Group representa el resultado de un único grupo de capturas. Dado que Group puede capturar ninguna, una o varias cadenas en una sola coincidencia (mediante los cuantificadores), contiene una colección de objetos Capture. Como Group se hereda de Capture, se puede tener acceso directo a la última subcadena capturada directamente (la propia instancia de Group es equivalente al último elemento de la colección devuelto por la propiedad Captures).
Las instancias de Group son devueltas al indizar el objeto GroupCollection devuelto por la propiedad Groups. El indizador puede ser un número de grupo o el nombre de un grupo captura si se utiliza el "(?<groupname>)" que agrupa la construcción. Por ejemplo, en código de C# puede utilizar Match.Groups[groupnum] o Match.Groups["groupname"]o en código de Visual Basic puede utilizar Match.Groups(groupnum) o Match.Groups("groupname").
En el siguiente ejemplo de código se utilizan construcciones de agrupamiento anidadas para capturar subcadenas en grupos.
Dim matchposition(20) As Integer
Dim results(20) As String
' Define substrings abc, ab, b.
Dim r As New Regex("(a(b))c")
Dim m As Match = r.Match("abdabc")
Dim i As Integer = 0
While Not (m.Groups(i).Value = "")
' Copy groups to string array.
results(i) = m.Groups(i).Value
' Record character position.
matchposition(i) = m.Groups(i).Index
i = i + 1
End While
int[] matchposition = new int[20];
String[] results = new String[20];
// Define substrings abc, ab, b.
Regex r = new Regex("(a(b))c");
Match m = r.Match("abdabc");
for (int i = 0; m.Groups[i].Value != ""; i++)
{
// Copy groups to string array.
results[i]=m.Groups[i].Value;
// Record character position.
matchposition[i] = m.Groups[i].Index;
}
Este ejemplo devuelve el siguiente resultado.
results(0) = "abc" matchposition(0) = 3
results(1) = "ab" matchposition(1) = 3
results(2) = "b" matchposition(2) = 4
results[0] = "abc" matchposition[0] = 3
results[1] = "ab" matchposition[1] = 3
results[2] = "b" matchposition[2] = 4
En el siguiente ejemplo de código se utilizan construcciones de agrupamiento con nombre para capturar subcadenas de una cadena que contiene datos en un formato "NOMBREDATOS:VALOR" que la expresión regular divide por el signo de dos puntos (:).
Dim r As New Regex("^(?<name>\w+):(?<value>\w+)")
Dim m As Match = r.Match("Section1:119900")
Regex r = new Regex("^(?<name>\\w+):(?<value>\\w+)");
Match m = r.Match("Section1:119900");
Esta expresión regular devuelve el siguiente resultado.
m.Groups("name").Value = "Section1"
m.Groups("value").Value = "119900"
m.Groups["name"].Value = "Section1"
m.Groups["value"].Value = "119900"
Capture
La clase Capture contiene el resultado de una única captura de subexpresiones.
En el siguiente ejemplo se recorre mediante un bucle una colección Group, se extrae la colección Capture de cada miembro de Group y se asignan las variables posn y length a la posición de carácter de la cadena original donde se encontró cada cadena Capture y a la longitud de cada cadena Capture, respectivamente.
Dim r As Regex
Dim m As Match
Dim cc As CaptureCollection
Dim posn, length As Integer
r = New Regex("(abc)+")
m = r.Match("bcabcabc")
Dim i, j As Integer
i = 0
While m.Groups(i).Value <> ""
' Grab the Collection for Group(i).
cc = m.Groups(i).Captures
For j = 0 To cc.Count - 1
' Position of Capture object.
posn = cc(j).Index
' Length of Capture object.
length = cc(j).Length
Next j
i += 1
End While
Regex r;
Match m;
CaptureCollection cc;
int posn, length;
r = new Regex("(abc)+");
m = r.Match("bcabcabc");
for (int i=0; m.Groups[i].Value != ""; i++)
{
// Capture the Collection for Group(i).
cc = m.Groups[i].Captures;
for (int j = 0; j < cc.Count; j++)
{
// Position of Capture object.
posn = cc[j].Index;
// Length of Capture object.
length = cc[j].Length;
}
}
Vea también
Referencia
System.Text.RegularExpressions