Delimitadores en expresiones regulares
Los delimitadores, o aserciones atómicas de ancho cero, especifican una posición en la cadena donde se debe producir una coincidencia. Al utilizar un delimitador en su expresión de búsqueda, el motor de expresiones regulares no avanza a través de la cadena o ni consume caracteres; 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 produce al principio de una línea. En la tabla siguiente se enumeran los delimitadores admitidos por las expresiones regulares de .NET Framework.
Delimitador |
Descripción |
|---|---|
^ |
La coincidencia se debe producir al principio de la cadena o de la línea. Para obtener más información, vea Inicio de cadena o línea. |
$ |
La coincidencia se debe producir al final de la cadena o línea, o antes de \n al final de la cadena o línea. Para obtener más información, vea Fin de cadena o línea. |
\A |
La coincidencia se debe producir solo al principio de la cadena (sin compatibilidad con varias líneas). Para obtener más información, vea Inicio de cadena solo. |
\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 Fin de cadena o antes de acabar nueva línea. |
\z |
La coincidencia se debe producir solo al final de la cadena. Para obtener más información, vea Fin de cadena solo. |
\G |
La coincidencia se debe iniciar en la posición donde la coincidencia anterior finalizó. 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 palabra. |
\B |
La coincidencia no se debe producir en un límite de palabras. Para obtener más información, vea Límite que no es una palabra. |
Inicio de cadena o línea: ^
El delimitador ^ especifica que el siguiente modelo debe comenzar en la posición del primer carácter de la cadena. Si utiliza ^ con la opción RegexOptions.Multiline (vea Opciones de expresiones regulares), la coincidencia se debe producir al principio de cada línea.
El siguiente ejemplo utiliza 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 en la cadena de entrada que coincide con el modelo de expresión regular.
La llamada a la sobrecarga Matches(String, String, RegexOptions) con el parámetro options establecido en RegexOptions.Multiline encuentra las cinco subcadenas.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim startPos As Integer = 0
Dim endPos As Integer = 70
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
' Provide minimal validation in the event the input is invalid.
If input.Substring(startPos, endPos).Contains(",") Then
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(".")
startPos = match.Index + match.Length
endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
match = match.NextMatch()
Loop
Console.WriteLine()
End If
startPos = 0
endPos = 70
If input.Substring(startPos, endPos).Contains(",") Then
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(".")
startPos = match.Index + match.Length
endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
match = match.NextMatch()
Loop
Console.WriteLine()
End If
' For Each match As Match in Regex.Matches(input, pattern, RegexOptions.Multiline)
' 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(".")
' Next
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.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
int startPos = 0, endPos = 70;
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;
if (input.Substring(startPos, endPos).Contains(",")) {
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(".");
startPos = match.Index + match.Length;
endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
if (! input.Substring(startPos, endPos).Contains(",")) break;
match = match.NextMatch();
}
Console.WriteLine();
}
if (input.Substring(startPos, endPos).Contains(",")) {
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(".");
startPos = match.Index + match.Length;
endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
if (! input.Substring(startPos, endPos).Contains(",")) break;
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.
El modelo 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 |
|---|---|
^ |
Comience la coincidencia 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,} |
Buscar una coincidencia de uno o más caracteres de palabra seguidos de cero o un espacio, exactamente dos veces. Éste es el primer grupo de captura. Esta expresión también define un segundo y tercer grupo de capturas: el segundo está compuesto de la palabra capturada y el tercero está compuesto de los espacios capturados. |
,\s |
Buscar una coincidencia de una coma seguida por un carácter de espacio en blanco. |
(\w+\s\w+) |
Buscar una coincidencia de cero o más caracteres seguidos de un espacio, seguidos de uno o varios caracteres de palabra. Éste es el cuarto grupo de captura. |
, |
Buscar coincidencias con una coma. |
\s\d{4} |
Buscar una coincidencia de un espacio seguido de cuatro dígitos decimales. |
(-(\d{4}|present))* |
Buscar una aparición de cero o un guión seguido de cuatro dígitos decimales o la cadena "present". Este es el sexto grupo de capturas. También incluye un séptimo grupo de captura. |
,* |
Buscar una aparición de cero o una coma. |
(\s\d{4}(-(\d{4}|present))*,*)+ |
Buscar una o más apariciones de lo siguiente: un espacio, cuatro dígitos decimales, cero o una aparición de un guión seguido de cuatro dígitos decimales o la cadena "present", y cero o una coma. Este es el quinto grupo de capturas. |
Volver al principio
Fin de cadena o línea: $
El delimitador $ especifica que el modelo anterior debe ocurrir al final de la cadena de entrada, o antes de \n al final de la cadena de entrada.
Si utiliza $ con la opción RegexOptions.Multiline, la coincidencia también se puede producir al final de una línea. Observe que $ coincide con \n pero no coincide con \r\n (la combinación de caracteres de retorno de carro y nueva línea, o CR/LF). Para buscar la combinación de caracteres CR/LF, incluya \r?$ en el modelo de expresión regular.
El siguiente ejemplo agrega el delimitador $ al modelo de expresión regular utilizado en el ejemplo en la sección Inicio de cadena o línea. Cuando se utiliza 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 fin de la primera línea no coincide con el modelo $. Cuando la cadena de entrada original se divide en una matriz de cadena, el método Regex.Matches(String, String) tiene éxito al buscar 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 modelo de expresión regular no responde del elemento de retorno de carro (\u+000D). Sin embargo, cuando el modelo de expresión regular se modifica reemplazando $ con \r?$, si se llama al método Regex.Matches(String, String, RegexOptions) con el parámetro options establecido de nuevo en RegexOptions.Multiline encuentra cinco coincidencias.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim startPos As Integer = 0
Dim endPos As Integer = 70
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:")
' Provide minimal validation in the event the input is invalid.
If input.Substring(startPos, endPos).Contains(",") Then
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(".")
startPos = match.Index + match.Length
endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
match = match.NextMatch()
Loop
Console.WriteLine()
End If
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
If team.Length > 70 Then Continue For
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()
startPos = 0
endPos = 70
Console.WriteLine("Attempting to match each line of an input string with '$':")
' Provide minimal validation in the event the input is invalid.
If input.Substring(startPos, endPos).Contains(",") Then
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(".")
startPos = match.Index + match.Length
endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
match = match.NextMatch()
Loop
Console.WriteLine()
End If
startPos = 0
endPos = 70
pattern = basePattern + "\r?$"
Console.WriteLine("Attempting to match each line of an input string with '\r?$':")
' Provide minimal validation in the event the input is invalid.
If input.Substring(startPos, endPos).Contains(",") Then
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(".")
startPos = match.Index + match.Length
endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
match = match.NextMatch()
Loop
Console.WriteLine()
End If
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.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
int startPos = 0, endPos = 70;
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:");
if (input.Substring(startPos, endPos).Contains(",")) {
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(".");
startPos = match.Index + match.Length;
endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
if (! input.Substring(startPos, endPos).Contains(",")) break;
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)
{
if (team.Length > 70) continue;
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();
startPos = 0;
endPos = 70;
Console.WriteLine("Attempting to match each line of an input string with '$':");
if (input.Substring(startPos, endPos).Contains(",")) {
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(".");
startPos = match.Index + match.Length;
endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
if (! input.Substring(startPos, endPos).Contains(",")) break;
match = match.NextMatch();
}
Console.WriteLine();
}
startPos = 0;
endPos = 70;
pattern = basePattern + "\r?$";
Console.WriteLine(@"Attempting to match each line of an input string with '\r?$':");
if (input.Substring(startPos, endPos).Contains(",")) {
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(".");
startPos = match.Index + match.Length;
endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
if (! input.Substring(startPos, endPos).Contains(",")) break;
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.
Volver al principio
Inicio de cadena solo: \A
El delimitador \A especifica que debe producirse una coincidencia al principio de la cadena de entrada. Es idéntico al delimitador ^, solo que \A omite la opción RegexOptions.Multiline. Por consiguiente, solo puede coincidir con el inicio de la primera línea en una cadena de entrada de múltiples líneas.
El siguiente ejemplo es similar a los ejemplos de los delimitadores $ y ^. Utiliza 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 en la cadena de entrada que coincide con el modelo de expresión regular. Como muestra el ejemplo, la opción Multiline no tiene ningún efecto.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim startPos As Integer = 0
Dim endPos As Integer = 70
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
' Provide minimal validation in the event the input is invalid.
If input.Substring(startPos, endPos).Contains(",") Then
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(".")
startPos = match.Index + match.Length
endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
match = match.NextMatch()
Loop
Console.WriteLine()
End If
End Sub
End Module
' The example displays the following output:
' The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
int startPos = 0, endPos = 70;
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;
if (input.Substring(startPos, endPos).Contains(",")) {
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(".");
startPos = match.Index + match.Length;
endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
if (! input.Substring(startPos, endPos).Contains(",")) break;
match = match.NextMatch();
}
Console.WriteLine();
}
}
}
// The example displays the following output:
// The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
Volver al principio
Fin de cadena o antes de acabar nueva línea: \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 $, solo que \Z omite la opción RegexOptions.Multiline. Por consiguiente, en una cadena de múltiples líneas, solo puede coincidir con el fin de la última línea o la última línea antes de \n.
Observe que \Z coincide con \n pero no coincide con \r\n (la combinación de caracteres de retorno de carro y nueva línea, o CR/LF). Para buscar CR/LF incluya \r?\Z en el modelo de expresión regular.
El siguiente ejemplo utiliza el delimitador \Z en una expresión regular que es similar al ejemplo de la sección Inicio 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 coincide con el final de una cadena, y también coincide con una cadena que finaliza con \n o \r\n. Como resultado, cada elemento de la matriz coincide con el modelo de expresión regular.
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
If input.Length > 70 Or Not input.Contains(",") Then Continue For
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.
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)
{
if (input.Length > 70 || ! input.Contains(",")) continue;
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.
Volver al principio
Fin de cadena solo: \z
El delimitador \z especifica que debe producirse una coincidencia al final de la cadena de entrada. Como el elemento del lenguaje $, \z, omite la opción RegexOptions.Multiline. A diferencia del elemento del lenguaje \Z, \z no coincide con un carácter \n al final de una cadena. Por consiguiente, solo puede coincidir con la última línea de la cadena de entrada.
El siguiente ejemplo utiliza 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 comparar cada uno de los cinco elementos de una matriz de cadena con el modelo 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, uno 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 las cadenas sin un carácter de retorno de carro o de salto de línea coinciden con el modelo.
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
If input.Length > 70 Or Not input.Contains(",") Then Continue For
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.
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\\r",
"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)
{
if (input.Length > 70 || ! input.Contains(",")) continue;
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.
Volver al principio
Coincidencias contiguas: \G
El delimitador \G especifica que debe producirse una coincidencia en el punto en el que finalizó la coincidencia anterior. Al utilizar este delimitador con el método Match.NextMatch o Regex.Matches, se asegura de que todas las coincidencias son contiguas.
En el siguiente ejemplo se utiliza una expresión regular para extraer los nombres de especies de roedores de una cadena separada por comas.
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
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
La expresión regular \G(\w+\s?\w*),? se interpreta como se muestra en la tabla siguiente.
Modelo |
Descripción |
|---|---|
\G |
Comience donde finalizó la última coincidencia. |
\w+ |
Buscar una coincidencia con uno o más caracteres de palabra. |
\s? |
Buscar una coincidencia de cero o un espacio. |
\w* |
Buscar una coincidencia de cero o más caracteres de palabra. |
(\w+\s? \w*) |
Buscar una coincidencia de uno o más caracteres de palabra seguidos de cero o un espacio, seguidos de cero o más caracteres de palabra. Éste es el primer grupo de captura. |
,? |
Buscar una aparición de cero o un carácter de coma literal. |
Volver al principio
Límite de palabra: \b
El delimitador \b especifica que la coincidencia se debe producir en un límite entre un carácter de palabra (el elemento del lenguaje \w) y un carácter no de palabra (el elemento del lenguaje \W ). Los caracteres de palabra están compuestos por caracteres alfanuméricos y de subrayado; un carácter no de palabra es cualquier carácter que no es alfanumérico ni de subrayado. (Para obtener más información, vea Clases de carácter). La coincidencia también se puede producir en un límite de palabras al principio o fin de la cadena.
El delimitador \b se utiliza con frecuencia para asegurarse de que una subexpresión coincide con una palabra completa en lugar de solo el principio o fin de una palabra. La expresión regular \bare\w*\b del siguiente ejemplo muestra este uso. Coincide con cualquier palabra que comience por la subcadena "are". El resultado del ejemplo también muestra que \b coincide al principio y final de la cadena de entrada.
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
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
El modelo de 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 |
Buscar una coincidencia de la subcadena "are". |
\w* |
Buscar una coincidencia de cero o más caracteres de palabra. |
\b |
Finalizar la búsqueda de coincidencias en un límite de palabras. |
Volver al principio
Límite que no es una palabra: \B
El delimitador \B especifica que la coincidencia no se debe producir en un límite de palabras. Es lo contrario del delimitador \b.
El siguiente ejemplo utiliza el delimitador \B para buscar apariciones de la subcadena "qu" en una palabra. El modelo de expresión regular \Bqu\w+ coincide con una subcadena que comienza con "qu" que no inicia una palabra y continúa al final de la palabra.
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
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
El modelo de expresión regular se interpreta como se muestra en la tabla siguiente.
Modelo |
Descripción |
|---|---|
\B |
No comience la búsqueda de coincidencia en un límite de palabras. |
qu |
Buscar una coincidencia de la subcadena "qu". |
\w+ |
Buscar una coincidencia con uno o más caracteres de palabra. |
Volver al principio
Vea también
Referencia
Opciones de expresiones regulares