Regex: ignorar distinção entre maiúsculas e minúsculas

Como posso fazer o seguinte regex ignorar a distinção entre maiúsculas e minúsculas? Ele deve corresponder a todos os caracteres corretos, mas ignora se são minúsculos ou maiúsculos.

G[a-b].*

Supondo que você queira que toda a regex ignore maiúsculas e minúsculas, procure o isinalizador . Quase todos os mecanismos regex suportam:

/G[a-b].*/i

string.match("G[a-b].*", "i")

Verifique a documentação do seu idioma / plataforma / ferramenta para descobrir como os modos correspondentes são especificados.

Se você deseja que apenas parte da regex não diferencie maiúsculas de minúsculas (como minha resposta original presumiu), você tem duas opções:

1. Use os modificadores de modo (?i)e [opcionalmente] (?-i):

   (?i)G[a-b](?-i).*

2. Coloque todas as variações (ou seja, minúsculas e maiúsculas) no regex - útil se os modificadores de modo não forem suportados:

   [gG][a-bA-B].*

Uma última observação: se você estiver lidando com caracteres Unicode além do ASCII, verifique se o mecanismo de expressão regular os suporta ou não.

Depende da implementação, mas eu usaria

(?i)G[a-b].

VARIAÇÕES:

(?i) case-insensitive mode ON    
(?-i) case-insensitive mode OFF

Os tipos modernos de expressões regulares permitem aplicar modificadores apenas a parte da expressão regular. Se você inserir o modificador (? Im) no meio da regex, o modificador se aplicará apenas à parte da regex à direita do modificador. Com esses sabores, você pode desativar os modos precedendo-os com um sinal de menos (? -I).

Descrição é da página: https://www.regular-expressions.info/modifiers.html

expressão regular para validar 'abc' ignorando maiúsculas de minúsculas

(?i)(abc)

O isinalizador é normalmente usado para diferenciar maiúsculas de minúsculas. Você não dá um idioma aqui, mas provavelmente será algo como /G[ab].*/iou /(?i)G[ab].*/.

Por uma questão de integridade, eu queria adicionar a solução para expressões regulares em C ++ com Unicode:

std::tr1::wregex pattern(szPattern, std::tr1::regex_constants::icase);

if (std::tr1::regex_match(szString, pattern))
{
...
}

Como descobri nesta postagem semelhante (caso ignorado no AWK ), nas versões antigas do awk (como no van OS Mac OS X), talvez você precise usá-lo 'tolower($0) ~ /pattern/'.

IGNORECASEou (?i)ou /pattern/igerará um erro ou retornará true para cada linha.

C #

using System.Text.RegularExpressions;
...    
Regex.Match(
    input: "Check This String",
    pattern: "Regex Pattern",
    options: RegexOptions.IgnoreCase)

especificamente: opções: RegexOptions.IgnoreCase

[gG] [aAbB]. * provavelmente solução simples se o padrão não for muito complicado ou longo.

Além das respostas já aceitas:

Uso de Grep:

Observe que, para grepisso, é simplesmente a adição do -imodificador. Ex: grep -rni regular_expressionpara procurar essa expressão 'regular' 'recursivamente, maiúsculas e minúsculas' i'ensensitive, mostrando a linha 'n'umbers no resultado.

Além disso, aqui está uma ótima ferramenta para verificar expressões regulares: https://regex101.com/

Ex: Veja a expressão e a explicação nesta imagem.

Referências:

• páginas de manual ( man grep)
• http://droptips.com/using-grep-and-ignoring-case-case-insensitive-grep

Em Java, o Regexconstrutor tem

Regex(String pattern, RegexOption option)

Então, para ignorar casos, use

option = RegexOption.IGNORE_CASE

Você pode praticar o Regex no Visual Studio e no Visual Studio Code usando localizar / substituir.

Você precisa selecionar Correspondência entre maiúsculas e minúsculas para expressões regex com maiúsculas e minúsculas. Senão [AZ] não funcionará. Introduza a descrição da imagem aqui

Você também pode levar sua string inicial, que você procurará pela correspondência de padrões, para minúsculas. E usando no seu padrão símbolos em minúsculas, respectivamente.