Vai al contenuto principale
Le espressioni regolari vengono utilizzate nei dizionari basati su espressioni regolari per definire quali parole sono consentite in una lingua e quali invece no.

Regole delle espressioni regolari

L’alfabeto delle espressioni regolari di ABBYY FineReader Engine è descritto nella tabella seguente:
Nome elementoSimbolo convenzionale dell’espressione regolareEsempi di utilizzo e spiegazioni
Qualsiasi carattere.c.t — indica parole come “cat”, “cot”
Carattere appartenente a un intervallo di caratteri[][b-d]ell — indica parole come “bell”, “cell”, “dell” [ty]ell — indica le parole “tell” e “yell”
Carattere non appartenente a un intervallo di caratteri[^][^y]ell — indica parole come “dell”, “cell”, “tell”, ma esclude “yell” [^n-s]ell — indica parole come “bell”, “cell”, ma esclude “nell”, “oell”, “pell”, “qell”, “rell” e “sell”
Oppure\c(a\u)t — indica le parole “cat” e “cut”
0 o più occorrenze consecutive*10* — indica i numeri 1, 10, 100, 1000 e così via
1 o più occorrenze consecutive+10+ — consente i numeri 10, 100, 1000 e così via, ma esclude 1.
Lettera o cifra[0-9a-zA-Z][0-9a-zA-Z] — consente un singolo carattere; [0-9a-zA-Z]+ — consente qualsiasi parola
Lettera latina maiuscola[A-Z]<br />
Lettera latina minuscola[a-z]<br />
Lettera cirillica maiuscola[А-Я]<br />
Lettera cirillica minuscola[а-я]<br />
Cifra[0-9]<br />
Spazio[\s]<br />
Carattere di sistema@<br />
Parola dal dizionario@(Dictionary)Il parametro Dictionary imposta il percorso del dizionario utente da cui devono essere prese le parole. Esempio di percorso Linux: @(/opt/MyDictionary.amd) esempio di percorso macOS: “/Users/user/Documents/MyDictionary.amd In Windows, le barre rovesciate nel percorso devono essere raddoppiate. Ad esempio: @(D:\MyFolder\MyDictionary.amd). <Note> Alcuni linguaggi di programmazione (come C++) richiedono di usare l’escape delle barre rovesciate nelle stringhe letterali. In questo caso, saranno necessarie due barre rovesciate con escape, con il risultato di una barra rovesciata quadruplicata. In C++, l’esempio precedente apparirà così: </Note> L"@(D:\\\\\\\\MyFolder\\\\\\\\MyDictionary.amd)"
  • Alcuni caratteri usati nelle espressioni regolari sono “ausiliari”, cioè vengono usati per scopi di sistema. Come puoi vedere dall’elenco sopra, questi caratteri includono parentesi quadre, punti e così via. Se desideri inserire un carattere ausiliario come carattere normale, metti una barra rovesciata () davanti a esso. Esempio: [t-v]x+ indica parole come “tx”, “txx”, “txxx” e così via, “ux”, “uxx” e così via, ma [t-v]x+ indica parole come “[t-v]x”, “[t-v]xx”, “[t-v]xxx” e così via.
  • Se devi raggruppare determinati elementi di un’espressione regolare, usa le parentesi. Ad esempio, (a|b)+|c indica “c” e qualsiasi combinazione come “abbbaaabbb”, “ababab” e così via (una parola di qualsiasi lunghezza diversa da zero in cui può esserci un numero qualsiasi di a e b in qualsiasi ordine), mentre a|b+|c indica “a”, “c” e “b”, “bb”, “bbb” e così via.

Espressioni regolari di esempio

Espressione regolare per le date Il numero che indica il giorno può essere composto da una cifra (ad esempio 1, 2 ecc.) o da due cifre (ad esempio 02, 12), ma non può essere zero (00 o 0). L’espressione regolare per il giorno avrà quindi questo aspetto: ((|0)[1-9])|([12][0-9])|(30)|(31). L’espressione regolare per il mese avrà questo aspetto: ((|0)[1-9])|(10)|(11)|(12). L’espressione regolare per l’anno avrà questo aspetto: (((19)|(20))[0-9][0-9])|([0-9][0-9]). A questo punto resta solo da combinare tutti questi elementi e separare i numeri con un punto (ad esempio 1.03.1999). Il punto è un carattere ausiliario, quindi dobbiamo inserire una barra rovesciata () prima di esso. L’espressione regolare per la data completa avrà quindi questo aspetto: (((|0)[1-9])|([12][0-9])|(30)|(31)).(((|0)[1-9])|(10)|(11)|(12)).((((19)|(20))[0-9][0-9])|([0-9][0-9])) Espressione regolare per gli indirizzi e-mail È possibile creare facilmente un modello per rappresentare gli indirizzi e-mail. L’espressione regolare per un indirizzo e-mail può avere questo aspetto: [a-zA-Z0-9_-.]+@[a-zA-Z0-9.-]+.[a-zA-Z]+

Uso per l’acquisizione dei dati

Se si usano espressioni regolari nel riconoscimento a livello di field, in genere è necessario riconoscere solo le parole che corrispondono esattamente all’espressione regolare. In questo caso, si consiglia di creare una lingua separata per il riconoscimento dei field e di impostare le seguenti proprietà:
  1. Come risultati del riconoscimento devono essere consentite solo le parole presenti nel dizionario: impostare la proprietà IBaseLanguage::AllowWordsFromDictionaryOnly su TRUE. Questo è necessario per la corrispondenza esatta.
  2. L’insieme di lettere della lingua di riconoscimento deve contenere solo i caratteri inclusi nell’espressione regolare: specificare la proprietà IBaseLanguage::LetterSet. Questo è necessario perché i caratteri dell’alfabeto della lingua possono essere riconosciuti anche se non corrispondono all’espressione regolare.
  3. Impostare la proprietà IBaseLanguage::IsNaturalLanguage su FALSE.

Esempi Windows

// Oggetto globale ABBYY FineReader Engine
FREngine.IEngine engine;
// Oggetto LanguageDatabase
FREngine.ILanguageDatabase languageDatabase = engine.CreateLanguageDatabase();
// Crea un oggetto TextLanguage
FREngine.ITextLanguage textLang = languageDatabase.CreateTextLanguage();
// Crea un oggetto BaseLanguage e specifica le impostazioni
FREngine.IBaseLanguage baseLang = textLang.BaseLanguages.AddNew();
baseLang.set_LetterSet(FREngine.BaseLanguageLetterSetEnum.BLLS_Alphabet, "$0123456789,.");
baseLang.IsNaturalLanguage = false;
baseLang.AllowWordsFromDictionaryOnly = true;
// Crea un nuovo dizionario basato su espressioni regolari e lo associa alla lingua
FREngine.IDictionaryDescription dictDescr = baseLang.DictionaryDescriptions.AddNew(FREngine.DictionaryTypeEnum.DT_RegularExpression);
// Imposta l'espressione regolare
dictDescr.GetAsRegExpDictionaryDescription().SetText(@"[$0-9,.]+");

Vedi anche

Uso dei dizionari RegExpDictionaryDescription