Regex Konstruktory

Definicja

Przestrzeń nazw:

System.Text.RegularExpressions

Zestaw:

System.Text.RegularExpressions.dll

Inicjuje nowe wystąpienie klasy Regex.

Przeciążenia

Regex()	Inicjuje nowe wystąpienie klasy Regex.
Regex(String)	Inicjuje nowe wystąpienie klasy Regex dla określonego wyrażenia regularnego.
Regex(SerializationInfo, StreamingContext)	Przestarzałe. Inicjuje nowe wystąpienie klasy Regex przy użyciu danych serializowanych.
Regex(String, RegexOptions)	Inicjuje nowe wystąpienie klasy Regex dla określonego wyrażenia regularnego z opcjami modyfikującą wzorzec.
Regex(String, RegexOptions, TimeSpan)	Inicjuje nowe wystąpienie klasy Regex dla określonego wyrażenia regularnego z opcjami modyfikującymi wzorzec i wartością określającą, jak długo metoda dopasowania wzorca powinna próbować dopasować przed upływem limitu czasu.

Regex()

Źródło:

Regex.cs

Inicjuje nowe wystąpienie klasy Regex.

protected:
 Regex();

protected Regex ();

Protected Sub New ()

Uwagi

Należy pamiętać, że ten konstruktor jest chroniony; może być wywoływana tylko przez klasy pochodzące z klasy Regex.

Regex(String)

Źródło:

Regex.cs

Inicjuje nowe wystąpienie klasy Regex dla określonego wyrażenia regularnego.

public:
 Regex(System::String ^ pattern);

public Regex (string pattern);

new System.Text.RegularExpressions.Regex : string -> System.Text.RegularExpressions.Regex

Public Sub New (pattern As String)

Parametry

pattern

String

Wzorzec wyrażenia regularnego do dopasowania.

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

pattern jest null.

Przykłady

W poniższym przykładzie pokazano, jak za pomocą tego konstruktora utworzyć wystąpienie wyrażenia regularnego zgodnego z dowolnym wyrazem rozpoczynającym się literami "a" lub "t".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex defaultRegex = new Regex(pattern);
      // Get matches of pattern in text
      matches = defaultRegex.Matches(text);
      Console.WriteLine("Parsing '{0}'", text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//       Parsing 'The threaded application ate up the thread pool as it executed.'
//       0. threaded
//       1. application
//       2. ate
//       3. the
//       4. thread
//       5. as

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim defaultRegex As New Regex(pattern)
      ' Get matches of pattern in text
      matches = defaultRegex.Matches(text)
      Console.WriteLine("Parsing '{0}'", text)
      ' Iterate matches
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Parsing 'The threaded application ate up the thread pool as it executed.'
'       0. threaded
'       1. application
'       2. ate
'       3. the
'       4. thread
'       5. as

Należy pamiętać, że wzorzec wyrażenia regularnego nie może być zgodny ze słowem "The" na początku tekstu, ponieważ porównania są domyślnie wrażliwe na wielkość liter. Aby zapoznać się z przykładem porównania bez uwzględniania wielkości liter, zobacz konstruktor Regex(String, RegexOptions).

Uwagi

Ostrzeżenie

W przypadku używania System.Text.RegularExpressions do przetwarzania niezaufanych danych wejściowych należy przekazać wartość limitu czasu , aby zapobiec spowodowaniu ataków typu "odmowa usługi" . Wartość limitu czasu określa, jak długo metoda dopasowywania wzorca powinna próbować znaleźć dopasowanie przed przekroczeniem limitu czasu.

Parametr pattern składa się z elementów języka wyrażeń regularnych, które symbolicznie opisują ciąg do dopasowania. Aby uzyskać więcej informacji na temat wyrażeń regularnych, zobacz .NET Regular Expressions i Regular Expression Language — Quick Reference tematów.

Wywołanie konstruktora Regex(String) jest równoważne wywołaniu konstruktora Regex(String, RegexOptions) z wartością None argumentu options.

Obiekt Regex jest niezmienny, co oznacza, że może być używany tylko dla wzorca dopasowania zdefiniowanego podczas jego tworzenia. Można go jednak używać dowolną liczbę razy bez ponownego skompilowania.

Ten konstruktor tworzy wystąpienie obiektu wyrażenia regularnego, który próbuje dopasować wielkość liter wszystkich znaków alfabetycznych zdefiniowanych w pattern. W przypadku dopasowania bez uwzględniania wielkości liter należy użyć konstruktora Regex.Regex(String, RegexOptions).

Uwagi dotyczące wywoływania

Ten konstruktor tworzy obiekt Regex, który używa domyślnej wartości limitu czasu domeny aplikacji, w której jest tworzony. Jeśli wartość limitu czasu nie została zdefiniowana dla domeny aplikacji, obiekt Regex używa wartości InfiniteMatchTimeout, co uniemożliwia przekroczenie limitu czasu operacji. Zalecanym konstruktorem do tworzenia obiektu Regex jest Regex(String, RegexOptions, TimeSpan), który umożliwia ustawienie interwału limitu czasu.

Zobacz też

• elementy języka wyrażeń regularnych

Regex(SerializationInfo, StreamingContext)

Źródło:

Regex.cs

Przestroga

This API supports obsolete formatter-based serialization. It should not be called or extended by application code.

Inicjuje nowe wystąpienie klasy Regex przy użyciu danych serializowanych.

protected:
 Regex(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);

[System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
protected Regex (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);

[<System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex

Protected Sub New (info As SerializationInfo, context As StreamingContext)

Parametry

info

SerializationInfo

Obiekt zawierający serializowany wzorzec i informacje RegexOptions.

context

StreamingContext

Miejsce docelowe tej serializacji. (Ten parametr nie jest używany; określ null.)

Atrybuty

ObsoleteAttribute

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

Wzorzec, który info zawiera, to null.

ArgumentOutOfRangeException

info zawiera nieprawidłową flagę RegexOptions.

Regex(String, RegexOptions)

Źródło:

Regex.cs

Inicjuje nowe wystąpienie klasy Regex dla określonego wyrażenia regularnego z opcjami modyfikującą wzorzec.

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options);

new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Regex

Public Sub New (pattern As String, options As RegexOptions)

Parametry

pattern

String

Wzorzec wyrażenia regularnego do dopasowania.

options

RegexOptions

Bitowa kombinacja wartości wyliczenia, które modyfikują wyrażenie regularne.

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

pattern jest null.

ArgumentOutOfRangeException

options zawiera nieprawidłową flagę.

Przykłady

W poniższym przykładzie pokazano, jak za pomocą tego konstruktora utworzyć wystąpienie wyrażenia regularnego zgodnego z dowolnym wyrazem rozpoczynającym się literami "a" lub "t".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.Compiled;
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex optionRegex = new Regex(pattern, options);
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString());
      // Get matches of pattern in text
      matches = optionRegex.Matches(text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//    Parsing 'The threaded application ate up the thread pool as it executed.'
//        with options IgnoreCase, Compiled:
//    0. The
//    1. threaded
//    2. application
//    3. ate
//    4. the
//    5. thread
//    6. as

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.Compiled
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim optionRegex As New Regex(pattern, options)
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString())
      ' Get matches of pattern in text
      matches = optionRegex.Matches(text)
      ' Iterate matches   
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    Parsing 'The threaded application ate up the thread pool as it executed.'
'       with options IgnoreCase, Compiled:
'    0. The
'    1. threaded
'    2. application
'    3. ate
'    4. the
'    5. thread
'    6. as

Należy pamiętać, że kolekcja dopasowań zawiera wyraz "The", który rozpoczyna tekst, ponieważ parametr options ma zdefiniowane porównania bez uwzględniania wielkości liter.

Uwagi

Ostrzeżenie

W przypadku używania System.Text.RegularExpressions do przetwarzania niezaufanych danych wejściowych należy przekazać wartość limitu czasu , aby zapobiec spowodowaniu ataków typu "odmowa usługi" . Wartość limitu czasu określa, jak długo metoda dopasowywania wzorca powinna próbować znaleźć dopasowanie przed przekroczeniem limitu czasu.

Parametr pattern składa się z elementów języka wyrażeń regularnych, które symbolicznie opisują ciąg do dopasowania. Aby uzyskać więcej informacji na temat wyrażeń regularnych, zobacz .NET Regular Expressions i Regular Expression Language — Quick Reference tematów.

Obiekt Regex jest niezmienny, co oznacza, że może być używany tylko dla parametrów dopasowania zdefiniowanych podczas jego tworzenia. Można go jednak używać dowolną liczbę razy bez ponownego skompilowania.

Uwagi dotyczące wywoływania

Ten konstruktor tworzy obiekt Regex, który używa domyślnej wartości limitu czasu domeny aplikacji, w której jest tworzony. Jeśli wartość limitu czasu nie została zdefiniowana dla domeny aplikacji, obiekt Regex używa wartości InfiniteMatchTimeout, co uniemożliwia przekroczenie limitu czasu operacji. Zalecanym konstruktorem do tworzenia obiektu Regex jest Regex(String, RegexOptions, TimeSpan), który umożliwia ustawienie interwału limitu czasu.

Zobacz też

• elementy języka wyrażeń regularnych

Regex(String, RegexOptions, TimeSpan)

Źródło:

Regex.cs

Inicjuje nowe wystąpienie klasy Regex dla określonego wyrażenia regularnego z opcjami modyfikującymi wzorzec i wartością określającą, jak długo metoda dopasowania wzorca powinna próbować dopasować przed upływem limitu czasu.

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public Regex (string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Regex

Public Sub New (pattern As String, options As RegexOptions, matchTimeout As TimeSpan)

Parametry

pattern

String

Wzorzec wyrażenia regularnego do dopasowania.

options

RegexOptions

Bitowa kombinacja wartości wyliczenia, które modyfikują wyrażenie regularne.

matchTimeout

TimeSpan

Interwał limitu czasu lub InfiniteMatchTimeout wskazujący, że metoda nie powinna upłynął limit czasu.

Wyjątki

ArgumentException

Wystąpił błąd analizowania wyrażeń regularnych.

ArgumentNullException

pattern jest null.

ArgumentOutOfRangeException

options nie jest prawidłową wartością RegexOptions.

-lub-

matchTimeout jest ujemna, zero lub większa niż około 24 dni.

Przykłady

Poniższy przykład wywołuje konstruktor Regex(String, RegexOptions, TimeSpan), aby utworzyć wystąpienie obiektu Regex z wartością limitu czasu jednego sekundy. Wzorzec wyrażenia regularnego (a+)+$, który pasuje do co najmniej jednej sekwencji co najmniej jednego znaku "a" na końcu wiersza, podlega nadmiernemu wycofywaniu. Jeśli zostanie zgłoszony RegexMatchTimeoutException, przykład zwiększy wartość limitu czasu do maksymalnej wartości wynoszącej trzy sekundy. W przeciwnym razie porzuca próbę dopasowania do wzorca.

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Security;
using System.Text.RegularExpressions;
using System.Threading; 

public class Example
{
   const int MaxTimeoutInSeconds = 3;

   public static void Main()
   {
      string pattern = @"(a+)+$";    // DO NOT REUSE THIS PATTERN.
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1));       
      Stopwatch sw = null;
      
      string[] inputs= { "aa", "aaaa>", 
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                         "aaaaaaaaaaaaaaaaaaaaaa>",
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" };
                                 
      foreach (var inputValue in inputs) {
         Console.WriteLine("Processing {0}", inputValue);
         bool timedOut = false;
         do { 
            try {
               sw = Stopwatch.StartNew();
               // Display the result.
               if (rgx.IsMatch(inputValue)) {
                  sw.Stop();
                  Console.WriteLine(@"Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed); 
               }
               else {
                  sw.Stop();
                  Console.WriteLine(@"'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed);
               }
            }
            catch (RegexMatchTimeoutException e) {   
               sw.Stop();
               // Display the elapsed time until the exception.
               Console.WriteLine(@"Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed);
               Thread.Sleep(1500);       // Pause for 1.5 seconds.

               // Increase the timeout interval and retry.
               TimeSpan timeout = e.MatchTimeout.Add(TimeSpan.FromSeconds(1));
               if (timeout.TotalSeconds > MaxTimeoutInSeconds) {
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds);
                  timedOut = false;
               }
               else {               
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout); 
                  rgx = new Regex(pattern, RegexOptions.IgnoreCase, timeout);
                  timedOut = true;
               }
            }
         } while (timedOut);
         Console.WriteLine();
      }   
   }
}
// The example displays output like the following :
//    Processing aa
//    Valid: 'aa' (00.0000779 seconds)
//    
//    Processing aaaa>
//    'aaaa>' is not a valid string. (00.00005 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
//    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
//    Changing the timeout interval to 00:00:02
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
//    Changing the timeout interval to 00:00:03
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
//    Maximum timeout interval of 3 seconds exceeded.
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
//    Maximum timeout interval of 3 seconds exceeded.

Imports System.ComponentModel
Imports System.Diagnostics
Imports System.Security
Imports System.Text.RegularExpressions
Imports System.Threading 

Module Example
   Const MaxTimeoutInSeconds As Integer = 3
   
   Public Sub Main()
      Dim pattern As String = "(a+)+$"    ' DO NOT REUSE THIS PATTERN.
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1))       
      Dim sw As Stopwatch = Nothing
      
      Dim inputs() As String = { "aa", "aaaa>", 
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                                 "aaaaaaaaaaaaaaaaaaaaaa>",
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" }
                                 
      For Each inputValue In inputs
         Console.WriteLine("Processing {0}", inputValue)
         Dim timedOut As Boolean = False
         Do 
            Try
               sw = Stopwatch.StartNew()
               ' Display the result.
               If rgx.IsMatch(inputValue) Then
                  sw.Stop()
                  Console.WriteLine("Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed) 
               Else
                  sw.Stop()
                  Console.WriteLine("'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed)
               End If
            Catch e As RegexMatchTimeoutException   
               sw.Stop()
               ' Display the elapsed time until the exception.
               Console.WriteLine("Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed)
               Thread.Sleep(1500)       ' Pause for 1.5 seconds.

               ' Increase the timeout interval and retry.
               Dim timeout As TimeSpan = e.MatchTimeout.Add(TimeSpan.FromSeconds(1))
               If timeout.TotalSeconds > MaxTimeoutInSeconds Then
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds)
                  timedOut = False
               Else                
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout) 
                  rgx = New Regex(pattern, RegexOptions.IgnoreCase, timeout)
                  timedOut = True
               End If
            End Try
         Loop While timedOut
         Console.WriteLine()
      Next   
   End Sub 
End Module
' The example displays output like the following:
'    Processing aa
'    Valid: 'aa' (00.0000779 seconds)
'    
'    Processing aaaa>
'    'aaaa>' is not a valid string. (00.00005 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
'    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
'    Changing the timeout interval to 00:00:02
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
'    Changing the timeout interval to 00:00:03
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
'    Maximum timeout interval of 3 seconds exceeded.
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
'    Maximum timeout interval of 3 seconds exceeded.

Uwagi

Parametr pattern składa się z elementów języka wyrażeń regularnych, które symbolicznie opisują ciąg do dopasowania. Aby uzyskać więcej informacji na temat wyrażeń regularnych, zobacz .NET Regular Expressions i Regular Expression Language — Quick Reference tematów.

Obiekt Regex jest niezmienny, co oznacza, że może być używany tylko dla wzorca dopasowania zdefiniowanego podczas jego tworzenia. Można go jednak używać dowolną liczbę razy bez ponownego skompilowania.

Parametr matchTimeout określa, jak długo metoda dopasowywania wzorca powinna próbować znaleźć dopasowanie przed upływem limitu czasu. Jeśli w tym interwale czasu nie znaleziono dopasowania, metoda dopasowania wzorca zgłasza wyjątek RegexMatchTimeoutException. matchTimeout zastępuje domyślną wartość limitu czasu zdefiniowaną dla domeny aplikacji, w której jest tworzony obiekt Regex. Metody dopasowywania wzorców wystąpień, które obserwują interwał przekroczenia limitu czasu matchTimeout obejmują następujące elementy:

• IsMatch

• Match

• Matches

• Replace

• Split

• Match.NextMatch

Ustawienie interwału limitu czasu zapobiega wyrażeniom regularnym, które polegają na nadmiernym wycofywaniu, aby przestać odpowiadać podczas przetwarzania danych wejściowych, które zawierają niemal dopasowania. Aby uzyskać więcej informacji, zobacz Best Practices for Regular Expressions and Backtracking. Aby ustawić rozsądny interwał limitu czasu, należy wziąć pod uwagę następujące czynniki:

• Długość i złożoność wzorca wyrażenia regularnego. Dłuższe i bardziej złożone wyrażenia regularne wymagają więcej czasu niż krótsze i prostsze.

• Oczekiwane obciążenie maszyny. Przetwarzanie zajmuje więcej czasu w systemach o wysokim wykorzystaniu procesora CPU i pamięci.

Uwagi dotyczące wywoływania

Zalecamy ustawienie parametru matchTimeout na odpowiednią wartość, na przykład dwie sekundy. Jeśli wyłączysz limity czasu, określając InfiniteMatchTimeout, aparat wyrażeń regularnych zapewnia nieco lepszą wydajność. Należy jednak wyłączyć limity czasu tylko w następujących warunkach:

• Gdy dane wejściowe przetwarzane przez wyrażenie regularne pochodzą ze znanego i zaufanego źródła lub składa się z tekstu statycznego. Wyklucza to tekst, który został dynamicznie wprowadzany przez użytkowników.

• Gdy wzorzec wyrażenia regularnego został dokładnie przetestowany w celu zapewnienia, że efektywnie obsługuje dopasowania, niezgodne i bliskie dopasowania.

• Gdy wzorzec wyrażenia regularnego nie zawiera żadnych elementów języka, które są znane, aby powodować nadmierne wycofywanie podczas przetwarzania niemal zgodnego.

Zobacz też

• wycofywanie w wyrażeniach regularnych
• elementy języka wyrażeń regularnych