Teckenklasser i reguljära uttryck

En teckenklass definierar en uppsättning tecken, av vilka någon kan förekomma i en indatasträng för att en matchning ska lyckas. Det reguljära uttrycksspråket i .NET stöder följande teckenklasser:

• Positiva teckengrupper. Ett tecken i indatasträngen måste matcha ett av en angiven uppsättning tecken. Mer information finns i Positiv teckengrupp.

• Negativa teckengrupper. Ett tecken i indatasträngen får inte matcha något av en angiven uppsättning tecken. Mer information finns i Negativ teckengrupp.

• Alla tecken. Tecknet . (punkt eller punkt) i ett reguljärt uttryck är ett jokertecken som matchar alla tecken utom \n. Mer information finns i Alla tecken.

• En allmän Unicode-kategori eller ett namngivet block. Ett tecken i indatasträngen måste vara medlem i en viss Unicode-kategori eller ligga inom ett sammanhängande intervall med Unicode-tecken för att en matchning ska lyckas. Mer information finns i Unicode-kategori eller Unicode-block.

• En negativ allmän Unicode-kategori eller namngivet block. Ett tecken i indatasträngen får inte vara medlem i en viss Unicode-kategori eller så får det inte ligga inom ett sammanhängande intervall med Unicode-tecken för att en matchning ska lyckas. Mer information finns i Negativ Unicode-kategori eller Unicode-block.

• Ett ordtecken. Ett tecken i indatasträngen kan tillhöra någon av de Unicode-kategorier som är lämpliga för tecken i ord. Mer information finns i Word-tecken.

• Ett tecken som inte är ord. Ett tecken i indatasträngen kan tillhöra valfri Unicode-kategori som inte är ett ordtecken. Mer information finns i Tecken som inte är ord.

• Ett blankstegstecken. Ett tecken i indatasträngen kan vara valfritt Unicode-avgränsningstecken, samt ett av ett antal kontrolltecken. Mer information finns i Blankstegstecken.

• Ett icke-blankstegstecken. Ett tecken i indatasträngen kan vara ett tecken som inte är ett blankstegstecken. Mer information finns i Icke-blankstegstecken.

• En decimalsiffra. Ett tecken i indatasträngen kan vara valfritt antal tecken som klassificeras som Unicode-decimaler. Mer information finns i Decimaltecken.

• En icke-decimalsiffra. Ett tecken i indatasträngen kan vara något annat än en Unicode-decimalsiffra. Mer information finns i Decimaltecken.

.NET stöder subtraktionsuttryck för teckenklass, vilket gör att du kan definiera en uppsättning tecken som ett resultat av att utesluta en teckenklass från en annan teckenklass. Mer information finns i Subtraktion för teckenklass.

Positiv teckengrupp: [ ]

En positiv teckengrupp anger en lista med tecken, av vilka någon kan visas i en indatasträng för att en matchning ska inträffa. Den här listan med tecken kan anges individuellt, som ett intervall eller båda.

Syntaxen för att ange en lista över enskilda tecken är följande:

[*character_group*]

där character_group är en lista över de enskilda tecken som kan visas i indatasträngen för att en matchning ska lyckas. character_group kan bestå av en kombination av ett eller flera literaltecken, escape-tecken eller teckenklasser.

Syntaxen för att ange ett teckenintervall är följande:

[firstCharacter-lastCharacter]

där firstCharacter är tecknet som börjar intervallet och lastCharacter är tecknet som avslutar intervallet. Ett teckenintervall är en sammanhängande serie med tecken som definieras genom att ange det första tecknet i serien, ett bindestreck (-) och sedan det sista tecknet i serien. Två tecken är sammanhängande om de har intilliggande Unicode-kodpunkter. firstCharacter måste vara tecknet med den nedre kodpunkten, och lastCharacter måste vara tecknet med den högre kodpunkten.

Om du vill inkludera ett bindestreck som en icke-perifer medlem i en teckengrupp kan du undvika det. Om du till exempel vill skapa en teckengrupp för tecknet a och tecknen från - till /är [a\--/]rätt syntax .

Några vanliga mönster för reguljära uttryck som innehåller positiva teckenklasser visas i följande tabell.

I följande exempel definieras en positiv teckengrupp som innehåller tecknen "a" och "e" så att indatasträngen måste innehålla orden "grå" eller "grå" följt av ett annat ord för att en matchning ska ske.

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

Det reguljära uttrycket gr[ae]y\s\S+?[\s|\p{P}] definieras på följande sätt:

Följande exempel matchar ord som börjar med valfri versal bokstav. Den använder underuttryck [A-Z] för att representera intervallet med versaler från A till 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

Det reguljära uttrycket \b[A-Z]\w*\b definieras enligt följande tabell.

Negativ teckengrupp: [^]

En negativ teckengrupp anger en lista med tecken som inte får visas i en indatasträng för att en matchning ska ske. Listan med tecken kan anges individuellt, som ett intervall eller båda.

Syntaxen för att ange en lista över enskilda tecken är följande:

[*^character_group*]

där character_group är en lista över enskilda tecken som inte kan visas i indatasträngen för att en matchning ska lyckas. character_group kan bestå av en kombination av ett eller flera literaltecken, escape-tecken eller teckenklasser.

Syntaxen för att ange ett teckenintervall är följande:

[^*firstCharacter*-*lastCharacter*]

där firstCharacter är tecknet som börjar intervallet och lastCharacter är tecknet som avslutar intervallet. Ett teckenintervall är en sammanhängande serie med tecken som definieras genom att ange det första tecknet i serien, ett bindestreck (-) och sedan det sista tecknet i serien. Två tecken är sammanhängande om de har intilliggande Unicode-kodpunkter. firstCharacter måste vara tecknet med den nedre kodpunkten, och lastCharacter måste vara tecknet med den högre kodpunkten.

Två eller flera teckenintervall kan sammanfogas. Om du till exempel vill ange intervallet med decimalsiffror från "0" till "9" använder [0-9a-fA-F]du intervallet med gemener från "a" till "f" och intervallet med versaler från "A" till "F".

Det inledande karaktertecknet (^) i en negativ teckengrupp är obligatoriskt och anger att teckengruppen är en negativ teckengrupp i stället för en positiv teckengrupp.

Några vanliga mönster för reguljära uttryck som innehåller negativa teckengrupper visas i följande tabell.

Följande exempel matchar alla ord som börjar med tecknen "th" och som inte följs av ett "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

Det reguljära uttrycket \bth[^o]\w+\b definieras enligt följande tabell.

Alla tecken: .

Periodtecknet (.) matchar alla tecken utom \n (det nya radtecknet) med följande två kvalifikationer:

• Om ett mönster för reguljära uttryck ändras av RegexOptions.Singleline alternativet, eller om den del av mönstret som innehåller teckenklassen . ändras av s alternativet, . matchar alla tecken. Mer information finns i Alternativ för reguljära uttryck.

  I följande exempel visas det olika beteendet för teckenklassen . som standard och med alternativet RegexOptions.Singleline . Det reguljära uttrycket ^.+ börjar i början av strängen och matchar varje tecken. Som standard slutar matchningen i slutet av den första raden. det reguljära uttrycksmönstret matchar vagnreturtecknet, \r, men det matchar \ninte . Eftersom alternativet RegexOptions.Singleline tolkar hela indatasträngen som en enda rad matchar det varje tecken i indatasträngen, inklusive \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\.
  

• I en positiv eller negativ teckengrupp behandlas en punkt som ett literalt periodtecken och inte som en teckenklass. Mer information finns i Positiv teckengrupp och Negativ teckengrupp tidigare i det här avsnittet. I följande exempel visas en bild genom att definiera ett reguljärt uttryck som innehåller periodtecknet (.) både som en teckenklass och som medlem i en positiv teckengrupp. Det reguljära uttrycket \b.*[.?!;:](\s|\z) börjar vid en ordgräns, matchar alla tecken tills det stöter på ett av fem skiljetecken, inklusive en punkt, och matchar sedan antingen ett blankstegstecken eller slutet av strängen.

  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.
  

Unicode-kategori eller Unicode-block: \p{}

Unicode-standarden tilldelar varje tecken en allmän kategori. Ett visst tecken kan till exempel vara en versal bokstav (representerad av Lu kategorin), en decimalsiffra ( Nd kategorin), en matematisk symbol ( Sm kategorin) eller en styckeavgränsare ( Zl kategorin). Specifika teckenuppsättningar i Unicode-standarden upptar också ett visst intervall eller block med på varandra följande kodpunkter. Till exempel finns den grundläggande latinska teckenuppsättningen från \u0000 till \u007F, medan den arabiska teckenuppsättningen hittas från \u0600 till \u06FF.

Konstruktionen för reguljära uttryck

\p{Namn }

matchar alla tecken som tillhör en allmän Unicode-kategori eller ett namngivet block, där namnet är kategoriförkortningen eller det namngivna blocknamnet. En lista över kategoriförkortningar finns i avsnittet Unicode Allmänna kategorier som stöds senare i det här avsnittet. En lista över namngivna block finns i avsnittet Namngivna block som stöds senare i det här avsnittet.

I följande exempel används namnkonstruktionen \p{} för att matcha både en allmän Unicode-kategori (i det här fallet Pd, eller Skiljetecken, Streckkategori) och ett namngivet block (och IsBasicLatin IsGreek namngivna block).

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

Det reguljära uttrycket \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ definieras enligt följande tabell.

Negativ Unicode-kategori eller Unicode-block: \P{}

Unicode-standarden tilldelar varje tecken en allmän kategori. Ett visst tecken kan till exempel vara en versal bokstav (representerad av Lu kategorin), en decimalsiffra ( Nd kategorin), en matematisk symbol ( Sm kategorin) eller en styckeavgränsare ( Zl kategorin). Specifika teckenuppsättningar i Unicode-standarden upptar också ett visst intervall eller block med på varandra följande kodpunkter. Till exempel finns den grundläggande latinska teckenuppsättningen från \u0000 till \u007F, medan den arabiska teckenuppsättningen hittas från \u0600 till \u06FF.

Konstruktionen för reguljära uttryck

\P{Namn }

matchar alla tecken som inte tillhör en allmän Unicode-kategori eller ett namngivet block, där namnet är kategoriförkortningen eller det namngivna blocknamnet. En lista över kategoriförkortningar finns i avsnittet Unicode Allmänna kategorier som stöds senare i det här avsnittet. En lista över namngivna block finns i avsnittet Namngivna block som stöds senare i det här avsnittet.

I följande exempel används namnkonstruktionen \P{}för att ta bort alla valutasymboler (i det här fallet Sckategorin , eller Symbol, Valuta) från numeriska strängar.

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

Mönster för (\P{Sc})+ reguljära uttryck matchar ett eller flera tecken som inte är valutasymboler. Det tar effektivt bort alla valutasymboler från resultatsträngen.

Ordtecken: \w

\w matchar alla ordtecken. Ett ordtecken är medlem i någon av de Unicode-kategorier som anges i följande tabell.

Om ECMAScript-kompatibelt beteende anges \w motsvarar det [a-zA-Z_0-9]. Information om vanliga ECMAScript-uttryck finns i avsnittet "ECMAScript Matching Behavior" i Alternativ för reguljära uttryck.

I följande exempel används \w språkelementet för att matcha duplicerade tecken i ett ord. Exemplet definierar ett mönster för reguljära uttryck, (\w)\1, som kan tolkas på följande sätt.

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.

Tecken som inte är ord: \W

\W matchar alla tecken som inte är ord. Språkelementet \W motsvarar följande teckenklass:

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

Med andra ord matchar det alla tecken förutom de i Unicode-kategorierna som anges i följande tabell.

Om ECMAScript-kompatibelt beteende anges \W motsvarar det [^a-zA-Z_0-9]. Information om vanliga ECMAScript-uttryck finns i avsnittet "ECMAScript Matching Behavior" i Alternativ för reguljära uttryck.

I följande exempel visas teckenklassen \W . Det definierar ett mönster för reguljära uttryck, \b(\w+)(\W){1,2}, som matchar ett ord följt av ett eller två tecken som inte är ord, till exempel blanksteg eller skiljetecken. Det reguljära uttrycket tolkas som det visas i följande tabell.

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)

Group Eftersom objektet för den andra insamlingsgruppen endast innehåller ett enda insamlat icke-ordtecken hämtar exemplet alla insamlade icke-ordtecken från objektet CaptureCollection som returneras av Group.Captures egenskapen.

Blankstegstecken: \s

\s matchar alla blankstegstecken. Det motsvarar escape-sekvenserna och Unicode-kategorierna som anges i följande tabell.

Om ECMAScript-kompatibelt beteende anges \s motsvarar det [ \f\n\r\t\v]. Information om vanliga ECMAScript-uttryck finns i avsnittet "ECMAScript Matching Behavior" i Alternativ för reguljära uttryck.

I följande exempel visas teckenklassen \s . Det definierar ett mönster för reguljära uttryck, \b\w+(e)?s(\s|$), som matchar ett ord som slutar med antingen "s" eller "es" följt av antingen ett blankstegstecken eller slutet av indatasträngen. Det reguljära uttrycket tolkas som det visas i följande tabell.

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

Icke-blankstegstecken: \S

\S matchar alla tecken som inte är blanksteg. Det motsvarar det [^\f\n\r\t\v\x85\p{Z}] reguljära uttrycksmönstret, eller motsatsen till \sdet reguljära uttrycksmönstret som motsvarar , som matchar blankstegstecken. Mer information finns i Blankstegstecken: \s.

Om ECMAScript-kompatibelt beteende anges \S motsvarar det [^ \f\n\r\t\v]. Information om vanliga ECMAScript-uttryck finns i avsnittet "ECMAScript Matching Behavior" i Alternativ för reguljära uttryck.

I följande exempel visas \S språkelementet. Mönster för \b(\S+)\s? reguljära uttryck matchar strängar som avgränsas med blankstegstecken. Det andra elementet i matchningens GroupCollection objekt innehåller den matchade strängen. Det reguljära uttrycket kan tolkas enligt följande tabell.

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.

Decimaltecken: \d

\d matchar valfri decimalsiffra. Det motsvarar \p{Nd} mönstret för reguljära uttryck, som innehåller standard decimaltalen 0–9 samt decimaltalen i ett antal andra teckenuppsättningar.

Om ECMAScript-kompatibelt beteende anges \d motsvarar det [0-9]. Information om vanliga ECMAScript-uttryck finns i avsnittet "ECMAScript Matching Behavior" i Alternativ för reguljära uttryck.

I följande exempel visas \d språkelementet. Den testar om en indatasträng representerar ett giltigt telefonnummer i USA och Kanada. Mönster för ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ reguljära uttryck definieras enligt följande tabell.

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

Icke-siffrigt tecken: \D

\D matchar alla icke-siffriga tecken. Det motsvarar det reguljära uttrycksmönstret \P{Nd} .

Om ECMAScript-kompatibelt beteende anges \D motsvarar det [^0-9]. Information om vanliga ECMAScript-uttryck finns i avsnittet "ECMAScript Matching Behavior" i Alternativ för reguljära uttryck.

I följande exempel visas språkelementet \D. Den testar om en sträng, till exempel ett delnummer, består av en lämplig kombination av decimaltecken och icke-decimaltecken. Mönster för ^\D\d{1,5}\D*$ reguljära uttryck definieras enligt följande tabell.

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:

Unicode-allmänna kategorier som stöds

Unicode definierar de allmänna kategorier som anges i följande tabell. Mer information finns i underavsnitten "UCD-filformat" och "Allmänna kategorivärden" i Unicode-teckendatabasen, s. 5.7.1, tabell 12.

Du kan fastställa Unicode-kategorin för ett visst tecken genom att skicka det tecknet till GetUnicodeCategory metoden. I följande exempel används GetUnicodeCategory metoden för att fastställa kategorin för varje element i en matris som innehåller markerade latinska tecken.

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

Namngivna block som stöds

.NET innehåller de namngivna blocken som anges i följande tabell. Uppsättningen namngivna block som stöds baseras på Unicode 4.0 och Perl 5.6. Ett reguljärt uttryck som använder namngivna block finns i avsnittet Unicode-kategori eller Unicode-block: \p{} .

Subtraktion för teckenklass: [base_group - [excluded_group]]

En teckenklass definierar en uppsättning tecken. Subtraktion av teckenklass ger en uppsättning tecken som är resultatet av att undanta tecknen i en teckenklass från en annan teckenklass.

Ett subtraktionsuttryck för teckenklass har följande formulär:

[ -[ base_group excluded_group ]]

Hakparenteser ([]) och bindestreck (-) är obligatoriska. Base_group är en positiv teckengrupp eller en negativ teckengrupp. Den excluded_group komponenten är en annan positiv eller negativ teckengrupp, eller ett annat subtraktionsuttryck för teckenklass (dvs. du kan kapsla subtraktionsuttryck för teckenklass).

Anta till exempel att du har en basgrupp som består av teckenintervallet från "a" till "z". Om du vill definiera den uppsättning tecken som består av basgruppen förutom tecknet "m" använder du [a-z-[m]]. Om du vill definiera den uppsättning tecken som består av basgruppen, förutom uppsättningen med tecknen "d", "j" och "p", använder du [a-z-[djp]]. Om du vill definiera den uppsättning tecken som består av basgruppen förutom teckenintervallet från "m" till "p", använder du [a-z-[m-p]].

Överväg subtraktionsuttrycket kapslad teckenklass, [a-z-[d-w-[m-o]]]. Uttrycket utvärderas från det innersta teckenintervallet utåt. Först subtraheras teckenintervallet från "m" till "o" från teckenintervallet "d" till "w", vilket ger uppsättningen tecken från "d" till "l" och "p" till "w". Den uppsättningen subtraheras sedan från teckenintervallet från "a" till "z", vilket ger uppsättningen tecken [abcmnoxyz].

Du kan använda valfri teckenklass med subtraktion för teckenklass. Om du vill definiera den uppsättning tecken som består av alla Unicode-tecken från \u0000 till \uFFFF utom blankstegstecken (\s), tecknen i den allmänna kategorin för skiljetecken (\p{P}), tecknen i det IsGreek namngivna blocket (\p{IsGreek}) och Unicode NEXT LINE-kontrolltecknet (\x85) använder du [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

Välj teckenklasser för ett subtraktionsuttryck för teckenklass som ger användbara resultat. Undvik ett uttryck som ger en tom uppsättning tecken, som inte kan matcha något, eller ett uttryck som motsvarar den ursprungliga basgruppen. Den tomma uppsättningen är till exempel resultatet av uttrycket [\p{IsBasicLatin}-[\x00-\x7F]], som subtraherar alla tecken i teckenintervallet IsBasicLatin från den IsBasicLatin allmänna kategorin. På samma sätt är den ursprungliga basgruppen resultatet av uttrycket [a-z-[0-9]]. Det beror på att basgruppen, som är teckenintervallet för bokstäver från "a" till "z", inte innehåller några tecken i den exkluderade gruppen, vilket är teckenintervallet för decimalsiffror från "0" till "9".

I följande exempel definieras ett reguljärt uttryck, ^[0-9-[2468]]+$, som matchar noll och udda siffror i en indatasträng. Det reguljära uttrycket tolkas som det visas i följande tabell.

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

Se även

• GetUnicodeCategory
• Språk för reguljärt uttryck – snabbreferens
• Alternativ för reguljära uttryck