RegexOptions Výčet

Definice

Obor názvů:

System.Text.RegularExpressions

Sestavení:

System.Text.RegularExpressions.dll

Poskytuje výčtové hodnoty, 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

Object

ValueType

Enum

RegexOptions

Atributy

FlagsAttribute

Pole

Compiled	8	Určuje, že regulární výraz je zkompilován do kódu MSIL, místo aby byl interpretován. Kompilované regulární výrazy maximalizují výkon za běhu na úkor doby inicializace. 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 se budou ignorovat kulturní rozdíly v jazyce. Další informace najdete v části "Porovnání pomocí invariantní jazykové verze" v článku Možnosti regulárních výrazů .
ECMAScript	256	Povolí pro výraz chování kompatibilní s ECMAScriptem. Tuto hodnotu lze použít pouze ve spojení s IgnoreCasehodnotami , Multilinea Compiled . Při použití této hodnoty s jinými hodnotami dojde k výjimce. Další informace o této ECMAScript možnosti najdete v části "ECMAScript Matching Behavior" v článku Možnosti regulárních výrazů .
ExplicitCapture	4	Určuje, že jediné platné záznamy jsou explicitně pojmenované nebo čísloné skupiny formuláře (?<name>...). To umožňuje, aby nepojmenované závorky fungovaly jako neochvějné skupiny bez syntaktické neohrabanosti výrazu (?:...). Další informace najdete v části "Pouze explicitní zachycení" v článku Možnosti regulárního výrazu .
IgnoreCase	1	Určuje porovnávání bez rozlišování velkých a malých písmen. Další informace najdete v části Párování nerozlišující malá a velká písmena v článku Možnosti regulárních výrazů .
IgnorePatternWhitespace	32	Vyloučí ze vzoru prázdné místo bez zobrazení a povolí komentáře označené znakem #. Tato hodnota však neovlivňuje ani neodstraní prázdné znaky ve třídách znaků, numerických kvantifikátorech nebo tokenech, které označují začátek jednotlivých prvků jazyka regulárních výrazů. Další informace najdete v části Ignorovat prázdné znaky v článku Možnosti regulárního výrazu .
Multiline	2	Víceřádkový režim. Změní význam ^ a $ tak, aby se shodovaly na začátku a na konci libovolného řádku, a ne pouze na začátku a na konci celého řetězce. Další informace najdete v části Víceřádkový režim v článku Možnosti regulárního výrazu .
NonBacktracking	1024	Povolte porovnávání pomocí přístupu, který se vyhne zpětnému navracení a zaručuje lineární zpracování času v délce vstupu.
None	0	Určuje, že nejsou nastavené žá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ího výrazu .
Singleline	16	Určuje jednořádkový režim. Změní význam tečky (.), aby odpovídal všem znakům (místo všech znaků kromě \n). Další informace najdete v části Režim jednoho řádku 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 která jsou vytvořena pomocí různých RegexOptions hodnot. První regulární výraz nerozlišuje velká a malá písmena; při určování, zda je slovo shodné s předchozím slovem, se ignoruje. Druhý regulární výraz rozlišuje velká a malá písmena; slovo musí přesně odpovídat písmenu předcházejícího slova, aby bylo považováno za duplikát.

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:

• Konstruktor Regex.Regex(String, RegexOptions) třídy.

• Metoda Regex.Split(String, String, RegexOptions) .

• Metoda Regex.IsMatch(String, String, RegexOptions) .

• Metoda Regex.Match(String, String, RegexOptions) .

• Metoda Regex.Matches(String, String, RegexOptions) .

• Metody Regex.Replace(String, String, String, RegexOptions) a Regex.Replace(String, String, MatchEvaluator, RegexOptions) .

Hodnotu RegexOptions lze také zadat jako parametr konstruktoru RegexCompilationInfo nebo ji lze přiřadit přímo vlastnosti RegexCompilationInfo.Options . 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členy , IgnoreCaseMultiline, aSingleline) lze místo toho poskytnout pomocí znaku vložené možnosti ve vzoru regulárního výrazu. Podrobnosti najdete v tématu Možnosti regulárního výrazu.

Viz také

• Options
• Možnosti regulárního výrazu