Classi di caratteri nelle espressioni regolariCharacter Classes in Regular Expressions

Una classe di caratteri definisce un set di caratteri, di cui uno qualsiasi può verificarsi in una stringa di input per trovare una corrispondenza.A character class defines a set of characters, any one of which can occur in an input string for a match to succeed. Il linguaggio delle espressioni regolari di .NET supporta le classi di caratteri seguenti:The regular expression language in .NET supports the following character classes:

  • Gruppi di caratteri positivi.Positive character groups. Un carattere nella stringa di input deve corrispondere a un set di caratteri specificato.A character in the input string must match one of a specified set of characters. Per altre informazioni, vedere Gruppo di caratteri positivi.For more information, see Positive Character Group.

  • Gruppi di caratteri negativi.Negative character groups. Un carattere nella stringa di input non deve corrispondere a un set di caratteri specificato.A character in the input string must not match one of a specified set of characters. Per altre informazioni, vedere Gruppo di caratteri negativi.For more information, see Negative Character Group.

  • Qualsiasi carattere.Any character. Il carattere . (punto) in un'espressione regolare è un carattere jolly che corrisponde a qualsiasi carattere, eccetto \n.The . (dot or period) character in a regular expression is a wildcard character that matches any character except \n. Per altre informazioni, vedere Qualsiasi carattere.For more information, see Any Character.

  • Categoria generale Unicode o blocco denominato.A general Unicode category or named block. Per trovare una corrispondenza, un carattere nella stringa di input deve appartenere a una particolare categoria Unicode o essere compreso in un intervallo contiguo di caratteri Unicode.A character in the input string must be a member of a particular Unicode category or must fall within a contiguous range of Unicode characters for a match to succeed. Per altre informazioni, vedere Categoria Unicode o blocco Unicode.For more information, see Unicode Category or Unicode Block.

  • Categoria Unicode generale o blocco denominato.A negative general Unicode category or named block. Per trovare una corrispondenza, un carattere nella stringa di input non deve appartenere a una particolare categoria Unicode o non deve essere compreso in un intervallo contiguo di caratteri Unicode.A character in the input string must not be a member of a particular Unicode category or must not fall within a contiguous range of Unicode characters for a match to succeed. Per altre informazioni, vedere Categoria Unicode negativa o blocco Unicode.For more information, see Negative Unicode Category or Unicode Block.

  • Carattere alfanumerico.A word character. Un carattere nella stringa di input può appartenere a qualsiasi categoria Unicode appropriata per i caratteri alfanumerico.A character in the input string can belong to any of the Unicode categories that are appropriate for characters in words. Per altre informazioni, vedere Carattere alfanumerico.For more information, see Word Character.

  • Carattere non alfanumerico.A non-word character. Un carattere nella stringa di input può appartenere a qualsiasi categoria Unicode che non sia un carattere alfanumerico.A character in the input string can belong to any Unicode category that is not a word character. Per altre informazioni, vedere Carattere non alfanumerico.For more information, see Non-Word Character.

  • Spazio vuoto.A white-space character. Un carattere nella stringa di input può essere qualsiasi carattere separatore Unicode, nonché un numero qualsiasi di caratteri di controllo.A character in the input string can be any Unicode separator character, as well as any one of a number of control characters. Per altre informazioni, vedere Spazio vuoto.For more information, see White-Space Character.

  • Carattere diverso da uno spazio vuoto.A non-white-space character. Un carattere nella stringa di input può essere qualsiasi carattere diverso da uno spazio vuoto.A character in the input string can be any character that is not a white-space character. Per altre informazioni, vedere Carattere diverso da uno spazio vuoto.For more information, see Non-White-Space Character.

  • Cifra decimale.A decimal digit. Un carattere nella stringa di input può essere qualsiasi numero di caratteri classificati come cifre decimali Unicode.A character in the input string can be any of a number of characters classified as Unicode decimal digits. Per altre informazioni, vedere Carattere cifra decimale.For more information, see Decimal Digit Character.

  • Cifra non decimale.A non-decimal digit. Un carattere nella stringa di input può essere qualsiasi carattere tranne una cifra decimale Unicode.A character in the input string can be anything other than a Unicode decimal digit. Per altre informazioni, vedere Carattere cifra decimale.For more information, see Decimal Digit Character.

.NET supporta espressioni di sottrazione di classi di caratteri che consentono di definire un set di caratteri come risultato dell'esclusione di una classe di caratteri da un'altra classe di caratteri..NET supports character class subtraction expressions, which enables you to define a set of characters as the result of excluding one character class from another character class. Per altre informazioni, vedere Sottrazione di classi di caratteri.For more information, see Character Class Subtraction.

Nota

Le classi di caratteri che corrispondono a caratteri in base alla categoria, ad esempio \w per la corrispondenza con caratteri alfanumerici o \p{} per la corrispondenza con una categoria Unicode, si basano sulla classe CharUnicodeInfo per offrire informazioni sulle categorie di caratteri.Character classes that match characters by category, such as \w to match word characters or \p{} to match a Unicode category, rely on the CharUnicodeInfo class to provide information about character categories. A partire da .NET Framework 4.6.2.NET Framework 4.6.2, le categorie di caratteri si basano sullo standard Unicode, versione 8.0.0.Starting with the .NET Framework 4.6.2.NET Framework 4.6.2, character categories are based on The Unicode Standard, Version 8.0.0. Da .NET Framework 4.NET Framework 4 a .NET Framework 4.6.1.NET Framework 4.6.1, si basano sullo standard Unicode, versione 6.3.0.In the .NET Framework 4.NET Framework 4 through the .NET Framework 4.6.1.NET Framework 4.6.1, they are based on The Unicode Standard, Version 6.3.0.

Gruppo di caratteri positivi: [ ]Positive Character Group: [ ]

Un gruppo di caratteri positivi specifica un elenco di caratteri che possono essere presenti in una stringa di input per trovare una corrispondenza.A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. È possibile specificare l'elenco di caratteri singolarmente, come intervallo o entrambi.This list of characters may be specified individually, as a range, or both.

Di seguito viene indicata la sintassi per specificare un elenco di singoli caratteri:The syntax for specifying a list of individual characters is as follows:

[character_group][character_group]

dove character_group è un elenco dei singoli caratteri che possono essere inclusi nella stringa di input affinché una corrispondenza riesca.where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group può contenere qualsiasi combinazione di uno o più caratteri letterali, caratteri di escape o classi di caratteri.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

Di seguito viene indicata la sintassi per specificare un intervallo di caratteri:The syntax for specifying a range of characters is as follows:

[firstCharacter-lastCharacter]  

dove firstCharacter è il carattere all'inizio dell'intervallo e lastCharacter è il carattere alla fine dell'intervallo.where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. Un intervallo di caratteri è una serie contigua di caratteri definita specificando il primo carattere della serie, un trattino (-), quindi l'ultimo carattere della serie.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Due caratteri sono contigui se hanno punti di codice Unicode adiacenti.Two characters are contiguous if they have adjacent Unicode code points.

Nella tabella seguente sono elencati alcuni criteri di espressione regolare comuni contenenti classi di caratteri positivi.Some common regular expression patterns that contain positive character classes are listed in the following table.

ModelloPattern DescriptionDescription
[aeiou] Corrisponde a tutte le vocali.Match all vowels.
[\p{P}\d] Corrisponde a tutti i caratteri di punteggiatura e tutte le cifre decimali.Match all punctuation and decimal digit characters.
[\s\p{P}] Corrisponde a tutti gli spazi e ai caratteri di punteggiatura.Match all white space and punctuation.

Nell'esempio seguente viene definito un gruppo di caratteri positivi contenente i caratteri "a" ed "e" in modo che la stringa di input contenga obbligatoriamente le parole "grey" o "gray" seguite da un'altra parola perché si verifichi una corrispondenza.The following example defines a positive character group that contains the characters "a" and "e" so that the input string must contain the words "grey" or "gray" followed by another word for a match to occur.

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

L'espressione regolare gr[ae]y\s\S+?[\s|\p{P}] viene definita come segue:The regular expression gr[ae]y\s\S+?[\s|\p{P}] is defined as follows:

ModelloPattern DescriptionDescription
gr Corrisponde ai caratteri letterali "gr".Match the literal characters "gr".
[ae] Corrisponde a una "a" o una "e".Match either an "a" or an "e".
y\s Corrisponde al carattere letterale "y" seguito da uno spazio vuoto.Match the literal character "y" followed by a white-space character.
\S+? Corrisponde a uno o più spazi vuoti, ma al minor numero possibile.Match one or more non-white-space characters, but as few as possible.
[\s\p{P}] Corrisponde a uno spazio vuoto o a un segno di punteggiatura.Match either a white-space character or a punctuation mark.

Le corrispondenze dell'esempio seguente sono relative a parole che iniziano con una lettera maiuscola qualsiasi.The following example matches words that begin with any capital letter. Viene usata la sottoespressione [A-Z] per rappresentare l'intervallo di lettere maiuscole da A a Z.It uses the subexpression [A-Z] to represent the range of capital letters from A to 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

L'espressione regolare \b[A-Z]\w*\b viene definita come illustrato nella tabella seguente.The regular expression \b[A-Z]\w*\b is defined as shown in the following table.

ModelloPattern DescriptionDescription
\b Inizia dal confine di una parola.Start at a word boundary.
[A-Z] Corrisponde a qualsiasi carattere maiuscolo da A a Z.Match any uppercase character from A to Z.
\w* Trova la corrispondenza di zero o più caratteri alfanumerici.Match zero or more word characters.
\b Trova la corrispondenza di un confine di parola.Match a word boundary.

Torna all'inizioBack to Top

Gruppo di caratteri negativi: [^]Negative Character Group: [^]

Un gruppo di caratteri negativi specifica un elenco di caratteri che non devono essere presenti in una stringa di input per trovare una corrispondenza.A negative character group specifies a list of characters that must not appear in an input string for a match to occur. È possibile specificare l'elenco di caratteri singolarmente, come intervallo o entrambi.The list of characters may be specified individually, as a range, or both.

Di seguito viene indicata la sintassi per specificare un elenco di singoli caratteri:The syntax for specifying a list of individual characters is as follows:

[^character_group][^character_group]

dove character_group è un elenco dei singoli caratteri che non possono essere inclusi nella stringa di input affinché una corrispondenza riesca.where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group può contenere qualsiasi combinazione di uno o più caratteri letterali, caratteri di escape o classi di caratteri.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

Di seguito viene indicata la sintassi per specificare un intervallo di caratteri:The syntax for specifying a range of characters is as follows:

[^firstCharacter-lastCharacter][^firstCharacter-lastCharacter]

dove firstCharacter è il carattere all'inizio dell'intervallo e lastCharacter è il carattere alla fine dell'intervallo.where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. Un intervallo di caratteri è una serie contigua di caratteri definita specificando il primo carattere della serie, un trattino (-), quindi l'ultimo carattere della serie.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Due caratteri sono contigui se hanno punti di codice Unicode adiacenti.Two characters are contiguous if they have adjacent Unicode code points.

Due o più intervalli di caratteri possono essere concatenati.Two or more character ranges can be concatenated. Ad esempio, per specificare l'intervallo di cifre decimali comprese tra "0" e "9", l'intervallo di lettere minuscole comprese tra "a" e "f" e l'intervallo di lettere maiuscole comprese tra "A" e "F", usare [0-9a-fA-F].For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].

L'accento circonflesso iniziale (^) in un gruppo di caratteri negativi è obbligatorio e indica che tale gruppo è un gruppo di caratteri negativi anziché un gruppo di caratteri positivi.The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.

Importante

Un gruppo di caratteri negativi in un criterio di ricerca di espressioni regolari più grande non è un'asserzione di larghezza zero.A negative character group in a larger regular expression pattern is not a zero-width assertion. Ovvero, dopo avere valutato il gruppo di caratteri negativi, il motore delle espressioni regolari avanza di un carattere nella stringa di input.That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.

Nella tabella seguente sono elencati alcuni criteri di espressione regolare comuni contenenti gruppi di caratteri negativi.Some common regular expression patterns that contain negative character groups are listed in the following table.

ModelloPattern DescriptionDescription
[^aeiou] Corrisponde a tutti i caratteri eccetto le vocali.Match all characters except vowels.
[^\p{P}\d] Corrisponde a tutti i caratteri eccetto caratteri di punteggiatura e cifre decimali.Match all characters except punctuation and decimal digit characters.

Le corrispondenze dell'esempio seguente sono relative a tutte le parole che iniziano con i caratteri "th" e non sono seguite dalla lettera "o".The following example matches any word that begins with the characters "th" and is not followed by an "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

L'espressione regolare \bth[^o]\w+\b viene definita come illustrato nella tabella seguente.The regular expression \bth[^o]\w+\b is defined as shown in the following table.

ModelloPattern DescriptionDescription
\b Inizia dal confine di una parola.Start at a word boundary.
th Corrisponde ai caratteri letterali "th".Match the literal characters "th".
[^o] Corrisponde a tutti i caratteri diversi da "o".Match any character that is not an "o".
\w+ Trova la corrispondenza di uno o più caratteri alfanumerici.Match one or more word characters.
\b Terminare al confine di una parola.End at a word boundary.

Torna all'inizioBack to Top

Qualsiasi carattere: .Any Character: .

Il carattere punto (.) corrisponde a qualsiasi carattere eccetto \n (carattere di nuova riga, \u000A), con le due qualificazioni seguenti:The period character (.) matches any character except \n (the newline character, \u000A), with the following two qualifications:

  • Se un criterio di ricerca di espressioni regolari viene modificato dall'opzione RegexOptions.Singleline o se la parte del criterio contenente la classe di caratteri . viene modificata dall'opzione s, . corrisponde a qualsiasi carattere.If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the s option, . matches any character. Per altre informazioni, vedere Regular Expression Options.For more information, see Regular Expression Options.

    Nell'esempio seguente viene illustrato il diverso comportamento della classe di caratteri . per impostazione predefinita e con l'opzione RegexOptions.Singleline.The following example illustrates the different behavior of the . character class by default and with the RegexOptions.Singleline option. L'espressione regolare ^.+ parte dall'inizio della stringa e individua una corrispondenza per ogni carattere.The regular expression ^.+ starts at the beginning of the string and matches every character. Per impostazione predefinita, la corrispondenza termina alla fine della prima riga. Il criterio di ricerca di espressioni regolari trova la corrispondenza del carattere di ritorno a capo, \r o \u000D, ma non di \n.By default, the match ends at the end of the first line; the regular expression pattern matches the carriage return character, \r or \u000D, but it does not match \n. Poiché l'opzione RegexOptions.Singleline interpreta l'intera stringa di input come riga singola, ottiene una corrispondenza per ogni carattere nella stringa di input, incluso \n.Because the RegexOptions.Singleline option interprets the entire input string as a single line, it matches every character in the input string, including \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

Poiché corrisponde a qualsiasi carattere eccetto \n, la classe di caratteri . corrisponde anche a \r (il carattere di ritorno a capo, \u000D).Because it matches any character except \n, the . character class also matches \r (the carriage return character, \u000D).

  • In un gruppo di caratteri positivi o negativi un punto viene interpretato come carattere punto letterale e non come classe di caratteri.In a positive or negative character group, a period is treated as a literal period character, and not as a character class. Per altre informazioni, vedere Gruppo di caratteri positivi e Gruppo di caratteri negativi descritti in precedenza in questo argomento.For more information, see Positive Character Group and Negative Character Group earlier in this topic. Nell'esempio seguente viene fornita un'illustrazione mediante la definizione di un'espressione regolare che include il carattere punto (.) sia come classe di caratteri che come membro di un gruppo di caratteri positivi.The following example provides an illustration by defining a regular expression that includes the period character (.) both as a character class and as a member of a positive character group. L'espressione regolare \b.*[.?!;:](\s|\z) inizia in corrispondenza di un confine di parola, corrisponde a qualsiasi carattere fino a quando non incontra uno dei cinque segni di punteggiatura, incluso un punto, quindi individua la corrispondenza con uno spazio vuoto o con la fine della stringa.The regular expression \b.*[.?!;:](\s|\z) begins at a word boundary, matches any character until it encounters one of five punctuation marks, including a period, and then matches either a white-space character or the end of the string.

    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

Poiché corrisponde a qualsiasi carattere, l'elemento di linguaggio . viene spesso usato con un quantificatore lazy se un criterio di ricerca di espressioni regolari tenta di ottenere più volte una corrispondenza con ogni carattere.Because it matches any character, the . language element is often used with a lazy quantifier if a regular expression pattern attempts to match any character multiple times. Per altre informazioni, vedere Quantifiers.For more information, see Quantifiers.

Torna all'inizioBack to Top

Categoria Unicode o blocco Unicode: \p{}Unicode Category or Unicode Block: \p{}

Lo standard Unicode assegna una categoria generale a ogni carattere.The Unicode standard assigns each character a general category. Ad esempio, un carattere particolare può essere una lettera maiuscola (rappresentata dalla categoria Lu), una cifra decimale (la categoria Nd), un simbolo matematico (la categoria Sm) o un separatore di paragrafo (la categoria Zl).For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). Anche set di caratteri specifici nello standard Unicode occupano un intervallo specifico o un blocco di punti di codice consecutivi.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. Il set di caratteri latini si trova ad esempio da \u0000 a \u007F, mentre il set di caratteri arabi si trova da \u0600 a \u06FF.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

Costrutto dell'espressione regolareThe regular expression construct

\p{ nome }\p{ name }

corrisponde a qualsiasi carattere appartenente a una categoria generale Unicode o a un blocco denominato, dove name è l'abbreviazione della categoria o il nome del blocco denominato.matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. Per un elenco di abbreviazioni della categoria, vedere la sezione Categorie generali Unicode supportate successiva in questo argomento.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. Per un elenco dei blocchi denominati, vedere la sezione Blocchi denominati supportati successiva in questo argomento.For a list of named blocks, see the Supported Named Blocks section later in this topic.

Nell'esempio seguente viene usato il costrutto \p{name} per individuare una corrispondenza per una categoria generale Unicode (in questo caso la categoria Pd o Punctuation, Dash) e un blocco denominato (i blocchi denominati IsGreek e IsBasicLatin).The following example uses the \p{name} construct to match both a Unicode general category (in this case, the Pd, or Punctuation, Dash category) and a named block (the IsGreek and IsBasicLatin named blocks).

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

L'espressione regolare \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ viene definita come illustrato nella tabella seguente.The regular expression \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ is defined as shown in the following table.

ModelloPattern DescriptionDescription
\b Inizia dal confine di una parola.Start at a word boundary.
\p{IsGreek}+ Corrisponde a uno o più caratteri greci.Match one or more Greek characters.
(\s)? Trova la corrispondenza di uno o nessuno spazio vuoto.Match zero or one white-space character.
(\p{IsGreek}+(\s)?)+ Ottiene una o più volte la corrispondenza con il modello di uno o più caratteri greci seguiti da zero o da uno spazio vuoto.Match the pattern of one or more Greek characters followed by zero or one white-space characters one or more times.
\p{Pd} Corrisponde a un carattere "Pd" (Punctuation, Dash).Match a Punctuation, Dash character.
\s Trova la corrispondenza con uno spazio vuoto.Match a white-space character.
\p{IsBasicLatin}+ Corrisponde a uno o più caratteri latini di base.Match one or more basic Latin characters.
(\s)? Trova la corrispondenza di uno o nessuno spazio vuoto.Match zero or one white-space character.
(\p{IsBasicLatin}+(\s)?)+ Ottiene una o più volte la corrispondenza con il modello di uno o più caratteri latini di base seguiti da zero o da uno spazio vuoto.Match the pattern of one or more basic Latin characters followed by zero or one white-space characters one or more times.

Torna all'inizioBack to Top

Categoria Unicode negativa o blocco Unicode: \P{}Negative Unicode Category or Unicode Block: \P{}

Lo standard Unicode assegna una categoria generale a ogni carattere.The Unicode standard assigns each character a general category. Ad esempio, un carattere particolare può essere una lettera maiuscola (rappresentata dalla categoria Lu), una cifra decimale (la categoria Nd), un simbolo matematico (la categoria Sm) o un separatore di paragrafo (la categoria Zl).For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). Anche set di caratteri specifici nello standard Unicode occupano un intervallo specifico o un blocco di punti di codice consecutivi.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. Il set di caratteri latini si trova ad esempio da \u0000 a \u007F, mentre il set di caratteri arabi si trova da \u0600 a \u06FF.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

Costrutto dell'espressione regolareThe regular expression construct

\P{ nome }\P{ name }

corrisponde a qualsiasi carattere non appartenente a una categoria generale Unicode o a un blocco denominato, dove name è l'abbreviazione della categoria o il nome del blocco denominato.matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. Per un elenco di abbreviazioni della categoria, vedere la sezione Categorie generali Unicode supportate successiva in questo argomento.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. Per un elenco dei blocchi denominati, vedere la sezione Blocchi denominati supportati successiva in questo argomento.For a list of named blocks, see the Supported Named Blocks section later in this topic.

L'esempio seguente usa il costrutto \P{name} per rimuovere qualsiasi simbolo di valuta (in questo caso la categoria Sc o Symbol, Currency) dalle stringhe numeriche.The following example uses the \P{name} construct to remove any currency symbols (in this case, the Sc, or Symbol, Currency category) from numeric strings.

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

Il criterio di ricerca di espressioni regolari (\P{Sc})+ corrisponde a uno o più caratteri che non siano simboli di valuta e rimuove efficacemente qualsiasi simbolo di valuta dalla stringa del risultato.The regular expression pattern (\P{Sc})+ matches one or more characters that are not currency symbols; it effectively strips any currency symbol from the result string.

Torna all'inizioBack to Top

Carattere alfanumerico: \wWord Character: \w

\w trova la corrispondenza con qualsiasi carattere alfanumerico.\w matches any word character. Un carattere alfanumerico è un membro di una delle categorie Unicode elencate nella seguente tabella.A word character is a member of any of the Unicode categories listed in the following table.

CategoryCategory DescriptionDescription
LlLl Letter, LowercaseLetter, Lowercase
LuLu Letter, UppercaseLetter, Uppercase
LtLt Letter, TitlecaseLetter, Titlecase
LoLo Letter, OtherLetter, Other
LmLm Letter, ModifierLetter, Modifier
MnMn Mark, NonspacingMark, Nonspacing
NdNd Number, Decimal DigitNumber, Decimal Digit
PcPc Punctuation, Connector.Punctuation, Connector. Questa categoria include dieci caratteri, tra cui quello più comunemente usato è () LOWLINE, u+005F.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

Se viene specificato il comportamento conforme a ECMAScript, \w equivale a [a-zA-Z_0-9].If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9]. Per informazioni sulle espressioni regolari ECMAScript, vedere la sezione "Comportamento di corrispondenza ECMAScript" in Opzioni di espressioni regolari.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Nota

Poiché corrisponde a qualsiasi carattere alfanumerico, l'elemento di linguaggio \w viene spesso usato con un quantificatore lazy se un criterio di ricerca di espressioni regolari tenta di ottenere più volte una corrispondenza con ogni carattere alfanumerico, seguito da un carattere alfanumerico specifico.Because it matches any word character, the \w language element is often used with a lazy quantifier if a regular expression pattern attempts to match any word character multiple times, followed by a specific word character. Per altre informazioni, vedere Quantifiers.For more information, see Quantifiers.

Nell'esempio seguente viene usato l'elemento di linguaggio \w per individuare una corrispondenza con i caratteri duplicati in una parola.The following example uses the \w language element to match duplicate characters in a word. L'esempio definisce un criterio di ricerca di espressioni regolari, (\w)\1, che può essere interpretato nel modo seguente.The example defines a regular expression pattern, (\w)\1, which can be interpreted as follows.

ElementoElement DescriptionDescription
(\w)(\w) Corrisponde a un carattere alfanumerico.Match a word character. Equivale al primo gruppo di acquisizione.This is the first capturing group.
\1\1 Corrisponde al valore della prima acquisizione.Match the value of the first capture.
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.

Torna all'inizioBack to Top

Carattere non alfanumerico: \WNon-Word Character: \W

\W trova la corrispondenza con qualsiasi carattere non alfanumerico.\W matches any non-word character. L'elemento di linguaggio \W è equivalente alla classe di caratteri seguente:The \W language element is equivalent to the following character class:

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

In altre parole, trova corrispondenza con tutti i caratteri, ad eccezione di quelli nelle categorie Unicode elencati nella tabella seguente.In other words, it matches any character except for those in the Unicode categories listed in the following table.

CategoryCategory DescriptionDescription
LlLl Letter, LowercaseLetter, Lowercase
LuLu Letter, UppercaseLetter, Uppercase
LtLt Letter, TitlecaseLetter, Titlecase
LoLo Letter, OtherLetter, Other
LmLm Letter, ModifierLetter, Modifier
MnMn Mark, NonspacingMark, Nonspacing
NdNd Number, Decimal DigitNumber, Decimal Digit
PcPc Punctuation, Connector.Punctuation, Connector. Questa categoria include dieci caratteri, tra cui quello più comunemente usato è () LOWLINE, u+005F.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

Se viene specificato il comportamento conforme a ECMAScript, \W equivale a [^a-zA-Z_0-9].If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9]. Per informazioni sulle espressioni regolari ECMAScript, vedere la sezione "Comportamento di corrispondenza ECMAScript" in Opzioni di espressioni regolari.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Nota

Poiché corrisponde a qualsiasi carattere non alfanumerico, l'elemento di linguaggio \W viene spesso usato con un quantificatore lazy se un criterio di ricerca di espressioni regolari tenta di ottenere più volte una corrispondenza con ogni carattere non alfanumerico, seguito da un carattere non alfanumerico specifico.Because it matches any non-word character, the \W language element is often used with a lazy quantifier if a regular expression pattern attempts to match any non-word character multiple times followed by a specific non-word character. Per altre informazioni, vedere Quantifiers.For more information, see Quantifiers.

L'esempio seguente illustra la classe di caratteri \W.The following example illustrates the \W character class. Definisce un criterio di ricerca di espressioni regolari, \b(\w+)(\W){1,2}, che corrisponde a una parola seguita da uno o due caratteri non alfanumerici, ad esempio uno spazio vuoto o un segno di punteggiatura.It defines a regular expression pattern, \b(\w+)(\W){1,2}, that matches a word followed by one or two non-word characters, such as white space or punctuation. L'espressione regolare viene interpretata come illustrato nella tabella seguente.The regular expression is interpreted as shown in the following table.

ElementoElement DescriptionDescription
\b\b Inizia la corrispondenza sul confine di parola.Begin the match at a word boundary.
(\w+)(\w+) Trova la corrispondenza di uno o più caratteri alfanumerici.Match one or more word characters. Equivale al primo gruppo di acquisizione.This is the first capturing group.
(\W){1,2}(\W){1,2} Ottiene una o due volte una corrispondenza con un carattere non alfanumerico.Match a non-word character either one or two times. Equivale al secondo gruppo di acquisizione.This is the second capturing group.
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)

Poiché l'oggetto Group per il secondo gruppo di acquisizione contiene un solo carattere non alfanumerico acquisito, nell'esempio vengono recuperati tutti i caratteri non alfanumerici acquisiti dall'oggetto CaptureCollection restituito dalla proprietà Group.Captures.Because the Group object for the second capturing group contains only a single captured non-word character, the example retrieves all captured non-word characters from the CaptureCollection object that is returned by the Group.Captures property.

Torna all'inizioBack to Top

Spazio vuoto: \sWhite-Space Character: \s

\s trova la corrispondenza con qualsiasi spazio vuoto.\s matches any white-space character. È equivalente alle sequenze di escape e alle categorie Unicode elencate nella tabella seguente.It is equivalent to the escape sequences and Unicode categories listed in the following table.

CategoryCategory DescriptionDescription
\f Carattere di avanzamento modulo, \u000C.The form feed character, \u000C.
\n Carattere di nuova riga, \u000A.The newline character, \u000A.
\r Carattere di ritorno a capo, \u000D.The carriage return character, \u000D.
\t Carattere di tabulazione, \u0009.The tab character, \u0009.
\v Carattere di tabulazione verticale, \u000B.The vertical tab character, \u000B.
\x85 Puntini di sospensione o carattere NEXT LINE (NEL) (...), \u0085.The ellipsis or NEXT LINE (NEL) character (…), \u0085.
\p{Z} Corrisponde a qualsiasi carattere separatore.Matches any separator character.

Se viene specificato il comportamento conforme a ECMAScript, \s equivale a [ \f\n\r\t\v].If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v]. Per informazioni sulle espressioni regolari ECMAScript, vedere la sezione "Comportamento di corrispondenza ECMAScript" in Opzioni di espressioni regolari.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

L'esempio seguente illustra la classe di caratteri \s.The following example illustrates the \s character class. Definisce un criterio di ricerca di espressioni regolari, \b\w+(e)?s(\s|$), che corrisponde a una parola che termina in "s" o "es" seguita da uno spazio vuoto o dalla fine della stringa di input.It defines a regular expression pattern, \b\w+(e)?s(\s|$), that matches a word ending in either "s" or "es" followed by either a white-space character or the end of the input string. L'espressione regolare viene interpretata come illustrato nella tabella seguente.The regular expression is interpreted as shown in the following table.

ElementoElement DescriptionDescription
\b\b Inizia la corrispondenza sul confine di parola.Begin the match at a word boundary.
\w+\w+ Trova la corrispondenza di uno o più caratteri alfanumerici.Match one or more word characters.
(e)?(e)? Ottiene zero o una volta la corrispondenza con una "e".Match an "e" either zero or one time.
ss Corrisponde a una "s".Match an "s".
(\s|$)(\s|$) Corrisponde a un carattere spazio o alla fine della stringa di input.Match either a white-space character or the end of the input string.
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

Torna all'inizioBack to Top

Carattere diverso da uno spazio vuoto: \SNon-White-Space Character: \S

\S trova la corrispondenza con qualsiasi carattere diverso da uno spazio.\S matches any non-white-space character. È equivalente al criterio di ricerca di espressioni regolari [^\f\n\r\t\v\x85\p{Z}] o è il contrario del criterio di ricerca di espressioni regolari equivalente a \s, che corrisponde a spazi vuoti.It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. Per altre informazioni, vedere Spazio vuoto: \s.For more information, see White-Space Character: \s.

Se viene specificato il comportamento conforme a ECMAScript, \S equivale a [^ \f\n\r\t\v].If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v]. Per informazioni sulle espressioni regolari ECMAScript, vedere la sezione "Comportamento di corrispondenza ECMAScript" in Opzioni di espressioni regolari.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

L'esempio seguente illustra l'elemento di linguaggio \S.The following example illustrates the \S language element. Il criterio di espressione regolare \b(\S+)\s? corrisponde a stringhe delimitate da spazi vuoti.The regular expression pattern \b(\S+)\s? matches strings that are delimited by white-space characters. Il secondo elemento nell'oggetto GroupCollection della corrispondenza contiene la stringa corrispondente.The second element in the match's GroupCollection object contains the matched string. L'espressione regolare può essere interpretata come indicato nella tabella seguente.The regular expression can be interpreted as shown in the following table.

ElementoElement DescriptionDescription
\b Inizia la corrispondenza sul confine di parola.Begin the match at a word boundary.
(\S+) Trova la corrispondenza con uno o più caratteri diversi dallo spazio vuoto.Match one or more non-white-space characters. Equivale al primo gruppo di acquisizione.This is the first capturing group.
\s? Trova la corrispondenza di uno o nessuno spazio vuoto.Match zero or one white-space character.
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.

Torna all'inizioBack to Top

Carattere cifra decimale: \dDecimal Digit Character: \d

\d trova la corrispondenza con qualsiasi cifra decimale.\d matches any decimal digit. È equivalente al criterio di ricerca di espressioni regolari \p{Nd} che include le cifre decimali standard da 0 a 9 e le cifre decimali di diversi altri set di caratteri.It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets.

Se viene specificato il comportamento conforme a ECMAScript, \d equivale a [0-9].If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9]. Per informazioni sulle espressioni regolari ECMAScript, vedere la sezione "Comportamento di corrispondenza ECMAScript" in Opzioni di espressioni regolari.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

L'esempio seguente illustra l'elemento di linguaggio \d.The following example illustrates the \d language element. Viene verificato se una stringa di input rappresenta un numero di telefono valido negli Stati Uniti e in Canada.It tests whether an input string represents a valid telephone number in the United States and Canada. Il criterio di ricerca di espressioni regolari ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ è definito nel modo illustrato nella tabella seguente.The regular expression pattern ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ is defined as shown in the following table.

ElementoElement DescriptionDescription
^ Inizia la corrispondenza all'inizio della stringa di input.Begin the match at the beginning of the input string.
\(? Corrisponde a zero o a un carattere letterale "(".Match zero or one literal "(" character.
\d{3} Trova la corrispondenza con tre cifre decimali.Match three decimal digits.
\)? Corrisponde a zero o a un carattere letterale ")".Match zero or one literal ")" character.
[\s-] Corrisponde a un trattino o a uno spazio vuoto.Match a hyphen or a white-space character.
(\(?\d{3}\)?[\s-])? Trova la corrispondenza zero o una volta con una parentesi di apertura facoltativa seguita da tre cifre decimali, una parentesi di chiusura facoltativa e uno spazio vuoto o un trattino.Match an optional opening parenthesis followed by three decimal digits, an optional closing parenthesis, and either a white-space character or a hyphen zero or one time. Equivale al primo gruppo di acquisizione.This is the first capturing group.
\d{3}-\d{4} Corrisponde a tre cifre decimali seguite da un trattino e da altre quattro cifre decimali.Match three decimal digits followed by a hyphen and four more decimal digits.
$ Trova la corrispondenza con la fine della stringa di input.Match the end of the input string.
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

Torna all'inizioBack to Top

Carattere non numerico: \DNon-Digit Character: \D

\D trova la corrispondenza con qualsiasi carattere non numerico.\D matches any non-digit character. È equivalente al criterio di ricerca di espressioni regolari \P{Nd}.It is equivalent to the \P{Nd} regular expression pattern.

Se viene specificato il comportamento conforme a ECMAScript, \D equivale a [^0-9].If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9]. Per informazioni sulle espressioni regolari ECMAScript, vedere la sezione "Comportamento di corrispondenza ECMAScript" in Opzioni di espressioni regolari.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Nell'esempio seguente viene illustrato l'elemento di linguaggio \D.The following example illustrates the \D language element. Verifica se una stringa, ad esempio un numero parte, è formata dalla combinazione corretta di caratteri decimali e non decimali.It tests whether a string such as a part number consists of the appropriate combination of decimal and non-decimal characters. Il criterio di ricerca di espressioni regolari ^\D\d{1,5}\D*$ è definito nel modo illustrato nella tabella seguente.The regular expression pattern ^\D\d{1,5}\D*$ is defined as shown in the following table.

ElementoElement DescriptionDescription
^ Inizia la corrispondenza all'inizio della stringa di input.Begin the match at the beginning of the input string.
\D Corrisponde a un carattere non numerico.Match a non-digit character.
\d{1,5} Corrisponde a una fino a cinque cifre decimali.Match from one to five decimal digits.
\D* Corrisponde a zero, uno o più caratteri non decimali.Match zero, one, or more non-decimal characters.
$ Trova la corrispondenza con la fine della stringa di input.Match the end of the input string.
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:

Torna all'inizioBack to Top

Categorie generali Unicode supportateSupported Unicode General Categories

In Unicode sono definite le categorie generali elencate nella tabella riportata di seguito.Unicode defines the general categories listed in the following table. Per altre informazioni, vedere gli argomenti correlati "UCD File Format" (Formato di file UCD) e "General Category Values" (Valori di categoria generale) in Unicode Character Database (Database di caratteri Unicode).For more information, see the "UCD File Format" and "General Category Values" subtopics at the Unicode Character Database.

CategoryCategory DescriptionDescription
Lu Letter, UppercaseLetter, Uppercase
Ll Letter, LowercaseLetter, Lowercase
Lt Letter, TitlecaseLetter, Titlecase
Lm Letter, ModifierLetter, Modifier
Lo Letter, OtherLetter, Other
L Tutti i caratteri alfanumerici.All letter characters. Sono inclusi i caratteri Lu, Ll, Lt, Lm e Lo.This includes the Lu, Ll, Lt, Lm, and Lo characters.
Mn Mark, NonspacingMark, Nonspacing
Mc Mark, Spacing CombiningMark, Spacing Combining
Me Mark, EnclosingMark, Enclosing
M Tutti i contrassegni diacritici.All diacritic marks. Sono incluse le categorie Mn, Mc e Me.This includes the Mn, Mc, and Me categories.
Nd Number, Decimal DigitNumber, Decimal Digit
Nl Number, LetterNumber, Letter
No Number, OtherNumber, Other
N Tutti i numeri.All numbers. Sono incluse le categorie Nd, Nl e No.This includes the Nd, Nl, and No categories.
Pc Punctuation, ConnectorPunctuation, Connector
Pd Punctuation, DashPunctuation, Dash
Ps Punctuation, OpenPunctuation, Open
Pe Punctuation, ClosePunctuation, Close
Pi Punctuation, Initial quote (può comportarsi come Ps o Pe a seconda dell'utilizzo)Punctuation, Initial quote (may behave like Ps or Pe depending on usage)
Pf Punctuation, Final quote (può comportarsi come Ps o Pe a seconda dell'utilizzo)Punctuation, Final quote (may behave like Ps or Pe depending on usage)
Po Punctuation, OtherPunctuation, Other
P Tutti i caratteri di punteggiatura.All punctuation characters. Sono incluse le categorie Pc, Pd, Ps, Pe, Pi, Pf e Po.This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories.
Sm Symbol, MathSymbol, Math
Sc Symbol, CurrencySymbol, Currency
Sk Symbol, ModifierSymbol, Modifier
So Symbol, OtherSymbol, Other
S Tutti i simboli.All symbols. Sono incluse le categorie Sm, Sc, Sk e So.This includes the Sm, Sc, Sk, and So categories.
Zs Separator, SpaceSeparator, Space
Zl Separator, LineSeparator, Line
Zp Separator, ParagraphSeparator, Paragraph
Z Tutti i caratteri separatori.All separator characters. Sono incluse le categorie Zs, Zl e Zp.This includes the Zs, Zl, and Zp categories.
Cc Other, ControlOther, Control
Cf Other, FormatOther, Format
Cs Other, SurrogateOther, Surrogate
Co Other, Private UseOther, Private Use
Cn Other, Not Assigned (nessun carattere ha questa proprietà)Other, Not Assigned (no characters have this property)
C Tutti i caratteri di controllo.All control characters. Sono incluse le categorie Cc, Cf, Cs, Co e Cn.This includes the Cc, Cf, Cs, Co, and Cn categories.

È possibile determinare la categoria Unicode di qualsiasi particolare carattere passando tale carattere al metodo GetUnicodeCategory.You can determine the Unicode category of any particular character by passing that character to the GetUnicodeCategory method. L'esempio seguente usa il metodo GetUnicodeCategory per determinare la categoria di ogni elemento in una matrice che contiene caratteri latini selezionati.The following example uses the GetUnicodeCategory method to determine the category of each element in an array that contains selected Latin characters.

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

Torna all'inizioBack to Top

Blocchi denominati supportatiSupported Named Blocks

In .NET sono supportati i blocchi denominati elencati nella tabella seguente..NET provides the named blocks listed in the following table. Il set di blocchi denominati supportati è basato su Unicode 4.0 e Perl 5.6.The set of supported named blocks is based on Unicode 4.0 and Perl 5.6.

Intervallo di punti di codiceCode point range Nome del bloccoBlock name
0000 - 007F0000 - 007F IsBasicLatin
0080 - 00FF0080 - 00FF IsLatin-1Supplement
0100 - 017F0100 - 017F IsLatinExtended-A
0180 - 024F0180 - 024F IsLatinExtended-B
0250 - 02AF0250 - 02AF IsIPAExtensions
02B0 - 02FF02B0 - 02FF IsSpacingModifierLetters
0300 - 036F0300 - 036F IsCombiningDiacriticalMarks
0370 - 03FF0370 - 03FF IsGreek

oppure-or-

IsGreekandCoptic
0400 - 04FF0400 - 04FF IsCyrillic
0500 - 052F0500 - 052F IsCyrillicSupplement
0530 - 058F0530 - 058F IsArmenian
0590 - 05FF0590 - 05FF IsHebrew
0600 - 06FF0600 - 06FF IsArabic
0700 - 074F0700 - 074F IsSyriac
0780 - 07BF0780 - 07BF IsThaana
0900 - 097F0900 - 097F IsDevanagari
0980 - 09FF0980 - 09FF IsBengali
0A00 - 0A7F0A00 - 0A7F IsGurmukhi
0A80 - 0AFF0A80 - 0AFF IsGujarati
0B00 - 0B7F0B00 - 0B7F IsOriya
0B80 - 0BFF0B80 - 0BFF IsTamil
0C00 - 0C7F0C00 - 0C7F IsTelugu
0C80 - 0CFF0C80 - 0CFF IsKannada
0D00 - 0D7F0D00 - 0D7F IsMalayalam
0D80 - 0DFF0D80 - 0DFF IsSinhala
0E00 - 0E7F0E00 - 0E7F IsThai
0E80 - 0EFF0E80 - 0EFF IsLao
0F00 - 0FFF0F00 - 0FFF IsTibetan
1000 - 109F1000 - 109F IsMyanmar
10A0 - 10FF10A0 - 10FF IsGeorgian
1100 - 11FF1100 - 11FF IsHangulJamo
1200 - 137F1200 - 137F IsEthiopic
13A0 - 13FF13A0 - 13FF IsCherokee
1400 - 167F1400 - 167F IsUnifiedCanadianAboriginalSyllabics
1680 - 169F1680 - 169F IsOgham
16A0 - 16FF16A0 - 16FF IsRunic
1700 - 171F1700 - 171F IsTagalog
1720 - 173F1720 - 173F IsHanunoo
1740 - 175F1740 - 175F IsBuhid
1760 - 177F1760 - 177F IsTagbanwa
1780 - 17FF1780 - 17FF IsKhmer
1800 - 18AF1800 - 18AF IsMongolian
1900 - 194F1900 - 194F IsLimbu
1950 - 197F1950 - 197F IsTaiLe
19E0 - 19FF19E0 - 19FF IsKhmerSymbols
1D00 - 1D7F1D00 - 1D7F IsPhoneticExtensions
1E00 - 1EFF1E00 - 1EFF IsLatinExtendedAdditional
1F00 - 1FFF1F00 - 1FFF IsGreekExtended
2000 - 206F2000 - 206F IsGeneralPunctuation
2070 - 209F2070 - 209F IsSuperscriptsandSubscripts
20A0 - 20CF20A0 - 20CF IsCurrencySymbols
20D0 - 20FF20D0 - 20FF IsCombiningDiacriticalMarksforSymbols

-oppure--or-

IsCombiningMarksforSymbols
2100 - 214F2100 - 214F IsLetterlikeSymbols
2150 - 218F2150 - 218F IsNumberForms
2190 - 21FF2190 - 21FF IsArrows
2200 - 22FF2200 - 22FF IsMathematicalOperators
2300 - 23FF2300 - 23FF IsMiscellaneousTechnical
2400 - 243F2400 - 243F IsControlPictures
2440 - 245F2440 - 245F IsOpticalCharacterRecognition
2460 - 24FF2460 - 24FF IsEnclosedAlphanumerics
2500 - 257F2500 - 257F IsBoxDrawing
2580 - 259F2580 - 259F IsBlockElements
25A0 - 25FF25A0 - 25FF IsGeometricShapes
2600 - 26FF2600 - 26FF IsMiscellaneousSymbols
2700 - 27BF2700 - 27BF IsDingbats
27C0 - 27EF27C0 - 27EF IsMiscellaneousMathematicalSymbols-A
27F0 - 27FF27F0 - 27FF IsSupplementalArrows-A
2800 - 28FF2800 - 28FF IsBraillePatterns
2900 - 297F2900 - 297F IsSupplementalArrows-B
2980 - 29FF2980 - 29FF IsMiscellaneousMathematicalSymbols-B
2A00 - 2AFF2A00 - 2AFF IsSupplementalMathematicalOperators
2B00 - 2BFF2B00 - 2BFF IsMiscellaneousSymbolsandArrows
2E80 - 2EFF2E80 - 2EFF IsCJKRadicalsSupplement
2F00 - 2FDF2F00 - 2FDF IsKangxiRadicals
2FF0 - 2FFF2FF0 - 2FFF IsIdeographicDescriptionCharacters
3000 - 303F3000 - 303F IsCJKSymbolsandPunctuation
3040 - 309F3040 - 309F IsHiragana
30A0 - 30FF30A0 - 30FF IsKatakana
3100 - 312F3100 - 312F IsBopomofo
3130 - 318F3130 - 318F IsHangulCompatibilityJamo
3190 - 319F3190 - 319F IsKanbun
31A0 - 31BF31A0 - 31BF IsBopomofoExtended
31F0 - 31FF31F0 - 31FF IsKatakanaPhoneticExtensions
3200 - 32FF3200 - 32FF IsEnclosedCJKLettersandMonths
3300 - 33FF3300 - 33FF IsCJKCompatibility
3400 - 4DBF3400 - 4DBF IsCJKUnifiedIdeographsExtensionA
4DC0 - 4DFF4DC0 - 4DFF IsYijingHexagramSymbols
4E00 - 9FFF4E00 - 9FFF IsCJKUnifiedIdeographs
A000 - A48FA000 - A48F IsYiSyllables
A490 - A4CFA490 - A4CF IsYiRadicals
AC00 - D7AFAC00 - D7AF IsHangulSyllables
D800 - DB7FD800 - DB7F IsHighSurrogates
DB80 - DBFFDB80 - DBFF IsHighPrivateUseSurrogates
DC00 - DFFFDC00 - DFFF IsLowSurrogates
E000 - F8FFE000 - F8FF IsPrivateUse o IsPrivateUseAreaIsPrivateUse or IsPrivateUseArea
F900 - FAFFF900 - FAFF IsCJKCompatibilityIdeographs
FB00 - FB4FFB00 - FB4F IsAlphabeticPresentationForms
FB50 - FDFFFB50 - FDFF IsArabicPresentationForms-A
FE00 - FE0FFE00 - FE0F IsVariationSelectors
FE20 - FE2FFE20 - FE2F IsCombiningHalfMarks
FE30 - FE4FFE30 - FE4F IsCJKCompatibilityForms
FE50 - FE6FFE50 - FE6F IsSmallFormVariants
FE70 - FEFFFE70 - FEFF IsArabicPresentationForms-B
FF00 - FFEFFF00 - FFEF IsHalfwidthandFullwidthForms
FFF0 - FFFFFFF0 - FFFF IsSpecials

Torna all'inizioBack to Top

Sottrazione di classi di caratteri: [base_group - excluded_group] []Character Class Subtraction: [base_group - [excluded_group]]

Una classe di caratteri definisce un set di caratteri.A character class defines a set of characters. La sottrazione di classi di caratteri produce un set di caratteri che è il risultato dell'esclusione dei caratteri di una classe di caratteri da un'altra classe di caratteri.Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class.

Un'espressione di sottrazione di classi di caratteri ha il formato seguente:A character class subtraction expression has the following form:

[ base_group -[ excluded_group ]][ base_group -[ excluded_group ]]

Le parentesi quadre ([]) e il trattino (-) sono obbligatori.The square brackets ([]) and hyphen (-) are mandatory. base_group è un gruppo di caratteri positivi o un gruppo di caratteri negativi.The base_group is a positive character group or a negative character group. Il componente excluded_group è un altro gruppo di caratteri positivi o negativi o un'altra espressione di sottrazione di classi di caratteri, ovvero è possibile annidare espressioni di sottrazione di classi di caratteri.The excluded_group component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions).

Si supponga ad esempio di disporre di un gruppo di base costituito dall'intervallo di caratteri compresi tra "a" e "z".For example, suppose you have a base group that consists of the character range from "a" through "z". Per definire il set di caratteri costituito dal gruppo di base con l'esclusione del carattere "m", usare [a-z-[m]].To define the set of characters that consists of the base group except for the character "m", use [a-z-[m]]. Per definire il set di caratteri costituito dal gruppo di base con l'esclusione del set di caratteri "d", "j" e "p", usare [a-z-[djp]].To define the set of characters that consists of the base group except for the set of characters "d", "j", and "p", use [a-z-[djp]]. Per definire il set di caratteri costituito dal gruppo di base con l'esclusione dell'intervallo di caratteri compresi tra "m" e "p", usare [a-z-[m-p]].To define the set of characters that consists of the base group except for the character range from "m" through "p", use [a-z-[m-p]].

Si consideri l'espressione di sottrazione di classi di caratteri annidata [a-z-[d-w-[m-o]]].Consider the nested character class subtraction expression, [a-z-[d-w-[m-o]]]. L'espressione viene valutata partendo dall'intervallo di caratteri più interno verso quello più esterno.The expression is evaluated from the innermost character range outward. Innanzitutto, l'intervallo di caratteri compresi tra "m" e "o" viene sottratto dall'intervallo di caratteri compresi tra "d" e "w", producendo il set di caratteri compresi tra "d" e "l" e tra "p" e "w".First, the character range from "m" through "o" is subtracted from the character range "d" through "w", which yields the set of characters from "d" through "l" and "p" through "w". Tale set viene quindi sottratto dall'intervallo di caratteri compreso tra "a" e "z", producendo il set di caratteri [abcmnoxyz].That set is then subtracted from the character range from "a" through "z", which yields the set of characters [abcmnoxyz].

È possibile usare qualsiasi classe di caratteri con sottrazione di classi di caratteri.You can use any character class with character class subtraction. Per definire il set di caratteri costituito da tutti i caratteri Unicode compresi tra \u0000 e \uFFFF eccetto gli spazi vuoti (\s), i caratteri nella categoria generale punteggiatura (\p{P}), i caratteri nel blocco denominato IsGreek (\p{IsGreek}) e il carattere di controllo Unicode NEXT LINE (\x85), usare [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].To define the set of characters that consists of all Unicode characters from \u0000 through \uFFFF except white-space characters (\s), the characters in the punctuation general category (\p{P}), the characters in the IsGreek named block (\p{IsGreek}), and the Unicode NEXT LINE control character (\x85), use [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

Scegliere le classi di caratteri per un'espressione di sottrazione di classi di caratteri che produrrà risultati utili.Choose character classes for a character class subtraction expression that will yield useful results. Evitare espressioni che producono set di caratteri vuoti, che non hanno corrispondenze o che equivalgono al gruppo di base originale.Avoid an expression that yields an empty set of characters, which cannot match anything, or an expression that is equivalent to the original base group. Ad esempio, il set vuoto è il risultato dell'espressione [\p{IsBasicLatin}-[\x00-\x7F]], che sottrae tutti i caratteri compresi nell'intervallo di caratteri IsBasicLatin dalla categoria generale IsBasicLatin.For example, the empty set is the result of the expression [\p{IsBasicLatin}-[\x00-\x7F]], which subtracts all characters in the IsBasicLatin character range from the IsBasicLatin general category. Analogamente, il gruppo di base originale è il risultato dell'espressione [a-z-[0-9]].Similarly, the original base group is the result of the expression [a-z-[0-9]]. Questo è dovuto al fatto che il gruppo di base, ovvero l'intervallo dei caratteri compresi tra le lettere "a" e "z", non contiene alcun carattere del gruppo escluso, ovvero dell'intervallo dei caratteri compresi tra le cifre decimali "0" e "9".This is because the base group, which is the character range of letters from "a" through "z", does not contain any characters in the excluded group, which is the character range of decimal digits from "0" through "9".

Nell'esempio seguente viene definita un'espressione regolare, ^[0-9-[2468]]+$, che corrisponde a zero e a cifre dispari in una stringa di input.The following example defines a regular expression, ^[0-9-[2468]]+$, that matches zero and odd digits in an input string. L'espressione regolare viene interpretata come illustrato nella tabella seguente.The regular expression is interpreted as shown in the following table.

ElementoElement DescriptionDescription
^ Inizia la corrispondenza all'inizio della stringa di input.Begin the match at the start of the input string.
[0-9-[2468]]+ Corrisponde a una o più occorrenze di qualsiasi carattere da 0 a 9 ad eccezione di 2, 4, 6 e 8.Match one or more occurrences of any character from 0 to 9 except for 2, 4, 6, and 8. In altre parole, corrisponde a una o più occorrenze di zero o di una cifra dispari.In other words, match one or more occurrences of zero or an odd digit.
$ Termina la ricerca della corrispondenza alla fine della stringa di input.End the match at the end of the input string.
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

Vedere ancheSee also