## Costrutti delle espressioni regolari

Le espressioni regolari (regex, in breve) ammesse per le operazioni di ricerca sono quelle riconosciute da Java. Se si desiderano ulteriori informazioni, consultare la pagina http://java.sun.com/j2se/1.5/docs/api/java/util/regex/Pattern.html. Vedere più avanti per ulteriori riferimenti ed esempi.

### Flag | ### Caratteri
### Citazioni | ### Classi per blocchi e categorie Unicode
### Classi di caratteri | ### Classi di carattere predefinite
### Rilevatori di limitazione | ### Quantificatori di ripetizione
### Quantificatori riluttanti (non ripetitivi) | ### Operatori logici
### Strumenti per le espressioni regolari ed esempi di utilizzo

### Il costrutto... | ### ...corrisponde al seguente:
### Flag
`(?i)` | Consente di avviare una ricerca che non consideri le lettere maiuscole e minuscole (per impostazione predefinita, il modello distingue tra maiuscole e minuscole).
### Caratteri
`x` | Viene rilevato il carattere corrispondente a x, ma con le seguenti eccezioni...
`\uhhhh` | Carattere col valore esadecimale `0x` hhhh
`\t` | Carattere di tabulazione (`'\u0009'`)
`\n` | Carattere corrispondente a un avanzamento di riga (line feed, LF) (`'\u000A'`)
`\r` | Carattere corrispondente a un ritorno di carrello (carriage-return, CR) (`'\u000D'`)
`\f` | Carattere corrispondente all'inizio di una nuova pagina in una stampa (form feed) (`'\u000C'`)
`\a` | Carattere di controllo bell (`'\u0007'`)
`\e` | Carattere escape (`'\u001B'`)
`\c` x | Carattere di controllo corrispondente a x
`\0` n | Carattere col valore ottale `0` n (0 `<=` n `<=` 7)
`\0` nn | Carattere col valore ottale `0` nn (0 `<=` n `<=` 7)
`\0` mnn | Carattere col valore ottale `0` mnn (0 `<=` m `<=` 3, 0 `<=` n `<=` 7)
`\x` hh | Carattere col valore esadecimale `0x` hh
### Citazioni
`\` | Nulla, se non il carattere immediatamente successivo. È necessario quando si desidera usare i metacaratteri `!$()*+.<>?[\]^{|}` in modo che vengano utilizzati come caratteri e non come operatori.
`\\` | Per esempio, questa combinazione corrisponde al carattere della barra rovesciata (“ \ ”).
`\Q` | Nulla, ma indica tutti i caratteri fino a `\E`
`\E` | Nulla, ma conclude la citazione iniziata da `\Q`
### Classi per blocchi e categorie Unicode
``\p{InGreek}`` | Carattere nel blocco greco (blocco semplice)
``\p{Lu}`` | Lettera maiuscola (categoria semplice)
``\p{Sc}`` | Simbolo di valuta
``\P{InGreek}`` | Qualsiasi carattere, eccetto uno nel blocco greco (negazione)
``[\p{L}&&[^\p{Lu}]]`` | Qualsiasi lettera, eccetto una lettera maiuscola (sottrazione)
### Classi di caratteri
`[abc]` | `a`, `b`, o `c` (classe semplice)
`[^abc]` | Qualsiasi carattere, eccetto `a`, `b`, o `c` (negazione)
`[a-zA-Z]` | Da `a` a `z` o da `A` a `Z`, compresi (intervallo)
### Classi di carattere predefinite
`.` | Qualsiasi carattere (eccetto i terminatori di riga)
`\d` | Una cifra: `[0-9]`
`\D` | Un carattere non numerico: `[^0-9]`
`\s` | Un carattere di spazio bianco: `[ \t\n\x0B\f\r]`
`\S` | Un carattere che non sia uno spazio bianco: `[^\s]`
`\w` | Un carattere parola: `[a-zA-Z_0-9]`
`\W` | Un carattere non-parola: `[^\w]`
### Rilevatori di limitazione
`^` | Inizio di una riga
`$` | Fine di una riga
`\b` | Limite di una parola
`\B` | Limite di una non-parola
### Quantificatori di ripetizione
Rileveranno tutte le ripetizioni possibili. Per esempio, `a+` rileverà `aaa` in `aaabbb`
X`?` | X, una sola volta oppure nessuna
X`*` | X, zero o più volte
X`+` | X, una o più volte
### Quantificatori riluttanti (non ripetitivi)
Rileveranno il numero minimo possibile. Per esempio, `a+?` rileverà la prima `a` in `aaabbb`
X`??` | X, una sola volta oppure nessuna
X`*?` | X, zero o più volte
X`+?` | X, una o più volte
### Operatori logici
XY | X seguito da Y
X`|`Y | X oppure Y
`(`XY`)` | XY come gruppo singolo

## Strumenti per le espressioni regolari ed esempi di utilizzo

Sono disponibili diversi strumenti interattivi dedicati allo sviluppo e alla verifica delle espressioni regolari. Essi seguono quasi tutti lo stesso schema (vedere sotto un esempio all'interno di un plugin per Firefox): l'espressione regolare (voce in alto) analizza il testo da ricercare (riquadro al centro), restituendo i risultati, mostrati nel riquadro dei risultati.
Per eseguire verifiche con uno strumento indipendente, nelle versioni per Windows, Linux, Mac e FreeBSD, usare The Regex Coach, che funziona in modo quasi identico all'esempio di cui sopra.
In OmegaT è pure presente una buona raccolta di utili esempi regex (si veda Opzioni > Segmentazione). L'elenco seguente include espressioni che potrebbero risultare utili quando si eseguono ricerche attraverso la memoria di traduzione:

Espressione regolare | Trova il seguente:
(\b\w+\b)\s\1\b | doppie parole
[\.,]\s*[\.,]+ | t virgole e punti mischiati
\. \s$ | spazi aggiuntivi, che seguono il punto alla fine della riga
\s+a\s+[aeiou] | Inglese: le parole, inizianti per vocali, devono essere precedute da "an" e non "a"
\s+an\s+[^aeiou] | Inglese: stesso controllo di cui sopra ma per le consonanti ("a", non "an")
\s\s+ | più di uno spazio
\.[A-Z] | spazio mancante tra un punto e l'inizio di una nuova frase

Avvertenze legali | Pagina iniziale | Indice