Una guía completa de expresiones regulares de C++: desde aplicaciones básicas hasta aplicaciones avanzadas

1. Conocimientos básicos

Una expresión regular es un patrón de cadena que se utiliza para hacer coincidir, buscar y editar texto. Consta de una serie de caracteres y símbolos especiales que pueden expresar de manera flexible el patrón, la estructura y las características del texto. Las expresiones regulares se utilizan ampliamente en varios lenguajes y aplicaciones de programación, incluido C++. Se puede utilizar para buscar cadenas de patrones específicos en el texto, verificar el formato de entrada, extraer información y realizar reemplazo de texto y otras operaciones.

Los elementos básicos de las expresiones regulares incluyen caracteres ordinarios (como letras, números y símbolos), caracteres especiales (como comodines, caracteres de límite y cuantificadores) y funciones avanzadas como la captura de grupos y referencias inversas. Combinando estos elementos, se pueden construir reglas de coincidencia complejas para lograr poderosas capacidades de procesamiento de texto.

Ventajas de utilizar expresiones regulares en C++:

1. Potentes capacidades de procesamiento de texto: las expresiones regulares proporcionan una forma flexible de describir patrones y reglas de texto y pueden implementar fácilmente funciones complejas de coincidencia, búsqueda y extracción de texto.

2. A través de expresiones regulares, puede verificar rápidamente si el formato de datos ingresado por el usuario cumple con los requisitos, mejorando la precisión y coherencia de los datos.

3. Las expresiones regulares pueden realizar fácilmente operaciones de reemplazo y formato de texto, como reemplazar contenido de texto en lotes o formatear el texto de salida.

4. Las expresiones regulares pueden implementar funciones complejas de procesamiento de texto con códigos más cortos, mejorando la legibilidad y simplicidad del código.

5. Las expresiones regulares se pueden utilizar en varios escenarios, como análisis de registros, extracción de datos, análisis de texto, etc., lo que proporciona a C++ una potente herramienta de procesamiento de texto.

El uso de expresiones regulares en C++ se <regex>implementa a través de los archivos de encabezado proporcionados. Sintaxis y reglas básicas:

1. Caracteres ordinarios: incluyen letras, números y algunos símbolos, que representan sus propios caracteres.

2. Caracteres especiales: incluidos metacaracteres (como ^, $, ., *, +, ?, |etc. \), utilizados para describir reglas de coincidencia.

3. Cuantificador: especifique el número de apariciones del patrón anterior, como *(cero o más veces), +(una o más veces), ?(cero o una vez), {m,n}(el número de apariciones varía de m a n veces), etc.

4. Caracteres de escape: utilícelo \para convertir caracteres especiales en caracteres normales.

5. Clase de personaje: utilice [ ] para representar cualquiera de un grupo de caracteres. Por ejemplo, [abc] coincide con cualquiera de "a", "b" o "c".

6. Grupo de captura: se utiliza ( )para combinar patrones en una unidad para obtener subcadenas coincidentes.

En el archivo de encabezado de C++ <regex>, las clases de uso común incluyen std::regex, std::smatchy, std::regex_matchetc., a través de las cuales se puede realizar la coincidencia, búsqueda y extracción de expresiones regulares. Por ejemplo, use std::regex_matchuna función para verificar si una cadena coincide con una expresión regular especificada y use std::smatchuna clase para almacenar los resultados coincidentes.

La sintaxis y las reglas básicas de las expresiones regulares en C++ son básicamente las mismas que las de las expresiones regulares en otros lenguajes, pero puede haber algunas diferencias en implementaciones específicas. Puedes ver la introducción oficial .

2. Coincidencia básica de expresiones regulares.

1. Coincidir con un solo carácter :

   • Utilice caracteres normales para hacer coincidencias, como una expresión regular aque pueda coincidir con el carácter "a" de la cadena.
   • Utilice metacaracteres .para hacer coincidir cualquier carácter individual. Por ejemplo, las expresiones regulares s.pueden coincidir con "sa", "sb", "sc", etc. en la cadena.

2. Combina varios personajes:

   • Utilice cuantificadores *para hacer coincidir cero o más apariciones del carácter anterior. Por ejemplo, la expresión regular ab*puede coincidir con "a", "ab", "abb", "abbb", etc.
   • Utilice cuantificadores +para hacer coincidir el carácter anterior que aparece una o más veces. Por ejemplo, la expresión regular ab+puede coincidir con "ab", "abb", "abbb", etc.
   • Utilice cuantificadores ?para hacer coincidir cero o una aparición del carácter anterior. Por ejemplo, una expresión regular ab?puede coincidir con "a", "ab", etc.
   • Utilice {m,n}llaves para hacer coincidir el carácter anterior que aparece de m a n veces. Por ejemplo, la expresión regular a{2,4}puede coincidir con "aa", "aaa", "aaaa".

3. Posiciones de inicio y fin del partido:

   • Utilice caracteres de anclaje ^para hacer coincidir la posición inicial de una cadena. Por ejemplo, una expresión regular ^startpuede coincidir con una cadena que comienza con "inicio".
   • Utilice caracteres de anclaje $para hacer coincidir el final de una cadena. Por ejemplo, una expresión regular end$puede hacer coincidir una cadena que termina con "fin".

Cuando utilice expresiones regulares para la coincidencia de texto, debe hacer coincidir las clases de caracteres y excluir las clases de caracteres. Las clases de caracteres se utilizan para hacer coincidir cualquier carácter de un juego de caracteres, mientras que las clases de caracteres de exclusión se utilizan para hacer coincidir cualquier carácter excepto el juego de caracteres especificado.

Los corchetes se utilizan en expresiones regulares []para representar una clase de carácter , y los corchetes contienen el conjunto de caracteres que deben coincidir. Por ejemplo:

• [aeiou]Puede coincidir con cualquier vocal minúscula.
• [A-Za-z]Puede coincidir con cualquier letra mayúscula o minúscula.
• [0-9]Puede coincidir con cualquier carácter numérico.

Además, puede utilizar guiones entre corchetes -para indicar un rango, como [a-z]hacer coincidir cualquier letra minúscula.

En su lugar, utilice el símbolo de intercalación ^dentro de una clase de personaje para excluir la clase de personaje . Por ejemplo:

• [^aeiou]Puede coincidir con cualquier carácter excepto las vocales minúsculas.

Las expresiones regulares admiten la coincidencia de patrones repetidos , utilizando diferentes cuantificadores para especificar reglas de coincidencia repetida.

Cuantificadores de uso común:

• *: Coincide con el patrón anterior cero o más veces.
• +: Coincide con el patrón anterior una o más veces.
• ?: Coincide con el patrón anterior cero o una vez.
• {n}: Coincide con el patrón anterior exactamente n veces.
• {n,}: Coincide con el patrón anterior al menos n veces.
• {n,m}: Coincide con el patrón anterior al menos n veces y como máximo m veces.

Por ejemplo:

• a*Puede coincidir con cero o más "a".
• a+Puede coincidir con una o más "a".
• a?Puede coincidir con cero o una "a".
• a{3}Puede coincidir exactamente con tres "a".
• a{2,4}Puede unir de dos a cuatro "a".

Hay otros dos conceptos importantes en las expresiones regulares: anclajes y grupos .

Los puntos de anclaje se utilizan para especificar posiciones coincidentes. Los puntos de anclaje más utilizados son:

• ^: Coincide con el comienzo de la cadena.
• $: Coincide con la posición final de la cadena.
• \b: Haga coincidir los límites de las palabras.
• \B: Coincide con límites que no son palabras.

Por ejemplo:

• ^abcPuede coincidir con cadenas que comienzan con "abc".
• xyz$Puede coincidir con cadenas que terminan en "xyz".
• \bword\bPuede coincidir con palabras de "palabras" individuales.
• \Bword\BPuede coincidir con el interior de la palabra "palabra".

La agrupación se utiliza para agrupar los resultados coincidentes del patrón y procesar cada grupo por separado. Las agrupaciones se indican entre paréntesis (). Por ejemplo:

• (ab)+Puede coincidir con "ab", "abab", "ababab", etc.
• (a|b)Puede coincidir con "a" o "b".

3. Usar expresiones regulares en C++

1. El uso de expresiones regulares en C++ requiere incluir <regex>archivos de encabezado y utilizar stdespacios de nombres.
2. Utilice std::regexclases para crear objetos de expresión regular. Los objetos de expresión regular se pueden utilizar para almacenar y representar un patrón de expresión regular específico.
3. Utilice expresiones regulares para hacer coincidencias y buscar. std::regex_searchFunciones y funciones se utilizan en C ++ std::regex_matchpara implementar estas funciones.

Ejemplo:

#include <iostream>
#include <regex>

int main() {
    
    
    std::string text = "Hello, this is a sample text with some numbers 12345.";
    std::regex pattern("\\d+"); // 匹配一个或多个数字

    std::smatch matches; // 用于存储匹配结果

    if (std::regex_search(text, matches, pattern)) {
    
    
        std::cout << "Found match: " << matches.str() << std::endl;
    } else {
    
    
        std::cout << "No match found." << std::endl;
    }

    return 0;
}

Utilice std::regex_searchuna función para buscar texto e intentar encontrar contenido que coincida con textun patrón de expresión regular . patternLas clases también se utilizan std::smatchpara almacenar los resultados coincidentes e imprimir el contenido coincidente.

También puede utilizar std::regex_matchfunciones para comprobar si una cadena completa coincide exactamente con un patrón de expresión regular.

if (std::regex_match(text, pattern)) {
    
    
    std::cout << "Full match found" << std::endl;
} else {
    
    
    std::cout << "No full match found" << std::endl;
}

Además, puede utilizar la biblioteca de expresiones regulares en C++ para extraer y reemplazar partes coincidentes . std::regexLas clases y funciones de la biblioteca estándar de C++ std::regex_replacepueden realizar estas tareas.

Ejemplo:

#include <iostream>
#include <regex>

int main() {
    
    
    std::string text = "The cat sat on the mat.";
    std::regex pattern("\\b(cat)\\b"); // 匹配整个单词"cat"

    std::sregex_iterator it(text.begin(), text.end(), pattern);
    std::sregex_iterator end;

    for (; it != end; ++it) {
    
    
        std::smatch match = *it;
        std::cout << "Match found: " << match.str() << " at position " << match.position() << std::endl;
    }

    // 替换匹配的部分
    std::string replaced_text = std::regex_replace(text, pattern, "dog");
    std::cout << "Replaced text: " << replaced_text << std::endl;

    return 0;
}

Úselo std::sregex_iteratorpara iterar a través de los resultados coincidentes y luego use std::regex_replacela función para reemplazar las partes coincidentes. Aquí también se utiliza una función position()para obtener la posición coincidente.

4. Expresiones regulares avanzadas

(1) Coincidencia de patrones más compleja . La biblioteca de expresiones regulares de C++ admite una serie de potentes sintaxis de expresiones regulares, que se pueden utilizar para necesidades de coincidencia de patrones más complejas y lograr una coincidencia y extracción de texto más sofisticadas.
Ejemplo:

#include <iostream>
#include <regex>

int main() {
    
    
    std::string text = "The cat sat on the mat. The dog sat on the rug.";
    std::regex pattern("\\b(\\w+)\\s+sat\\s+on\\s+the\\s+(\\w+)\\b"); // 匹配类似"xxx sat on the xxx"的句子

    std::sregex_iterator it(text.begin(), text.end(), pattern);
    std::sregex_iterator end;

    for (; it != end; ++it) {
    
    
        std::smatch match = *it;
        std::cout << "Match found: " << match.str() << std::endl;
        std::cout << "First captured group: " << match[1].str() << std::endl;
        std::cout << "Second captured group: " << match[2].str() << std::endl;
    }

    return 0;
}

(2) Utilice grupos de captura y rastreo . Los grupos de captura permiten marcar y capturar partes específicas de una expresión regular, mientras que los rastreos permiten hacer referencia al contenido capturado en el texto de reemplazo.
Ejemplo:

#include <iostream>
#include <regex>

int main() {
    
    
    std::string text = "The price is $10.99. The total is $25.50.";
    std::regex pattern("\\$(\\d+\\.\\d+)"); // 匹配美元金额

    std::string replaced_text = std::regex_replace(text, pattern, "¥$1"); // 使用捕获组的内容进行替换
    std::cout << "Replaced text: " << replaced_text << std::endl;

    return 0;
}

Se utiliza un grupo de captura para igualar la cantidad y se usa en el texto de reemplazo $1para hacer referencia al contenido capturado para su reemplazo. La representación aquí $1es reemplazar la parte coincidente con el contenido del primer grupo de captura.

(3) Emparejamiento perezoso y emparejamiento codicioso . La coincidencia diferida y la coincidencia codiciosa se utilizan para describir cómo se comparan los cuantificadores. La coincidencia codiciosa coincide con la mayor cantidad de cadena posible, mientras que la coincidencia diferida coincide con la menor cantidad de cadena posible.

Se utiliza en expresiones regulares de C++ ?para representar coincidencias diferidas. Ejemplo:

#include <iostream>
#include <regex>

int main() {
    
    
    std::string text = "The cat sat on the mat. The dog sat on the rug.";
    std::regex greedy_pattern("s[a-z]+t"); // 贪婪匹配，尽可能多地匹配s和t之间的字母
    std::regex lazy_pattern("s[a-z]+?t");  // 懒惰匹配，尽可能少地匹配s和t之间的字母

    std::sregex_iterator it_greedy(text.begin(), text.end(), greedy_pattern);
    std::sregex_iterator end_greedy;
    for (; it_greedy != end_greedy; ++it_greedy) {
    
    
        std::smatch match = *it_greedy;
        std::cout << "Greedy Match found: " << match.str() << std::endl;
    }

    std::sregex_iterator it_lazy(text.begin(), text.end(), lazy_pattern);
    std::sregex_iterator end_lazy;
    for (; it_lazy != end_lazy; ++it_lazy) {
    
    
        std::smatch match = *it_lazy;
        std::cout << "Lazy Match found: " << match.str() << std::endl;
    }

    return 0;
}

La coincidencia codiciosa coincide con tantas letras entre s y t como sea posible, mientras que la coincidencia diferida coincide con la menor cantidad de letras posible entre s y t.

(4) Buscar hacia adelante y hacia atrás . Las búsquedas hacia adelante y hacia atrás proporcionan una función de posicionamiento relativo basada en la posición de coincidencia actual, encontrando patrones antes o después de una posición específica. Esto es útil para situaciones en las que necesita coincidir con un contexto específico.

Ejemplo:

#include <iostream>
#include <regex>

int main() {
    
    
    std::string text = "The quick brown fox jumps over the lazy dog";
    std::regex forward_pattern("\\b\\w+(?=\\sfox)"); // 向前查找，匹配fox之前的单词
    std::regex backward_pattern("(?<=brown\\s)\\w+\\b"); // 向后查找，匹配brown之后的单词

    std::smatch match;
    if (std::regex_search(text, match, forward_pattern)) {
    
    
        std::cout << "Forward match found: " << match.str() << std::endl;
    }

    if (std::regex_search(text, match, backward_pattern)) {
    
    
        std::cout << "Backward match found: " << match.str() << std::endl;
    }

    return 0;
}

La búsqueda hacia adelante utiliza (?=\sfox)para buscar la palabra antes de zorro, y la búsqueda hacia atrás utiliza (?<=brown\s)para buscar la palabra después de marrón.

5. Ejemplos prácticos

(1) Verificación y formato de datos. La dirección de correo electrónico está verificada y formateada:

#include <iostream>
#include <regex>
#include <string>

bool isValidEmail(const std::string& email) {
    
    
    std::regex pattern(R"([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})");
    return std::regex_match(email, pattern);
}

std::string formatPhoneNumber(const std::string& phoneNumber) {
    
    
    std::regex pattern(R"(\b(\d{3})(\d{3})(\d{4})\b)");
    return std::regex_replace(phoneNumber, pattern, R"($1-$2-$3)");
}

int main() {
    
    
    // 邮箱验证
    std::string email = "[email protected]";
    if (isValidEmail(email)) {
    
    
        std::cout << "Email is valid" << std::endl;
    } else {
    
    
        std::cout << "Invalid email" << std::endl;
    }

    // 电话号码格式化
    std::string phoneNumber = "12345678901";
    std::string formattedNumber = formatPhoneNumber(phoneNumber);
    std::cout << "Formatted phone number: " << formattedNumber << std::endl;

    return 0;
}

La validación se realiza mediante std::regex_matchimplementación y el formato se realiza mediante std::regex_replaceimplementación.

(2 Extracción y análisis de texto. Extraiga números en el texto y analícelos:

#include <iostream>
#include <regex>
#include <string>
#include <vector>

std::vector<int> extractNumbers(const std::string& input) {
    
    
    std::vector<int> numbers;
    std::regex pattern(R"(\d+)");
    std::sregex_iterator iter(input.begin(), input.end(), pattern);
    std::sregex_iterator end;

    for (; iter != end; ++iter) {
    
    
        numbers.push_back(std::stoi(iter->str()));
    }

    return numbers;
}

int main() {
    
    
    std::string text = "The price of the item is $250. The weight is 5.5 pounds.";
    std::vector<int> numbers = extractNumbers(text);

    std::cout << "Extracted numbers: ";
    for (int num : numbers) {
    
    
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 分析提取的数字
    int sum = 0;
    for (int num : numbers) {
    
    
        sum += num;
    }

    std::cout << "Sum of the numbers: " << sum << std::endl;

    return 0;
}

(3) Análisis del archivo de registro. Extraiga y analice información clave en archivos de registro, como marcas de tiempo, direcciones IP, mensajes de error, etc.:

#include <iostream>
#include <fstream>
#include <regex>
#include <string>

void analyzeLogFile(const std::string& filename) {
    
    
    std::ifstream file(filename);
    if (!file.is_open()) {
    
    
        std::cerr << "Error opening file " << filename << std::endl;
        return;
    }

    std::regex timePattern(R"((\d{2}:\d{2}:\d{2}))");
    std::regex ipPattern(R"((\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}))");
    std::regex errorPattern(R"(error|ERROR)");

    std::string line;
    while (std::getline(file, line)) {
    
    
        std::smatch timeMatch;
        std::smatch ipMatch;
        std::smatch errorMatch;

        if (std::regex_search(line, timeMatch, timePattern) && std::regex_search(line, ipMatch, ipPattern) && std::regex_search(line, errorMatch, errorPattern)) {
    
    
            std::cout << "Timestamp: " << timeMatch[0] << ", IP address: " << ipMatch[0] << ", Error: " << errorMatch[0] << std::endl;
        }
    }

    file.close();
}

int main() {
    
    
    analyzeLogFile("example.log");
    return 0;
}

(4) Aplicaciones avanzadas de procesamiento de textos.

#include <iostream>
#include <regex>
#include <string>

void advancedTextProcessing(const std::string& text) {
    
    
    // 通过正则表达式替换文本中的日期格式
    std::regex datePattern(R"(\b(\d{1,2})/(\d{1,2})/(\d{4})\b)");
    std::string processedText = std::regex_replace(text, datePattern, "$3-$1-$2");
    std::cout << "Processed text with date format replaced: " << processedText << std::endl;

    // 提取文本中的URL
    std::regex urlPattern(R"((https?://\S+))");
    std::sregex_iterator iter(text.begin(), text.end(), urlPattern);
    std::sregex_iterator end;

    std::cout << "Extracted URLs: ";
    for (; iter != end; ++iter) {
    
    
        std::cout << iter->str() << " ";
    }
    std::cout << std::endl;

    // 使用正则表达式分组提取文本中的标题和内容
    std::regex articlePattern(R"(<title>(.*?)</title>.*?<content>(.*?)</content>)", std::regex::dotall);
    std::smatch match;
    if (std::regex_search(text, match, articlePattern)) {
    
    
        std::cout << "Title: " << match[1].str() << std::endl;
        std::cout << "Content: " << match[2].str() << std::endl;
    }
}

int main() {
    
    
    std::string sampleText = "Today's date is 12/30/2023. Visit our website at https://www.baidu.com/ for more information. <title>Sample Title</title><content>This is a sample content.</content>";
    advancedTextProcessing(sampleText);
    return 0;
}

6. Optimización del rendimiento

6.1 Compilar expresiones regulares

1. Precompilar expresiones regulares: para las expresiones regulares que se usarán repetidamente, se recomienda compilarlas durante la etapa de inicialización del programa para evitar volver a compilarlas cada vez que coincidan. Se puede std::regexcompilar usando el constructor de .

   std::regex regExpr(pattern); // 预先编译正则表达式
   

2. Siempre que sea posible, intente utilizar patrones de expresión regular simples y evite reglas de coincidencia demasiado complejas y que requieran mucho tiempo.

3. *?Intente utilizar cuantificadores no codiciosos ( ,, ) en expresiones regulares para la coincidencia para evitar problemas +?de {n, m}?rendimiento causados ​​por la coincidencia codiciosa.

4. Si es posible, intente utilizar cadenas específicas en expresiones regulares en lugar de comodines genéricos para reducir la complejidad de las coincidencias.

5. Si su programa utiliza con frecuencia varias expresiones regulares, se pueden precompilar y almacenar para mejorar el rendimiento.

   std::unordered_map<std::string, std::regex> regexCache;
   regexCache["datePattern"] = std::regex(R"((\d{1,2})/(\d{1,2})/(\d{4}))");
   

6.2 Evite el uso excesivo de retroceso

Al escribir expresiones regulares, es muy importante evitar el uso excesivo del retroceso, ya que el retroceso puede causar una degradación del rendimiento en las expresiones regulares, especialmente cuando se procesa texto largo o patrones complejos.

1. Intente utilizar cuantificadores no codiciosos (por ejemplo *?, +?, {n,m}?) para evitar retrocesos innecesarios durante el proceso de comparación.

2. Evite el uso excesivo de repeticiones anidadas en expresiones regulares, ya que esto puede provocar un mayor retroceso. Intente simplificar el esquema y reducir la profundidad del anidamiento.

3. Utilice grupos atómicos: los grupos atómicos evitan el retroceso, por lo que puede usarlos para limitar el alcance en el que se produce el retroceso.

4. Si solo necesita hacer coincidir una cadena fija específica, es mejor usar la función de coincidencia de cadenas directamente en lugar de usar una expresión regular.

5. Algunos motores de expresiones regulares pueden compilar expresiones regulares en autómatas finitos deterministas (DFA), este método puede evitar el retroceso y mejorar el rendimiento de las coincidencias.

6. Precompilar expresiones regulares: como se mencionó anteriormente, compilar expresiones regulares durante la fase de inicialización del programa puede evitar tener que volver a compilar cada vez que se realiza una coincidencia y mejorar el rendimiento.

6.3 Optimizar el algoritmo de coincidencia

1. Diferentes algoritmos tienen diferente rendimiento en diferentes escenarios. Por ejemplo, al procesar textos grandes, los algoritmos basados ​​en autómatas finitos (DFA) son más eficientes que los algoritmos de retroceso.

2. El retroceso es una operación que requiere mucho tiempo. Intente evitar que las expresiones regulares requieran mucho retroceso. Puede reducir el número de retrocesos optimizando los patrones de expresión regular o utilizando cuantificadores no codiciosos.

3. Si solo necesita hacer coincidir una cadena fija específica, strstrpuede ser más eficiente usar una función de coincidencia de cadenas directamente (como la función equivalente en otros idiomas) que usar una expresión regular.

4. Si necesita hacer coincidir la misma expresión regular con frecuencia, puede almacenar en caché los resultados coincidentes para reducir las operaciones de coincidencia repetidas.

5. Preprocesar el texto de entrada (por ejemplo, eliminar partes que no son necesarias para la coincidencia) puede reducir la complejidad de la coincidencia y mejorar el rendimiento de la misma.

6. Para una gran cantidad de datos que deben compararse, se utiliza la coincidencia paralela de subprocesos múltiples para acelerar la coincidencia.

7. Resumen

Dirección de aplicación de expresiones regulares:

1. Validación de entrada: Se utiliza para verificar si los datos ingresados ​​por el usuario se ajustan a un formato específico, como dirección de correo electrónico, número de teléfono, fecha, contraseña, etc.

2. Extracción de datos: extraiga patrones específicos de datos del texto, como extraer enlaces de páginas web, extraer datos en formatos específicos de archivos de registro, etc.

3. Reemplazo y formato: Se utiliza en el procesamiento de textos para reemplazar cadenas o texto formateado de patrones específicos, como unificar formatos de fecha, eliminar espacios innecesarios, etc.

4. Enrutamiento de URL: se utiliza en el desarrollo web para definir y hacer coincidir reglas de enrutamiento de URL para lograr saltos de página y extracción de parámetros.

5. Análisis de sintaxis: se utiliza en compiladores e intérpretes para analizar y procesar sintaxis y estructuras específicas. Por ejemplo, el motor de expresiones regulares en sí es una implementación de un analizador de sintaxis.

6. Análisis de registros: se utiliza para analizar y filtrar patrones e información específicos en grandes cantidades de datos de registros.

7. Limpieza de datos: utilice expresiones regulares en el procesamiento y limpieza de datos para identificar y tratar formatos de datos no estándar.

8. Filtrado de palabras sensibles: se utiliza para filtrar palabras sensibles y contenido inapropiado en el texto.

9. Coincidencia de cadenas: se utiliza para encontrar si una cadena contiene un patrón o palabra clave específica.