Clases de caracteres

Las clases de caracteres especifican los caracteres que está intentando hacer coincidir o no. Asegúrese de sustituir . en .*s por un carácter más específico. .* cambiará invariablemente al final de la entrada y, a continuación, retrocederá, es decir, volverá al estado guardado anteriormente para continuar con la búsqueda de una coincidencia. Al usar una clase de carácter específico, tiene el control sobre cuántos caracteres hará el * que el motor de expresiones regulares consuma, permitiendo detener el retroceso incontrolado.

Tenga en cuenta la siguiente expresión regular de ejemplo:

(\d{4})(\d{2})(\d{2}),(\S+),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([0-9.]+),([0-9.]+),([0-9.]+),([0-9.]+),([0-9.]+),([0-9.]+)

Para la siguiente entrada:

Como resultado de la expresión regular especificada, se puede buscar la coincidencia con retroceso. Oracle Logging Analytics detecta esta situación y se cancela la operación de coincidencia.

Al cambiar la expresión regular al ejemplo siguiente, puede asegurarse de que la coincidencia termine antes. Observe que [\S\s]* se cambia a [^,], lo que evita el retroceso innecesario.

(\d{4})(\d{2})(\d{2}),(\S+),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),([0-9.]+),([0-9.]+),([0-9.]+),([0-9.]+),([0-9.]+),([0-9.]+)

Cuantificadores diferidos

En muchas expresiones regulares, los cuantificadores expansivos (.*s) se pueden reemplazar de forma segura con cuantificadores diferidos (.*?s), lo que mejora el rendimiento de la expresión regular sin cambiar el resultado.

Considere la entrada:

Trace file /u01/app/oracle/diag/rdbms/navisdb/NAVISDB/trace/NAVISDB_arc0_3941.trc
Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 - 64bit Production
With the Partitioning, OLAP, Data Mining and Real Application Testing options
ORACLE_HOME = /u01/app/oracle/product/11.2.0/db_1
System name: Linux
Node name: NAVISDB
Release: 2.6.18-308.el5
Version: #1 SMP Fri Jan 27 17:17:51 EST 2012
Machine: x86_64
Instance name: NAVISDB
Redo thread mounted by this instance: 1
Oracle process number: 21
Unix process pid: 3941, image: oracle@NAVISDB (ARC0)

Tenga en cuenta la siguiente expresión regular expansiva para la entrada especificada:

Trace\sfile\s(\S*).*ORACLE_HOME\s*[:=]\s*(\S*).*System\sname:\s*(\S*).*Node\sname:\s*(\S*).*Release:\s*(\S*).*Machine:\s*(\S*).*Instance\sname:\s*(\S*).*Redo\sthread\smounted\sby\sthis\sinstance:\s(\d*).*Oracle\sprocess\snumber:\s*(\d*).*Unix\sprocess\spid:\s(\d*).*image:\s+([^\n\r]*)

El motor de expresiones regulares se dispararía hasta el final de la entrada, cada vez que encuentre .*.. La primera vez que aparece .*, consume todas las entradas y, a continuación, retrocede hasta que llega a ORACLE_HOME. Este método no es eficaz para buscar las coincidencias. La expresión regular diferida alternativa es como la siguiente:

Trace\sfileRelease:\s*(\S*).*?Machine:\s*(\S*).*?Instance\sname:\s*(\S*).*?Redo\sthread\smounted\sby\sthis\sinstance:\s(\d*).*?Oracle\sprocess\snumber:\s*(\d*).*?Unix\sprocess\spid:\s(\d*).*?image:\s+([^\n\r]*)

La expresión regular anterior se consume starting desde el principio de la cadena hasta que alcance ORACLE_HOME, momento en el que puede proceder a la coincidencia con el resto de la cadena.

Nota: Si el campo ORACLE_HOME aparece al principio de la entrada, se debe utilizar el cuantificador expansivo. Si el campo ORACLE_HOME aparece al final, es posible que sea adecuado utilizar el cuantificador expansivo.

Anclajes

Los anclajes indican al motor de expresiones regulares que desea que el cursor esté en un lugar concreto de la entrada. Los anclajes más habituales son ^ y $, lo que indica el principio y el final de la entrada.

Tenga en cuenta las siguientes expresiones regulares para buscar una dirección IPv4:

\d{1,3}\.d{1,3}.\d{1,3}.\d{1,3}

^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}

Observe que la segunda expresión regular comienza con ^ y, por lo tanto, es específica de la dirección IP que aparece al principio de la entrada.

Estamos buscando la expresión regular que, en la entrada, se parezca al siguiente ejemplo:

107.21.20.1 - - [07/Dec/2012:18:55:53 -0500] "GET
      /extension/bsupport/design/cl/images/btn_letschat.png HTTP/1.1" 200
    2144

Una entrada no coincidente sería similar al siguiente ejemplo:

[07/Dec/2012:23:57:13 +0000] 1354924633 GET "/favicon.ico" "" HTTP/1.1 200 82726 "-"
      "ELB-HealthChecker/1.0"

La segunda expresión regular (que comienza con ^) se ejecuta mucho más rápido en la entrada no coincidente, ya que descarta la entrada no coincidente casi de inmediato.

La importancia de la alternancia

El orden de alternancia cuenta, así que coloque las opciones más comunes en la parte delantera para que puedan emparejarse más rápidamente. Si las opciones más raras se colocan en primer lugar, el motor de expresiones regulares perderá tiempo en comprobarlas antes de comprobar las opciones más comunes que es más probable que tengan éxito. Además, intente extraer patrones comunes. Por ejemplo, en lugar de (abcd|abef), utilice ab(cd|ef).

Tenga en cuenta las siguientes expresiones regulares:

{TIMEDATE}\s{0,1}:\s*(?:|\[)(\w+)(?:\:|\])(?:\[|)(\d+)(?:\:|\])(.{1,1000}).*

{TIMEDATE}\s{0,1}:\s*(?:\[|)(\w+)(?:\:|\])(?:\[|)(\d+)(?:\:|\])(.{1,1000}).*

En la siguiente entrada:

2014-06-16 12:13:46.743: [UiServer][1166092608] {0:7:2} Done for
ctx=0x2aaab45d8330

La segunda expresión regular coincide más rápido, ya que la alternancia busca el carácter [ primero, seguido de null. A medida que la entrada tiene [, la coincidencia se ejecuta más rápido.