# Ricerche

## Sommario

- 1. Finestra “Cerca”
- 2. Posizioni di ricerca
- 3. Metodi di ricerca
  - 3.1. Ricerca esatta
  - 3.2. Ricerca con parole chiave
- 4. Ricerca con caratteri jolly
- 5. Ricerca tramite espressioni
  - 5.1. Espressioni ammesse nelle operazioni di ricerca
  - 5.2. Breve riepilogo della creazione di espressioni per la ricerca

## Finestra “Cerca”

OmegaT mette a disposizione un'ampia gamma di funzioni di ricerca.

Richiamare la finestra “Cerca” tramite la combinazione rapida da tastiera `Ctrl+F` e inserire nel campo “Cerca” la parola o la frase che si desidera reperire.

In alternativa, selezionare una parola o una frase da un campo di modifica (campo nel quale si scrive il testo di arrivo del segmento attivo) e premere `Ctrl+F`. La parola o la frase selezionata viene automaticamente immessa all'interno del campo “Cerca”.

Quando si richiama la finestra “Cerca” ne viene sempre aperta una nuova. Il risultato potrebbe essere che, se si dimentica di chiudere le finestre di ricerca precedentemente aperte, vi saranno varie finestre “Cerca” aperte.

La ricerca viene avviata sia sul testo di partenza sia su quello di arrivo di un progetto.

## Posizioni di ricerca

Selezionare la posizione di ricerca attivando le opportune caselle di opzione.

La ricerca può essere avviata su varie posizioni:

- Solo all'interno del progetto (condizione predefinita);
- Nel progetto e all'interno delle memorie di traduzione di riferimento contenute nella directory /tm/ (in questo caso attivare la casella di controllo Ricerca nella TM);
- In un singolo file o in una particolare cartella che contiene una serie di file (in questo caso attivare la casella di controllo Ricerca file).

In quest'ultimo caso, OmegaT avvierà la ricerca solo all'interno dei file che è in grado di riconoscere (si veda Formati di file riconosciuti).

## Metodi di ricerca

Selezionare il metodo di ricerca attivando l'opportuno pulsante di opzione.

Si ha la possibilità di attivare due metodi di ricerca:

- Ricerca esatta: avvia la ricerca dei segmenti contenenti esattamente la stringa immessa nel campo “Cerca”;
- Ricerca parola chiave: avvia la ricerca dei segmenti contenenti tutte le parole immesse all'interno del campo “Cerca”, indipendentemente dall'ordine di immissione.

Per entrambi questi metodi si avrà la possibilità di selezionare una delle tre opzioni seguenti:

- Case sensitive: la selezione di questa casella di opzione farà sì che venga ricercata l'esatta corrispondenza (comprese le lettere maiuscole e minuscole) della stringa immessa nel campo “Cerca”; in caso contrario la ricerca verrà avviata ignorando la presenza di lettere maiuscole e minuscole.
- Regular expressions: se si seleziona questa casella di opzione, la stringa immessa nel campo “Cerca” verrà considerata come un'espressione (nel caso di una ricerca di più parole chiave, queste verranno considerate come più espressioni).
- Ricerca nella TM: la selezione di questa casella di opzione farà si che la ricerca venga avviata in tutte le memorie di traduzione.

## Ricerca esatta

Una ricerca esatta di una frase, ovvero della sequenza di parole immessa nel campo “Cerca”, darà un risultato solo se le parole immesse verranno reperite nella medesima sequenza. Le ricerche esatte sono simili alla funzione “frase esatta” di un motore di ricerca Internet, come Google.

## Ricerca con parole chiave

Selezionare il pulsante di opzione “Ricerca parole chiave” e immettere nel campo “Cerca” una serie di parole singole, separate da uno spazio e in un qualsiasi ordine; OmegaT visualizzerà un elenco di tutti i segmenti nei quali compaiono tutte le parole immesse. Le ricerche di parole chiave sono simili alle ricerche di “tutte le parole” di un motore di ricerca Internet, come Google (in base a un operatore logico AND).

## Ricerca con caratteri jolly

Sia le ricerche esatte, sia quelle di parole chiave consentono di utilizzare i caratteri jolly “`*`” e “`?`”. Quando si usano i caratteri jolly accertarsi di non selezionare la casella di opzione Regular expressions, perché l'attivazione di questa casella farebbe sì che i caratteri jolly vengano interpretati come operatori di un'espressione.

Il carattere jolly “`?`” corrisponde all'indicazione di un singolo carattere nella posizione specificata (ovvero, l'immissione di “`ca?a`” estrarrà le corrispondenze contenenti, per esempio, “`casa`” e “`cara`”. Il carattere jolly “`*`” corrisponde a un qualsiasi carattere e a un qualsiasi numero di caratteri a partire dalla posizione di immissione (ovvero, l'immissione di “`ca*a`” estrarrà, per esempio, le corrispondenze contenenti “`casa`”, “`cara`” ma anche “`caserma`” e “`campata`”.

Se si desidera ricercare segmenti contenenti questi caratteri (in modo che non vengano interpretati come caratteri jolly) sarà necessario avviare una ricerca per espressioni e associare questi caratteri a una barra rovesciata (“`\`”); per esempio, se nel campo “Cerca” viene immessa la stringa “`x\*y`” verranno estratti i segmenti contenenti “`x*y`”, mentre “`x\?y`” estrae quelli contenenti “`x?y`”.

## Ricerca tramite espressioni

La ricerca tramite espressioni è un sistema particolarmente valido per reperire alcuni elementi di un segmento. È simile a una ricerca normale, ma consente una flessibilità maggiore. Il Web mette a disposizione varie spiegazioni semplificate sull'uso delle espressioni (si acceda, per esempio, a http://www.regular-expressions.info/quickstart.html).

### Espressioni ammesse nelle operazioni di ricerca

Le espressioni ammesse per le operazioni di ricerca sono quelle riconosciute da Java. Se si desiderano ulteriori informazioni, si consiglia di accedere alla pagina http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/Pattern.html.

#### Breve riepilogo della creazione di espressioni

Espressione | Risultato
--- | ---
Flag
`(?i)` | Consente di avviare una ricerca che tenga in considerazione lettere maiuscole e minuscole (per default, il modello riconosce le maiuscole e le minuscole).
Caratteri
x | Viene rilevato il carattere corrispondente a “x”, ma con le seguenti eccezioni...
`\u` hhhh | Carattere associato a un 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'`)
Citazioni
`\` | Nulla, se non il carattere immediatamente successivo. È necessario quando si desidera usare i metacaratteri `!$()*+.<>?[\]^{|}` in modo che vengano rilevati 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 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 (con eccezione dei 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

Avvertenze legali