Compartir a través de

Clases de carácter

  • Artículo

Una clase de caracteres define un juego de caracteres, cualquiera de los cuales se puede estar en una cadena de entrada para que una coincidencia tenga éxito. El lenguaje de expresiones regulares de .NET Framework admite las siguientes clases de caracteres:

  • Grupo de caracteres positivos. Un carácter de la cadena de entrada debe coincidir con uno de un juego de caracteres especificado. Para obtener más información, vea Grupo de caracteres positivos.

  • Grupo de caracteres negativos. Un carácter de la cadena de entrada no debe coincidir con uno de un juego de caracteres especificado. Para obtener más información, vea 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, vea Cualquier carácter.

  • Una categoría Unicode general o bloque con nombre. Un carácter en la cadena de entrada debe ser un miembro de una categoría Unicode determinada o debe estar dentro de un intervalo contiguo de caracteres Unicode para que una coincidencia tenga éxito. Para obtener más información, vea Categoría Unicode o bloque Unicode.

  • Una categoría Unicode general negativa o bloque con nombre. Un carácter en la cadena de entrada no debe ser un miembro de una categoría Unicode determinada o no debe estar dentro de un intervalo contiguo de caracteres Unicode para que una coincidencia tenga éxito. Para obtener más información, vea Categoría Unicode negativa o bloque Unicode.

  • Un carácter de palabra. Un carácter en la cadena de entrada puede pertenecer a cualquiera de las categorías Unicode que son adecuadas para los caracteres en palabras. Para obtener más información, vea Carácter de palabra.

  • Un carácter que no sea de palabra. Un carácter en la cadena de entrada puede pertenecer a cualquier categoría Unicode que no sea un carácter de palabra. Para obtener más información, vea Carácter que no pertenezca a una palabra.

  • Un carácter que sea un espacio en blanco. Un carácter en la cadena de entrada puede ser cualquiera de los caracteres separadores Unicode, así como cualquiera de los caracteres de control. Para obtener más información, vea Carácter de espacio en blanco.

  • Un carácter que no sea un espacio en blanco. Un carácter en la cadena de entrada puede ser cualquier carácter que no sea un espacio en blanco. Para obtener más información, vea Carácter que no sea un espacio en blancoNon-White-Space Character.

  • Dígito decimal. Un carácter en la cadena de entrada puede ser cualquiera de los caracteres clasificados como dígitos decimales de Unicode. Para obtener más información, vea Carácter de dígito decimal.

  • Un dígito no decimal. Un carácter en la cadena de entrada puede ser algo distinto de un dígito decimal de Unicode. Para obtener más información, vea Carácter de dígito decimal.

.NET Framework admite expresiones de sustracción de clases de caracteres, que le 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, vea Sustracción de clases de caracteres.

Grupo de caracteres positivos: [ ]

Un grupo de caracteres positivos especifica una lista de caracteres que pueden aparecer en una cadena de entrada para que una coincidencia se produzca. Se puede especificar esta lista de caracteres individualmente, como un intervalo o ambos.

La sintaxis para especificar una lista de caracteres individuales es como sigue:

[grupo_caracteres]

donde grupo_caracteres es una lista de los caracteres individuales que pueden aparecer en la cadena de entrada para que una coincidencia tenga éxito. character_group puede estar compuestos de cualquier combinación de uno o más caracteres literales, caracteres de escape o clases de caracteres.

La sintaxis para especificar un intervalo de caracteres es como sigue:

[firstCharacter-lastCharacter]

donde primerCarácter es el carácter que comienza el intervalo y últimoCarácter es el carácter que finaliza el intervalo. Un intervalo de caracteres es una serie contigua de caracteres que se define mediante la especificación del primer carácter de la serie, un guión (-) y, a continuación, el último carácter de la serie. Dos caracteres son contiguos si tienen puntos de código Unicode adyacentes.

En la siguiente tabla se recogen algunos de los modelos de expresión regular comunes que contienen clases de caracteres positivos.

Modelo

Descripción

[aeiou]

Busca una coincidencia de todas las vocales.

[\p{P}\d]

Busca una coincidencia de todos los caracteres de puntuación y de dígitos decimales.

[\s\p{P}]

Busca una coincidencia de todos los caracteres de espacio en blanco y de puntuación.

En el siguiente ejemplo se define un grupo de caracteres positivo que contiene los caracteres "a" y "o" de manera que la cadena de entrada deba contener las palabras "casa" o "cosa" seguidas de otra palabra para que se produzca una coincidencia.

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.

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.

La expresión regular gr[ae]y\s\S+?[\s|\p{P}] se define como sigue:

Modelo

Descripción

gr

Busca una coincidencia con los caracteres literales "gr".

[ae]

Busca una coincidencia de una "a" o una "e".

y\s

Busca una coincidencia con el carácter literal "y" seguido de un carácter de espacio en blanco.

\S+?

Busca una coincidencia con uno o varios caracteres que no sean un espacio en blanco, pero con la menor cantidad posible de caracteres.

[\s|\p{P}]

Busca una coincidencia de un carácter de espacio en blanco o un signo de puntuación.

En el siguiente ejemplo se buscan coincidencias de palabras que comienzan con cualquier letra mayúscula. Utiliza la subexpresión [A-Z] para representar el intervalo de letras mayúsculas de la A a la Z.

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

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

La expresión regular \b[A-Z]\w*\b se define como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Empezar en un límite de palabras.

[A-Z]

Busca una coincidencia de cualquier letra mayúscula de la A a la Z.

\w*

Buscar una coincidencia de cero o más caracteres de palabra.

\b

Hacer coincidir con un límite de palabras.

Volver al principio

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 una coincidencia se produzca. Se puede especificar la lista de caracteres individualmente, como un intervalo o ambos.

La sintaxis para especificar una lista de caracteres individuales es como sigue:

[^grupo_caracteres]

donde grupo_caracteres es una lista de los caracteres individuales que no pueden aparecer en la cadena de entrada para que una coincidencia tenga éxito. character_group puede estar compuestos de cualquier combinación de uno o más caracteres literales, caracteres de escape o clases de caracteres.

La sintaxis para especificar un intervalo de caracteres es como sigue:

[^primerCarácter-últimoCarácter]

donde primerCarácter es el carácter que comienza el intervalo y últimoCarácter es el carácter que finaliza el intervalo. Un intervalo de caracteres es una serie contigua de caracteres que se define mediante la especificación del primer carácter de la serie, un guión (-) y, a continuación, el último carácter de la serie. Dos caracteres son contiguos si tienen puntos de código Unicode adyacentes.

Es posible concatenar dos o más intervalos de caracteres. Por ejemplo, para especificar el intervalo de dígitos decimales de "0" a "9", el intervalo de letras minúsculas de "a" a "f" y el intervalo de letras mayúsculas de "A" a "F", utilice [0-9a-fA-F].

El carácter de intercalación inicial (^) en un grupo de caracteres negativo es obligatorio e indica que el grupo de caracteres es un grupo de caracteres negativo en lugar de un grupo de caracteres positivo.

Nota importanteImportante

Un grupo de caracteres negativos de un modelo de expresión regular mayor 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 siguiente tabla se recogen algunos de los modelos de expresión regular comunes que contienen grupos de caracteres negativos.

Modelo

Descripción

[^aeiou]

Busca una coincidencia con todos los caracteres excepto las vocales.

[^\p{P}\d]

Busca una coincidencia de todos los caracteres excepto los caracteres de puntuación y de dígitos decimales.

En el siguiente ejemplo se busca una coincidencia de cualquier palabra que comience con los caracteres "ll" y no vaya seguida de "o".

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

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

La expresión regular \bth[^o]\w+\b se define como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Empezar en un límite de palabras.

th

Busca una coincidencia con los caracteres literales "th".

[^o]

Busca una coincidencia de cualquier carácter que no sea "o".

\w+

Buscar una coincidencia con uno o más caracteres de palabra.

\b

Finalizar en un límite de palabras.

Volver al principio

Cualquier carácter:

El carácter punto (.) busca coincidencias con cualquier carácter excepto \n (carácter de nueva línea, \u000A), con las siguientes dos calificaciones:

  • Si la opción RegexOptions.Singleline modifica un modelo de expresión regular o si la opción s modifica la parte del modelo que contiene la clase de caracteres ., . coincide con cualquier carácter. Para obtener más información, vea Opciones de expresiones regulares.

    El siguiente ejemplo muestra el comportamiento diferente de la clase de caracteres . de forma predeterminada y con la opción RegexOptions.Singleline. La expresión regular ^.+ comienza en el principio de la cadena y coincide con cada carácter. De forma predeterminada, la coincidencia finaliza al final de la primera línea; el modelo de expresión regular coincide con el carácter de retorno de carro, \r o \u000D, pero no coincide con \n. Dado que la opción RegexOptions.Singleline interpreta la cadena de entrada completa como una línea única, coincide con cada carácter de la cadena de entrada, incluido \n.

    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\.

    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\.
NotaNota

Dado que coincide con cualquier carácter excepto \n, la clase de caracteres . también coincide con \r (el carácter de retorno de carro, \u000D).

  • En un grupo de caracteres positivos o negativos, un punto se considera un carácter de punto literal, no una clase de caracteres. Para obtener más información, vea las secciones Grupo de caracteres positivos y Grupo de caracteres negativos que figuran anteriormente en este tema. En el siguiente ejemplo se proporciona una ilustración definiendo 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 positivo. La expresión regular \b.*[.?!;:](\s|\z) comienza en un límite de palabras, coincide con cualquier carácter hasta que encuentra uno de cuatro signos de puntuación, incluyendo un punto, y después coincide con un carácter de espacio en blanco o con el final de la cadena.

    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.

    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.
NotaNota

Dado que coincide con cualquier carácter, el elemento del lenguaje . se utiliza a menudo con un cuantificador no expansivo si un modelo de expresión regular intenta coincidir varias veces con cualquier carácter.Para obtener más información, vea Cuantificadores.

Volver al principio

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 en el 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 dese \u0000 hasta \u007F, mientras que el juego de caracteres árabes se encuentra desde \u0600 hasta \u06FF.

La construcción de expresión regular

\p{name}

busca coincidencias con cualquier carácter que pertenezca a una categoría general de Unicode o el bloque con nombre, donde nombre es la abreviatura de la categoría o el nombre del bloque con nombre. Para obtener una lista de abreviaturas de categoría, consulte Categorías generales Unicode compatibles más adelante en este tema. Para obtener una lista de bloques con nombre, vea Bloques con nombre compatibles más adelante en este tema.

En el siguiente ejemplo se utiliza 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 nombreIsGreek e IsBasicLatin).

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

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.
   }
}

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

Empezar en un límite de palabras.

\p{IsGreek}+

Busca una coincidencia con uno o varios caracteres griegos.

(\s)?

Busca coincidencias con el cero o un carácter de espacio en blanco.

(\p{IsGreek}+(\s)?)+

Busca una o varias coincidencias con el modelo de uno varios caracteres griegos seguidos de cero o un carácter de espacio en blanco.

\p{Pd}

Busca una coincidencia con un carácter de puntuación, guión.

\s

Hacer coincidir con un carácter que sea un espacio en blanco.

\p{IsBasicLatin}+

Busca una coincidencia con uno o varios caracteres latinos básicos.

(\s)?

Busca coincidencias con el cero o un carácter de espacio en blanco.

(\p{IsBasicLatin}+(\s)?)+

Busca una o varias coincidencias con el modelo de uno varios caracteres latinos básicos seguidos de cero o un carácter de espacio en blanco.

Volver al principio

Categoría Unicode negativa 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 en el 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 dese \u0000 hasta \u007F, mientras que el juego de caracteres árabes se encuentra desde \u0600 hasta \u06FF.

La construcción de expresión regular

\P{name}

busca coincidencias con cualquier carácter que no pertenezca a una categoría general de Unicode o el bloque con nombre, donde nombre es la abreviatura de la categoría o el nombre del bloque con nombre. Para obtener una lista de abreviaturas de categoría, consulte Categorías generales Unicode compatibles más adelante en este tema. Para obtener una lista de bloques con nombre, vea Bloques con nombre compatibles más adelante en este tema.

En el siguiente ejemplo se utiliza la construcción \P{nombre} para quitar cualquier símbolo de divisa (en este caso,Sc , o la categoría Symbol, Currency) de las cadenas numéricas.

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

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

El modelo de expresión regular (\P{Sc})+ coincide con uno o más caracteres que no son símbolos de divisa; quita eficazmente cualquier símbolo de divisa de la cadena de resultado.

Volver al principio

Carácter de palabra: \w

\w busca cualquier carácter de una palabra. Un carácter de palabra es un miembro de alguna de las categorías Unicode enumeradas en la siguiente tabla.

Categoría

Descripción

Ll

Letra, minúscula

Lu

Letra, mayúscula

Lt

Letra, título

Lo

Letra, otra

Lm

Letra, modificador

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 expresiones regulares ECMAScript, vea la sección "Comportamiento del motor de búsqueda de coincidencias ECMAScript" en Opciones de expresiones regulares.

NotaNota

Dado que coincide con cualquier carácter que forme parte de palabras, el elemento del lenguaje \w se utiliza a menudo con un cuantificador no expansivo si un modelo de expresión regular intenta coincidir varias veces con cualquier carácter que forme parte de palabras seguido de un carácter que forme parte de palabras concreto.Para obtener más información, vea Cuantificadores.

En el siguiente ejemplo se utiliza el elemento del lenguaje \w para buscar coincidencias de caracteres duplicados en una palabra. El ejemplo define un modelo de expresión regular, (\w)\1, que se puede interpretar de esta manera.

Elemento

Descripción

(\w)

Busca una coincidencia con un carácter de palabra. Éste es el primer grupo de captura.

\1

Busca una coincidencia con el valor de la primera captura.

 
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.

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.

Volver al principio

Carácter que no pertenezca a una palabra: \W

\W busca cualquier carácter que no pertenezca a una palabra. El elemento del lenguaje \W es equivalente a la siguiente clase de caracteres:

[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]

En otras palabras, coincide con cualquier carácter salvo con los que figuran en la siguiente tabla.

Categoría

Descripción

Ll

Letra, minúscula

Lu

Letra, mayúscula

Lt

Letra, título

Lo

Letra, otra

Lm

Letra, modificador

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 expresiones regulares ECMAScript, vea la sección "Comportamiento del motor de búsqueda de coincidencias ECMAScript" en Opciones de expresiones regulares.

NotaNota

Dado que coincide con cualquier carácter que no forme parte de palabras, el elemento del lenguaje \W se utiliza a menudo con un cuantificador no expansivo si un modelo de expresión regular intenta coincidir varias veces con cualquier carácter que no forme parte de palabras seguido de un carácter que no forme parte de palabras concreto.Para obtener más información, vea Cuantificadores.

En el siguiente ejemplo se muestra la clase de caracteres \w. Define un modelo de expresión regular, \b(\w+)(\W){1,2}, que coincide con una palabra seguida de uno o varios caracteres que no pertenezcan a una palabra, como un espacio en blanco o la 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 una coincidencia con uno o más caracteres de palabra. Éste es el primer grupo de captura.

(\w){1,2}

Busca una o dos coincidencias con un carácter que no pertenezca a una palabra. Éste es el segundo grupo de captura.

 
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)

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)

Dado que el objeto Group del segundo grupo capturador contiene sólo un carácter que no pertenece a palabras, el ejemplo recupera todos los caracteres que no pertenecen a palabras del objeto CaptureCollection que devuelve la propiedad Group.Captures.

Volver al principio

Carácter de espacio en blanco: \s

\s busca cualquier carácter que sea un espacio en blanco. Equivale a las secuencias de escape y las categorías Unicode que figuran en la siguiente tabla.

Categoría

Descripción

\f

El carácter de avance de página, \u000C.

\n

El carácter de nueva línea, \u000A.

\r

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

Los puntos suspensivos o el carácter de LÍNEA SIGUIENTE (…), \u0085.

\p{Z}

Busca una coincidencia con cualquier carácter separador.

Si se especifica un comportamiento conforme a ECMAScript, \s es equivalente a [\f\n\r\t\v]. Para obtener información sobre expresiones regulares ECMAScript, vea la sección "Comportamiento del motor de búsqueda de coincidencias ECMAScript" en Opciones de expresiones regulares.

En el siguiente ejemplo se muestra la clase de caracteres \s. Define un modelo de expresión regular, \b\w+(e)*s(\s|$), que coincide con una palabra que termina con "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 una coincidencia con uno o más caracteres de palabra.

(e)*

Busca una o cero coincidencias de una "e".

s

Busca una coincidencia de una "s".

(\s|$)

Busca una coincidencia de un carácter de espacio en blanco o el final de la cadena de entrada.

 
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

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

Volver al principio

Carácter que no sea un espacio en blanco: \S

\S busca cualquier carácter que no sea un espacio en blanco. Equivale al modelo de expresión regular [^\f\n\r\t\v\x85\p{Z}] o al contrario del modelo de expresión regular equivalente a \s, que coincide con caracteres de espacio en blanco. Para obtener más información, vea 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 expresiones regulares ECMAScript, vea la sección "Comportamiento del motor de búsqueda de coincidencias ECMAScript" en Opciones de expresiones regulares.

En el siguiente ejemplo se muestra el elemento de lenguaje \S. El modelo 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 se puede interpretar como se muestra en la tabla siguiente.

Elemento

Descripción

\b

Iniciar la búsqueda de coincidencias en un límite de palabras.

(\S+)

Busca una coincidencia con uno o varios caracteres que no sean un espacio en blanco. Éste es el primer grupo de captura.

\s*

Busca coincidencias con el cero o un carácter de espacio en blanco.

 
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.

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.

Volver al principio

Carácter de dígito decimal: \d

\d busca cualquier dígito decimal. Equivale al modelo de expresión regular \p{Nd}, que incluye los dígitos decimales estándar 0-9 así como los dígitos decimales de varios otros juegos de caracteres.

Si se especifica un comportamiento conforme a ECMAScript, \d es equivalente a [0-9]. Para obtener información sobre expresiones regulares ECMAScript, vea la sección "Comportamiento del motor de búsqueda de coincidencias ECMAScript" en Opciones de expresiones regulares.

En el siguiente ejemplo se muestra el elemento de lenguaje \d. Comprueba si una cadena de entrada representa un número de teléfono válido de los Estados Unidos y Canadá. El modelo 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.

\(*

Busca una coincidencia con cero o un carácter "(" literal.

\d{3}

Buscar coincidencias con tres dígitos decimales.

\)*

Busca una coincidencia con cero o un carácter ")" literal.

[\s-]

Busca una coincidencia con un guión o un carácter de espacio en blanco.

(\(*\d{3}\)*[\s-])*

Busca una o cero coincidencias de 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 guión. Éste es el primer grupo de captura.

\d{3}=\d{4}

Busca una coincidencia con tres dígitos decimales seguidos de un guión y cuatro dígitos decimales.

$

Buscar coincidencias con el final de la cadena de entrada.

 
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

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

Volver al principio

Carácter que no sea un dígito: \D

\D busca cualquier carácter que no sea un dígito. Equivale al modelo 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 expresiones regulares ECMAScript, vea la sección "Comportamiento del motor de búsqueda de coincidencias ECMAScript" en Opciones de expresiones regulares.

En el siguiente ejemplo se muestra el elemento de lenguaje \D. Comprueba si una cadena, como un número de pieza, se compone de la combinación adecuada de caracteres decimales y no decimales. El modelo 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

Busca una coincidencia con un carácter que no sea un dígito.

\d{1,5}

Busca una coincidencia de uno a cinco dígitos decimales.

\D*

Busca una coincidencia con cero o un carácter no decimal.

$

Buscar coincidencias con el final de la cadena de entrada.

 
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:

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

Volver al principio

Categorías generales Unicode compatibles

Unicode define las categorías generales que se muestran en la siguiente tabla. Para obtener más información, vea los subtemas sobre el formato de archivo UCD y los valores de las categorías generales en la base de datos de caracteres Unicode (en inglés).

Categoría

Descripción

Lu

Letra, mayúscula

Ll

Letra, minúscula

Lt

Letra, título

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, espacio combinable

Me

Marca, cerrar

M

Todo las marcas diacríticas. 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, guión

Ps

Puntuación, abrir

Pe

Puntuación, cerrar

Pi

Puntuación, comilla inicial (puede comportarse como Ps o Pe, en función del uso)

Pf

Puntuación, comilla final (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 de separador. Esto incluye las categorías Zs, Zl y Zp.

Cc

Otro, control

Cf

Otro, formato

Cs

Otro, suplente

Co

Otro, uso privado

Cn

Otro, no asignado (ningún carácter tiene esta propiedad)

C

Todos los caracteres de control. Esto incluye las categorías Cc, Cf, Cs, Co y Cn.

Puede determinar la categoría Unicode de cualquier carácter determinado pasando ese carácter al método GetUnicodeCategory. En el siguiente ejemplo se utiliza el método GetUnicodeCategory para determinar la categoría de cada elemento en una matriz que contiene determinados caracteres latinos.

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

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

Volver al principio

Bloques con nombre compatibles

.NET Framework proporciona los bloques con nombre que se muestra en la siguiente tabla. El conjunto de bloques con nombre compatibles está basado en Unicode 4.0 y Perl 5.6.

Intervalo de puntos de código

Nombre de 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

IsGreek

O 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

IsCombiningDiacriticalMarksforSymbols

O 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

Volver al principio

Sustracción de clases de caracteres

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 siguiente formato:

[grupo_base-[grupo_excluido]]

Los corchetes ([]) y el guión (-) son obligatorios. El grupo_base es un grupo de caracteres positivo o negativo, tal y como se describe en la tabla Sintaxis de clase de caracteres. El componente grupo_excluido es otro grupo de caracteres positivo o negativo, 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 "a" a "z". Para definir el juego de caracteres que componen el grupo base, salvo el carácter "m", utilice [a-z-[m]]. Para definir el juego de caracteres que componen el grupo base, salvo el juego de caracteres "d", "j" y "p", utilice [a-z-[djp]]. Para definir el juego de caracteres que componen 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 juego de caracteres de "d" a "l" y de "p" a "w". A continuación, ese juego se resta del intervalo de caracteres de "a" a "z", lo que da lugar al juego de caracteres [abcmnoxyz].

Puede utilizar cualquier clase de caracteres con sustracción de clases de caracteres. Para definir el conjunto de caracteres formado por todos los caracteres Unicode de \u0000 a \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), utilice [\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 juego 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 siguiente ejemplo se define una expresión regular, ^[0-9-[2468]]+$, que coincide con cero y con dígitos impares en una cadena de entrada. La expresión regular se interpreta como se muestra en la tabla siguiente.

Elemento

Descripción

^

Comenzar la búsqueda de coincidencia en el principio de la cadena de entrada.

[0-9-[2468]]+

Busca una o varias coincidencias con 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.

 
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

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

Volver al principio

Vea también

Referencia

GetUnicodeCategory

Opciones de expresiones regulares

Conceptos

Elementos del lenguaje de expresiones regulares