RegexOptions RegexOptions RegexOptions RegexOptions Enum

Definicja

Zawiera wartości wyliczane służące do ustawiania opcji wyrażenia regularnego.Provides enumerated values to use to set regular expression options.

To wyliczenie ma atrybut FlagsAttribute zezwalający na bitową kombinację jego wartości składowych.

public enum class RegexOptions
[System.Flags]
public enum RegexOptions
type RegexOptions = 
Public Enum RegexOptions
Dziedziczenie
Atrybuty

Pola

Compiled Compiled Compiled Compiled 8

Określa, że wyrażenie regularne jest kompilowane do zestawu.Specifies that the regular expression is compiled to an assembly. Zapewnia to szybsze wykonywanie, ale wydłuża czas uruchamiania.This yields faster execution but increases startup time. Tej wartości nie należy przypisywać do Options właściwości podczas CompileToAssembly(RegexCompilationInfo[], AssemblyName) wywoływania metody.This value should not be assigned to the Options property when calling the CompileToAssembly(RegexCompilationInfo[], AssemblyName) method. Aby uzyskać więcej informacji, zobacz sekcję "skompilowane wyrażenia regularne" w temacie Opcje wyrażenia regularnego .For more information, see the "Compiled Regular Expressions" section in the Regular Expression Options topic.

CultureInvariant CultureInvariant CultureInvariant CultureInvariant 512

Określa, że różnice kulturowe w języku są ignorowane.Specifies that cultural differences in language is ignored. Aby uzyskać więcej informacji, zobacz sekcję "Porównanie przy użyciu kultury niezmiennej" w temacie Opcje wyrażenia regularnego .For more information, see the "Comparison Using the Invariant Culture" section in the Regular Expression Options topic.

ECMAScript ECMAScript ECMAScript ECMAScript 256

Włącza zachowanie zgodne ze standardem ECMAScript dla wyrażenia.Enables ECMAScript-compliant behavior for the expression. Ta wartość może być używana tylko w połączeniu z IgnoreCasewartościami, Multilinei. CompiledThis value can be used only in conjunction with the IgnoreCase, Multiline, and Compiled values. Użycie tej wartości z innymi wartościami spowoduje wyjątek.The use of this value with any other values results in an exception.

Aby uzyskać więcej informacji na ECMAScript temat tej opcji, zobacz sekcję "zachowanie dopasowania ECMAScript" w temacie Opcje wyrażenia regularnego .For more information on the ECMAScript option, see the "ECMAScript Matching Behavior" section in the Regular Expression Options topic.

ExplicitCapture ExplicitCapture ExplicitCapture ExplicitCapture 4

Określa, że jedyne prawidłowe przechwycenia są jawnie nazwanymi lub numerowanymi grupami formularza (?< Nazwa>...). Dzięki temu nienazwane nawiasy mogą działać jako nieprzechwycone grupy bez składni clumsiness wyrażenia (?:...). Aby uzyskać więcej informacji, zobacz sekcję "tylko jawne przechwycenia" w temacie Opcje wyrażenia regularnego .Specifies that the only valid captures are explicitly named or numbered groups of the form (?<name>...). This allows unnamed parentheses to act as noncapturing groups without the syntactic clumsiness of the expression (?:...). For more information, see the "Explicit Captures Only" section in the Regular Expression Options topic.

IgnoreCase IgnoreCase IgnoreCase IgnoreCase 1

Określa Dopasowywanie bez uwzględniania wielkości liter.Specifies case-insensitive matching. Aby uzyskać więcej informacji, zobacz sekcję "dopasowanie bez uwzględniania wielkości liter" w temacie Opcje wyrażenia regularnego .For more information, see the "Case-Insensitive Matching " section in the Regular Expression Options topic.

IgnorePatternWhitespace IgnorePatternWhitespace IgnorePatternWhitespace IgnorePatternWhitespace 32

Eliminuje niezmieniony biały znak ze wzorca i włącza Komentarze oznaczone #.Eliminates unescaped white space from the pattern and enables comments marked with #. Jednakże ta wartość nie wpływa ani nie eliminuje białych znaków w klasach znakowych, kwantyfikatorachliczbowych ani tokenach, które oznaczają początek poszczególnych elementów języka wyrażenia regularnego.However, this value does not affect or eliminate white space in character classes, numeric quantifiers, or tokens that mark the beginning of individual regular expression language elements. Aby uzyskać więcej informacji, zobacz sekcję "ignorowanie białych znaków" tematu opcji wyrażenia regularnego .For more information, see the "Ignore White Space" section of the Regular Expression Options topic.

Multiline Multiline Multiline Multiline 2

Tryb wielowierszowy.Multiline mode. Zmienia znaczenie wartości ^ i $, aby były zgodne na początku i na końcu, w dowolnym wierszu, a nie tylko na początku i na końcu całego ciągu.Changes the meaning of ^ and $ so they match at the beginning and end, respectively, of any line, and not just the beginning and end of the entire string. Aby uzyskać więcej informacji, zobacz sekcję "tryb wielowierszowy" w temacie Opcje wyrażenia regularnego .For more information, see the "Multiline Mode" section in the Regular Expression Options topic.

None None None None 0

Określa, że nie są ustawione żadne opcje.Specifies that no options are set. Aby uzyskać więcej informacji na temat domyślnego zachowania aparatu wyrażeń regularnych, zobacz sekcję "opcje domyślne" w temacie Opcje wyrażenia regularnego .For more information about the default behavior of the regular expression engine, see the "Default Options" section in the Regular Expression Options topic.

RightToLeft RightToLeft RightToLeft RightToLeft 64

Określa, że wyszukiwanie będzie od prawej do lewej zamiast od lewej do prawej.Specifies that the search will be from right to left instead of from left to right. Aby uzyskać więcej informacji, zobacz sekcję "tryb" od prawej do lewej "w temacie Opcje wyrażenia regularnego .For more information, see the "Right-to-Left Mode" section in the Regular Expression Options topic.

Singleline Singleline Singleline Singleline 16

Określa tryb jednowierszowy.Specifies single-line mode. Zmienia znaczenie kropki (.), więc dopasowuje każdy znak (zamiast każdego znaku z wyjątkiem \n).Changes the meaning of the dot (.) so it matches every character (instead of every character except \n). Aby uzyskać więcej informacji, zobacz sekcję "tryb jednowierszowy" w temacie Opcje wyrażenia regularnego .For more information, see the "Single-line Mode" section in the Regular Expression Options topic.

Przykłady

W poniższym przykładzie zdefiniowano dwa wyrażenia regularne, które identyfikują powtórzone wyrazy w tekście, ale są RegexOptions tworzone przy użyciu różnych wartości.The following example defines two regular expressions that identify repeated words in text but that are instantiated using different RegexOptions values. W pierwszym wyrażeniu regularnym nie jest rozróżniana wielkość liter. wielkość liter jest ignorowana w przypadku określenia, czy słowo jest identyczne z poprzednim słowem.The first regular expression is case-insensitive; case is ignored when determining whether a word is identical to the preceding word. W drugim wyrażeniu regularnym jest rozróżniana wielkość liter. słowo musi być zgodne z wielkością liter w poprzednim wyrazie, aby można je było uznać za duplikat.The second regular expression is case-sensitive; a word must match the case of the preceding word exactly to be considered a duplicate.

using System;
using System.Text.RegularExpressions;

public class Test
{
    public static void Main ()
    {
        // Define a case-insensitive regular expression for repeated words.
        Regex rxInsensitive = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);
        // Define a case-sensitive regular expression for repeated words.
        Regex rxSensitive = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled);

        // Define a test string.        
        string text = "The the quick brown fox  fox jumps over the lazy dog dog.";
        
        // Find matches using case-insensitive regular expression.
        MatchCollection matches = rxInsensitive.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}", 
                          matches.Count, 
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",  
                              groups["word"].Value, 
                              groups[0].Index, 
                              groups[1].Index);
        }
        Console.WriteLine();
        
        // Find matches using case-sensitive regular expression.
        matches = rxSensitive.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}", 
                          matches.Count, 
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",  
                              groups["word"].Value, 
                              groups[0].Index, 
                              groups[1].Index);
        }
    }
}
// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54
//       
//       2 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54
Imports System.Text.RegularExpressions

Public Module Test

    Public Sub Main()
        ' Define a case-insensitive regular expression for repeated words.
        Dim rxInsensitive As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled Or RegexOptions.IgnoreCase)
        ' Define a case-sensitive regular expression for repeated words.
        Dim rxSensitive As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled)

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
        
        ' Find matches using case-insensitive regular expression.
        Dim matches As MatchCollection = rxInsensitive.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
        Console.WriteLine()
        
        ' Find matches using case-sensitive regular expression.
        matches = rxSensitive.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
        Console.WriteLine()
    End Sub
End Module
' The example produces the following output to the console:
'       3 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'The' repeated at positions 0 and 4
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 50 and 54
'       
'       2 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 50 and 54

Uwagi

Wartość można podać jako parametr do następujących elementów członkowskich Regex klasy: RegexOptionsA RegexOptions value can be provided as a parameter to the following members of the Regex class:

Wartość może być również podana jako parametr RegexCompilationInfo do konstruktora lub może RegexCompilationInfo.Options być przypisana bezpośrednio do właściwości. RegexOptionsA RegexOptions value can also be supplied as a parameter to the RegexCompilationInfo constructor, or it can be assigned directly to the RegexCompilationInfo.Options property. Otrzymany RegexCompilationInfo obiekt jest następnie używany w wywołaniu Regex.CompileToAssembly metody.The resulting RegexCompilationInfo object is then used in the call to the Regex.CompileToAssembly method.

Niektóre opcje udostępniane przez RegexOptions elementy członkowskie wyliczenia (w szczególności przez IgnoreCasejego ExplicitCapture Multilineelementy członkowskie,, i Singleline ) można zamiast tego dostarczyć przy użyciu wbudowanego znaku opcji w wyrażeniu regularnym znaczne.Several options provided by members of the RegexOptions enumeration (in particular, by its ExplicitCapture, IgnoreCase, Multiline, and Singleline members) can instead be provided by using an inline option character in the regular expression pattern. Aby uzyskać szczegółowe informacje, zobacz Opcje wyrażenia regularnego.For details, see Regular Expression Options.

Dotyczy

Zobacz też