Regex Konstruktoren
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Initialisiert eine neue Instanz der Regex-Klasse.
Überlädt
Regex() |
Initialisiert eine neue Instanz der Regex-Klasse. |
Regex(String) |
Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck. |
Regex(SerializationInfo, StreamingContext) |
Veraltet.
Initialisiert eine neue Instanz der Regex-Klasse mithilfe von serialisierten Daten. |
Regex(String, RegexOptions) |
Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen zum Verändern des Musters. |
Regex(String, RegexOptions, TimeSpan) |
Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen, die das Muster und einen Wert ändern, der angibt, wie lange eine Mustervergleichsmethode versuchen sollte, eine Übereinstimmung zu finden, bevor ein Timeout eintritt. |
Regex()
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- Regex.cs
Initialisiert eine neue Instanz der Regex-Klasse.
protected:
Regex();
protected Regex ();
Protected Sub New ()
Hinweise
Beachten Sie, dass dieser Konstruktor geschützt ist. Sie kann nur von Klassen aufgerufen werden, die von der Regex -Klasse abgeleitet sind.
Gilt für:
Regex(String)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- Regex.cs
Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck.
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)
Parameter
- pattern
- String
Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.
Ausnahmen
Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.
pattern
ist null
.
Beispiele
Im folgenden Beispiel wird veranschaulicht, wie dieser Konstruktor verwendet wird, um einen regulären Ausdruck zu instanziieren, der mit einem beliebigen Wort übereinstimmt, das mit den Buchstaben "a" oder "t" beginnt.
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
Beachten Sie, dass das Muster für reguläre Ausdrücke nicht mit dem Wort "The" am Anfang des Texts übereinstimmen kann, da bei Vergleichen standardmäßig die Groß-/Kleinschreibung beachtet wird. Ein Beispiel für einen Vergleich ohne Beachtung der Groß-/Kleinschreibung finden Sie im Regex(String, RegexOptions) Konstruktor.
Hinweise
Der pattern
Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie in den Themen .NET Regular Expressions und Regular Expression Language – Schnellreferenz .
Das Aufrufen des Regex(String) Konstruktors entspricht dem Aufrufen des Regex(String, RegexOptions) Konstruktors mit dem Wert für None das options
Argument.
Ein Regex Objekt ist unveränderlich, was bedeutet, dass es nur für das Übereinstimmungsmuster verwendet werden kann, das Sie beim Erstellen definieren. Es kann jedoch beliebig oft verwendet werden, ohne neu kompiliert zu werden.
Dieser Konstruktor instanziiert ein Objekt mit regulären Ausdrücken, das versucht, eine Übereinstimmung mit allen in pattern
definierten alphabetischen Zeichen zu berücksichtigen. Verwenden Sie für eine Übereinstimmung ohne Berücksichtigung der Groß-/Kleinschreibung den Regex.Regex(String, RegexOptions) -Konstruktor.
Hinweise für Aufrufer
Dieser Konstruktor erstellt ein Regex -Objekt, das den Standardtimeoutwert der Anwendungsdomäne verwendet, in der er erstellt wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, verwendet das Regex Objekt den Wert InfiniteMatchTimeout, wodurch ein Timeout für den Vorgang verhindert wird. Der empfohlene Konstruktor zum Erstellen eines Regex Objekts ist Regex(String, RegexOptions, TimeSpan), mit dem Sie das Timeoutintervall festlegen können.
Weitere Informationen
Gilt für:
Regex(SerializationInfo, StreamingContext)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- Regex.cs
Achtung
This API supports obsolete formatter-based serialization. It should not be called or extended by application code.
Initialisiert eine neue Instanz der Regex-Klasse mithilfe von serialisierten Daten.
protected:
Regex(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);
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);
new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex
[<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)
Parameter
- info
- SerializationInfo
Das Objekt, das ein serialisiertes Muster und RegexOptions-Informationen enthält.
- context
- StreamingContext
Das Ziel dieser Serialisierung. (Dieser Parameter wird nicht verwendet, geben Sie null
an.)
- Attribute
Ausnahmen
Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.
Das Muster, das diese info
enthält, ist null
.
info
enthält ein ungültiges RegexOptions-Flag.
Gilt für:
Regex(String, RegexOptions)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- Regex.cs
Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen zum Verändern des Musters.
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)
Parameter
- pattern
- String
Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.
- options
- RegexOptions
Eine bitweise Kombination der Enumerationswerte, die den regulären Ausdruck ändern.
Ausnahmen
Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.
pattern
ist null
.
options
enthält ein ungültiges Flag.
Beispiele
Im folgenden Beispiel wird veranschaulicht, wie dieser Konstruktor verwendet wird, um einen regulären Ausdruck zu instanziieren, der mit einem beliebigen Wort übereinstimmt, das mit den Buchstaben "a" oder "t" beginnt.
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
Beachten Sie, dass die Übereinstimmungsauflistung das Wort "The" enthält, das den Text beginnt, da der Parameter Vergleiche ohne Berücksichtigung der options
Groß-/Kleinschreibung definiert hat.
Hinweise
Der pattern
Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie in den Themen .NET Regular Expressions und Regular Expression Language – Schnellreferenz .
Ein Regex Objekt ist unveränderlich, was bedeutet, dass es nur für die Übereinstimmungsparameter verwendet werden kann, die Sie beim Erstellen definieren. Es kann jedoch beliebig oft verwendet werden, ohne neu kompiliert zu werden.
Hinweise für Aufrufer
Dieser Konstruktor erstellt ein Regex -Objekt, das den Standardtimeoutwert der Anwendungsdomäne verwendet, in der er erstellt wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, verwendet das Regex Objekt den Wert InfiniteMatchTimeout, wodurch ein Timeout für den Vorgang verhindert wird. Der empfohlene Konstruktor zum Erstellen eines Regex Objekts ist Regex(String, RegexOptions, TimeSpan), mit dem Sie das Timeoutintervall festlegen können.
Weitere Informationen
Gilt für:
Regex(String, RegexOptions, TimeSpan)
- Source:
- Regex.cs
- Source:
- Regex.cs
- Source:
- Regex.cs
Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen, die das Muster und einen Wert ändern, der angibt, wie lange eine Mustervergleichsmethode versuchen sollte, eine Übereinstimmung zu finden, bevor ein Timeout eintritt.
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)
Parameter
- pattern
- String
Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.
- options
- RegexOptions
Eine bitweise Kombination der Enumerationswerte, die den regulären Ausdruck ändern.
- matchTimeout
- TimeSpan
Ein Timeoutintervall oder InfiniteMatchTimeout, das angibt, dass die Methode kein Timeout haben sollte.
Ausnahmen
Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.
pattern
ist null
.
options
ist kein gültiger RegexOptions-Wert.
- oder -
matchTimeout
ist negativ, null oder größer als ca. 24 Tage.
Beispiele
Im folgenden Beispiel wird der Regex(String, RegexOptions, TimeSpan) Konstruktor aufgerufen, um ein Regex Objekt mit einem Timeoutwert von einer Sekunde zu instanziieren. Das Muster des regulären Ausdrucks (a+)+$
, das mit mindestens einer Sequenz von einem oder mehreren "a"-Zeichen am Ende einer Zeile übereinstimmt, unterliegt übermäßiger Rückverfolgung. Wenn ein RegexMatchTimeoutException ausgelöst wird, erhöht das Beispiel den Timeoutwert auf den maximalen Wert von drei Sekunden. Andernfalls wird der Versuch aufgegeben, dem Muster zu entsprechen.
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.
Hinweise
Der pattern
Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie in den Themen .NET Regular Expressions und Regular Expression Language – Schnellreferenz .
Ein Regex Objekt ist unveränderlich, was bedeutet, dass es nur für das Übereinstimmungsmuster verwendet werden kann, das Sie beim Erstellen definieren. Es kann jedoch beliebig oft verwendet werden, ohne neu kompiliert zu werden.
Der matchTimeout
Parameter gibt an, wie lange eine Musterabgleichsmethode versuchen soll, eine Übereinstimmung zu finden, bevor ein Zeitüberschreitung vorliegt. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die Musterabgleichsmethode eine Ausnahme aus RegexMatchTimeoutException . matchTimeout
Überschreibt jeden Standardtimeoutwert, der für die Anwendungsdomäne definiert ist, in der das Regex Objekt erstellt wird. Die instance Methoden zum Musterabgleich, die das matchTimeout
Timeoutintervall beobachten, umfassen Folgendes:
Das Festlegen eines Timeoutintervalls verhindert, dass reguläre Ausdrücke, die auf übermäßiger Rückverfolgung basieren, nicht mehr reagieren, wenn sie Eingaben verarbeiten, die nahezu Übereinstimmungen enthalten. Weitere Informationen finden Sie unter Bewährte Methoden für reguläre Ausdrücke und Rückverfolgung. Berücksichtigen Sie die folgenden Faktoren, um ein angemessenes Timeoutintervall festzulegen:
Die Länge und Komplexität des Musters für reguläre Ausdrücke. Längere und komplexere reguläre Ausdrücke erfordern mehr Zeit als kürzere und einfachere Ausdrücke.
Die erwartete Computerlast. Die Verarbeitung nimmt bei Systemen mit hoher CPU- und Arbeitsspeicherauslastung mehr Zeit in Anspruch.
Hinweise für Aufrufer
Es wird empfohlen, den matchTimeout
Parameter auf einen geeigneten Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Timeouts deaktivieren, indem Sie angeben InfiniteMatchTimeout, bietet die Engine für reguläre Ausdrücke eine etwas bessere Leistung. Sie sollten Timeouts jedoch nur unter den folgenden Bedingungen deaktivieren:
Wenn die von einem regulären Ausdruck verarbeitete Eingabe von einer bekannten und vertrauenswürdigen Quelle abgeleitet wird oder aus statischem Text besteht. Dies schließt Text aus, der von Benutzern dynamisch eingegeben wurde.
Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass Übereinstimmungen, Nicht-Übereinstimmungen und Fast-Übereinstimmungen effizient verarbeitet werden.
Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, von denen bekannt ist, dass sie bei der Verarbeitung einer nahen Übereinstimmung eine übermäßige Rückverfolgung verursachen.
Weitere Informationen
Gilt für:
Feedback
https://aka.ms/ContentUserFeedback.
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unterFeedback senden und anzeigen für