Regex Modifiers-Turning them On

Esta é uma página de referência – não sinta que tem de a ler, pois é bastante concisa. Outras seções se conectam a ela quando necessário.
Regex modificadores aparecem em cada canto deste site. Ao invés de explicar repetidamente o que eles fazem e as múltiplas maneiras de ligá-los em cada sabor regex, eu decidi reunir os quatro comuns (i, s, m e x) em um só lugar. A seção final pesquisa brevemente outros modificadores, que geralmente são específicos de cada idioma.
Pontos de Salto
Para facilitar a navegação, aqui estão alguns pontos de salto para várias seções da página:
✽ Insensibilidade do Caso: i
✽ DOTALL (Dot Match Line Breaks): s (exceto Ruby e JavaScript)
✽ Multiline (^ e $ Match on Every Line): m (excepto Ruby)
✽ Espaçamento livre: x (excepto JavaScript)
✽ Outros modificadores
✽ Modificadores especiais de arranque de padrão PCRE
(link directo)

Insensibilidade de caso: i

Por defeito, todos os principais motores regex coincidem em modo sensível a maiúsculas e minúsculas. Se você quiser padrões como o Name: + para combinar em modo não sensível a maiúsculas e minúsculas, precisamos ligar essa funcionalidade.
Sim, mas…
O que significa realmente não sensível a maiúsculas e minúsculas?
Desde que você se mantenha fiel às 26 letras do alfabeto inglês, a definição de maiúsculas e minúsculas é simples. Quando você se ramifica para niceties tipográficos ou outros idiomas e scripts, as coisas nem sempre são tão simples. Aqui estão algumas perguntas que você pode encontrar em.
✽ Will fl (um caractere, ou seja, a ligadura fl) combina FL?
✽ Will à (um caractere) combina À?
✽ Will à (dois caracteres, ou seja, a letra a e o acento grave) combina À? Todos os motores parecem lidar corretamente com isso.
✽ Irá ß corresponder à ss? Nenhum motor parece fazer isso.
✽ Será que eu vou corresponder a İ (turco capital i) assim como I?
Estas perguntas são apenas a ponta do iceberg. Mesmo se eu soubesse todas as respostas, seria impossível incluí-las todas nesta seção: se você usar um script em particular, você precisará pesquisar como seu motor específico lida com a correspondência não sensível a maiúsculas e minúsculas nesse script.
Mais de uma maneira
Para vários motores, note que há duas maneiras de ligar a correspondência não sensível a minúsculas: como um modificador em linha (?i) ou como uma opção no método ou função regex.
Inline Modifier (?i)
In .NET, PCRE (C, PHP, R…), Perl, Python, Java e Ruby (mas não JavaScript), você pode usar o modificador inline (?i), por exemplo em (?i)cat. Veja a seção sobre modificadores inline para detalhes suculentos sobre três recursos adicionais (não disponíveis em Python): ligá-lo no meio da corda, desligá-lo com (?-i), ou aplicá-lo apenas ao conteúdo de um grupo não-capturado com (?i:foo)

.NET
Parte do modificador (?i) inline, as linguagens .NET têm a opção IgnoreCase. Por exemplo, em C# você pode usar:
var catRegex = new Regex("cat", RegexOptions.IgnoreCase);
Perl
Apart do modificador inline (?i), Perl permite que você adicione a bandeira i após o delimitador de fechamento do seu padrão. Por exemplo, você pode usar:
if ($the_subject =~ m/cat/i) { … }
PCRE (C, PHP, R…)
Nota que em PCRE, para usar correspondência não sensível a maiúsculas e minúsculas que não fazem parte do seu local, você terá que ativar o modificador Unicode – por exemplo, com o modificador especial de início de padrão (*UTF8).
Parte do modificador (?i) inline modifier, PCRE permite que você configure o modo PCRE_CASELESS quando chamar a função pcre_compile() (ou similar):

cat_regex = pcre_compile( "cat", PCRE_CASELESS, &error, &erroroffset, NULL ); 

No PHP, a opção PCRE_CASELESS é passada através da bandeira i, que você pode adicionar na sua string regex após o delimitador de fechamento. Por exemplo, você pode usar:
$cat_regex = '~cat~i';
Em R, a opção PCRE_CASELESS é passada através da opção ignore.case=TRUE. Por exemplo, você pode usar:
grep("cat", subject, perl=TRUE, value=TRUE, ignore.case=TRUE);
Python
Uma parte do modificador (?i) inline, Python tem a opção IGNORECASE. Por exemplo, você pode usar:
cat_regex = re.compile("cat", re.IGNORECASE)
Java
Parte do modificador inline (?i), Java tem a opção CASE_INSENSITIVE. Por exemplo, você pode usar:

Pattern catRegex = Pattern.compile( "cat", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE );

A opção UNICODE_CASE adicionada aqui garante que a característica de insensibilidade a maiúsculas e minúsculas seja Unicode-aware. Se você estiver trabalhando apenas com ASCII, você não precisa usá-lo.
JavaScript
Em JavaScript, sua única opção é adicionar a bandeira i após o delimitador de fechamento do seu padrão. Por exemplo, você pode usar:
019
Ruby
Parte do modificador (?i) em linha, Ruby permite-lhe adicionar a bandeira i após o delimitador de fecho do seu padrão. Por exemplo, você pode usar:
cat_regex = /cat/i
(link directo)

DOTALL (Dot Match Line Breaks): s (com excepções)

Por defeito, o ponto . não corresponde a caracteres de quebra de linha tais como line feeds e retornos de carruagem. Se você quiser padrões como BEGIN .*? END para combinar entre linhas, precisamos ativar esse recurso em.
Este modo é às vezes chamado de linha única (daí os s) porque, no que diz respeito ao ponto, ele transforma toda a string em uma grande linha.* irá combinar do primeiro caractere ao último, não importa quantas quebras de linha fiquem no meio.

O modo também é chamado de DOTALL em PCRE, Python e Java (para ser mais preciso, a documentação do PCRE usa PCRE_DOTALL). Para mim, o nome DOTALL é uma forma sensata de chamar este modo. A terceira opção dot-matches-line-breaks é descritiva, mas um pouco bocado boca-a-boca.
Para vários motores, note que existem duas maneiras de ligá-lo: como um modificador em linha ou como uma opção no método regex ou função.
JavaScript
JavaScript não suporta o modo de linha única. Para combinar qualquer caractere em JavaScript, incluindo quebras de linha, use uma construção como . Esta classe de caracteres corresponde a um caractere que ou é um dígito \D ou um dígito \d. Portanto, ela corresponde a qualquer caractere.
Uma outra solução JavaScript é usar a biblioteca regex do XRegExp. Se você tem tempo infinito em suas mãos, você também pode tentar portar o PCRE para JavaScript usando Emscripten, como Firas parece ter feito no regex 101.
Inline Modifier (?s)
In .NET, PCRE (C, PHP, R…), Perl, Python e Java (mas não Ruby), você pode usar o modificador inline (?s), por exemplo em (?s)BEGIN .*? TERMINAR. Veja a seção sobre modificadores inline para detalhes suculentos sobre três características adicionais (não disponíveis em Python): ligá-lo no meio da corda, desligá-lo com (?-s), ou aplicá-lo apenas ao conteúdo de um grupo não-capturado com (?s:foo)
.NET
Parte do modificador inline (?s), as linguagens .NET têm a opção Linha Única. Por exemplo, em C# você pode usar:

var blockRegex = new Regex( "BEGIN .*? END", RegexOptions.IgnoreCase | RegexOptions.Singleline );

Perl
Uma parte do modificador inline (?s), Perl permite que você adicione a bandeira s após o delimitador de fechamento do seu padrão. Por exemplo, você pode usar:
if ($the_subject =~ m/BEGIN .*? END/s) { … }
PCRE (C, PHP, R…)
Parte do modificador inline (?s), PCRE permite que você defina o modo PCRE_DOTALL quando chamar a função pcre_compile() (ou similar):

block_regex = pcre_compile( "BEGIN .*? END", PCRE_DOTALL, &error, &erroroffset, NULL ); 

Em PHP, a opção PCRE_DOTALL é passada através da bandeira s, que você pode adicionar na sua string regex após o delimitador de fechamento. Por exemplo, você pode usar:
$block_regex = '~BEGIN .*? END~s';
Python
Parte do modificador inline (?s), Python tem a opção DOTALL. Por exemplo, você pode usar:
block_regex = re.compile("BEGIN .*? END", re.IGNORECASE | re.DOTALL)
Java
Uma parte do modificador inline (?s), Java tem a opção DOTALL. Por exemplo, você pode usar:

Pattern blockRegex = Pattern.compile( "BEGIN .*? END", Pattern.CASE_INSENSITIVE | Pattern.DOTALL ); 

Ruby: (?m) modificador e m flag
Em Ruby, você pode usar o modificador inline (?m), por exemplo, em (?m)BEGIN .*? END. Esta é uma peculiar peculiaridade do Ruby como outros motores usam (?m) para o modo “^ e $ match em cada linha”.
Veja a secção sobre modificadores inline para detalhes suculentos sobre três características adicionais: ligá-lo no meio da string, desligá-lo com (?-m), ou aplicá-lo apenas ao conteúdo de um grupo não-capturado com (?m:foo)
Ruby também lhe permite adicionar a bandeira m no final da sua string regex. Por exemplo, você pode usar:
block_regex = /BEGIN .*? END/m
(link direto)
Origins of DOTALL
O modo de linha única também é frequentemente chamado DOTALL (que significa “ponto combina com todos”) por causa da opção PCRE_DOTALL em PCRE, a opção re.DOTALL em Python e a opção Pattern.DOTALL em Java.
Ouvi dizer várias vezes que “DOTALL é uma coisa Python” mas isto parecia vir de pessoas que não tinham ouvido falar sobre as opções equivalentes em PCRE e Java. Ainda assim isso me fez pensar: onde DOTALL apareceu primeiro? Olhando para o Registro de Mudanças do PCRE e a documentação antiga do Python, parece que ele apareceu no PCRE com a versão 0.96 (outubro de 1997), no Python com a versão 1.5 (fevereiro de 1998), depois no Java 1.4 (fevereiro de 2002). A lacuna entre as introduções do PCRE e Python não era conclusiva – a palavra poderia estar em circulação em versões beta anteriores, ou mesmo em outras ferramentas – então eu perguntei a Philip Hazel (o pai do PCRE) sobre isso. Ele respondeu:

Eu acredito que o inventei – eu certamente não o tinha visto em outro lugar quando estava tentando pensar em um nome para a opção PCRE que correspondesse à opção /s do Perl. (“S” ali significa “single-line” (…) então eu queria um nome melhor.)

Então ali. Aqueles que gostam de um pouco de história podem apreciar este saboroso nugget.
(link directo)

Multiline (^ e $ Match on Every Line): m (excepto Ruby)

Por defeito, em todos os motores principais excepto Ruby, as ^ e $ só combinam (respectivamente) no início e no fim da string.
Em Ruby, combinam no início e no fim de cada linha, e não há forma de desligar essa funcionalidade. Esta é realmente uma forma razoável de fazer as coisas, com a qual o Ruby se redime parcialmente por usar m para o modo DOTALL quando outros motores usam s.
Em outros motores, se quiser padrões como ^Define e >>>$ para coincidir (respectivamente) no início e no fim de cada linha, precisamos de ligar essa funcionalidade.
Esta funcionalidade é normalmente chamada multi-linhas (daí o m) porque as âncoras ^ e $ funcionam em várias linhas.

Para vários motores, note que existem duas maneiras de ligá-lo: como um modificador inline (?m) ou como uma opção no método regex ou função.
Ruby
Em Ruby, as ^ âncoras e $ sempre combinam em todas as linhas. Não há maneira de desligar esta opção. Esta é realmente uma boa maneira de fazer as coisas, uma vez que, como na maioria dos sabores, existem âncoras separadas para o início e fim das strings: \A, \Z e \z.
Por outro lado, pode-se lamentar a escolha do Ruby de usar a bandeira m e o modificador de uma forma não padrão (ver DOTALL).
Inline Modifier (?m)
In .NET, PCRE (C, PHP, R…), Perl, Python, Java e Ruby (mas não JavaScript), pode-se usar o modificador inline (?m), por exemplo em (?m)^cat. Veja a seção sobre modificadores inline para detalhes suculentos sobre três características adicionais (não disponíveis em Python): ligá-lo no meio da corda, desligá-lo com (?-m), ou aplicá-lo apenas ao conteúdo de um grupo não-capturado com (?m:foo)
.NET
Parte do modificador inline (?m), as linguagens .NET têm a opção Multiline. Por exemplo, em C# você pode usar:

var catRegex = new Regex("^cat", RegexOptions.IgnoreCase | RegexOptions.Multiline); 

Perl
Uma parte do modificador (?m) inline, Perl permite adicionar a bandeira m após o delimitador de fechamento do seu padrão. Por exemplo, você pode usar:
if ($the_subject =~ m/^cat/m) { … }
PCRE (C, PHP, R…)
Parte do modificador (?m) inline, PCRE permite que você defina o modo PCRE_MULTILINE quando chamar a função pcre_compile() (ou similar):

Em PHP, a opção PCRE_MULTILINE é passada através da bandeira m, que você pode adicionar na sua string regex após o delimitador de fechamento. Por exemplo, você pode usar:
$cat_regex = '~^cat~m';
Python
Parte do modificador (?m) em linha, Python tem a opção MULTILINE. Por exemplo, você pode usar:
cat_regex = re.compile("^cat", re.IGNORECASE | re.MULTILINE)
Java
Parte do modificador inline (?m), Java tem a opção MULTILINE. Por exemplo, você pode usar:

Pattern catRegex = Pattern.compile( "^cat", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE ); 

JavaScript
Em JavaScript, sua única opção é adicionar a bandeira m após o delimitador de fechamento do seu padrão. Por exemplo, você pode usar:
var catRegex = /^cat/m;
(link direto)

Free-Spacing: x (exceto JavaScript)

Por padrão, qualquer espaço em uma string regex especifica um caractere a ser correspondido. Em linguagens onde você pode escrever strings regex em várias linhas, as quebras de linha também especificam caracteres literais a serem correspondidos. Como você não pode inserir espaços para separar grupos que possuem significados diferentes (como você faz entre frases e pragrafos quando escreve em inglês), um regex pode tornar-se difícil de ler, como por exemplo o Meaning of Life regex da página de humor regex:

^(?=(?!(.))()(?-1)(?<!\d(?<=(?!)\d))).$
Felizmente, muitos motores suportam um modo de espaçamento livre que permite que você areje o seu regex. Por exemplo, você pode adicionar espaços entre os tokens. No PHP, você poderia escrever esta nota a bandeira x após o delimitador final ~:
$word_with_digit_and_cap_regex = '~ ^ (?=\D*\d) \w*\w* $ ~x';
Mas por que ficar em uma linha? Você pode espalhar seu regex por tantas linhas quantas quiser – inserindo e adicionando comentários – que são introduzidos por um #. Por exemplo, em C# você pode fazer algo como isto:

var wordWithDigitAndCapRegex = new Regex(@"(?x) # Free-spacing mode ^ # Assert that position = beginning of string ######### Lookahead ########## (?= # Start lookahead \D* # Match any non-digits \d # Match one digit ) # End lookahead ######## Matching Section ######## \w* # Match any word chars # Match one upper-case letter \w* # Match any word chars $ # Assert that position = end of string");

Este modo é chamado de modo de espaçamento livre. Você também pode vê-lo chamado de modo espaço em branco, modo comentário ou modo verboso.
Pode ser exagerado em um regex simples como o acima (embora qualquer um que tenha que manter seu código lhe agradecerá por isso). Mas se você está construindo um padrão regex sério como o do truque para combinar números em inglês simples… A menos que você seja um masoquista, você não tem escolha.
Note que dentro de uma classe de caracteres, o caractere de espaço e o # (que de outra forma introduz comentários) ainda são honrados – exceto em Java, onde ambos precisam ser escapados se você pretende combinar esses caracteres.
Para vários motores, há duas maneiras de ligar o modo de espaçamento livre: como um modificador em linha ou como uma opção no método regex ou função.
O modo de espaçamento livre é maravilhoso, mas há um par de perigos menores que você deve estar ciente, pois podem deixá-lo coçando a cabeça se perguntando por que um padrão não está funcionando como você espera.
Perigo de viagem #1: O significado do espaço
Primeiro, você não pode mais usar a função Número: \D+ para corresponder a uma string como Número: 24. A razão é que o espaço em : \já não corresponde a um espaço. Estamos no modo de espaçamento livre, lembra-se? Esse é o ponto.
Para corresponder a um caractere de espaço, você precisa especificá-lo. As duas principais formas de o fazer são colocá-lo dentro de uma classe de caracteres, ou escapar-lhe com uma barra invertida. Qualquer uma dessas formas funcionaria: Number:\d+ ou Number:\d+

Of course Number:\d+ também funcionaria, mas lembrem-se que o número:\d+ corresponde a muito mais do que um carácter de espaço. Por exemplo, poderia corresponder a uma aba ou a uma quebra de linha. Isto pode não ser o que você quer.
Perigo de Abertura #2: Início Tardio
Segundo, você pode ficar muito confiante no poder do espaçamento livre e tentar algo assim para deixar o regex por si mesmo:

O problema com isto é que embora possa parecer como se fosse um modificador de espaçamento livre (?x) é a primeira coisa no seu regex, não é.
Após a abertura de aspas duplas”, temos uma quebra de linha e um número de espaços. O motor tenta igualá-los, porque nessa fase ainda não estamos no modo de espaçamento livre. Esse modo só é ligado quando nos deparamos (?x). Este regex nunca irá coincidir com a string etc e mais, porque quando encontramos o início da ^ ^ ^ ^ da string, é suposto já termos correspondido uma quebra de linha e caracteres de espaço!
É por isso que se olhar para o primeiro exemplo, verá que o modificador de espaçamento livre (?x) é a primeira coisa a seguir ao caractere de abertura da citação.
O espaço em branco não é apenas aparado do padrão
O espaço em branco é ignorado, a posição de um espaço em branco ainda separa o símbolo anterior do seguinte. Por exemplo,
✽ (A)\1 2 não é o mesmo que (A)\12. O primeiro corresponde a AA2, o segundo corresponde a A\n em .NET, PCRE, Perl e Ruby (12 é o código octal para o caractere linefeed)
✽ \p{Nd} é válido, mas \p{N d} não é excepção em Perl e Ruby
JavaScript
JavaScript não suporta o modo de espaçamento livre. Em JavaScript, para combinar qualquer caractere incluindo quebras de linha, use uma construção tal como . Esta classe de caracteres corresponde a um caracter que ou é um caracter que não tem dígito \D ou um dígito \d. Portanto, ela corresponde a qualquer caractere.
Uma outra solução JavaScript é usar a biblioteca regex do XRegExp. Se você tem tempo infinito em suas mãos, você também pode tentar portar o PCRE para JavaScript usando Emscripten, como Firas parece ter feito no regex 101.
Inline Modifier (?s)
In .NET, PCRE (C, PHP, R…), Perl, Python, Java e Ruby (mas não JavaScript), você pode usar o modificador inline (?x), por exemplo, este é um regex aerado para combinar palavras repetidas:
(?x) (\w+) + \bVeja também a secção sobre modificadores inline.
.NET
Parte do modificador inline (?x), as linguagens .NET têm a opção IgnorePatternWhitespace. Por exemplo, em C# você pode usar:

var repeatedWordRegex = new Regex(@" (\w+) + \b", RegexOptions.IgnorePatternWhitespace );

Perl
Apart do modificador (?x) inline, Perl permite que você adicione a bandeira x após o delimitador de fechamento do seu padrão. Por exemplo, você pode usar:
if ($the_subject =~ m/(\w+) + \b/x) { … }
PCRE (C, PHP, R…)
Parte do modificador inline (?x), PCRE permite que você defina o modo PCRE_EXTENDED quando chamar a função pcre_compile() (ou similar):

repeated_word_regex = pcre_compile( "(\w+) + \b", PCRE_EXTENDED, &error, &erroroffset, NULL ); 

Em PHP, a opção PCRE_EXTENDED é passada através da bandeira x, que você pode adicionar na sua string regex após o delimitador de fechamento. Por exemplo, você pode usar:
$repeated_word_regex = '~(\w+) + \b~x';
Python
Parte do modificador (?x) em linha, Python tem a opção VERBOSE. Por exemplo, você pode usar:
repeated_word_regex = re.compile(r"(\w+) + \b", re.VERBOSE)
Java
Unlike em outros motores, dentro de um hashes de classe de caracteres Java introduz comentários e espaços são ignorados, então você precisa escapar deles se quiser usar esses caracteres em uma classe, por exemplo, +
Apart do modificador inline (?x), Java tem a opção COMENTÁRIOS. Por exemplo, você pode usar:

Pattern repeatedWordRegex = Pattern.compile( "(\w+) + \1\b", Pattern.COMMENTS );

Ruby
Apart from the (?x) inline modifier, Ruby permite que você adicione a bandeira x no final da sua string regex. Por exemplo, você pode usar:
repeated_word_regex = /(\w+) + \b/x
(link direto)

Outros modificadores

Alguns motores suportam modificadores e flags além de i, s, m e x. Eu planejo cobrir aqueles nas páginas dedicadas a esses sabores.
Por exemplo,
✽ .NET tem o modificador (?n) (também acessível através da opção ExplicitCapture). Isto transforma todos (parênteses) em grupos não-capturados. Para capturar, você deve usar grupos nomeados.
✽ Java tem o modificador (?d) (também acessível através da opção UNIX_LINES). Quando este está ligado, o caractere de alimentação de linha \n é o único que afeta o ponto . (que não corresponde a quebras de linha a menos que DOTALL esteja ligado) e as ^ e $ (que correspondem a inícios e finais de linha no modo multi-linha.)
✽ Perl tem várias outras bandeiras. Veja a seção de documentação do modificador.
✽ PCRE tem o modificador (?J) (também disponível em código através da opção PCRE_DUPNAMES). Quando definido, diferentes grupos de captura podem usar o mesmo nome – embora lhes sejam atribuídos números diferentes.
(direct link)
✽ PCRE tem o modificador (?U) (também disponível em código através da opção PCRE_UNGREEDY). Quando definidos, os quantificadores são, por omissão, pouco fiáveis. Anexando um ? torna-os gananciosos.

(link direto)
✽ PCRE tem o modificador (?X) (também disponível em código através da opção PCRE_EXTRA). Historicamente, este modo tem sido usado para habilitar novos recursos em desenvolvimento. No momento, ele aciona erros se tokens como \B forem usados em uma classe de caracteres (onde normalmente combina com a letra maiúscula B, ao contrário de fora de uma classe de caracteres, onde é uma afirmação não limitada a palavras).
✽ PCRE tem vários modificadores especiais que podem ser definidos no início do padrão (estes são mostrados abaixo). Além disso, muitas opções podem ser enviadas para a família de funções pcre_compile(), se você tiver acesso a elas. Para detalhes sobre elas, obtenha pcre_compile.html na pasta doc baixando PCRE.
(direct link)

PCRE’s Special Start-of-Pattern Modifiers

PCRE tem um número de “modificadores especiais” que você pode definir no início de um padrão. Ao invés da sintaxe padrão (?z) para modificadores em linha, a sintaxe do modificador especial se parece com (*MYMODIFIER). Estes modificadores são particularmente úteis em contextos onde o PCRE está integrado dentro de uma ferramenta ou de uma linguagem – pois eles substituem um número de opções que você enviaria para pcre_compile().
UTF Strings
Assumindo que o PCRE é compilado com as opções relevantes, você pode instruir o mecanismo para tratar a string sujeita como vários tipos de strings UTF.
✽ (*UTF) é uma maneira genérica de tratar o sujeito como uma string-detectando se ele deve ser tratado como UTF-8, UTF-16 ou UTF-32.
✽ (*UTF8), (*UTF16) e (*UTF32) tratam a string como uma das três codificações UTF específicas.
Propriedades Unicode para \d e \w
Por padrão, \d só combina com dígitos ASCII, enquanto \w só combina com dígitos ASCII, letras e sublinhados.
O modificador (*UCP) (que significa Unicode Character Properties) permite que estes tokens correspondam aos dígitos Unicode e aos caracteres das palavras.
Por exemplo, (*UCP)\d+ :: \w+ corresponde a 1۳۲١८৮੪ :: Aれま래도ᚠᚱᚩ
(Veja demo).
Em combinação com (*UCP), você também pode precisar usar um dos modificadores (*UTF). Para ver como isso funciona, considere a saída desse programa com um PHP padrão Xampp:

$string = '1۳۲١८৮੪ :: Aれま래도ᚠᚱᚩ';$utfregex = "~\d+ :: \w+~";$utfregex = "~(*UCP)\d+ :: \w+~";$utfregex = "~(*UTF)(*UCP)\d+ :: \w+~";$utfregex = "~(*UTF)\d+ :: \w+~";$utfregex = "~\d+ :: \w+~u";foreach (range(0, 4) as $i) { echo "$i: ".preg_match($utfregex,$string)."<br />"; }// Output:// 0: 0// 1: 0// 2: 1 => (*UTF)(*UCP)// 3: 0// 4: 1 => The u flag produces the same result as (*UTF)(*UCP)

Line Break Modifiers
Por padrão, quando PCRE é compilado, você diz a ele o que considerar como uma quebra de linha ao encontrar um . (como o ponto não combina com quebras de linha a menos que no modo pontoall), assim como o comportamento dos ^ e $ anchors no modo multilinha. Você pode sobrepor este padrão com os seguintes modificadores:
✽ (*CR) Apenas um retorno de linha é considerado uma quebra de linha
✽ (*LF) Apenas um feed de linha é considerado uma quebra de linha (como no Unix)
✽ (*CRLF) Apenas um retorno de linha seguido por um feed de linha é considerada uma quebra de linha (como no Windows)
✽ (*ANYCRLF) Qualquer uma das três acima é considerada uma quebra de linha
✽ (*ANY) Qualquer sequência de linha nova Unicode é considerada uma quebra de linha
Por exemplo, (*CR)\i+.\w+ coincide com a linha 1\nLinha2 porque o ponto é capaz de coincidir com a linha 1\n, o que não é considerado como uma quebra de linha. Veja demo.
Controlling \\R
Por padrão, o metacaracter \R corresponde a qualquer sequência de nova linha Unicode. Quando o modo UTF-8 está desligado, estas novas sequências de linha são o par \r\n, bem como o retorno da carruagem, alimentação de linha, tabulação vertical, alimentação de formulário ou caracteres da linha seguinte. No modo UTF-8, o símbolo também corresponde ao separador de linha e ao separador de parágrafo.
Dois modificadores de início de padrão permitem alterar o comportamento de \R:
✽ Com (*BSR_ANYCRLF), \R corresponde apenas à sequência \r,r ou \n. Isto também pode ser definido quando o PCRE é compilado ou solicitado através da opção PCRE_BSR_ANYCRLF
✽ Com (*BSR_UNICODE), \R corresponde a qualquer sequência de nova linha Unicode (substituindo a opção PCRE_BSR_ANYCRLF se definida). Isto também pode ser definido quando PCRE é compilado ou solicitado através da opção PCRE_BSR_UNICODE
Controlling Runaway Patterns
Para limitar o número de vezes que PCRE chama a função match(), use o modificador (*LIMIT_MATCH=x), definindo x para o número desejado.
Para limitar a recorrência, use (*LIMIT_RECURSION=d), definindo d para o nível de recorrência mais profundo permitido.
Otimizações de Desactivação
(link directo)
Por defeito, o PCRE estuda o padrão e faz automaticamente um token atómico quantificado quando o token seguinte é incompatível – por exemplo, transformando A+X em A++X. O modificador (*NO_AUTO_POSSESS) desactiva esta optimização. Use isto quando quiser usar o pcretest para comparar dois padrões e se sentir bem com todos os ciclos que a auto-possification está salvando você.
Por padrão, o PCRE executa várias otimizações para descobrir mais rapidamente se uma combinação falhará. O modificador (*NO_START_OPT) desabilita essas otimizações.
Desabilitar partidas vazias
Em PCRE2, (*NOTEMPTY) diz ao mecanismo para não retornar partidas vazias. Da mesma forma, (*NOTEMPTY_ATSTART) diz ao motor para não retornar correspondências vazias encontradas no início do assunto.
Desabilitando a otimização automática da ancoragem
Em PCRE2, PCRE2_NO_DOTSTAR_ANCHOR diz ao motor para não ancorar automaticamente os padrões que começam com .*
Pode ler mais sobre esta bandeira na página PCRE2 API (procure por PCRE2_NO_DOTSTAR_ANCHOR).

Não perca The Regex Style Guide
e The Best Regex Trick Ever!!!!

As 1001 formas de usar Regex