Scrivere espressioni regolari con prestazioni efficaci

Classi di caratteri

Le classi di caratteri specificano i caratteri che si sta cercando o non si sta cercando di trovare una corrispondenza. Assicurarsi di sostituire . nel file .*s con un carattere più specifico. .* passerà invariabilmente alla fine dell'input e quindi tornerà indietro, ovvero tornerà a uno stato salvato in precedenza per continuare la ricerca di una corrispondenza. Quando si utilizza una classe di caratteri specifica, si ha il controllo sul numero di caratteri che * farà consumare il motore regex, dando la potenza per arrestare il backtracking dilagante.

Si consideri l'espressione regolare di esempio riportata di seguito.

(\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.]+)

Per il seguente input:

Come risultato dell'espressione regolare specificata, la corrispondenza può essere eseguita nel backtracking. Questa situazione viene rilevata da Oracle Log Analytics e l'operazione di corrispondenza viene interrotta.

Modificando l'espressione regolare nell'esempio riportato di seguito, è possibile assicurarsi che la corrispondenza venga completata più rapidamente. Si noti che [\S\s]* viene modificato in [^,], evitando il backtracking non necessario.

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

Quantificatori lazy

In molte espressioni regolare, i quantificatori greedy (.*s) possono essere sostituiti in tutta sicurezza con i quantificatori lazy (.*?s), assegnando all'espressione regolare un incremento delle prestazioni senza modificare il risultato.

Prendere in considerazione l'input:

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)

Considerare la seguente espressione regolare avida per l'input dato:

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]*)

Il motore regex spara alla fine dell'input ogni volta che incontra .*.. La prima volta che viene visualizzato .*, consuma tutto l'input e quindi esegue il backtracks fino a raggiungere ORACLE_HOME. Questo è un modo inefficiente di abbinare. Il regex pigro alternativo è come mostrato di seguito:

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]*)

L'espressione regolare sopra riportata viene utilizzata a partire dall'inizio della stringa finché non raggiunge ORACLE_HOME, il punto in cui potrebbe continuare a cercare corrispondenze per il resto della stringa.

Nota: se il campo ORACLE_HOME viene visualizzato all'inizio dell'input, si consiglia di usare il quantificatore lazy. Se il campo ORACLE_HOME viene visualizzato verso la fine, potrebbe essere opportuno utilizzare il quantificatore greedy.

Ancoraggi

Gli ancoraggi indicano al motore regex che si intende che il cursore si trovi in una posizione specifica nell'input. Gli ancoraggi più comuni sono ^ e $, che indicano l'inizio e la fine dell'input.

Prendere in considerazione le espressioni regolari seguenti per trovare un indirizzo 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}

Notare che la seconda espressione regolare inizia con ^ ed è pertanto specifica dell'indirizzo IP visualizzato all'inizio dell'input.

Si sta cercando l'espressione regolare nell'input simile all'esempio seguente:

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

Un input non corrispondente sarebbe simile al seguente esempio:

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

La seconda espressione regolare (che inizia con ^) viene eseguita più velocemente sull'input non corrispondente perché elimina l'input non corrispondente immediatamente.

L'importanza dell'alternanza

L'ordine di alternanza conta, quindi posiziona le opzioni più comuni nella parte anteriore in modo che possano essere abbinate più velocemente. Se le opzioni più rare vengono posizionate per prime, il motore delle espressioni regolari perderà tempo nel controllare quelle prima di controllare le opzioni più comuni che sono più probabili avere successo. Inoltre, cercare di estrarre i modelli comuni. Ad esempio, al posto di (abcd|abef) utilizzare ab(cd|ef).

Osservare le espressioni regolari seguenti:

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

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

Nell'input seguente:

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

La seconda espressione regolare trova più velocemente la corrispondenza in quanto l'alternanza cerca prima un carattere [, seguito da uno nullo. Poiché l'input contiene [, la corrispondenza viene eseguita più velocemente.