Regex: ignorar mayúsculas y minúsculas

¿Cómo puedo hacer que la siguiente expresión regular ignore mayúsculas y minúsculas? Debe coincidir con todos los caracteres correctos pero ignorar si son minúsculas o mayúsculas.

G[a-b].*

Suponiendo que desea que toda la expresión regular ignore las mayúsculas y minúsculas, debe buscar la ibandera . Casi todos los motores regex lo admiten:

/G[a-b].*/i

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

Consulte la documentación de su idioma / plataforma / herramienta para encontrar cómo se especifican los modos coincidentes.

Si desea que solo una parte de la expresión regular no distinga entre mayúsculas y minúsculas (como suponía mi respuesta original), tiene dos opciones:

1. Utilice los modificadores de modo (?i)y [opcionalmente] (?-i):

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

2. Ponga todas las variaciones (es decir, minúsculas y mayúsculas) en la expresión regular, útil si no se admiten modificadores de modo:

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

Una última nota: si se trata de caracteres Unicode además de ASCII, verifique si su motor de expresiones regulares los admite o no.

Depende de la implementación pero usaría

(?i)G[a-b].

Variaciones

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

Los sabores regex modernos le permiten aplicar modificadores a solo una parte de la expresión regular. Si inserta el modificador (? Im) en el medio de la expresión regular, entonces el modificador solo se aplica a la parte de la expresión regular a la derecha del modificador. Con estos sabores, puede desactivar los modos precediéndolos con un signo menos (? -I).

La descripción es de la página: https://www.regular-expressions.info/modifiers.html

expresión regular para validar 'abc' ignorando mayúsculas y minúsculas

(?i)(abc)

La ibandera se usa normalmente para la insensibilidad a mayúsculas y minúsculas. No das un idioma aquí, pero probablemente será algo así como /G[ab].*/io /(?i)G[ab].*/.

Solo por completo, quería agregar la solución para expresiones regulares en C ++ con Unicode:

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

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

Como descubrí en esta publicación similar ( ignorecase en AWK ), en versiones antiguas de awk (como en Mac OS X), es posible que deba usar 'tolower($0) ~ /pattern/'.

IGNORECASEo (?i)o /pattern/igenerará un error o devolverá verdadero para cada línea.

C#

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

específicamente: opciones: RegexOptions.IgnoreCase

[gG] [aAbB]. * probablemente una solución simple si el patrón no es demasiado complicado o largo.

Además de las respuestas ya aceptadas:

Uso de grep:

Tenga en cuenta que para grepello es simplemente la adición del -imodificador. Ej .: grep -rni regular_expressionpara buscar esta 'expresión_ regular' 'r'ecursivamente, use el caso' i'nsensitive, mostrando la línea 'n'umbers en el resultado.

Además, aquí hay una gran herramienta para verificar expresiones regulares: https://regex101.com/

Ej: Vea la expresión y explicación en esta imagen.

Referencias

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

En Java, el Regexconstructor tiene

Regex(String pattern, RegexOption option)

Entonces, para ignorar los casos, use

option = RegexOption.IGNORE_CASE

Puede practicar Regex en Visual Studio y Visual Studio Code usando buscar / reemplazar.

Debe seleccionar Coincidir mayúsculas y minúsculas para expresiones regulares con mayúsculas. De lo contrario [AZ] no funcionará. Ingrese la descripción de la imagen aquí

También puede dirigir su cadena inicial, que va a verificar para la coincidencia de patrones, en minúsculas. Y usando en su patrón símbolos en minúsculas respectivamente.