RegexOptions RegexOptions RegexOptions RegexOptions Enum

Definição

Fornece valores enumerados para definir opções de expressão regular.Provides enumerated values to use to set regular expression options.

Esta enumeração tem um atributo FlagsAttribute que permite uma combinação bit a bit dos seus valores membros.

public enum class RegexOptions
[System.Flags]
public enum RegexOptions
type RegexOptions = 
Public Enum RegexOptions
Herança
Atributos

Campos

Compiled Compiled Compiled Compiled 8

Especifica que a expressão regular será compilada em um assembly.Specifies that the regular expression is compiled to an assembly. Isso leva a uma execução mais rápida, mas aumenta o tempo de inicialização.This yields faster execution but increases startup time. Esse valor não deve ser atribuído à propriedade Options ao chamar o método CompileToAssembly(RegexCompilationInfo[], AssemblyName).This value should not be assigned to the Options property when calling the CompileToAssembly(RegexCompilationInfo[], AssemblyName) method. Para obter mais informações, consulte a seção "Expressões regulares compiladas" no tópico Opções de expressão regular.For more information, see the "Compiled Regular Expressions" section in the Regular Expression Options topic.

CultureInvariant CultureInvariant CultureInvariant CultureInvariant 512

Especifica que as diferenças culturais no idioma serão ignoradas.Specifies that cultural differences in language is ignored. Para obter mais informações, consulte a seção "Comparação usando a cultura invariável" no tópico Opções de expressão regular.For more information, see the "Comparison Using the Invariant Culture" section in the Regular Expression Options topic.

ECMAScript ECMAScript ECMAScript ECMAScript 256

Habilita o comportamento em conformidad com ECMAScript para a expressão.Enables ECMAScript-compliant behavior for the expression. Esse valor pode ser usado somente em conjunto com os valores IgnoreCase, Multiline e Compiled.This value can be used only in conjunction with the IgnoreCase, Multiline, and Compiled values. O uso deste valor com qualquer outro valor resulta em uma exceção.The use of this value with any other values results in an exception.

Para obter mais informações sobre a opção ECMAScript, consulte a seção "Comportamento de correspondência ECMAScript" no tópico Opções de expressão regular.For more information on the ECMAScript option, see the "ECMAScript Matching Behavior" section in the Regular Expression Options topic.

ExplicitCapture ExplicitCapture ExplicitCapture ExplicitCapture 4

Especifica que as únicas capturas válidas são grupos explicitamente nomeados ou numerados do formato (?<name>…). Isso permite que parênteses sem nome funcionem como grupos que não são de captura, sem a confusão sintática da expressão (?:...). Para obter mais informações, consulte a seção "Apenas capturas explícitas" no tópico Opções de expressão regular.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

Especifica a correspondência sem diferenciação de maiúsculas e minúsculas.Specifies case-insensitive matching. Para obter mais informações, consulte a seção "Correspondência sem diferenciação de maiúsculas e minúsculas" no tópico Opções de expressão regular.For more information, see the "Case-Insensitive Matching " section in the Regular Expression Options topic.

IgnorePatternWhitespace IgnorePatternWhitespace IgnorePatternWhitespace IgnorePatternWhitespace 32

Elimina um espaço em branco sem escape do padrão e habilita comentários marcados por #.Eliminates unescaped white space from the pattern and enables comments marked with #. No entanto, esse valor não afeta nem elimina espaços em branco em classes de caracteres, em quantificadores numéricos nem em tokens que marcam o início dos elementos de idioma de expressão regular individuais.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. Para obter mais informações, consulte a seção "Ignorar espaço em branco" no tópico Opções de expressão regular.For more information, see the "Ignore White Space" section of the Regular Expression Options topic.

Multiline Multiline Multiline Multiline 2

Modo multilinha.Multiline mode. Altera o significado de ^ e $ de modo que eles correspondam ao início e ao final, respectivamente, de qualquer linha, e não apenas ao início e ao final da cadeia de caracteres inteira.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. Para obter mais informações, consulte a seção "Modo multilinha" no tópico Opções de expressão regular.For more information, see the "Multiline Mode" section in the Regular Expression Options topic.

None None None None 0

Especifica que nenhuma opção será definida.Specifies that no options are set. Para obter mais informações sobre o comportamento padrão do mecanismo de expressão regular, consulte a seção "Opções padrão" no tópico Opções de expressão regular.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

Especifica que a pesquisa se moverá da direita para a esquerda, em vez de se mover da esquerda para a direita.Specifies that the search will be from right to left instead of from left to right. Para obter mais informações, consulte a seção "Modo da direita para esquerda" no tópico Opções de expressão regular.For more information, see the "Right-to-Left Mode" section in the Regular Expression Options topic.

Singleline Singleline Singleline Singleline 16

Especifica o modo de linha única.Specifies single-line mode. Altera o significado do ponto (.) para que coincida com cada caractere (em vez de cada caractere exceto \n).Changes the meaning of the dot (.) so it matches every character (instead of every character except \n). Para obter mais informações, consulte a seção "Modo de linha única" no tópico Opções de expressão regular.For more information, see the "Single-line Mode" section in the Regular Expression Options topic.

Exemplos

O exemplo a seguir define duas expressões regulares que identificam palavras repetidas no texto, mas que são RegexOptions instanciadas usando valores diferentes.The following example defines two regular expressions that identify repeated words in text but that are instantiated using different RegexOptions values. A primeira expressão regular não diferencia maiúsculas de minúsculas; o caso é ignorado ao determinar se uma palavra é idêntica à palavra anterior.The first regular expression is case-insensitive; case is ignored when determining whether a word is identical to the preceding word. A segunda expressão regular diferencia maiúsculas de minúsculas; uma palavra deve corresponder exatamente ao caso da palavra anterior para ser considerada uma duplicata.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

Comentários

Um RegexOptions valor pode ser fornecido como um parâmetro para os seguintes membros Regex da classe:A RegexOptions value can be provided as a parameter to the following members of the Regex class:

Um RegexOptions valor também pode ser fornecido como um parâmetro para o RegexCompilationInfo Construtor ou pode RegexCompilationInfo.Options ser atribuído diretamente à propriedade.A RegexOptions value can also be supplied as a parameter to the RegexCompilationInfo constructor, or it can be assigned directly to the RegexCompilationInfo.Options property. O objeto RegexCompilationInfo resultante é então usado na chamada para o Regex.CompileToAssembly método.The resulting RegexCompilationInfo object is then used in the call to the Regex.CompileToAssembly method.

Várias opções fornecidas por membros da RegexOptions Enumeração (em particular, por seus ExplicitCaptureMembros, IgnoreCase Multiline, e Singleline ) podem ser fornecidas usando um caractere de opção embutida na expressão regular padrão.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. Para obter detalhes, consulte Opções de expressão regular.For details, see Regular Expression Options.

Aplica-se a

Veja também