Delimitadores en expresiones regulares
Los delimitadores, o aserciones atómicas de ancho cero, especifican la posición de la cadena en que se debe producir una coincidencia. Cuando se usa un delimitador en una expresión de búsqueda, el motor de expresiones regulares no avanza por la cadena o ni consume caracteres, sino que solo busca una coincidencia en la posición especificada. Por ejemplo, ^ especifica que la coincidencia debe empezar al principio de una cadena o línea. Por consiguiente, la expresión regular ^http: coincide con "http": solo cuando se encuentra al principio de una línea. En la tabla siguiente, se enumeran los delimitadores que admiten las expresiones regulares de .NET.
| Delimitador | Descripción |
|---|---|
^ |
De forma predeterminada, la coincidencia se debe producir al principio de la cadena. Por su parte, en el modo multilínea, se debe producir al principio de la línea. Para obtener más información, vea Principio de cadena o línea. |
$ |
De forma predeterminada, la coincidencia se debe producir al final de la cadena o antes de \n al final de la cadena. Por su parte, en el modo multilínea, se debe producir al final de la línea o antes de \n al final de la línea. Para obtener más información, vea Final de cadena o línea. |
\A |
La coincidencia se debe producir solo al principio de la cadena (no se admiten varias líneas). Para obtener más información, vea Principio de cadena solamente. |
\Z |
La coincidencia se debe producir al final de la cadena o antes de \n al final de la cadena. Para obtener más información, vea Final de cadena o antes de nueva línea al final. |
\z |
La coincidencia se debe producir solo al final de la cadena. Para obtener más información, vea Final de cadena solamente. |
\G |
La coincidencia debe comenzar en la posición donde finalizó la coincidencia anterior, o si no había ninguna coincidencia anterior, en la posición de la cadena donde se inició la búsqueda de coincidencias. Para obtener más información, vea Coincidencias contiguas. |
\b |
La coincidencia se debe producir en un límite de palabras. Para obtener más información, vea Límite de palabras. |
\B |
La coincidencia no se debe producir en un límite de palabras. Para obtener más información, vea Fuera de un límite de palabras. |
Principio de cadena o línea: ^
De forma predeterminada, el delimitador ^ especifica que el patrón siguiente debe comenzar en la posición del primer carácter de la cadena. Si usa ^ con la opción RegexOptions.Multiline (vea Opciones de expresiones regulares), la coincidencia se debe producir al principio de cada línea.
En el ejemplo siguiente se usa el delimitador ^ en una expresión regular que extrae información sobre los años durante los que existieron algunos equipos de béisbol profesionales. En el ejemplo se llama a dos sobrecargas del método Regex.Matches :
La llamada a la sobrecarga Matches(String, String) encuentra solo la primera subcadena que coincide con el patrón de la expresión regular en la cadena de entrada.
La llamada a la sobrecarga Matches(String, String, RegexOptions) con el parámetro
optionsestablecido en RegexOptions.Multiline encuentra las cinco subcadenas.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957\n" +
"Chicago Cubs, National League, 1903-present\n" +
"Detroit Tigers, American League, 1901-present\n" +
"New York Giants, National League, 1885-1957\n" +
"Washington Senators, American League, 1901-1960\n";
string pattern = @"^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+";
Match match;
match = Regex.Match(input, pattern);
while (match.Success)
{
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
match = match.NextMatch();
}
Console.WriteLine();
match = Regex.Match(input, pattern, RegexOptions.Multiline);
while (match.Success)
{
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
match = match.NextMatch();
}
Console.WriteLine();
}
}
// The example displays the following output:
// The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//
// The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
// The Chicago Cubs played in the National League in 1903-present.
// The Detroit Tigers played in the American League in 1901-present.
// The New York Giants played in the National League in 1885-1957.
// The Washington Senators played in the American League in 1901-1960.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf +
"Chicago Cubs, National League, 1903-present" + vbCrLf +
"Detroit Tigers, American League, 1901-present" + vbCrLf +
"New York Giants, National League, 1885-1957" + vbCrLf +
"Washington Senators, American League, 1901-1960" + vbCrLf
Dim pattern As String = "^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+"
Dim match As Match
match = Regex.Match(input, pattern)
Do While match.Success
Console.Write("The {0} played in the {1} in",
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
match = match.NextMatch()
Loop
Console.WriteLine()
match = Regex.Match(input, pattern, RegexOptions.Multiline)
Do While match.Success
Console.Write("The {0} played in the {1} in",
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
match = match.NextMatch()
Loop
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'
' The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
' The Chicago Cubs played in the National League in 1903-present.
' The Detroit Tigers played in the American League in 1901-present.
' The New York Giants played in the National League in 1885-1957.
' The Washington Senators played in the American League in 1901-1960.
El patrón de expresión regular ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+ se define como se muestra en la tabla siguiente.
| Modelo | Descripción |
|---|---|
^ |
Comienza la búsqueda de coincidencias al principio de la cadena de entrada (o al principio de la línea si se llama al método con la opción RegexOptions.Multiline ). |
((\w+(\s?)){2,} |
Coincide con uno o varios caracteres que se usan para formar palabras seguidos de cero o un espacio, al menos dos veces. Este es el primer grupo de captura. Esta expresión también define un segundo y un tercer grupo de capturas: el segundo está compuesto por la palabra capturada, y el tercero está compuesto por el espacio en blanco capturado. |
,\s |
Coincide con una coma seguida de un carácter de espacio en blanco. |
(\w+\s\w+) |
Coincide con uno o varios caracteres que se usan para formar palabras seguidos de un espacio, seguidos de uno o varios caracteres que se usan para formar palabras. Este es el cuarto grupo de captura. |
, |
Coincide con una coma. |
\s\d{4} |
Coincide con un espacio seguido de cuatro dígitos decimales. |
(-(\d{4}|present))? |
Coincide con cero o un guion seguido de cuatro dígitos decimales o de la cadena "present". Este es el sexto grupo de captura. También incluye un séptimo grupo de captura. |
,? |
Coincide con una coma o ninguna. |
(\s\d{4}(-(\d{4}|present))?,?)+ |
Coincide con una o más apariciones de lo siguiente: un espacio, cuatro dígitos decimales, cero o un guion seguido de cuatro dígitos decimales o de la cadena "present", y una coma o ninguna. Este es el quinto grupo de captura. |
Final de cadena o línea: $
El delimitador $ especifica que el patrón que le precede debe aparecer al final de la cadena de entrada o antes de \n al final de la cadena de entrada.
Si usa $ con la opción RegexOptions.Multiline , la coincidencia también se puede producir al final de una línea. Observe que $ se satisface en \n, pero no en \r\n (la combinación de caracteres de retorno de carro y nueva línea, o CR/LF). Para controlar la combinación de caracteres CR/LF, incluya \r?$ en el patrón de expresión regular. Tenga en cuenta que \r?$ incluirá cualquier instancia de \r en la coincidencia.
En el ejemplo siguiente se agrega el delimitador $ al patrón de expresión regular usado en el ejemplo de la sección Principio de cadena o línea . Cuando se usa con la cadena de entrada original, que incluye cinco líneas de texto, el método Regex.Matches(String, String) no puede encontrar una coincidencia, porque el final de la primera línea no coincide con el patrón $ . Cuando la cadena de entrada original se divide en una matriz de cadenas, el método Regex.Matches(String, String) consigue encontrar coincidencias en cada una de las cinco líneas. Cuando se llama al método Regex.Matches(String, String, RegexOptions) con el parámetro options establecido en RegexOptions.Multiline, no se encuentra ninguna coincidencia porque el patrón de la expresión regular no tiene en cuenta el carácter de retorno de carro \r. Sin embargo, cuando el patrón de la expresión regular se modifica al remplazar $ por \r?$, si se llama al método Regex.Matches(String, String, RegexOptions) con el parámetro options establecido en RegexOptions.Multiline , ahora encuentra cinco coincidencias.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string cr = Environment.NewLine;
string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + cr +
"Chicago Cubs, National League, 1903-present" + cr +
"Detroit Tigers, American League, 1901-present" + cr +
"New York Giants, National League, 1885-1957" + cr +
"Washington Senators, American League, 1901-1960" + cr;
Match match;
string basePattern = @"^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+";
string pattern = basePattern + "$";
Console.WriteLine("Attempting to match the entire input string:");
match = Regex.Match(input, pattern);
while (match.Success)
{
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
match = match.NextMatch();
}
Console.WriteLine();
string[] teams = input.Split(new String[] { cr }, StringSplitOptions.RemoveEmptyEntries);
Console.WriteLine("Attempting to match each element in a string array:");
foreach (string team in teams)
{
match = Regex.Match(team, pattern);
if (match.Success)
{
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
}
}
Console.WriteLine();
Console.WriteLine("Attempting to match each line of an input string with '$':");
match = Regex.Match(input, pattern, RegexOptions.Multiline);
while (match.Success)
{
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
match = match.NextMatch();
}
Console.WriteLine();
pattern = basePattern + "\r?$";
Console.WriteLine(@"Attempting to match each line of an input string with '\r?$':");
match = Regex.Match(input, pattern, RegexOptions.Multiline);
while (match.Success)
{
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
match = match.NextMatch();
}
Console.WriteLine();
}
}
// The example displays the following output:
// Attempting to match the entire input string:
//
// Attempting to match each element in a string array:
// The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
// The Chicago Cubs played in the National League in 1903-present.
// The Detroit Tigers played in the American League in 1901-present.
// The New York Giants played in the National League in 1885-1957.
// The Washington Senators played in the American League in 1901-1960.
//
// Attempting to match each line of an input string with '$':
//
// Attempting to match each line of an input string with '\r?$':
// The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
// The Chicago Cubs played in the National League in 1903-present.
// The Detroit Tigers played in the American League in 1901-present.
// The New York Giants played in the National League in 1885-1957.
// The Washington Senators played in the American League in 1901-1960.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf +
"Chicago Cubs, National League, 1903-present" + vbCrLf +
"Detroit Tigers, American League, 1901-present" + vbCrLf +
"New York Giants, National League, 1885-1957" + vbCrLf +
"Washington Senators, American League, 1901-1960" + vbCrLf
Dim basePattern As String = "^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+"
Dim match As Match
Dim pattern As String = basePattern + "$"
Console.WriteLine("Attempting to match the entire input string:")
match = Regex.Match(input, pattern)
Do While match.Success
Console.Write("The {0} played in the {1} in",
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
match = match.NextMatch()
Loop
Console.WriteLine()
Dim teams() As String = input.Split(New String() {vbCrLf}, StringSplitOptions.RemoveEmptyEntries)
Console.WriteLine("Attempting to match each element in a string array:")
For Each team As String In teams
match = Regex.Match(team, pattern)
If match.Success Then
Console.Write("The {0} played in the {1} in",
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
End If
Next
Console.WriteLine()
Console.WriteLine("Attempting to match each line of an input string with '$':")
match = Regex.Match(input, pattern, RegexOptions.Multiline)
Do While match.Success
Console.Write("The {0} played in the {1} in",
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
match = match.NextMatch()
Loop
Console.WriteLine()
pattern = basePattern + "\r?$"
Console.WriteLine("Attempting to match each line of an input string with '\r?$':")
match = Regex.Match(input, pattern, RegexOptions.Multiline)
Do While match.Success
Console.Write("The {0} played in the {1} in",
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
match = match.NextMatch()
Loop
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' Attempting to match the entire input string:
'
' Attempting to match each element in a string array:
' The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
' The Chicago Cubs played in the National League in 1903-present.
' The Detroit Tigers played in the American League in 1901-present.
' The New York Giants played in the National League in 1885-1957.
' The Washington Senators played in the American League in 1901-1960.
'
' Attempting to match each line of an input string with '$':
'
' Attempting to match each line of an input string with '\r?$':
' The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
' The Chicago Cubs played in the National League in 1903-present.
' The Detroit Tigers played in the American League in 1901-present.
' The New York Giants played in the National League in 1885-1957.
' The Washington Senators played in the American League in 1901-1960.
Principio de cadena solamente: \A
El delimitador \A especifica que debe producirse una coincidencia al principio de la cadena de entrada. Es idéntico al delimitador ^ , salvo en que \A omite la opción RegexOptions.Multiline . Por consiguiente, solo puede coincidir con el principio de la primera línea en una cadena de entrada de varias líneas.
El ejemplo siguiente es similar a los ejemplos de los delimitadores ^ y $ . Usa el delimitador \A en una expresión regular que extrae información sobre los años durante los que existieron algunos equipos de béisbol profesionales. La cadena de entrada incluye cinco líneas. La llamada al método Regex.Matches(String, String, RegexOptions) encuentra solo la primera subcadena que coincide con el patrón de la expresión regular en la cadena de entrada. Como muestra el ejemplo, la opción Multiline no tiene ningún efecto.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957\n" +
"Chicago Cubs, National League, 1903-present\n" +
"Detroit Tigers, American League, 1901-present\n" +
"New York Giants, National League, 1885-1957\n" +
"Washington Senators, American League, 1901-1960\n";
string pattern = @"\A((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+";
Match match = Regex.Match(input, pattern, RegexOptions.Multiline);
while (match.Success)
{
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
match = match.NextMatch();
}
Console.WriteLine();
}
}
// The example displays the following output:
// The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf +
"Chicago Cubs, National League, 1903-present" + vbCrLf +
"Detroit Tigers, American League, 1901-present" + vbCrLf +
"New York Giants, National League, 1885-1957" + vbCrLf +
"Washington Senators, American League, 1901-1960" + vbCrLf
Dim pattern As String = "\A((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+"
Dim match As Match = Regex.Match(input, pattern, RegexOptions.Multiline)
Do While match.Success
Console.Write("The {0} played in the {1} in",
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
match = match.NextMatch()
Loop
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
Final de cadena o antes de nueva línea al final: \Z
El delimitador \Z especifica que se debe producir una coincidencia al final de la cadena de entrada o antes de \n al final de la cadena de entrada. Es idéntico al delimitador $ , salvo en que \Z omite la opción RegexOptions.Multiline . Por tanto, en una cadena de varias líneas, solo se puede satisfacer con el final de la última línea o la última línea antes de \n.
Tenga en cuenta que \Z se satisface en \n pero no en \r\n (la combinación de caracteres CR/LF). Para tratar a CR/LF como si fuera \n, incluya \r?\Z en el patrón de expresión regular. Tenga en cuenta que esto formará la parte \r de la coincidencia.
En el ejemplo siguiente, se usa el delimitador \Z en una expresión regular que es similar al ejemplo de la sección Principio de cadena o línea , que extrae información sobre los años durante los que existieron algunos equipos del béisbol profesionales. La subexpresión \r?\Z de la expresión regular ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z se satisface en el final de una cadena, y al final de una cadena que termina con \n o \r\n. Como resultado, cada elemento de la matriz coincide con el patrón de la expresión regular.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] inputs = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
"Chicago Cubs, National League, 1903-present" + Environment.NewLine,
"Detroit Tigers, American League, 1901-present" + Regex.Unescape(@"\n"),
"New York Giants, National League, 1885-1957",
"Washington Senators, American League, 1901-1960" + Environment.NewLine};
string pattern = @"^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z";
foreach (string input in inputs)
{
Console.WriteLine(Regex.Escape(input));
Match match = Regex.Match(input, pattern);
if (match.Success)
Console.WriteLine(" Match succeeded.");
else
Console.WriteLine(" Match failed.");
}
}
}
// The example displays the following output:
// Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
// Match succeeded.
// Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
// Match succeeded.
// Detroit\ Tigers,\ American\ League,\ 1901-present\n
// Match succeeded.
// New\ York\ Giants,\ National\ League,\ 1885-1957
// Match succeeded.
// Washington\ Senators,\ American\ League,\ 1901-1960\r\n
// Match succeeded.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim inputs() As String = {"Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
"Chicago Cubs, National League, 1903-present" + vbCrLf,
"Detroit Tigers, American League, 1901-present" + vbLf,
"New York Giants, National League, 1885-1957",
"Washington Senators, American League, 1901-1960" + vbCrLf}
Dim pattern As String = "^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z"
For Each input As String In inputs
Console.WriteLine(Regex.Escape(input))
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
Console.WriteLine(" Match succeeded.")
Else
Console.WriteLine(" Match failed.")
End If
Next
End Sub
End Module
' The example displays the following output:
' Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
' Match succeeded.
' Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
' Match succeeded.
' Detroit\ Tigers,\ American\ League,\ 1901-present\n
' Match succeeded.
' New\ York\ Giants,\ National\ League,\ 1885-1957
' Match succeeded.
' Washington\ Senators,\ American\ League,\ 1901-1960\r\n
' Match succeeded.
Final de cadena solamente: \z
El delimitador \z especifica que debe producirse una coincidencia al final de la cadena de entrada. Al igual que el elemento del lenguaje $ , \z omite la opción RegexOptions.Multiline . A diferencia del elemento del lenguaje \Z, \z no se satisface mediante un carácter \n al final de una cadena. Por tanto, solo puede coincidir con el final de la cadena de entrada.
En el ejemplo siguiente, se usa el delimitador \z en una expresión regular que por lo demás es idéntica al ejemplo de la sección anterior, que extrae información sobre los años durante los que existieron algunos equipos del béisbol profesionales. En el ejemplo, se intenta buscar coincidencias con cada uno de los cinco elementos de una matriz de cadenas con el patrón de expresión regular ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z. Dos de las cadenas finalizan con caracteres de retorno de carro y salto de línea, una finaliza con un carácter de salto de línea, y dos no finalizan con un carácter de retorno de carro ni con un carácter de salto de línea. Como muestra la salida, solo coinciden con el patrón las cadenas sin un carácter de retorno de carro ni de salto de línea.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] inputs = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
"Chicago Cubs, National League, 1903-present" + Environment.NewLine,
"Detroit Tigers, American League, 1901-present\n",
"New York Giants, National League, 1885-1957",
"Washington Senators, American League, 1901-1960" + Environment.NewLine };
string pattern = @"^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z";
foreach (string input in inputs)
{
Console.WriteLine(Regex.Escape(input));
Match match = Regex.Match(input, pattern);
if (match.Success)
Console.WriteLine(" Match succeeded.");
else
Console.WriteLine(" Match failed.");
}
}
}
// The example displays the following output:
// Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
// Match succeeded.
// Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
// Match failed.
// Detroit\ Tigers,\ American\ League,\ 1901-present\n
// Match failed.
// New\ York\ Giants,\ National\ League,\ 1885-1957
// Match succeeded.
// Washington\ Senators,\ American\ League,\ 1901-1960\r\n
// Match failed.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim inputs() As String = {"Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
"Chicago Cubs, National League, 1903-present" + vbCrLf,
"Detroit Tigers, American League, 1901-present" + vbLf,
"New York Giants, National League, 1885-1957",
"Washington Senators, American League, 1901-1960" + vbCrLf}
Dim pattern As String = "^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z"
For Each input As String In inputs
Console.WriteLine(Regex.Escape(input))
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
Console.WriteLine(" Match succeeded.")
Else
Console.WriteLine(" Match failed.")
End If
Next
End Sub
End Module
' The example displays the following output:
' Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
' Match succeeded.
' Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
' Match failed.
' Detroit\ Tigers,\ American\ League,\ 1901-present\n
' Match failed.
' New\ York\ Giants,\ National\ League,\ 1885-1957
' Match succeeded.
' Washington\ Senators,\ American\ League,\ 1901-1960\r\n
' Match failed.
Coincidencias contiguas: \G
El delimitador \G especifica que debe haber una coincidencia en la posición donde finalizó la coincidencia anterior, o si no había ninguna coincidencia anterior, en la posición de la cadena donde se inició la búsqueda de coincidencias. El uso de este delimitador con el método Regex.Matches o Match.NextMatch permite asegurarse de que todas las coincidencias son contiguas.
Sugerencia
Normalmente, un delimitador \G se coloca en el extremo izquierdo del patrón. En el caso poco habitual de que se esté realizando una búsqueda de derecha a izquierda, coloque el delimitador \G en el extremo derecho del patrón.
En el ejemplo siguiente se usa una expresión regular para extraer los nombres de especies de roedores de una cadena delimitada por comas.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "capybara,squirrel,chipmunk,porcupine,gopher," +
"beaver,groundhog,hamster,guinea pig,gerbil," +
"chinchilla,prairie dog,mouse,rat";
string pattern = @"\G(\w+\s?\w*),?";
Match match = Regex.Match(input, pattern);
while (match.Success)
{
Console.WriteLine(match.Groups[1].Value);
match = match.NextMatch();
}
}
}
// The example displays the following output:
// capybara
// squirrel
// chipmunk
// porcupine
// gopher
// beaver
// groundhog
// hamster
// guinea pig
// gerbil
// chinchilla
// prairie dog
// mouse
// rat
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "capybara,squirrel,chipmunk,porcupine,gopher," +
"beaver,groundhog,hamster,guinea pig,gerbil," +
"chinchilla,prairie dog,mouse,rat"
Dim pattern As String = "\G(\w+\s?\w*),?"
Dim match As Match = Regex.Match(input, pattern)
Do While match.Success
Console.WriteLine(match.Groups(1).Value)
match = match.NextMatch()
Loop
End Sub
End Module
' The example displays the following output:
' capybara
' squirrel
' chipmunk
' porcupine
' gopher
' beaver
' groundhog
' hamster
' guinea pig
' gerbil
' chinchilla
' prairie dog
' mouse
' rat
La expresión regular \G(\w+\s?\w*),? se interpreta como se muestra en la tabla siguiente.
| Modelo | Descripción |
|---|---|
\G |
Comienza donde finalizó la última coincidencia. |
\w+ |
Buscar coincidencias con uno o más caracteres alfabéticos. |
\s? |
Coincide con cero o un espacio. |
\w* |
Buscar una coincidencia con cero o más caracteres alfabéticos. |
(\w+\s?\w*) |
Coincide con uno o varios caracteres que se usan para formar palabras seguidos de cero o un espacio, seguidos de cero o más caracteres que se usan para formar palabras. Este es el primer grupo de captura. |
,? |
Coincide con cero o un carácter de coma literal. |
Límite de palabras: \b
El delimitador \b especifica que la coincidencia se debe producir en un límite entre un carácter que se usa para formar palabras (el elemento del lenguaje \w ) y un carácter que no se usa para formar palabras (el elemento del lenguaje \W ). Los caracteres que se usan para formar palabras son los caracteres alfanuméricos y de subrayado; un carácter que no se usa para formar palabras es cualquier carácter que no es alfanumérico ni de subrayado. (Para obtener más información, vea Clases de caracteres). La coincidencia también se puede producir en un límite de palabra al principio o al final de la cadena.
El delimitador \b se usa con frecuencia para asegurarse de que una subexpresión coincide con una palabra completa en lugar de solo con el principio o el final de una palabra. La expresión regular \bare\w*\b del ejemplo siguiente muestra este uso. Coincide con cualquier palabra que comience por la subcadena "are". El resultado del ejemplo también muestra que \b coincide tanto con el principio como con el final de la cadena de entrada.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "area bare arena mare";
string pattern = @"\bare\w*\b";
Console.WriteLine("Words that begin with 'are':");
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("'{0}' found at position {1}",
match.Value, match.Index);
}
}
// The example displays the following output:
// Words that begin with 'are':
// 'area' found at position 0
// 'arena' found at position 10
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "area bare arena mare"
Dim pattern As String = "\bare\w*\b"
Console.WriteLine("Words that begin with 'are':")
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("'{0}' found at position {1}",
match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' Words that begin with 'are':
' 'area' found at position 0
' 'arena' found at position 10
El patrón de la expresión regular se interpreta como se muestra en la tabla siguiente.
| Modelo | Descripción |
|---|---|
\b |
Iniciar la búsqueda de coincidencias en un límite de palabras. |
are |
Coincide con la subcadena "are". |
\w* |
Buscar una coincidencia con cero o más caracteres alfabéticos. |
\b |
Finalizar la búsqueda de coincidencias en un límite de palabras. |
Fuera de un límite de palabras: \B
El delimitador \B especifica que la coincidencia no se debe producir en un límite de palabras. Es lo contrario del delimitador \b .
En el ejemplo siguiente, se usa el delimitador \B para buscar apariciones de la subcadena "qu" en una palabra. El patrón de expresión regular \Bqu\w+ coincide con una subcadena que comienza por "qu" que no está al principio de una palabra y que continúa hasta el final de la palabra.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "equity queen equip acquaint quiet";
string pattern = @"\Bqu\w+";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("'{0}' found at position {1}",
match.Value, match.Index);
}
}
// The example displays the following output:
// 'quity' found at position 1
// 'quip' found at position 14
// 'quaint' found at position 21
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "equity queen equip acquaint quiet"
Dim pattern As String = "\Bqu\w+"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("'{0}' found at position {1}",
match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' 'quity' found at position 1
' 'quip' found at position 14
' 'quaint' found at position 21
El patrón de la expresión regular se interpreta como se muestra en la tabla siguiente.
| Modelo | Descripción |
|---|---|
\B |
La búsqueda de coincidencias no comienza en un límite de palabras. |
qu |
Coincide con la subcadena "qu". |
\w+ |
Buscar coincidencias con uno o más caracteres alfabéticos. |
