RegexOptions Výčet

Definice

Poskytuje výčet hodnot, které se mají použít k nastavení možností regulárního výrazu.

Tento výčet podporuje bitové kombinace hodnot jeho členů.

public enum class RegexOptions
[System.Flags]
public enum RegexOptions
[<System.Flags>]
type RegexOptions = 
Public Enum RegexOptions
Dědičnost
RegexOptions
Atributy

Pole

Compiled 8

Určuje, že regulární výraz je zkompilován do kódu MSIL místo toho, aby byl interpretován. Kompilované regulární výrazy maximalizují výkon za běhu na úkor inicializační doby. Tato hodnota by neměla být přiřazena Options vlastnosti při volání CompileToAssembly(RegexCompilationInfo[], AssemblyName) metody. Další informace najdete v části Kompilované regulární výrazy v článku Možnosti regulárních výrazů .

CultureInvariant 512

Určuje, že kulturní rozdíly v jazyce se ignorují. Další informace najdete v části Porovnání pomocí invariantní jazykové verze v článku Možnosti regulárních výrazů .

ECMAScript 256

Umožňuje chování kompatibilní s ECMAScriptem pro výraz. Tuto hodnotu lze použít pouze ve spojení s IgnoreCasehodnotou , Multilinea Compiled hodnotami. Použití této hodnoty s jinými hodnotami vede k výjimce.

Další informace o možnosti najdete v části "ECMAScript Matching Behavior" v článku Možnosti regulárních ECMAScript výrazů.

ExplicitCapture 4

Určuje, že jediné platné zachytávání jsou explicitně pojmenované nebo očíslované skupiny formuláře (?< name>...). To umožňuje, aby nenájmové závorky fungovaly jako nešiktické skupiny bez syntaktické složitosti výrazu (?:...). Další informace najdete v části Explicit Captures Only (Explicit Captures Only) v článku Možnosti regulárního výrazu .

IgnoreCase 1

Určuje porovnávání malých a malých písmen. Další informace najdete v části "Porovnávání malých a malých písmen" v článku Možnosti regulárních výrazů .

IgnorePatternWhitespace 32

Eliminuje neuskutečněné prázdné znaky ze vzoru a umožňuje komentáře označené znakem #. Tato hodnota ale nemá vliv na prázdné mezery ve třídách znaků, číselných kvantifikátorech nebo tokenech, které označují začátek jednotlivých prvků jazyka regulárního výrazu. Další informace najdete v části Ignorovat prázdné místo v článku Možnosti regulárních výrazů .

Multiline 2

Víceřádkový režim. Změní význam ^ a $ tak, aby odpovídaly na začátku a konci, v uvedeném pořadí, libovolného řádku, a ne pouze začátek a konec celého řetězce. Další informace najdete v části Režim víceřádkového režimu v článku Možnosti regulárních výrazů .

NonBacktracking 1024

Povolte porovnávání pomocí přístupu, který zabraňuje zpětnému navracení a zaručuje zpracování lineárního času v délce vstupu.

None 0

Určuje, že nejsou nastaveny žádné možnosti. Další informace o výchozím chování modulu regulárních výrazů najdete v části Výchozí možnosti v článku Možnosti regulárních výrazů .

RightToLeft 64

Určuje, že hledání bude zprava doleva místo zleva doprava. Další informace najdete v části Režim zprava doleva v článku Možnosti regulárních výrazů .

Singleline 16

Určuje režim s jedním řádkem. Změní význam tečky (.), aby odpovídal každému znaku (místo každého znaku kromě \n). Další informace najdete v části Režim s jedním řádkem v článku Možnosti regulárních výrazů .

Příklady

Následující příklad definuje dva regulární výrazy, které identifikují opakovaná slova v textu, ale vytvoří instanci pomocí různých RegexOptions hodnot. První regulární výraz je nerozlišující malá a velká písmena; při určování, zda je slovo stejné jako předchozí slovo, se ignoruje. Druhý regulární výraz je citlivý na malá a velká písmena; slovo musí odpovídat písmenu předcházejícího slova, aby bylo možné považovat za duplicitní.

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

Poznámky

Hodnotu RegexOptions lze poskytnout jako parametr následujícím členům Regex třídy:

Hodnotu RegexOptions lze také zadat jako parametr konstruktoru RegexCompilationInfo nebo ji lze přiřadit přímo k RegexCompilationInfo.Options vlastnosti. Výsledný RegexCompilationInfo objekt se pak použije ve volání Regex.CompileToAssembly metody.

Několik možností poskytovaných členy výčtu RegexOptions (zejména jeho ExplicitCapture, IgnoreCase, a Multiline``Singleline členy) lze místo toho poskytnout pomocí znaku vložené možnosti v vzoru regulárního výrazu. Podrobnosti najdete v tématu Možnosti regulárních výrazů.

Platí pro

Viz také