Clases de caracteres en expresiones regulares
Una clase de caracteres define un conjunto de caracteres, cualquiera de los cuales puede estar en una cadena de entrada para que se produzca una coincidencia. El lenguaje de expresiones regulares de .NET admite las siguientes clases de caracteres:
Grupos de caracteres positivos. Un carácter de la cadena de entrada debe coincidir con uno de los caracteres del conjunto especificado. Para obtener más información, consulte Grupo de caracteres positivos.
Grupos de caracteres negativos. Ningún carácter de la cadena de entrada debe coincidir con ninguno de los caracteres del conjunto especificado. Para obtener más información, consulte Grupo de caracteres negativos.
Cualquier carácter. El carácter
.(punto) en una expresión regular es un carácter comodín que coincide con cualquier carácter excepto con\n. Para obtener más información, consulte Cualquier carácter.Una categoría general o un bloque con nombre Unicode. Para que se produzca una coincidencia, un carácter de la cadena de entrada debe ser miembro de una categoría Unicode determinada o debe estar dentro de un intervalo contiguo de caracteres Unicode. Para obtener más información, consulte Categoría Unicode o bloque Unicode.
Un bloque con nombre o una categoría general negativa Unicode. Para que se produzca una coincidencia, un carácter de la cadena de entrada no debe ser miembro de una categoría Unicode determinada o no debe estar dentro de un intervalo contiguo de caracteres Unicode. Para obtener más información, consulte Categoría Unicode o bloque Unicode negativo.
Un carácter de palabra. Un carácter de la cadena de entrada puede pertenecer a cualquiera de las categorías Unicode que son adecuadas para los caracteres que se usan para formar palabras. Para obtener más información, consulte Carácter de palabra.
Un carácter que no se usa en las palabras. Un carácter de la cadena de entrada puede pertenecer a cualquier categoría Unicode que no se usa para formar palabras. Para obtener más información, consulte Carácter que no se usa en las palabras.
Un carácter de espacio en blanco. Un carácter de la cadena de entrada puede ser cualquiera de los caracteres separadores Unicode, así como cualquiera de los caracteres de una serie de caracteres de control. Para obtener más información, consulte Carácter de espacio en blanco.
Un carácter que no sea un espacio en blanco. Un carácter de la cadena de entrada puede ser cualquier carácter que no sea un espacio en blanco. Para obtener más información, consulte Carácter que no sea un espacio en blanco.
Un dígito decimal. Un carácter de la cadena de entrada puede ser cualquiera de los caracteres clasificados como dígitos decimales de Unicode. Para obtener más información, consulte Carácter de dígito decimal.
Un carácter que no sea un dígito decimal. Un carácter de la cadena de entrada puede ser cualquier carácter que no sea un dígito decimal de Unicode. Para obtener más información, consulte Carácter de dígito decimal.
.NET admite expresiones de sustracción de clases de caracteres, que permiten definir un conjunto de caracteres como el resultado de excluir una clase de caracteres de otra clase de caracteres. Para obtener más información, consulte Sustracción de clases de caracteres.
Nota
Las clases que coinciden con los caracteres por categoría, como \w para que coincidan con caracteres alfabéticos o \p{} para que coincidan con una categoría Unicode, que se basan en la clase CharUnicodeInfo para proporcionar información sobre las categorías de caracteres. En .NET Framework 4.6.2 y versiones posteriores, las categorías de caracteres se basan en el estándar Unicode, versión 8.0.0.
Grupo de caracteres positivos: [ ]
Un grupo de caracteres positivos especifica una lista de caracteres cualquiera de los cuales puede aparecer en una cadena de entrada para que se produzca una coincidencia. Los caracteres de la lista se pueden especificar individualmente, como un intervalo o de ambas formas.
La sintaxis para especificar la lista de caracteres individuales es la siguiente:
[*character_group*]
donde grupo_caracteres es una lista de cada uno de los caracteres que pueden aparecer en la cadena de entrada para que se produzca una coincidencia. grupo_caracteres puede estar formado por cualquier combinación de uno o varios caracteres literales, caracteres de escape o clases de caracteres.
La sintaxis para especificar un intervalo de caracteres es la siguiente:
[firstCharacter-lastCharacter]
donde firstCharacter es el carácter que comienza el intervalo y lastCharacter es el carácter final del intervalo. Un intervalo de caracteres es una serie contigua de caracteres que se define especificando el primer carácter de la serie, un guion (-) y, a continuación, el último carácter de la serie. Dos caracteres son contiguos si tienen puntos de código Unicode adyacentes. firstCharacter debe ser el carácter con el punto de código inferior y lastCharacter debe ser el carácter con el punto de código superior.
Nota
Dado que un grupo de caracteres positivos puede incluir un conjunto de caracteres y un rango de caracteres, un carácter de guión (-) siempre se interpreta como el separador de rango, a menos que sea el primer carácter del grupo o el último.
Para incluir un guión como miembro no periférico de un grupo de caracteres, escape de él. Por ejemplo, para crear un grupo de caracteres para el carácter a y los caracteres de - a /, la sintaxis correcta es [a\--/].
En la tabla siguiente se recogen algunos de los patrones de expresiones regulares comunes que contienen clases de caracteres positivos.
| Patrón | Descripción |
|---|---|
[aeiou] |
Coincide con todas las vocales. |
[\p{P}\d] |
Coincide con todos los caracteres de puntuación y de dígitos decimales. |
[\s\p{P}] |
Coincide con todos los caracteres de espacio en blanco y de puntuación. |
En el ejemplo siguiente se define un grupo de caracteres positivos que contiene los caracteres "a" y "e" de manera que la cadena de entrada deba contener las palabras "grey" o "gray" seguidas de cualquier otra palabra para que se produzca una coincidencia.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"gr[ae]y\s\S+?[\s\p{P}]";
string input = "The gray wolf jumped over the grey wall.";
MatchCollection matches = Regex.Matches(input, pattern);
foreach (Match match in matches)
Console.WriteLine($"'{match.Value}'");
}
}
// The example displays the following output:
// 'gray wolf '
// 'grey wall.'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "gr[ae]y\s\S+?[\s\p{P}]"
Dim input As String = "The gray wolf jumped over the grey wall."
Dim matches As MatchCollection = Regex.Matches(input, pattern)
For Each match As Match In matches
Console.WriteLine($"'{match.Value}'")
Next
End Sub
End Module
' The example displays the following output:
' 'gray wolf '
' 'grey wall.'
La expresión regular gr[ae]y\s\S+?[\s|\p{P}] se define de la siguiente manera:
| Patrón | Descripción |
|---|---|
gr |
Coincide con los caracteres literales "gr". |
[ae] |
Coincide con una "a" o una "e". |
y\s |
Coincide con el carácter literal "y" seguido de un carácter de espacio en blanco. |
\S+? |
Coincide con uno o varios caracteres que no sean un espacio en blanco, pero con la menor cantidad posible de caracteres. |
[\s\p{P}] |
Coincide con un carácter de espacio en blanco o un signo de puntuación. |
En el ejemplo siguiente se buscan palabras que comienzan por cualquier letra mayúscula. Utiliza la subexpresión [A-Z] para representar el intervalo de letras mayúsculas de la A a la Z.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b[A-Z]\w*\b";
string input = "A city Albany Zulu maritime Marseilles";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// A
// Albany
// Zulu
// Marseilles
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b[A-Z]\w*\b"
Dim input As String = "A city Albany Zulu maritime Marseilles"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
Next
End Sub
End Module
La expresión regular \b[A-Z]\w*\b se define como se muestra en la tabla siguiente.
| Modelo | Descripción |
|---|---|
\b |
Empieza en un límite de palabras. |
[A-Z] |
Coincide con cualquier letra mayúscula de la A a la Z. |
\w* |
Buscar una coincidencia con cero o más caracteres alfabéticos. |
\b |
Coincide con un límite de palabras. |
Grupo de caracteres negativos: [^]
Un grupo de caracteres negativos especifica una lista de caracteres que no deben aparecer en una cadena de entrada para que se produzca una coincidencia. Los caracteres de la lista se pueden especificar individualmente, como un intervalo o de ambas formas.
La sintaxis para especificar la lista de caracteres individuales es la siguiente:
[*^character_group*]
donde grupo_caracteres es una lista de cada uno de los caracteres que no pueden aparecer en la cadena de entrada para que se produzca una coincidencia. grupo_caracteres puede estar formado por cualquier combinación de uno o varios caracteres literales, caracteres de escape o clases de caracteres.
La sintaxis para especificar un intervalo de caracteres es la siguiente:
[^*firstCharacter*-*lastCharacter*]
donde firstCharacter es el carácter que comienza el intervalo y lastCharacter es el carácter final del intervalo. Un intervalo de caracteres es una serie contigua de caracteres que se define especificando el primer carácter de la serie, un guion (-) y, a continuación, el último carácter de la serie. Dos caracteres son contiguos si tienen puntos de código Unicode adyacentes. firstCharacter debe ser el carácter con el punto de código inferior y lastCharacter debe ser el carácter con el punto de código superior.
Nota
Dado que un grupo de caracteres negativos puede incluir un conjunto de caracteres y un rango de caracteres, un carácter de guión (-) siempre se interpreta como el separador de rango, a menos que sea el primer carácter del grupo o el último.
Es posible concatenar dos o más intervalos de caracteres. Por ejemplo, para especificar el intervalo de dígitos decimales del "0" al "9", el intervalo de letras minúsculas de la "a" a la "f" y el intervalo de letras mayúsculas de la "A" a la "F", utilice [0-9a-fA-F].
El carácter inicial de acento circunflejo (^) de un grupo de caracteres negativos es obligatorio e indica que el grupo de caracteres es un grupo de caracteres negativos en lugar de un grupo de caracteres positivos.
Importante
Un grupo de caracteres negativos dentro de un patrón de expresión regular más grande no es una aserción de ancho cero. Es decir, después de evaluar el grupo de caracteres negativos, el motor de expresiones regulares avanza un carácter en la cadena de entrada.
En la tabla siguiente se recogen algunos de los patrones de expresiones regulares comunes que contienen grupos de caracteres negativos.
| Patrón | Descripción |
|---|---|
[^aeiou] |
Coincide con todos los caracteres excepto las vocales. |
[^\p{P}\d] |
Coincide con todos los caracteres excepto los caracteres de puntuación y de dígitos decimales. |
En el ejemplo siguiente se busca cualquier palabra que comience por los caracteres "th" y no vaya seguida de una "o".
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\bth[^o]\w+\b";
string input = "thought thing though them through thus thorough this";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// thing
// them
// through
// thus
// this
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\bth[^o]\w+\b"
Dim input As String = "thought thing though them through thus " + _
"thorough this"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' thing
' them
' through
' thus
' this
La expresión regular \bth[^o]\w+\b se define como se muestra en la tabla siguiente.
| Modelo | Descripción |
|---|---|
\b |
Empieza en un límite de palabras. |
th |
Coincide con los caracteres literales "th". |
[^o] |
Coincide con cualquier carácter que no sea una "o". |
\w+ |
Buscar coincidencias con uno o más caracteres alfabéticos. |
\b |
Finaliza en un límite de palabras. |
Cualquier carácter: .
El carácter de punto (.) coincide con cualquier carácter excepto con \n (el carácter de nueva línea), con los dos requisitos siguientes:
Si la opción RegexOptions.Singleline modifica un patrón de expresión regular o si la opción
.modifica la parte del patrón que contiene la clase de caracteress,.coincide con cualquier carácter. Para obtener más información, consulte Opciones de expresiones regulares.El ejemplo siguiente muestra el comportamiento predeterminado de la clase de caracteres
.y con la opción RegexOptions.Singleline. La expresión regular^.+comienza en el principio de la cadena y coincide con todos los caracteres. De manera predeterminada, la coincidencia termina al final de la primera línea; el patrón de expresión regular coincide con el carácter de retorno de carro,\r, pero no coincide con\n. Dado que la opción RegexOptions.Singleline interpreta la cadena de entrada completa como una sola línea, coincide con cada carácter de la cadena de entrada, incluido\n.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = "^.+"; string input = "This is one line and" + Environment.NewLine + "this is the second."; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine(Regex.Escape(match.Value)); Console.WriteLine(); foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline)) Console.WriteLine(Regex.Escape(match.Value)); } } // The example displays the following output: // This\ is\ one\ line\ and\r // // This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "^.+" Dim input As String = "This is one line and" + vbCrLf + "this is the second." For Each match As Match In Regex.Matches(input, pattern) Console.WriteLine(Regex.Escape(match.Value)) Next Console.WriteLine() For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine) Console.WriteLine(Regex.Escape(match.Value)) Next End Sub End Module ' The example displays the following output: ' This\ is\ one\ line\ and\r ' ' This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Nota
Como coincide con cualquier carácter excepto con \n, la clase de caracteres . también coincide con \r (el carácter de retorno de carro).
En un grupo de caracteres positivos o negativos, un punto se considera un carácter de punto literal, no una clase de caracteres. Para más información, consulte las secciones Grupo de caracteres positivos y Grupo de caracteres negativos anteriormente en este tema. En el ejemplo siguiente se define una expresión regular que incluye el carácter de punto (
.) como una clase de caracteres y como un miembro de un grupo de caracteres positivos. La expresión regular\b.*[.?!;:](\s|\z)comienza en un límite de palabras, coincide con cualquier carácter hasta que encuentra uno de cinco signos de puntuación, incluido el punto, y después coincide con un carácter de espacio en blanco o con el final de la cadena.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"\b.*[.?!;:](\s|\z)"; string input = "this. what: is? go, thing."; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine(match.Value); } } // The example displays the following output: // this. what: is? go, thing.Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As STring = "\b.*[.?!;:](\s|\z)" Dim input As String = "this. what: is? go, thing." For Each match As Match In Regex.Matches(input, pattern) Console.WriteLine(match.Value) Next End Sub End Module ' The example displays the following output: ' this. what: is? go, thing.
Nota
Dado que coincide con cualquier carácter, el elemento del lenguaje . se utiliza a menudo con un cuantificador no expansivo si un patrón de expresión regular intenta coincidir varias veces con cualquier carácter. Para obtener más información, consulte Cuantificadores.
Categoría Unicode o bloque Unicode: \p{}
El estándar Unicode asigna una categoría general a cada carácter. Por ejemplo, un carácter concreto puede ser una letra mayúscula (representada por la categoría Lu), un dígito decimal (categoría Nd), un símbolo matemático (categoría Sm) o un separador de párrafos (categoría Zl). Determinados juegos de caracteres del estándar Unicode también ocupan un intervalo o bloque específico de puntos de código consecutivos. Por ejemplo, el juego de caracteres latinos básico se encuentra desde \u0000 hasta \u007F, mientras que el juego de caracteres árabes se encuentra desde \u0600 hasta \u06FF.
La construcción de expresión regular
\p{ nombre }
coincide con cualquier carácter que pertenezca a una categoría general o bloque con nombre de Unicode, donde nombre es la abreviatura de la categoría o el nombre del bloque con nombre. Para obtener una lista de abreviaturas de categorías, consulte la sección Categorías generales Unicode compatibles más adelante en este tema. Para obtener una lista de bloques con nombre, consulte la sección Bloques con nombre compatibles más adelante en este tema.
Sugerencia
La coincidencia se puede mejorar si la cadena se normaliza por primera vez llamando al método String.Normalize.
En el ejemplo siguiente se usa la construcción \p{nombre} para buscar coincidencias con una categoría general de Unicode (en este caso, Pd o Punctuation, Dash) y un bloque con nombre (los bloques con nombre IsGreek e IsBasicLatin).
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
string input = "Κατα Μαθθαίον - The Gospel of Matthew";
Console.WriteLine(Regex.IsMatch(input, pattern)); // Displays True.
}
}
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
Dim input As String = "Κατα Μαθθαίον - The Gospel of Matthew"
Console.WriteLine(Regex.IsMatch(input, pattern)) ' Displays True.
End Sub
End Module
La expresión regular \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ se define como se muestra en la tabla siguiente.
| Modelo | Descripción |
|---|---|
\b |
Empieza en un límite de palabras. |
\p{IsGreek}+ |
Coincide con uno o varios caracteres griegos. |
(\s)? |
Busca coincidencias con cero o un carácter de espacio en blanco. |
(\p{IsGreek}+(\s)?)+ |
Coincide una o varias veces con el patrón de uno o varios caracteres griegos seguidos de cero o un carácter de espacio en blanco. |
\p{Pd} |
Coincide con un carácter de puntuación, guion. |
\s |
Coincide con un carácter de espacio en blanco. |
\p{IsBasicLatin}+ |
Coincide con uno o varios caracteres latinos básicos. |
(\s)? |
Busca coincidencias con cero o un carácter de espacio en blanco. |
(\p{IsBasicLatin}+(\s)?)+ |
Coincide una o varias veces con el patrón de uno varios caracteres latinos básicos seguidos de cero o un carácter de espacio en blanco. |
Categoría Unicode o bloque Unicode negativo: \P{}
El estándar Unicode asigna una categoría general a cada carácter. Por ejemplo, un carácter concreto puede ser una letra mayúscula (representada por la categoría Lu), un dígito decimal (categoría Nd), un símbolo matemático (categoría Sm) o un separador de párrafos (categoría Zl). Determinados juegos de caracteres del estándar Unicode también ocupan un intervalo o bloque específico de puntos de código consecutivos. Por ejemplo, el juego de caracteres latinos básico se encuentra desde \u0000 hasta \u007F, mientras que el juego de caracteres árabes se encuentra desde \u0600 hasta \u06FF.
La construcción de expresión regular
\P{ nombre }
coincide con cualquier carácter que no pertenezca a una categoría general o bloque con nombre de Unicode, donde nombre es la abreviatura de la categoría o el nombre del bloque con nombre. Para obtener una lista de abreviaturas de categorías, consulte la sección Categorías generales Unicode compatibles más adelante en este tema. Para obtener una lista de bloques con nombre, consulte la sección Bloques con nombre compatibles más adelante en este tema.
Sugerencia
La coincidencia se puede mejorar si la cadena se normaliza por primera vez llamando al método String.Normalize.
En el siguiente ejemplo se usa la construcción \P{nombre} para quitar cualquier símbolo de divisa (en este caso, la categoría Sc, o Symbol, Currency) de las cadenas numéricas.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"(\P{Sc})+";
string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" };
foreach (string value in values)
Console.WriteLine(Regex.Match(value, pattern).Value);
}
}
// The example displays the following output:
// 164,091.78
// 1,073,142.68
// 73
// 120
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(\P{Sc})+"
Dim values() As String = {"$164,091.78", "£1,073,142.68", "73¢", "€120"}
For Each value As String In values
Console.WriteLine(Regex.Match(value, pattern).Value)
Next
End Sub
End Module
' The example displays the following output:
' 164,091.78
' 1,073,142.68
' 73
' 120
El patrón de expresión regular (\P{Sc})+ coincide con uno o varios caracteres que no son símbolos de divisa; quita eficazmente cualquier símbolo de divisa de la cadena de resultado.
Carácter de palabra: \w
\w coincide con cualquier carácter de palabra. Un carácter de palabra es un miembro de alguna de las categorías Unicode enumeradas en la tabla siguiente.
| Category | Descripción |
|---|---|
| Ll | Letra, minúscula |
| Lu | Letra, mayúscula |
| Lt | Letra, inicial en mayúscula |
| Lo | Letra, otra |
| Lm | Letra, modificador |
| Mn | Marca, sin espacios |
| Nd | Número, dígito decimal |
| Pc | Puntuación, Conector Esta categoría incluye diez caracteres, el más usado de los cuales es el carácter LOWLINE (_), u+005F. |
Si se especifica un comportamiento conforme a ECMAScript, \w es equivalente a [a-zA-Z_0-9]. Para obtener información sobre las expresiones regulares ECMAScript, consulte la sección "Comportamiento de la búsqueda de coincidencias de ECMAScript" en Opciones de expresiones regulares.
Nota
Dado que coincide con cualquier carácter de palabra, el elemento del lenguaje \w se suele usar con un cuantificador diferido si un patrón de expresión regular intenta coincidir varias veces con cualquier carácter de palabra, seguido de un carácter de palabra específico. Para obtener más información, consulte Cuantificadores.
En el ejemplo siguiente se usa el elemento del lenguaje \w para buscar coincidencias de caracteres duplicados en una palabra. El ejemplo define un patrón de expresión regular, (\w)\1, que se puede interpretar de la siguiente manera.
| Elemento | Descripción |
|---|---|
| (\w) | Coincide con un carácter de palabra. Este es el primer grupo de captura. |
| \1 | Coincide con el valor de la primera captura. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"(\w)\1";
string[] words = { "trellis", "seer", "latter", "summer",
"hoarse", "lesser", "aardvark", "stunned" };
foreach (string word in words)
{
Match match = Regex.Match(word, pattern);
if (match.Success)
Console.WriteLine("'{0}' found in '{1}' at position {2}.",
match.Value, word, match.Index);
else
Console.WriteLine("No double characters in '{0}'.", word);
}
}
}
// The example displays the following output:
// 'll' found in 'trellis' at position 3.
// 'ee' found in 'seer' at position 1.
// 'tt' found in 'latter' at position 2.
// 'mm' found in 'summer' at position 2.
// No double characters in 'hoarse'.
// 'ss' found in 'lesser' at position 2.
// 'aa' found in 'aardvark' at position 0.
// 'nn' found in 'stunned' at position 3.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(\w)\1"
Dim words() As String = {"trellis", "seer", "latter", "summer", _
"hoarse", "lesser", "aardvark", "stunned"}
For Each word As String In words
Dim match As Match = Regex.Match(word, pattern)
If match.Success Then
Console.WriteLine("'{0}' found in '{1}' at position {2}.", _
match.Value, word, match.Index)
Else
Console.WriteLine("No double characters in '{0}'.", word)
End If
Next
End Sub
End Module
' The example displays the following output:
' 'll' found in 'trellis' at position 3.
' 'ee' found in 'seer' at position 1.
' 'tt' found in 'latter' at position 2.
' 'mm' found in 'summer' at position 2.
' No double characters in 'hoarse'.
' 'ss' found in 'lesser' at position 2.
' 'aa' found in 'aardvark' at position 0.
' 'nn' found in 'stunned' at position 3.
Carácter que no se usa para formar palabras: \W
\W coincide con cualquier carácter que no sea de palabra. El elemento del lenguaje \W es equivalente a la clase de caracteres siguiente:
[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]
En otras palabras, coincide con cualquier carácter excepto con los que figuran en las categorías Unicode de la tabla siguiente.
| Category | Descripción |
|---|---|
| Ll | Letra, minúscula |
| Lu | Letra, mayúscula |
| Lt | Letra, inicial en mayúscula |
| Lo | Letra, otra |
| Lm | Letra, modificador |
| Mn | Marca, sin espacios |
| Nd | Número, dígito decimal |
| Pc | Puntuación, Conector Esta categoría incluye diez caracteres, el más usado de los cuales es el carácter LOWLINE (_), u+005F. |
Si se especifica un comportamiento conforme a ECMAScript, \W es equivalente a [^a-zA-Z_0-9]. Para obtener información sobre las expresiones regulares ECMAScript, consulte la sección "Comportamiento de la búsqueda de coincidencias de ECMAScript" en Opciones de expresiones regulares.
Nota
Dado que coincide con cualquier carácter que no sea de palabra, el elemento del lenguaje \W se suele usar con un cuantificador diferido si un patrón de expresión regular intenta coincidir varias veces con cualquier carácter que no sea de palabra, seguido de un carácter que no sea de palabra específico. Para obtener más información, consulte Cuantificadores.
En el ejemplo siguiente se ilustra la clase de caracteres \W. Define un patrón de expresión regular, \b(\w+)(\W){1,2}, que coincide con una palabra seguida de uno o dos caracteres que no son de palabra, como un espacio en blanco o un signo de puntuación. La expresión regular se interpreta como se muestra en la tabla siguiente.
| Elemento | Descripción |
|---|---|
| \b | Iniciar la búsqueda de coincidencias en un límite de palabras. |
| (\w+) | Buscar coincidencias con uno o más caracteres alfabéticos. Este es el primer grupo de captura. |
| (\W){1,2} | Coincide una o dos veces con un carácter que no se usa para formar palabras. Este es el segundo grupo de captura. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(\w+)(\W){1,2}";
string input = "The old, grey mare slowly walked across the narrow, green pasture.";
foreach (Match match in Regex.Matches(input, pattern))
{
Console.WriteLine(match.Value);
Console.Write(" Non-word character(s):");
CaptureCollection captures = match.Groups[2].Captures;
for (int ctr = 0; ctr < captures.Count; ctr++)
Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value,
Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"),
ctr < captures.Count - 1 ? ", " : "");
Console.WriteLine();
}
}
}
// The example displays the following output:
// The
// Non-word character(s):' ' (\u0020)
// old,
// Non-word character(s):',' (\u002C), ' ' (\u0020)
// grey
// Non-word character(s):' ' (\u0020)
// mare
// Non-word character(s):' ' (\u0020)
// slowly
// Non-word character(s):' ' (\u0020)
// walked
// Non-word character(s):' ' (\u0020)
// across
// Non-word character(s):' ' (\u0020)
// the
// Non-word character(s):' ' (\u0020)
// narrow,
// Non-word character(s):',' (\u002C), ' ' (\u0020)
// green
// Non-word character(s):' ' (\u0020)
// pasture.
// Non-word character(s):'.' (\u002E)
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\w+)(\W){1,2}"
Dim input As String = "The old, grey mare slowly walked across the narrow, green pasture."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
Console.Write(" Non-word character(s):")
Dim captures As CaptureCollection = match.Groups(2).Captures
For ctr As Integer = 0 To captures.Count - 1
Console.Write("'{0}' (\u{1}){2}", captures(ctr).Value, _
Convert.ToUInt16(captures(ctr).Value.Chars(0)).ToString("X4"), _
If(ctr < captures.Count - 1, ", ", ""))
Next
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' The
' Non-word character(s):' ' (\u0020)
' old,
' Non-word character(s):',' (\u002C), ' ' (\u0020)
' grey
' Non-word character(s):' ' (\u0020)
' mare
' Non-word character(s):' ' (\u0020)
' slowly
' Non-word character(s):' ' (\u0020)
' walked
' Non-word character(s):' ' (\u0020)
' across
' Non-word character(s):' ' (\u0020)
' the
' Non-word character(s):' ' (\u0020)
' narrow,
' Non-word character(s):',' (\u002C), ' ' (\u0020)
' green
' Non-word character(s):' ' (\u0020)
' pasture.
' Non-word character(s):'.' (\u002E)
Dado que el objeto Group del segundo grupo de captura contiene solo un carácter que no se usa para formar palabras, el ejemplo recupera todos los caracteres que no se usan para formar palabras capturados del objeto CaptureCollection que devuelve la propiedad Group.Captures.
Carácter de espacio en blanco: \s
\s coincide con cualquier carácter de espacio en blanco. Equivale a las secuencias de escape y las categorías Unicode que figuran en la tabla siguiente.
| Category | Descripción |
|---|---|
\f |
El carácter de avance de página, \u000C. |
\n |
El carácter de nueva línea, \u000A. |
\r |
El carácter de retorno de carro, \u000D. |
\t |
El carácter de tabulación, \u0009. |
\v |
El carácter de tabulación vertical, \u000B. |
\x85 |
El carácter de LÍNEA SIGUIENTE, \u0085. |
\p{Z} |
Coincide con todos los caracteres separadores. Esto incluye las categorías Zs, Zl y Zp. |
Si se especifica un comportamiento conforme a ECMAScript, \s es equivalente a [ \f\n\r\t\v]. Para obtener información sobre las expresiones regulares ECMAScript, consulte la sección "Comportamiento de la búsqueda de coincidencias de ECMAScript" en Opciones de expresiones regulares.
En el ejemplo siguiente se ilustra la clase de caracteres \s. Define un patrón de expresión regular, \b\w+(e)?s(\s|$), que coincide con una palabra que termina por "s" o "es" seguida de un carácter de espacio en blanco o el final de la cadena de entrada. La expresión regular se interpreta como se muestra en la tabla siguiente.
| Elemento | Descripción |
|---|---|
| \b | Iniciar la búsqueda de coincidencias en un límite de palabras. |
| \w+ | Buscar coincidencias con uno o más caracteres alfabéticos. |
| (e)? | Coincide cero o una vez con una "e". |
| s | Coincide con una "s". |
| (\s|$) | Coincide con un carácter de espacio en blanco o el final de la cadena de entrada. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b\w+(e)?s(\s|$)";
string input = "matches stores stops leave leaves";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// matches
// stores
// stops
// leaves
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b\w+(e)?s(\s|$)"
Dim input As String = "matches stores stops leave leaves"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' matches
' stores
' stops
' leaves
Carácter que no sea un espacio en blanco: \S
\S coincide con cualquier carácter que no sea un espacio en blanco. Equivale al patrón de expresión regular [^\f\n\r\t\v\x85\p{Z}] o es lo contrario del patrón de expresión regular equivalente a \s, que coincide con los caracteres de espacio en blanco. Para más información, consulte Carácter de espacio en blanco: \s.
Si se especifica un comportamiento conforme a ECMAScript, \S es equivalente a [^ \f\n\r\t\v]. Para obtener información sobre las expresiones regulares ECMAScript, consulte la sección "Comportamiento de la búsqueda de coincidencias de ECMAScript" en Opciones de expresiones regulares.
En el ejemplo siguiente se ilustra el elemento del lenguaje \S. El patrón de expresión regular \b(\S+)\s? coincide con cadenas delimitadas por caracteres de espacio en blanco. El segundo elemento del objeto GroupCollection de la coincidencia contiene la cadena coincidente. La expresión regular puede interpretarse como se muestra en la tabla siguiente.
| Elemento | Descripción |
|---|---|
\b |
Iniciar la búsqueda de coincidencias en un límite de palabras. |
(\S+) |
Coincide con caracteres que no son espacio en blanco. Este es el primer grupo de captura. |
\s? |
Busca coincidencias con cero o un carácter de espacio en blanco. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(\S+)\s?";
string input = "This is the first sentence of the first paragraph. " +
"This is the second sentence.\n" +
"This is the only sentence of the second paragraph.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Groups[1]);
}
}
// The example displays the following output:
// This
// is
// the
// first
// sentence
// of
// the
// first
// paragraph.
// This
// is
// the
// second
// sentence.
// This
// is
// the
// only
// sentence
// of
// the
// second
// paragraph.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\S+)\s?"
Dim input As String = "This is the first sentence of the first paragraph. " + _
"This is the second sentence." + vbCrLf + _
"This is the only sentence of the second paragraph."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Groups(1))
Next
End Sub
End Module
' The example displays the following output:
' This
' is
' the
' first
' sentence
' of
' the
' first
' paragraph.
' This
' is
' the
' second
' sentence.
' This
' is
' the
' only
' sentence
' of
' the
' second
' paragraph.
Carácter de dígito decimal: \d
\d coincide con cualquier dígito decimal. Equivale al patrón de expresión regular \p{Nd}, que incluye los dígitos decimales estándar 0-9 así como los dígitos decimales de varios juegos de caracteres.
Si se especifica un comportamiento conforme a ECMAScript, \d es equivalente a [0-9]. Para obtener información sobre las expresiones regulares ECMAScript, consulte la sección "Comportamiento de la búsqueda de coincidencias de ECMAScript" en Opciones de expresiones regulares.
En el ejemplo siguiente se ilustra el elemento del lenguaje \d. Comprueba si una cadena de entrada representa un número de teléfono válido de los Estados Unidos y Canadá. El patrón de expresión regular ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ se define como se muestra en la tabla siguiente.
| Elemento | Descripción |
|---|---|
^ |
Iniciar la búsqueda de coincidencias con el principio de la cadena de entrada. |
\(? |
Coincide con cero o un carácter "(" literal. |
\d{3} |
Coincide con tres dígitos decimales. |
\)? |
Coincide con cero o un carácter ")" literal. |
[\s-] |
Coincide con un guion o un carácter de espacio en blanco. |
(\(?\d{3}\)?[\s-])? |
Coincide cero o una vez con un paréntesis de apertura opcional seguido de tres dígitos decimales, un paréntesis de cierre opcional y un carácter de espacio en blanco o un guion. Este es el primer grupo de captura. |
\d{3}-\d{4} |
Coincide con tres dígitos decimales seguidos de un guion y otros cuatro dígitos decimales. |
$ |
Coincide con el final de la cadena de entrada. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$";
string[] inputs = { "111 111-1111", "222-2222", "222 333-444",
"(212) 111-1111", "111-AB1-1111",
"212-111-1111", "01 999-9999" };
foreach (string input in inputs)
{
if (Regex.IsMatch(input, pattern))
Console.WriteLine(input + ": matched");
else
Console.WriteLine(input + ": match failed");
}
}
}
// The example displays the following output:
// 111 111-1111: matched
// 222-2222: matched
// 222 333-444: match failed
// (212) 111-1111: matched
// 111-AB1-1111: match failed
// 212-111-1111: matched
// 01 999-9999: match failed
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$"
Dim inputs() As String = {"111 111-1111", "222-2222", "222 333-444", _
"(212) 111-1111", "111-AB1-1111", _
"212-111-1111", "01 999-9999"}
For Each input As String In inputs
If Regex.IsMatch(input, pattern) Then
Console.WriteLine(input + ": matched")
Else
Console.WriteLine(input + ": match failed")
End If
Next
End Sub
End Module
' The example displays the following output:
' 111 111-1111: matched
' 222-2222: matched
' 222 333-444: match failed
' (212) 111-1111: matched
' 111-AB1-1111: match failed
' 212-111-1111: matched
' 01 999-9999: match failed
Carácter que no sea un dígito: \D
\D coincide con cualquier carácter que no sea un dígito. Equivale al patrón de expresión regular \P{Nd}.
Si se especifica un comportamiento conforme a ECMAScript, \D es equivalente a [^0-9]. Para obtener información sobre las expresiones regulares ECMAScript, consulte la sección "Comportamiento de la búsqueda de coincidencias de ECMAScript" en Opciones de expresiones regulares.
En el ejemplo siguiente se muestra el elemento del lenguaje \D. Comprueba si una cadena, como un número de pieza, consta de la combinación adecuada de caracteres decimales y no decimales. El patrón de expresión regular ^\D\d{1,5}\D*$ se define como se muestra en la tabla siguiente.
| Elemento | Descripción |
|---|---|
^ |
Iniciar la búsqueda de coincidencias con el principio de la cadena de entrada. |
\D |
Coincide con un carácter que no sea un dígito. |
\d{1,5} |
Coincide con entre uno y cinco dígitos decimales. |
\D* |
Coincide con cero, uno o más caracteres no decimales. |
$ |
Coincide con el final de la cadena de entrada. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"^\D\d{1,5}\D*$";
string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" };
foreach (string input in inputs)
{
if (Regex.IsMatch(input, pattern))
Console.WriteLine(input + ": matched");
else
Console.WriteLine(input + ": match failed");
}
}
}
// The example displays the following output:
// A1039C: matched
// AA0001: match failed
// C18A: matched
// Y938518: match failed
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "^\D\d{1,5}\D*$"
Dim inputs() As String = {"A1039C", "AA0001", "C18A", "Y938518"}
For Each input As String In inputs
If Regex.IsMatch(input, pattern) Then
Console.WriteLine(input + ": matched")
Else
Console.WriteLine(input + ": match failed")
End If
Next
End Sub
End Module
' The example displays the following output:
Categorías generales Unicode compatibles
Unicode define las categorías generales que se muestran en la tabla siguiente. Para más información, consulte las secciones sobre el "formato de archivo UCD" y los "valores de categorías generales" en la base de datos de caracteres Unicode, sección 5.7.1, tabla 12.
| Category | Descripción |
|---|---|
Lu |
Letra, mayúscula |
Ll |
Letra, minúscula |
Lt |
Letra, inicial en mayúscula |
Lm |
Letra, modificador |
Lo |
Letra, otra |
L |
Todos los caracteres de letras. Esto incluye los caracteres Lu, Ll, Lt, Lm y Lo. |
Mn |
Marca, sin espacios |
Mc |
Marca, con espacios y combinación |
Me |
Marca, inclusión |
M |
Todas las marcas combinadas. Esto incluye las categorías Mn, Mc y Me. |
Nd |
Número, dígito decimal |
Nl |
Número, letra |
No |
Número, otro |
N |
Todos los números. Esto incluye las categorías Nd, Nl y No. |
Pc |
Puntuación, conector |
Pd |
Puntuación, raya |
Ps |
Puntuación, abrir |
Pe |
Puntuación, cerrar |
Pi |
Puntuación, comilla de apertura (puede comportarse como Ps o Pe, en función del uso) |
Pf |
Puntuación, comilla de cierre (puede comportarse como Ps o Pe, en función del uso) |
Po |
Puntuación, otro |
P |
Todos los signos de puntuación. Esto incluye las categorías Pc, Pd, Ps, Pe, Pi, Pf y Po. |
Sm |
Símbolo, matemático |
Sc |
Símbolo, divisa |
Sk |
Símbolo, modificador |
So |
Símbolo, otro |
S |
Todos los símbolos. Esto incluye las categorías Sm, Sc, Sk y So. |
Zs |
Separador, espacio |
Zl |
Separador, línea |
Zp |
Separador, párrafo |
Z |
Todos los caracteres separadores. Esto incluye las categorías Zs, Zl y Zp. |
Cc |
Otro, control |
Cf |
Otro, formato |
Cs |
Otro, suplente |
Co |
Otro, uso privado |
Cn |
Otro, sin asignar o sin carácter |
C |
Todos los demás caracteres. Esto incluye las categorías Cc, Cf, Cs, Co y Cn. |
Puede determinar la categoría Unicode de cualquier carácter concreto pasando dicho carácter al método GetUnicodeCategory. En el ejemplo siguiente se utiliza el método GetUnicodeCategory para determinar la categoría de cada elemento de una matriz que contiene determinados caracteres latinos.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
char[] chars = { 'a', 'X', '8', ',', ' ', '\u0009', '!' };
foreach (char ch in chars)
Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()),
Char.GetUnicodeCategory(ch));
}
}
// The example displays the following output:
// 'a': LowercaseLetter
// 'X': UppercaseLetter
// '8': DecimalDigitNumber
// ',': OtherPunctuation
// '\ ': SpaceSeparator
// '\t': Control
// '!': OtherPunctuation
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim chars() As Char = {"a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c}
For Each ch As Char In chars
Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), _
Char.GetUnicodeCategory(ch))
Next
End Sub
End Module
' The example displays the following output:
' 'a': LowercaseLetter
' 'X': UppercaseLetter
' '8': DecimalDigitNumber
' ',': OtherPunctuation
' '\ ': SpaceSeparator
' '\t': Control
' '!': OtherPunctuation
Bloques con nombre compatibles
.NET proporciona los bloques con nombre que se muestran en la tabla siguiente. El conjunto de bloques con nombre compatibles está basado en Unicode 4.0 y Perl 5.6. Para una expresión regular que usa bloques con nombre, consulte la sección Categoría Unicode o bloque Unicode: sección \p{}.
| Intervalo de puntos de código | Nombre del bloque |
|---|---|
| 0000 - 007F | IsBasicLatin |
| 0080 - 00FF | IsLatin-1Supplement |
| 0100 - 017F | IsLatinExtended-A |
| 0180 - 024F | IsLatinExtended-B |
| 0250 - 02AF | IsIPAExtensions |
| 02B0 - 02FF | IsSpacingModifierLetters |
| 0300 - 036F | IsCombiningDiacriticalMarks |
| 0370 - 03FF | IsGreekO bien IsGreekandCoptic |
| 0400 - 04FF | IsCyrillic |
| 0500 - 052F | IsCyrillicSupplement |
| 0530 - 058F | IsArmenian |
| 0590 - 05FF | IsHebrew |
| 0600 - 06FF | IsArabic |
| 0700 - 074F | IsSyriac |
| 0780 - 07BF | IsThaana |
| 0900 - 097F | IsDevanagari |
| 0980 - 09FF | IsBengali |
| 0A00 - 0A7F | IsGurmukhi |
| 0A80 - 0AFF | IsGujarati |
| 0B00 - 0B7F | IsOriya |
| 0B80 - 0BFF | IsTamil |
| 0C00 - 0C7F | IsTelugu |
| 0C80 - 0CFF | IsKannada |
| 0D00 - 0D7F | IsMalayalam |
| 0D80 - 0DFF | IsSinhala |
| 0E00 - 0E7F | IsThai |
| 0E80 - 0EFF | IsLao |
| 0F00 - 0FFF | IsTibetan |
| 1000 - 109F | IsMyanmar |
| 10A0 - 10FF | IsGeorgian |
| 1100 - 11FF | IsHangulJamo |
| 1200 - 137F | IsEthiopic |
| 13A0 - 13FF | IsCherokee |
| 1400 - 167F | IsUnifiedCanadianAboriginalSyllabics |
| 1680 - 169F | IsOgham |
| 16A0 - 16FF | IsRunic |
| 1700 - 171F | IsTagalog |
| 1720 - 173F | IsHanunoo |
| 1740 - 175F | IsBuhid |
| 1760 - 177F | IsTagbanwa |
| 1780 - 17FF | IsKhmer |
| 1800 - 18AF | IsMongolian |
| 1900 - 194F | IsLimbu |
| 1950 - 197F | IsTaiLe |
| 19E0 - 19FF | IsKhmerSymbols |
| 1D00 - 1D7F | IsPhoneticExtensions |
| 1E00 - 1EFF | IsLatinExtendedAdditional |
| 1F00 - 1FFF | IsGreekExtended |
| 2000 - 206F | IsGeneralPunctuation |
| 2070 - 209F | IsSuperscriptsandSubscripts |
| 20A0 - 20CF | IsCurrencySymbols |
| 20D0 - 20FF | IsCombiningDiacriticalMarksforSymbolsO bien IsCombiningMarksforSymbols |
| 2100 - 214F | IsLetterlikeSymbols |
| 2150 - 218F | IsNumberForms |
| 2190 - 21FF | IsArrows |
| 2200 - 22FF | IsMathematicalOperators |
| 2300 - 23FF | IsMiscellaneousTechnical |
| 2400 - 243F | IsControlPictures |
| 2440 - 245F | IsOpticalCharacterRecognition |
| 2460 - 24FF | IsEnclosedAlphanumerics |
| 2500 - 257F | IsBoxDrawing |
| 2580 - 259F | IsBlockElements |
| 25A0 - 25FF | IsGeometricShapes |
| 2600 - 26FF | IsMiscellaneousSymbols |
| 2700 - 27BF | IsDingbats |
| 27C0 - 27EF | IsMiscellaneousMathematicalSymbols-A |
| 27F0 - 27FF | IsSupplementalArrows-A |
| 2800 - 28FF | IsBraillePatterns |
| 2900 - 297F | IsSupplementalArrows-B |
| 2980 - 29FF | IsMiscellaneousMathematicalSymbols-B |
| 2A00 - 2AFF | IsSupplementalMathematicalOperators |
| 2B00 - 2BFF | IsMiscellaneousSymbolsandArrows |
| 2E80 - 2EFF | IsCJKRadicalsSupplement |
| 2F00 - 2FDF | IsKangxiRadicals |
| 2FF0 - 2FFF | IsIdeographicDescriptionCharacters |
| 3000 - 303F | IsCJKSymbolsandPunctuation |
| 3040 - 309F | IsHiragana |
| 30A0 - 30FF | IsKatakana |
| 3100 - 312F | IsBopomofo |
| 3130 - 318F | IsHangulCompatibilityJamo |
| 3190 - 319F | IsKanbun |
| 31A0 - 31BF | IsBopomofoExtended |
| 31F0 - 31FF | IsKatakanaPhoneticExtensions |
| 3200 - 32FF | IsEnclosedCJKLettersandMonths |
| 3300 - 33FF | IsCJKCompatibility |
| 3400 - 4DBF | IsCJKUnifiedIdeographsExtensionA |
| 4DC0 - 4DFF | IsYijingHexagramSymbols |
| 4E00 - 9FFF | IsCJKUnifiedIdeographs |
| A000 - A48F | IsYiSyllables |
| A490 - A4CF | IsYiRadicals |
| AC00 - D7AF | IsHangulSyllables |
| D800 - DB7F | IsHighSurrogates |
| DB80 - DBFF | IsHighPrivateUseSurrogates |
| DC00 - DFFF | IsLowSurrogates |
| E000 - F8FF | IsPrivateUse o IsPrivateUseArea |
| F900 - FAFF | IsCJKCompatibilityIdeographs |
| FB00 - FB4F | IsAlphabeticPresentationForms |
| FB50 - FDFF | IsArabicPresentationForms-A |
| FE00 - FE0F | IsVariationSelectors |
| FE20 - FE2F | IsCombiningHalfMarks |
| FE30 - FE4F | IsCJKCompatibilityForms |
| FE50 - FE6F | IsSmallFormVariants |
| FE70 - FEFF | IsArabicPresentationForms-B |
| FF00 - FFEF | IsHalfwidthandFullwidthForms |
| FFF0 - FFFF | IsSpecials |
Sustracción de clases de caracteres: [grupo_base - [grupo_excluido]]
Una clase de caracteres define un conjunto de caracteres. La sustracción de clases de caracteres genera un conjunto de caracteres que es el resultado de excluir los caracteres de una clase de caracteres de otra clase de caracteres.
Una expresión de sustracción de clases de caracteres tiene el formato siguiente:
[ base_group -[ excluded_group ]]
Los corchetes ([]) y el guion (-) son obligatorios. El grupo_base es un grupo de caracteres positivos o un grupo de caracteres negativos. El componente grupo_excluido es otro grupo de caracteres positivos o negativos, u otra expresión de sustracción de clases de caracteres (es decir, pueden anidarse expresiones de sustracción de clases de caracteres).
Por ejemplo, supongamos que tiene un grupo base formado por el intervalo de caracteres de "a" a "z". Para definir el conjunto de caracteres formado por el grupo base, salvo el carácter "m", utilice [a-z-[m]]. Para definir el conjunto de caracteres formado por el grupo base, salvo el conjunto de caracteres "d", "j" y "p", utilice [a-z-[djp]]. Para definir el conjunto de caracteres formado por el grupo base, salvo el intervalo de caracteres de "m" a "p", utilice [a-z-[m-p]].
Considere la expresión de sustracción de clases de caracteres anidada [a-z-[d-w-[m-o]]]. La expresión se evalúa desde el intervalo de caracteres más profundo hacia el exterior. Primero, el intervalo de caracteres de "m" a "o" se resta del intervalo de caracteres de "d" a "w", lo que da como resultado el conjunto de caracteres de "d" a "l" y de "p" a "w". A continuación, ese conjunto se resta del intervalo de caracteres de "a" a "z", lo que da lugar al conjunto de caracteres [abcmnoxyz].
Puede utilizar cualquier clase de caracteres con la sustracción de clases de caracteres. Para definir el conjunto de caracteres formado por todos los caracteres Unicode desde \u0000 hasta \uFFFF, a excepción de los caracteres de espacio en blanco (\s), los caracteres de la categoría general de puntuación (\p{P}), los caracteres del bloque con nombre IsGreek (\p{IsGreek}) y el carácter de control Unicode NEXT LINE (\x85), use [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].
Elija las clases de caracteres para que una expresión de sustracción de clases de caracteres produzca resultados satisfactorios. Evite el uso de expresiones que produzcan un conjunto vacío de caracteres, que no coincidan con nada, o expresiones equivalentes al grupo base original. Por ejemplo, el conjunto vacío es el resultado de la expresión [\p{IsBasicLatin}-[\x00-\x7F]], que resta todos los caracteres del intervalo de caracteres IsBasicLatin de la categoría general IsBasicLatin. Ocurre lo mismo con el grupo base original, que es el resultado de la expresión [a-z-[0-9]]. Esto se debe a que el grupo base, que está formado por el intervalo de caracteres comprendido entre las letras de la "a" a la "z", no contiene ningún carácter del grupo excluido, que es el intervalo de caracteres formado por los dígitos decimales del "0" al "9".
En el ejemplo siguiente se define una expresión regular, ^[0-9-[2468]]+$, que coincide con cero y con los dígitos impares de una cadena de entrada. La expresión regular se interpreta como se muestra en la tabla siguiente.
| Elemento | Descripción |
|---|---|
| ^ | Comienza la búsqueda de coincidencias al principio de la cadena de entrada. |
[0-9-[2468]]+ |
Coincide con una o varias apariciones de cualquier carácter del 0 al 9, salvo con el 2, 4, 6 y 8. En otras palabras, busca una o varias coincidencias con cero o un dígito impar. |
| $ | Finalizar la búsqueda de coincidencias al final de la cadena de entrada. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] inputs = { "123", "13579753", "3557798", "335599901" };
string pattern = @"^[0-9-[2468]]+$";
foreach (string input in inputs)
{
Match match = Regex.Match(input, pattern);
if (match.Success)
Console.WriteLine(match.Value);
}
}
}
// The example displays the following output:
// 13579753
// 335599901
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim inputs() As String = {"123", "13579753", "3557798", "335599901"}
Dim pattern As String = "^[0-9-[2468]]+$"
For Each input As String In inputs
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' 13579753
' 335599901
