<?xml version="1.0" encoding="UTF-8"?>
<article id="Filters">
  <title>Uso dei filtri<indexterm>
      <primary>filtri</primary>

      <seealso>filtri di file</seealso>

      <seealso>maschere di file</seealso>

      <seealso>filtri di linea</seealso>

      <seealso>filtri sostitutivi</seealso>
    </indexterm></title>

  <para>Quando confronti file o cartelle, puoi usare i filtri per restringere
l'ambito del confronto. Ciò può essere utile quando vuoi semplificare il
risultato del confronto eliminando le differenze che non ti interessano. I
filtri sono regole basate su espressioni regolari. WinMerge usa il popolare
motore di espressioni regolari PCRE (Perl Compatibile Regular
Expressions).<indexterm>
      <primary>espressioni regolari</primary>

      <secondary>motore supportato</secondary>
    </indexterm><indexterm>
      <primary>Motore di espressioni regolari PCRE</primary>
    </indexterm><indexterm>
      <primary>espressione regolare</primary>

      <see>espressioni regolari</see>
    </indexterm></para>

  <para>La funzione di base del filtro è semplice: valuta ogni elemento che verrebbe
normalmente confrontato (una cartella, un file o una riga all'interno di un
file) e, se l'espressione del filtro corrisponde all'elemento di
destinazione, applica il filtro. A seconda del tipo di filtro, l'elemento
viene incluso o escluso dal confronto.</para>

  <para>Esistono diversi filtri WinMerge per le operazioni di confronto di cartelle
e file:</para>

  <variablelist>
    <varlistentry>
      <term>Confronto cartelle: maschere di file e filtri di file<indexterm>
          <primary>confronto delle cartelle</primary>

          <secondary>filtraggio</secondary>
        </indexterm></term>

      <listitem>
        <para>È possibile specificare i file da includere in un confronto di cartelle
usando semplici maschere di file o, per filtri più complessi, applicando più
regole specificate in un filtro di file.</para>

        <para>I file e le cartelle filtrati vengono nascosti nel risultato per
impostazione predefinita, che in genere è ciò che vuoi. Puoi fare clic su
<menuchoice> <guimenu>Visualizza</guimenu> <guimenuitem>Visualizza elementi
saltati</guimenuitem> </menuchoice> per visualizzare gli elementi filtrati,
ma la finestra Confronta cartellevisualizza solo informazioni minime su di
essi. Ad esempio, non è possibile stabilire se un file ignorato è un file di
testo o binario.</para>

        <para>Il filtro visualizzazione file/cartelle è disponibile anche per le
operazioni di confronto delle cartelle. A differenza dei filtri file, non
influisce sul risultato del confronto; controlla solo quali elementi sono
visibili nella finestra 'Confronto cartelle'. Vedi <xref
linkend="Filters_DisplayFileFolderFilter"/>.</para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term>Confronti di file: filtri di riga e filtri di sostituzione<indexterm>
          <primary>confronto dei file</primary>

          <secondary>filtraggio</secondary>
        </indexterm></term>

      <listitem>
        <para>I filtri di riga vengono applicati solo alle operazioni di confronto dei
file. Ti consentono di ignorare le differenze su una singola riga.</para>
        <para>I filtri di sostituzione vengono applicati solo alle operazioni di confronto
dei file. Sostituiscono le stringhe nel blocco diff con le stringhe
specificate, le confrontano e ignorano il blocco diff se i risultati della
sostituzione corrispondono. Sono utili per ignorare un gran numero di
modifiche poco interessanti.</para>
        <para>Il filtro della riga di visualizzazione viene applicato anche solo alle
operazioni di confronto dei file. A differenza dei filtri di linea, non
influisce sul risultato del confronto; controlla solo quali linee sono
visibili nella finestra 'Confronta file'. Vedi <xref
linkend="Filters_DisplayLineFilter"/>.</para>
      </listitem>
    </varlistentry>
  </variablelist>

  <section id="Filters_Mask">
    <title>Uso delle maschere dei file<indexterm>
        <primary>maschere di file</primary>
      </indexterm><indexterm>
        <primary>filtri</primary>

        <secondary>maschere di file</secondary>
      </indexterm><indexterm>
        <primary>filtri</primary>

        <secondary>nei confronti delle cartelle</secondary>
      </indexterm></title>

    <para>È possibile usare una o più <glossterm>maschere file</glossterm> che
specificano le estensioni dei file da includere in un confronto di
cartelle. Tutti gli altri file vengono omessi dalla selezione.</para>

    <section id="Filters_MaskApply">
      <title>Definizione e applicazione di maschere di file<indexterm>
          <primary>riga di comando</primary>

          <secondary>applicare maschere di file</secondary>
        </indexterm></title>

      <para>Definisci e applica una maschera file nel momento in cui avvii l'operazione
di confronto delle cartelle:</para>

      <itemizedlist>
        <listitem>
          <para>Se stai usando la finestra di dialogo Seleziona file o cartelle, dopo aver
scelto le cartelle <guilabel>1a</guilabel> e <guilabel>2a</guilabel>,
inserisci una o più maschere di file nel campo
<guilabel>Filtro</guilabel>. Le maschere vengono applicate quando si avvia
l'operazione di confronto delle cartelle.</para>
        </listitem>

        <listitem>
          <para>Se stai usando la riga di comando di WinMerge, usa il flag
<option>-f</option> per specificare le maschere dei file (vedi l'esempio
nella prossima sezione).</para>
        </listitem>
      </itemizedlist>
    </section>

    <section id="Filters_MaskSyntax">
      <title>Sintassi ed esempio della maschera file<indexterm>
          <primary>regole</primary>

          <secondary>maschere di file</secondary>
        </indexterm><indexterm>
          <primary>filtri</primary>

          <secondary>maschere di file</secondary>
        </indexterm><indexterm>
          <primary>espressioni regolari</primary>

          <secondary>nelle maschere dei file</secondary>
        </indexterm></title>

      <para>Puoi specificare maschere file e filtri estesi usando questo formato:</para>

      <synopsis>
        <replaceable>Filtro1 Gruppo1</replaceable>;<replaceable>Filtro2</replaceable> ...|<replaceable>Filtro1 Gruppo2</replaceable>;<replaceable>Filtro2</replaceable> ...|...
      </synopsis>

      <itemizedlist>
        <listitem><para>Il carattere <filename>|</filename> separa i gruppi di filtri e funge da AND
logico.</para></listitem>
        <listitem><para>I filtri all'interno dello stesso gruppo sono separati da
<filename>;</filename> e vengono interpretati con un OR logico.</para></listitem>
        <listitem><para>Un file viene incluso solo se corrisponde ad almeno un filtro in ciascun
gruppo.</para></listitem>
        <listitem>
          <para>Per includere un carattere letterale <filename>|</filename> (pipe) in
un'espressione regolare che non è racchiusa tra virgolette doppie (come nei
filtri <filename>f:</filename> o <filename>f!:</filename>), usare invece
<filename>||</filename>.</para>
          <para>Esempio: <userinput>f:(abc||def)\.txt$</userinput></para>
        </listitem>
        <listitem>
          <para>Ciascun filtro (ad esempio, Filtro1, Filtro2) può essere uno dei seguenti
tipi:</para>
          <variablelist>
            <varlistentry><term><replaceable>*.ext</replaceable></term><listitem><para>Maschera file per estensione (ad es. *.txt)</para></listitem></varlistentry>
            <varlistentry><term><replaceable>*.</replaceable></term><listitem><para>File senza estensione (ad esempio README)</para></listitem></varlistentry>
            <varlistentry><term>!<replaceable>*.ext</replaceable></term><listitem><para>Escludi file corrispondenti all'estensione (disponibile dalla versione
2.16.19)</para></listitem></varlistentry>
            <varlistentry><term><replaceable>cartella</replaceable>\</term><listitem><para>Cartelle di destinazione (devono terminare con \) (disponibile dal 16.2.19)</para></listitem></varlistentry>
            <varlistentry><term>!<replaceable>cartella</replaceable>\</term><listitem><para>Escludi cartelle corrispondenti (disponibile dal 16.2.19)</para></listitem></varlistentry>
            <varlistentry><term>f: <replaceable>regexp</replaceable></term><listitem><para>Abbina i nomi dei file usando le espressioni regolari (disponibile dalla
versione 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>f!: <replaceable>regexp</replaceable></term><listitem><para>Escludi file corrispondenti a regex (disponibile dalla versione 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>d: <replaceable>regexp</replaceable></term><listitem><para>Abbina i nomi delle cartelle usando regex (disponibile dalla versione
2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>d!: <replaceable>regexp</replaceable></term><listitem><para>Escludi cartelle corrispondenti a regex (disponibile dal 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>fe: <replaceable>espressione</replaceable></term><listitem><para>Espressione di filtro per file (ad esempio fe:Size &lt; 1KB) (disponibile
dal 16.2.49)</para></listitem></varlistentry>
            <varlistentry><term>fe!: <replaceable>expr</replaceable></term><listitem><para>Espressione di filtro per escludere file (disponibile dalla versione
2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>de: <replaceable>espressione</replaceable></term><listitem><para>Espressione di filtro per cartelle (disponibile dalla versione 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>de!: <replaceable>espressione</replaceable></term><listitem><para>Espressione di filtro per escludere cartelle (disponibile dalla versione
2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>pf: <replaceable>nome filtro file</replaceable></term><listitem><para>Applica un filtro file per nome (disponibile dalla versione 2.16.49)</para></listitem></varlistentry>
          </variablelist>
        </listitem>
      </itemizedlist>

      <example>
        <title>Maschera di archivio</title>

        <para>In questo esempio da riga di comando, l'operazione di confronto delle
cartelle include solo file con estensioni <filename>xml</filename> o
<filename>txt</filename>. Tutti gli altri file vengono omessi:</para>

        <para><userinput>WinMergeU c:\project\docs c:\temp /f *.xml;*.txt</userinput></para>
      </example>

      <example>
        <title>Escluse le cartelle (dalla versione 2.16.19)</title>

        <para>In questo esempio da riga di comando, l'operazione di confronto delle
cartelle esclude le cartelle <filename>.git</filename> e
<filename>.vs</filename>:</para>

        <para><userinput>WinMergeU c:\project\docs c:\temp /f !.git\;!.vs\</userinput></para>
      </example>

      <example>
        <title>Espressione filtro (dalla versione 2.16.49)</title>

        <para>In questo esempio da riga di comando, l'operazione di confronto delle
cartelle include solo file con estensioni <filename>cpp</filename> o
<filename>h</filename> e una dimensione di file inferiore a 1 KB:</para>

        <para><userinput>WinMergeU c:\project\docs c:\temp /f "*.cpp;*.h|fe:Dimensione
&lt; 1KB"</userinput></para>
      </example>
    </section>

    <section id="FilterExpression_Syntax">
      <title>Sintassi dell'espressione di filtro</title>

      <para>
WinMerge consente un potente filtraggio usando espressioni che operano sui
metadati dei file, sui contenuti e sul contesto di confronto. Questa sezione
descrive gli attributi, gli operatori, le funzioni, i tipi di dati e le
regole di valutazione supportati.</para>

      <section id="FilterExpression_Literals">
        <title>Letterali e tipi</title>

        <para>I tipi letterali supportati includono:</para>
        <itemizedlist>
          <listitem><para><emphasis>Booleano</emphasis>: <literal>vero</literal>,
<literal>falso</literal></para></listitem>
          <listitem><para><emphasis>Null</emphasis>: <literal>none</literal> (rappresenta un valore
nullo o mancante)</para></listitem>
          <listitem><para><emphasis>Intero</emphasis>: interi con segno a 64 bit (ad esempio,
<literal>1024</literal> o con unità come <literal>100KB</literal>,
<literal>7 giorni</literal>)</para></listitem>
          <listitem><para><emphasis>Reale (doppio)</emphasis>: numeri in virgola mobile con decimale o
esponente opzionale (ad esempio, <literal>3.14</literal>,
<literal>.5</literal>, <literal>1e6</literal>)</para></listitem>
          <listitem><para><emphasis>Stringa</emphasis>: racchiusa tra virgolette doppie (ad esempio,
<literal>"esempio"</literal>)</para></listitem>
          <listitem><para><emphasis>Data/Ora</emphasis>: preceduto da <literal>d</literal> e racchiuso
tra virgolette doppie (ad esempio, <literal>d"2026-05-21
07:16:33"</literal>, <literal>d"2026-05-21"</literal>)</para></listitem>
        </itemizedlist>

        <para>
Internamente, i valori possono essere dei seguenti tipi: booleano, intero,
reale, timestamp, stringa, contenuto file, array o
<literal>nessuno</literal>.</para>
      </section>

      <section id="FilterExpression_Directives">
        <title>Direttive</title>

        <para>
Le espressioni di filtro supportano direttive che controllano il modo in cui
viene valutata l'espressione. Le direttive sono specificate all'inizio
dell'espressione, precedute da <literal>@</literal> e separate
dall'espressione da spazi bianchi.</para>

        <section id="FilterExpression_CaseSensitivity">
          <title>Direttive sulla distinzione tra maiuscole e minuscole</title>

          <para>
Per impostazione predefinita, tutti gli operatori di confronto di stringhe
(<literal>=</literal>, <literal>!=</literal>, <literal>&lt;</literal>,
<literal>&lt;=</literal>, <literal>&gt;</literal>, <literal>&gt;=</literal>,
<literal>contains</literal>, <literal>recontains</literal>,
<literal>like</literal>,<literal>corrispondenze</literal>) non fanno
distinzione tra maiuscole e minuscole. Puoi controllare questo comportamento
usando le seguenti direttive:</para>

          <variablelist>
            <varlistentry>
              <term><literal>@cs</literal>, <literal>@casesensitive</literal></term>
              <listitem>
                <para>
Abilita il confronto con distinzione tra maiuscole e minuscole. Con queste
direttive, <literal>"ABC"</literal> e <literal>"abc"</literal> sono
considerati diversi.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><literal>@ci</literal>, <literal>@caseinsensitive</literal></term>
              <listitem>
                <para>
Abilita il confronto senza distinzione tra maiuscole e minuscole
(comportamento predefinito). Con queste direttive, <literal>"ABC"</literal>
e <literal>"abc"</literal> sono considerati identici.</para>
              </listitem>
            </varlistentry>
          </variablelist>

          <example>
            <title>Esempi di distinzione tra maiuscole e minuscole</title>
<programlisting>@cs Name = "README.txt" ## Con distinzione tra maiuscole e minuscole: corrisponde solo a "README.txt"
@ci Name = "readme.txt" ## Senza distinzione tra maiuscole e minuscole: corrisponde a "README.txt", "readme.txt", "ReadMe.TXT", ecc.
@casesensitive Estensione = "TXT" ## Con distinzione tra maiuscole e minuscole: corrisponde solo ai file con estensione ".TXT".
@caseinsensitive Il contenuto contiene "errore" ## Non distingue tra maiuscole e minuscole: corrisponde a "Errore", "ERRORE", "errore", ecc.</programlisting></example>
        </section>

        <section id="FilterExpression_Optimize">
          <title>Direttive di ottimizzazione</title>

          <para>
Per impostazione predefinita, le espressioni di filtro sono ottimizzate per
migliorare le prestazioni. Puoi controllare questo comportamento usando le
seguenti direttive:</para>

          <variablelist>
            <varlistentry>
              <term><literal>@ottimizzare</literal>, <literal>@opt</literal></term>
              <listitem>
                <para>
Abilita l'ottimizzazione dell'espressione del filtro (comportamento
predefinito). Ciò potrebbe migliorare le prestazioni per le espressioni
complesse.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><literal>@nooptimize</literal>, <literal>@noopt</literal></term>
              <listitem>
                <para>
Disabilita l'ottimizzazione dell'espressione del filtro. Ciò è utile per il
debug o quando l'ottimizzazione provoca risultati imprevisti.</para>
              </listitem>
            </varlistentry>
          </variablelist>

          <example>
            <title>Esempi di ottimizzazione</title>
<programlisting>@ottimizza dimensioni &gt;10 MB ed estensione = "log" ## Abilita ottimizzazione (impostazione predefinita)
@noopt Il nome corrisponde a "complesso[0-9]+modello" ## Disabilita l'ottimizzazione per il debug
@nooptimize Il contenuto contiene "caso speciale" ## Disattiva l'ottimizzazione</programlisting></example>
        </section>

        <section id="FilterExpression_Name">
          <title>Direttiva sui nomi</title>

          <para>
La direttiva <literal>@name</literal> consente di assegnare un nome
descrittivo a un'espressione di filtro. Questo nome è destinato all'uso nei
messaggi di errore e nei log per identificare quale espressione di filtro ha
causato un problema.</para>

          <variablelist>
            <varlistentry>
              <term><literal>@name="Nome filtro"</literal>, <literal>@name=Nome filtro</literal></term>
              <listitem>
                <para>
Assegna un nome all'espressione di filtro. Se il nome contiene spazi o
caratteri speciali, deve essere racchiuso tra virgolette doppie. I nomi
senza spazi possono essere specificati senza virgolette.</para>
                <para>
Il nome specificato verrà usato nei messaggi di errore e nell'output
diagnostico per identificare il filtro. Ciò è particolarmente utile quando
si lavora con più espressioni di filtro complesse.</para>
              </listitem>
            </varlistentry>
          </variablelist>

          <example>
            <title>Esempi di direttive sui nomi</title>
<programlisting>@name="Dimensioni file immagine di grandi dimensioni" &gt;10 MB ed estensione = "png"
@name=Dimensione SmallTextFiles &lt;1KB ed estensione = "txt"
@name="Data modificata oggi" &gt;= oggi()
@name="Test Filter" @cs Nome come "test_*.cpp"</programlisting></example>

          <note>
            <para>
La direttiva <literal>@name</literal> può essere combinata con altre
direttive. Quando vengono usate più direttive, dovrebbero apparire tutte
all'inizio dell'espressione, separate da spazi bianchi.</para>
          </note>
        </section>
      </section>

      <section id="FilterExpression_Attributes">
        <title>Attributi</title>

        <para>
Le espressioni di filtro supportano una varietà di attributi che fanno
riferimento ai metadati e al contenuto dei file. I nomi degli attributi non
fanno distinzione tra maiuscole e minuscole. Facoltativamente, è possibile
specificare a quale lato del confronto (Sinistra, Destra o Centro) si
applica un attributo usando un prefisso.</para>

        <section>
          <title>Attributi fondamentali</title>
          <variablelist>
            <varlistentry>
              <term><varname>Exists</varname></term>
              <listitem><para>Restituisce <literal>true</literal> se il file esiste,
<literal>false</literal> altrimenti</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Name</varname></term>
              <listitem><para>Nome del file</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>BaseName</varname></term>
              <listitem><para>Restituisce il nome del file senza estensione. Ad esempio, "document.txt"
restituisce "documento".</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Extension</varname></term>
              <listitem><para>Estensione file</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>IsFolder</varname></term>
              <listitem><para>Restituisce vero se l'elemento è una cartella/cartella, falso se è un file.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Folder</varname></term>
              <listitem><para>Restituisce il percorso relativo escludendo il nome del file e la cartella
di base</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>RelPath</varname></term>
              <listitem><para>Restituisce il percorso relativo dalla cartella principale di confronto,
inclusi sia il percorso della cartella che il nome del file. Ad esempio, se
si confronta "C:\Project" e il file si trova in "C:\Project\src\main.cpp",
RelPath restituisce "src\main.cpp".</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>FullPath</varname></term>
              <listitem><para>Restituisce il percorso completo del file</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Size</varname></term>
              <listitem><para>Dimensioni del file</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Date</varname></term>
              <listitem><para>Ultima data e ora modificata</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>DateStr</varname></term>
              <listitem><para>Stringa della data dell'ultima modifica nel formato
<literal>aaaa-MM-gg</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>CreationTime</varname></term>
              <listitem><para>Timestamp della data di creazione</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Attributes</varname></term>
              <listitem><para>Restituisce gli attributi del file come valore intero</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>AttrStr</varname></term>
              <listitem>
                <para>Restituisce la stringa dell'attributo del file. Esempi:
<literal>"R"</literal> per sola lettura, <literal>"H"</literal> per
nascosto, <literal>"A"</literal> per archivio, <literal>"S"</literal> per
file di sistema.</para>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section>
          <title>Attributi solo file</title>
          <para>
I seguenti attributi sono disponibili solo per gli elementi di confronto
file. Se usato con elementi di cartelle, il comportamento non è definito.</para>

          <variablelist>
            <varlistentry>
              <term><varname>Content</varname></term>
              <listitem><para>Contenuto del file. Restituisce un valore di tipo FileContent. Con questo
tipo è possibile usare solo <literal>contains</literal> e
<literal>recontains</literal>.</para></listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section>
          <title>Attributi solo cartella</title>
          <para>
I seguenti attributi sono disponibili solo per gli elementi di confronto
delle cartelle. Se usato con elementi file, il comportamento non è definito.</para>

          <variablelist>
            <varlistentry>
              <term><varname>Files</varname></term>
              <listitem><para>Numero di file direttamente contenuti nella cartella.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>RecursiveFiles</varname></term>
              <listitem><para>Numero di file contenuti nella cartella, incluse tutte le sottocartelle.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Items</varname></term>
              <listitem><para>Numero di elementi (file e sottocartelle) contenuti direttamente nella
cartella.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>RecursiveItems</varname></term>
              <listitem><para>Numero di elementi (file e sottocartelle) contenuti nella cartella, incluse
tutte le sottocartelle.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>TotalSize</varname></term>
              <listitem><para>Dimensione totale di tutti i file direttamente contenuti nella cartella, in
byte.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>RecursiveTotalSize</varname></term>
              <listitem><para>Dimensione totale di tutti i file contenuti nella cartella, incluse tutte le
sottocartelle, in byte.</para></listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section>
          <title>Prefissi specifici del lato</title>
          <para>
È possibile aggiungere prefissi per specificare il lato di confronto:</para>
          <itemizedlist>
            <listitem><para><emphasis>Sinistra</emphasis>: si applica al file sul lato sinistro (ad
esempio, <literal>LeftSize</literal>)</para></listitem>
            <listitem><para><emphasis>Destra</emphasis>: si applica al file sul lato destro (ad esempio,
<literal>RightDate</literal>)</para></listitem>
            <listitem><para><emphasis>Medio</emphasis>: si applica al file centrale nel confronto a 3
vie (ad esempio, <literal>MiddleName</literal>)</para></listitem>
          </itemizedlist>

          <para>
Gli attributi senza prefisso (ad esempio, <literal>Size</literal>)
restituiscono una matrice di valori da tutti i lati disponibili (Sinistra,
Centro, Destra).</para>
        </section>

        <section>
          <title>Attributi delle proprietà di Windows</title>
          <para>
Questi attributi forniscono l'accesso ai valori del sistema di proprietà di
Windows, come i metadati definiti dallo schema del sistema di proprietà di
Windows (ad esempio, <literal>System.Title</literal>,
<literal>System.FileOwner</literal>,
<literal>System. Image.HorizontalResolution</literal>).</para>

          <variablelist>
            <varlistentry>
              <term><varname>Prop</varname></term>
              <listitem>
                <para>
Restituisce una matrice di valori di proprietà (Sinistra, Centro, Destra)
per il nome della proprietà canonica specificata. Esempio:
<literal>prop("System.Title")</literal></para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>LeftProp</varname></term>
              <listitem>
                <para>
Valore della proprietà del file sul lato sinistro. Esempio:
<literal>leftprop("System.FileOwner")</literal></para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>MiddleProp</varname></term>
              <listitem>
                <para>Valore della proprietà del file centrale (nel confronto a 3 vie).</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>RightProp</varname></term>
              <listitem>
                <para>Valore della proprietà del file sul lato destro.</para>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section>
          <title>Display Filters Only Attributes</title>
          <para>
I seguenti attributi sono progettati per essere usati solo nei filtri
<emphasis role="bold">Display fileters only</emphasis> (specificati tramite
i prefissi <guilabel>e:</guilabel>, <guilabel>e!:</guilabel>,
<guilabel>fe:</guilabel>, <guilabel>fe!:</guilabel>,
<guilabel>de:</guilabel> o <guilabel>de!:</guilabel> in il campo
Filtro). Non devono essere usati nelle regole di inclusione/esclusione del
filtro file (<filename>.flt</filename>), poiché richiedono che il confronto
venga prima completato e potrebbero causare comportamenti imprevisti.</para>

          <variablelist>
            <varlistentry>
              <term><varname>Identical</varname></term>
              <listitem>
                <para>
Restituisce <literal>true</literal> se il risultato del confronto indica che
gli elementi sono identici, <literal>false</literal> se non sono
identici. Questo è un attributo globale (non supporta prefissi specifici del
lato). Esempio: <literal>Identical</literal> visualizzare solo file
identici.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Different</varname></term>
              <listitem>
                <para>
Restituisce <literal>true</literal> se il risultato del confronto indica che
gli elementi sono diversi, <literal>false</literal>se non sono
diversi. Questo è un attributo globale (non supporta prefissi specifici del
lato). Esempio: <literal>Different</literal> per visualizzare solo file
diversi.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Skipped</varname></term>
              <listitem>
                <para>
Restituisce <literal>true</literal> se il confronto è stato saltato a causa
di un errore o di una regola di filtro, <literal>false</literal> se non è
stato saltato. Questo è un attributo globale (non supporta prefissi
specifici del lato). Esempio: <literal>Skipped</literal> per visualizzare
solo gli elementi saltati.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Binary</varname></term>
              <listitem>
                <para>
Restituisce <literal>true</literal> se il file viene rilevato come binario,
<literal>false</literal> se è testo o <literal>none</literal> se il file non
esiste. Questo attributo supporta prefissi specifici del lato (ad esempio,
<literal>LeftBinary</literal>, <literal>RightBinary</literal>). Esempio:
<literal>allof(Binary)</literal> per visualizzare i file binari in tutti i
lati.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>DifferentLeftMiddle</varname></term>
              <listitem>
                <para>
Restituisce <literal>true</literal> se i file a sinistra e in mezzo sono
diversi in un confronto a tre, altrimenti
<literal>false</literal>. Restituisce <literal>none</literal> nei confronti
a due vie. Questo è un attributo globale (non supporta prefissi specifici
del lato). Esempio: <literal>DifferentLeftMiddle e non
DifferentMiddleRight</literal> per trovare file in cui solo la parte a
sinistra differisce da quella centrale.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>DifferentMiddleRight</varname></term>
              <listitem>
                <para>
Restituisce <literal>true</literal> se i file centrale e destro sono diversi
in un confronto a 3 vie, altrimenti <literal>false</literal>. Restituisce
<literal>none</literal> nei confronti a due vie. Questo è un attributo
globale (non supporta prefissi specifici del lato). Esempio:
<literal>DifferentMiddleRight</literal> per visualizza i file in cui al
centro e a destra differiscono.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>DifferentLeftRight</varname></term>
              <listitem>
                <para>
Nei confronti a 3 vie restituisce <literal>true</literal> se i file sinistro
e destro sono diversi, <literal>false</literal> se non sono diversi. Nei
confronti a due vie restituisce <literal>true</literal> se entrambi i file
esistono e sono diversi. Questo è un attributo globale (non supporta
prefissi specifici del lato). Esempio: <literal>DifferentLeftRight</literal>
per visualizzare i file in cui la sinistra e la destra differiscono.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Differences</varname></term>
              <listitem>
                <para>
Restituisce il numero di differenze di testo nel confronto dei file. Questo
attributo è significativo solo per i file di testo che sono stati
confrontati. Questo è un attributo globale (non supporta prefissi specifici
del lato). Esempio: <literal>Differences> 0</literal> per visualizzare file
con differenze, o <literal>Differences> 10</literal> per visualizzare file
con più di 10 differenze.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>IgnoredDiffs</varname></term>
              <listitem>
                <para>
Restituisce il numero di differenze ignorate nel confronto dei file
(differenze filtrate dai filtri di linea o dalle impostazioni degli spazi
bianchi). Questo attributo è significativo solo per i file di testo che sono
stati confrontati. Questo è un attributo globale (non supporta prefissi
specifici del lato). Esempio: <literal>IgnoredDiffs> 0</literal> per
visualizzare file con differenze ignorate, o <literal>Differences = 0 e
IgnoredDiffs> 0</literal> per visualizzare file identici tranne che per le
differenze ignorate.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Unpacker</varname></term>
              <listitem>
                <para>
Restituisce il nome del plugin di decompressione usato per il confronto dei
file o una stringa vuota se non è stato usato alcun programma di
decompressione. Questo è un attributo globale (non supporta prefissi
specifici del lato). Esempio: <literal>Unpacker =
"CompareMSExcelFiles"</literal> per visualizzare i file confrontati usando
il decompressore di Excel o <literal>Unpacker != ""</literal> per
visualizzare tutti i file in cui è stato usato un decompressore.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Prediffer</varname></term>
              <listitem>
                <para>
Restituisce il nome del plugin prediffer usato per il confronto dei file o
una stringa vuota se non è stato usato alcun prediffer. Questo è un
attributo globale (non supporta prefissi specifici del lato). Esempio:
<literal>Prediffer = "IgnoreColumns"</literal> per visualizzare i file
confrontati usando il prediffer IgnoreColumns, o <literal>Prediffer !=
""</literal> per visualizzare tutti i file in cui è stato usato prediffer.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>EOL</varname></term>
              <listitem>
                <para>Restituisce lo stile di fine riga (EOL) come valore intero. Per i file,
restituisce lo stile EOL predominante; per le righe, restituisce lo stile
EOL di quella specifica riga.</para>
                <para>Valori: 0 = None, 1 = LF (Unix), 2 = CR (Mac), 3 = CRLF (Windows), 4 = Mixed
(più stili EOL nel file)</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>EOLStr</varname></term>
              <listitem>
                <para>Restituisce lo stile di fine riga (EOL) come stringa. Per i file,
restituisce lo stile EOL predominante; per le righe, restituisce lo stile
EOL di quella specifica riga.</para>
                <para>Valori: "None", "LF", "CR", "CRLF", "Mixed"</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Codepage</varname></term>
              <listitem>
                <para>
Restituisce la pagina codici del file (codifica dei caratteri) come valore
intero. Questo attributo supporta prefissi specifici del lato (ad esempio,
<literal>LeftCodepage</literal>, <literal>RightCodepage</literal>). Esempio:
<literal>Codepage = 65001</literal> per visualizzare file UTF-8 o
<literal>allof(Codepage = 65001)</literal> per visualizzare file UTF-8 in
tutti i lati.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>HasBOM</varname></term>
              <listitem>
                <para>
Restituisce <literal>true</literal> se il file ha un Byte Order Mark (BOM),
<literal>false</literal> altrimenti. Questo attributo supporta prefissi
specifici del lato (ad esempio, <literal>LeftHasBOM</literal>,
<literal>RightHasBOM</literal>). Esempio: <literal>HasBOM</literal> per
visualizzare file con BOM, o <literal>not HasBOM</literal> per visualizzare
file senza BOM.</para>
              </listitem>
            </varlistentry>

          </variablelist>
        </section>

        <section id="FilterExpression_ArrayEvaluation">
          <title>Valutazione della matrice</title>

          <para>
Gli attributi senza prefisso laterale (ad esempio, <literal>Size</literal>)
restituiscono una matrice di valori da tutti i lati disponibili (Sinistra,
Centro, Destra). Quando si applica un operatore a tali array, il
comportamento varia a seconda che il confronto avvenga con una matrice
scalare o con un altro.</para>

          <section id="FilterExpression_ArrayVsScalar">
            <title>Array vs scalare</title>
            <para>
Quando si confronta una matrice con uno scalare, l'operazione viene
applicata individualmente a ciascun elemento dell'array. Ciò si traduce in
una matrice booleano. Se qualsiasi elemento in questo array booleano è
<literal>true</literal>, l'espressione complessiva restituisce
<literal>true</literal>. Altrimenti, restituisce <literal>false</literal>.</para>
            <example>
              <title>Esempio</title>
<programlisting>[3, 5, 8] &gt;6 -> [falso, falso, vero] -> vero</programlisting></example>
          </section>

          <section id="FilterExpression_ArrayVsArray">
            <title>Array contro array</title>
            <para>
Quando si confrontano due array, il comportamento dipende dall'operatore:</para>
            <itemizedlist>
              <listitem>
                <para>
Per <literal>=</literal> e <literal>!=</literal>: gli array devono avere la
stessa lunghezza. Il risultato è un singolo valore booleano, non una
matrice.<literal>=</literal> restituisce <literal>true</literal> solo se
tutti gli elementi sono uguali.<literal>!=</literal> restituisce
<literal>true</literal> se qualche elemento è diverso.</para>
              </listitem>
              <listitem>
                <para>
Per tutti gli altri operatori (ad esempio, <literal>&gt;</literal>,
<literal>&lt;</literal>): l'operazione viene applicata per elemento,
producendo una matrice booleana. Il risultato finale dell'espressione è
<literal>true</literal> se qualsiasi elemento nell'array booleano è
<literal>true</literal> e <literal>false</literal> se tutti gli elementi
sono <literal>false</literal>.</para>
              </listitem>
            </itemizedlist>

            <example>
              <title>Esempi</title>
<programlisting>[2, 4] = [2, 4] -> vero</programlisting> <programlisting>[2, 4] != [2, 5] -> vero (perché 4 != 5)</programlisting> <programlisting>[3, 5, 8] &gt;[6, 4, 2]
-> [falso, vero, vero]
-> vero (perché almeno un confronto è vero)
              </programlisting></example>
          </section>

          <section id="FilterExpression_ArraySummary">
            <title>Riepilogo</title>
            <itemizedlist>
              <listitem>
                <para>
I confronti tra array e scalari producono una matrice booleano. Il risultato
complessivo dell'espressione è <literal>true</literal> se almeno un elemento
è <literal>true</literal>.</para>
              </listitem>
              <listitem>
                <para>
Array vs array con <literal>=</literal> o <literal>!=</literal> restituisce
un singolo valore booleano.</para>
              </listitem>
              <listitem>
                <para>
Array vs array con altri operatori produce una matrice booleano. Il
risultato finale è <literal>true</literal> se qualsiasi elemento è
<literal>true</literal>.</para>
              </listitem>
            </itemizedlist>
          </section>
        </section>
      </section>

      <section id="FilterExpression_Operators">
        <title>Operatori</title>

        <para>
Per impostazione predefinita, tutti gli operatori di confronto di stringhe
(come <literal>=</literal>, <literal>!=</literal>, <literal>&lt;</literal>,
<literal>&lt;=</literal>, <literal>&gt;</literal>, <literal>&gt;=</literal>,
<literal>like</literal>, <literal>match</literal>,
<literal>contains</literal> e<literal>recontains</literal>) non fanno
distinzione tra maiuscole e minuscole. Puoi controllare questo comportamento
usando le direttive (vedi <xref linkend="FilterExpression_CaseSensitivity"
/>).</para>

        <variablelist>
          <varlistentry>
            <term><literal>&lt;</literal>, <literal>&lt;=</literal>, <literal>&gt;</literal>,
<literal>&gt;=</literal></term>
            <listitem><para>Confronto numerico, timestamp o stringa</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>=</literal></term>
            <listitem><para>Confronto sull'uguaglianza</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>!=</literal></term>
            <listitem><para>Confronto delle disuguaglianze</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>+</literal>, <literal>-</literal>, <literal>*</literal>,
<literal>/</literal>, <literal>%</literal></term>
            <listitem>
              <para>
Operatori aritmetici.<literal>+</literal> e <literal>-</literal> eseguono
addizioni e sottrazioni.<literal>*</literal> e <literal>/</literal> eseguono
moltiplicazioni e divisioni.<literal>%</literal> è l'operatore modulo
(resto).</para>
            </listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>e</literal>, <literal>o</literal>, <literal>non</literal></term>
            <listitem><para>Operatori logici</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>mi piace</literal></term>
            <listitem>
              <para>Corrispondenza di stringhe di caratteri jolly</para>
              <para>Puoi anche usare <literal>not like</literal> per eseguire la corrispondenza
inversa.</para>
            </listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>corrisponde</literal></term>
            <listitem>
              <para>Corrisponde alle espressioni regolari</para>
              <para>Puoi anche usare <literal>notmatch</literal> per eseguire la corrispondenza
inversa.</para>
            </listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>contiene</literal></term>
            <listitem>
              <para>Controlla se una stringa contiene una sottostringa</para>
              <para>Puoi anche usare <literal>not contiene</literal> per verificare l'assenza
della sottostringa.</para>
            </listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>contiene</literal></term>
            <listitem>
              <para>Controlla se qualche sottostringa corrisponde a un'espressione regolare</para>
              <para>Puoi anche usare <literal>not recontains</literal> per assicurarti che non
esista alcuna corrispondenza.</para>
            </listitem>
          </varlistentry>
        </variablelist>
      </section>

      <section id="FilterExpression_Functions">
        <title>Funzioni</title>

        <para>
Le espressioni di filtro supportano varie funzioni per la manipolazione e
l'analisi dei dati. Per una più facile consultazione le funzioni sono
organizzate per categoria.</para>

        <section id="FilterExpression_StringFunctions">
          <title>Funzioni stringa</title>
          <variablelist>
            <varlistentry>
              <term><function>strlen</function>(<replaceable>fonte</replaceable>)</term>
              <listitem><para>Restituisce la lunghezza della stringa come <literal>Intero</literal>. Se
<replaceable>source</replaceable> è una matrice di stringhe, il risultato è
una matrice di numeri interi. Esempio: <literal>strlen(Nome)</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>strCount</function>(<replaceable>str</replaceable>,
<replaceable>substr</replaceable>)</term>
              <listitem>
                <para>
Conta quante volte la sottostringa <replaceable>substr</replaceable> appare
in <replaceable>str</replaceable>. Per impostazione predefinita, la ricerca
non fa distinzione tra maiuscole e minuscole (rispetta le direttive
<literal>@cs</literal>/<literal>@ci</literal>). Se
<replaceable>str</replaceable> è una matrice, il risultato è una matrice di
numeri interi con conteggi per ciascun elemento. Le corrispondenze
sovrapposte vengono conteggiate separatamente (ad esempio,
<literal>strCount("aaaa", "aa")</literal> restituisce 2).</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>strCount("ciao ciao mondo", "ciao")</literal> restituisce 2</para></listitem>
                  <listitem><para><literal>strCount("Test TEST test", "test")</literal> restituisce 3 (senza
distinzione maiuscole/minuscole)</para></listitem>
                  <listitem><para><literal>@cs strCount("Test TEST test", "test")</literal> restituisce 1 (con
distinzione tra maiuscole e minuscole)</para></listitem>
                  <listitem><para><literal>le:strCount(Line, "ERROR") > 2</literal> visualizza le righe
contenenti "ERROR" più di due volte</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>regexCount</function>(<replaceable>str</replaceable>,
<replaceable>pattern</replaceable>)</term>
              <listitem>
                <para>
Conta quante volte l'espressione regolare <replaceable>pattern</replaceable>
corrisponde a <replaceable>str</replaceable>. Per impostazione predefinita,
la ricerca non fa distinzione tra maiuscole e minuscole (rispetta le
direttive <literal>@cs</literal>/<literal>@ci</literal>). Se
<replaceable>str</replaceable> è una matrice, il risultato è una matrice di
numeri interi con conteggi per ciascun elemento. Le corrispondenze di
lunghezza zero vengono gestite con garbo per evitare cicli infiniti.</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>regexCount("test123abc456", "\d+")</literal> restituisce 2</para></listitem>
                  <listitem><para><literal>regexCount("AAA BBB CCC", "[A-Z]+")</literal> restituisce 3</para></listitem>
                  <listitem><para><literal>@cs regexCount("Test TEST", "TEST")</literal> restutuisce 1</para></listitem>
                  <listitem><para><literal>le:regexCount(Line, "\b(error|warning)\b") > 0</literal> visualizza
righe con parole chiave errore o avviso</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>strFind</function>(<replaceable>str</replaceable>,
<replaceable>substr</replaceable>[, <replaceable>occurrence</replaceable>])</term>
              <listitem>
                <para>
Trova la posizione (in base 0) dell'ennesima occorrenza della sottostringa
<replaceable>substr</replaceable> in <replaceable>str</replaceable>. Il
parametro facoltativo <replaceable>occurrence</replaceable> specifica quale
occorrenza trovare (in base 0, il valore predefinito è 0 per la prima
occorrenza). Per impostazione predefinita, la ricerca non fa distinzione tra
maiuscole e minuscole (rispetta le direttive
<literal>@cs</literal>/<literal>@ci</literal>). Se la sottostringa non viene
trovata o se l'indice delle occorrenze è fuori intervallo restituisce
<literal>none</literal>. Se <replaceable>str</replaceable> è una matrice, il
risultato è una matrice di posizioni (o nessun valore).</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>strFind("ciao mondo", "o")</literal> restituisce 4 (prima 'o')</para></listitem>
                  <listitem><para><literal>strFind("hello world", "o", 1)</literal> restituisce 7 (seconda
'o')</para></listitem>
                  <listitem><para><literal>@cs strFind("Test TEST test", "test")</literal> restituisce 10 (con
distinzione tra maiuscole e minuscole)</para></listitem>
                  <listitem><para><literal>strFind(array("abc", "def"), "b")</literal> restituisce
<literal>array(1, none)</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>regexFind</function>(<replaceable>str</replaceable>,
<replaceable>pattern</replaceable>[, <replaceable>group</replaceable>[,
<replaceable>occurrence</replaceable>]])</term>
              <listitem>
                <para>
Trova la posizione (in base 0) dell'ennesima occorrenza di una
corrispondenza di espressione regolare in <replaceable>str</replaceable>. Il
parametro facoltativo <replaceable>group</replaceable> specifica quale
gruppo di acquisizione individuare (in base 0, il valore predefinito è 0 per
l'intera corrispondenza). Il parametro facoltativo
<replaceable>occurrence</replaceable> specifica quale occorrenza del modello
trovare (in base 0, il valore predefinito è 0 per la prima occorrenza). Per
impostazione predefinita, la ricerca non fa distinzione tra maiuscole e
minuscole (rispetta le direttive
<literal>@cs</literal>/<literal>@ci</literal>). Se il modello non
corrisponde, l'indice del gruppo è fuori intervallo o l'indice delle
occorrenze è fuori intervallo restituisce <literal>none</literal> . Se
<replaceable>str</replaceable> è una matrive, il risultato è una matrice di
posizioni (o nessun valore).</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>regexFind("test123abc456", "\d+")</literal> restituisce 4
(posizione di "123")</para></listitem>
                  <listitem><para><literal>regexFind("test123abc456", "\d+", 0, 1)</literal> restituisce 10
(posizione di "456", seconda corrispondenza)</para></listitem>
                  <listitem><para><literal>regexFind("abc-def-ghi", "([a-z]+)-([a-z]+)", 1)</literal>
restituisce 0 (posizione del primo gruppo acquisizione "abc")</para></listitem>
                  <listitem><para><literal>regexFind("v1.0 and v2.5", "v(\d+)\.(\d+)", 1, 1)</literal>
restituisce 10 (versione principale "2" nella seconda occorrenza)</para></listitem>
                  <listitem><para><literal>regexFind(array("test123", "abc"), "\d+")</literal> restituisce
<literal>array(4, none)</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>substr</function>(<replaceable>sorgente</replaceable>,
<replaceable>inizio</replaceable>, <replaceable>conteggio</replaceable>)</term>
              <listitem><para>Restituisce un intervallo specifico di testo dalla <emphasis>stringa o
dall'array di stringhe</emphasis> come <literal>Stringa</literal>. Se
<replaceable>source</replaceable> è una matrice di stringhe, il risultato è
una matrice di stringhe. Esempio: <literal>substr(Nome, 0, 3)</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>replace</function> (da, a, in)</term>
              <listitem>
                <para>
Sostituisce tutte le occorrenze della stringa
<replaceable>from</replaceable> con <replaceable>to</replaceable>. Se
<replaceable>str</replaceable> è una matrice, il risultato è una matrice di
stringhe a cui sono applicate le sostituzioni. Esempio:
<literal>sostituisci(nome, ".bak", ".txt")</literal></para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>regexReplace</function>(str, modello, sostituzione)</term>
              <listitem>
                <para>
Sostituisce tutte le corrispondenze del modello di espressione regolare con
la stringa sostitutiva. Supporta i riferimenti all'indietro ($1, $2, ecc.)
nella stringa di sostituzione. Se <replaceable>str</replaceable> è una
matrice, il risultato è una matrice di stringhe a cui sono applicate le
sostituzioni. Esempio: <literal>regexReplace(name, "^(\w+)_(\w+)$",
"$2_$1")</literal> scambia le parole separate da un carattere di
sottolineatura.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>replaceWithList</function>(str, percorsofile)</term>
              <listitem>
                <para>
Sostituisce più stringhe in <replaceable>str</replaceable> usando le regole
di sostituzione caricate da un file separato da tabulazioni. Il formato del
file è una regola di sostituzione per riga:
<literal>search_string&lt;TAB&gt;replacement_string</literal>. Le righe che
iniziano con <literal>#</literal> vengono trattate come commenti e
ignorate. Anche le righe vuote vengono ignorate. Se
<replaceable>str</replaceable> è una matrice, il risultato è una matrice di
stringhe a cui sono applicate le sostituzioni.</para>
                <para>Esempio di formato file:</para>
                <screen># Riga di commento
mela arancia
cane gatto
vecchio nuovo</screen>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>replaceWithList(Name, "C:\Filters\replacements.txt")</literal> -
applica le sostituzioni dal file al nome del file</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>regexReplaceWithList</function>(str, percorsofile)</term>
              <listitem>
                <para>
Sostituisce le stringhe in <replaceable>str</replaceable> usando modelli di
espressioni regolari caricati da un file separato da tabulazioni. Il formato
del file è un modello per riga:
<literal>regex_pattern&lt;TAB&gt;replacement_string</literal>. La stringa di
sostituzione può includere riferimenti all'indietro ($1, $2 e così via) ai
gruppi acquisiti. Le righe che iniziano con <literal>#</literal> vengono
trattate come commenti e ignorate. Anche le righe vuote vengono ignorate. Se
<replaceable>str</replaceable> è una matrice, il risultato è una matrice di
stringhe a cui sono applicate le sostituzioni.</para>
                <para>Esempio di formato file:</para>
                <screen># Riga di commento
\d+ NUMERO
(\d{4})-(\d{2})-(\d{2}) $1_$2_$3</screen>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>regexReplaceWithList(Name,
"C:\Filters\regex_replacements.txt")</literal> - applica sostituzioni regex
al nome del file</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>regexExtract</function>(<replaceable>str</replaceable>,
<replaceable>pattern</replaceable>[, <replaceable>group</replaceable>[,
<replaceable>offset</replaceable>]])</term>
              <listitem>
                <para>
Cattura il testo che corrisponde a un modello di espressione regolare dalla
stringa. Il parametro facoltativo <replaceable>group</replaceable> specifica
quale gruppo di acquisizione estrarre (in base 0). Il gruppo 0 (predefinito)
restituisce l'intera corrispondenza; i gruppi 1, 2, ecc. restituiscono i
gruppi di acquisizione corrispondenti definiti tra parentesi nel modello.  l
parametro facoltativo <replaceable>offset</replaceable> specifica quale
occorrenza del modello acquisire (in base 0). Offset 0 (predefinito)
restituisce la prima corrispondenza; offset 1 restituisce la seconda
corrispondenza, ecc. Questo è utile per catturare l'ennesima occorrenza in
una riga, come il secondo numero in una stringa. Restituisce
<literal>none</literal> se il modello non corrisponde, l'indice del gruppo è
fuori intervallo o l'offset supera il numero di corrispondenze. Se
<replaceable>str</replaceable> è una matrice, il risultato è una matrice con
acquisizioni per ciascun elemento. Per impostazione predefinita, la ricerca
non fa distinzione tra maiuscole e minuscole (rispetta le direttive
<literal>@cs</literal>/<literal>@ci</literal>).</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>regexExtract("abc123", "[a-z]+\d+")</literal> restituisce
<literal>"abc123"</literal> (intera corrispondenza)</para></listitem>
                  <listitem><para><literal>regexExtract("abc123", "([a-z]+)(\d+)", 1)</literal> restituisce
<literal>"abc"</literal> (primo gruppo acquisizione)</para></listitem>
                  <listitem><para><literal>regexExtract("abc123", "([a-z]+)(\d+)", 2)</literal> restituisce
<literal>"123"</literal> (secondo gruppo acquisizione)</para></listitem>
                  <listitem><para><literal>regexExtract("2025-05-16", "(\d{4})-(\d{2})-(\d{2})", 1)</literal>
restituisce <literal>"2025"</literal></para></listitem>
                  <listitem><para><literal>regexExtract("utente@esempio.com", "([^@]+)@([^@]+)", 1)</literal>
restituisce <literal>"utente"</literal></para></listitem>
                  <listitem><para><literal>regexExtract("utente@esempio.com", "([^@]+)@([^@]+)", 2)</literal>
restituisce <literal>"esempio.com"</literal></para></listitem>
                  <listitem><para><literal>regexExtract("valore 123 e valore 456", "(\d+)", 0, 0)</literal>
restituisce <literal>"123"</literal> (primo numero)</para></listitem>
                  <listitem><para><literal>regexExtract("valore 123 e valore 456", "(\d+)", 0, 1)</literal>
restituisce <literal>"456"</literal> (secondo numero)</para></listitem>
                  <listitem><para><literal>regexExtract("v1.0.0 and v2.0.0", "v(\d+)\.(\d+)\.(\d+)", 1,
1)</literal> restituisce <literal>"2"</literal> (versione principale seconda
occorrenza)</para></listitem>
                  <listitem><para><literal>regexExtract("test", "\d+")</literal> restituisce
<literal>none</literal> (nessuna corrispondenza)</para></listitem>
                  <listitem><para><literal>regexExtract("abc", "([a-z])", 5)</literal> restituisce
<literal>none</literal> (gruppo fuori intervallo)</para></listitem>
                  <listitem><para><literal>regexExtract(array("abc123", "def456"), "([a-z]+)(\d+)",
1)</literal> restituisce <literal>matrice("abc", "def")</literal></para></listitem>
                  <listitem><para><literal>@cs regexExtract("ABC123", "([a-z]+)", 1)</literal> restitusce
<literal>none</literal> (sensibile maiuscolo/minuscolo, nessuna
corrispndenza)</para></listitem>
                  <listitem><para><literal>le:regexExtract(Line, "error:\s+(\w+)", 1)</literal> estrae il tipo
di errore dalle righe del registro</para></listitem>
                  <listitem><para><literal>fe:regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2"</literal>
filtra i file con la versione principale 2</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>normalizeUnicode</function>(str[, modulo])</term>
              <listitem>
                <para>
Normalizza la stringa Unicode. Il parametro facoltativo del modulo specifica
il modulo di normalizzazione: "NFC" o "C" (predefinito), "NFD" o "D", "NFKC"
o "KC", "NFKD" o "KD". È possibile usare anche forme numeriche: 1=NFC,
2=NFD, 5=NFKC, 6=NFKD. Se <replaceable>str</replaceable> è una matrice, il
risultato è una matrice di stringhe normalizzate. Esempio:
<literal>normalizeUnicode(name, "NFC")</literal></para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toLower</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converte tutti i caratteri della stringa in minuscolo. Se
<replaceable>str</replaceable> è una matrice, il risultato è una matrice di
stringhe minuscole. Esempio: <literal>toLower("Hello World")</literal>
restituisce <literal>"hello world"</literal></para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toUpper</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converte tutti i caratteri della stringa in maiuscolo. Se
<replaceable>str</replaceable> è una matrice, il risultato è una matrice di
stringhe maiuscole. Esempio: <literal>toUpper("Hello World")</literal>
restituisce <literal>"HELLO WORLD"</literal></para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toHalfWidth</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converte i caratteri a larghezza intera in caratteri a metà larghezza. Usato
principalmente per convertire caratteri alfanumerici e katakana a larghezza
intera in caratteri a metà larghezza. Se <replaceable>str</replaceable> è
una matrice, il risultato è una matrice di stringhe convertite.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toFullWidth</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converte i caratteri a mezza larghezza in caratteri a larghezza
intera. Usato principalmente per convertire caratteri alfanumerici e
katakana da metà larghezza a larghezza intera. Se
<replaceable>str</replaceable> è una matrice, il risultato è una matrice di
stringhe convertite.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toKatakana</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converte i caratteri hiragana in katakana. I caratteri non hiragana
rimangono invariati. Se <replaceable>str</replaceable> è una matrice, il
risultato è una matrice di stringhe convertite.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toHiragana</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converte i caratteri katakana in hiragana. I caratteri non katakana
rimangono invariati. Se <replaceable>str</replaceable> è una matrice, il
risultato è una matrice di stringhe convertite.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toSimplifiedChinese</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converte i caratteri cinesi tradizionali in caratteri cinesi semplificati. I
caratteri che non hanno una forma semplificata rimangono invariati. Se
<replaceable>str</replaceable> è una matrice, il risultato è una matrice di
stringhe convertite.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toTraditionalChinese</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converte i caratteri cinesi semplificati in caratteri cinesi tradizionali. I
caratteri che non hanno una forma tradizionale rimangono invariati. Se
<replaceable>str</replaceable> è una matrice, il risultato è una matrice di
stringhe convertite.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>trim</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Rimuove gli spazi bianchi iniziali e finali (spazio, tabulazione, nuova
riga, ritorno a capo) dalla stringa. Se <replaceable>str</replaceable> è una
matrice, il risultato è una matrice di stringhe tagliate.</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>trim(" ciao ")</literal> restituisce <literal>"ciao"</literal></para></listitem>
                  <listitem><para><literal>trim(array(" test ", " data "))</literal> restituisce
<literal>array("test", "data")</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>trimLeft</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Rimuove i caratteri di spazio bianco iniziali (spazio, tabulazione, nuova
riga, ritorno a capo) dall'inizio della stringa. Gli spazi bianchi finali
vengono conservati. Se <replaceable>str</replaceable> è una matrice, il
risultato è una matrice di stringhe tagliate a sinistra.</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>trimLeft(" ciao ")</literal> restituisce <literal>"ciao "</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>trimRight</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Rimuove gli spazi bianchi finali (spazio, tabulazione, nuova riga, ritorno a
capo) dalla fine della stringa. Gli spazi iniziali vengono mantenuti. Se
<replaceable>str</replaceable> è una matrice, il risultato è una matrice di
stringhe tagliate a destra.</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>trimRight(" ciao ")</literal> restituisce <literal>"
ciao"</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_FileContentFunctions">
          <title>Funzioni contenuto file</title>
          <variablelist>
            <varlistentry>
              <term><function>lineCount</function>(<replaceable>contenuto</replaceable>)</term>
              <listitem><para>Restituisce il numero di righe nel contenuto del file o nell'array del
contenuto del file come <literal>Intero</literal>. Se
<replaceable>content</replaceable> è una matrice, il risultato è una matrice
di numeri interi. Esempio: <literal>lineCount(Content)</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>sublines</function>(<replaceable>contenuto</replaceable>,
<replaceable>inizio</replaceable>, <replaceable>conteggio</replaceable>)</term>
              <listitem>
                <para>
Estrae il numero specificato di righe a partire dall'indice di riga
specificato nel contenuto del file o nell'array del contenuto del file e li
restituisce come un'unica stringa concatenata. Se
<replaceable>content</replaceable> è una matrice, il risultato è una matrice
di stringhe.</para>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_TypeConversionFunctions">
          <title>Funzioni conversione tipo</title>
          <variablelist>
            <varlistentry>
              <term><function>toNumber</function>(<replaceable>str</replaceable>),
<function>toInt</function>(<replaceable>str</replaceable>),
<function>toDouble</function>(<replaceable>str</replaceable>)</term>
              <listitem><para>Converte una stringa in un numero. <function>toNumber</function> restituisce
un numero intero o in virgola mobile a seconda del formato sorgente;
<function>toInt</function> restituisce solo numeri interi;
<function>toDouble</function> restituisce solo numeri a virgola mobile. Le
virgole nel dato sorgente vengono ignorate. In caso di errore di analisi
restituisce <literal>none</literal>. Esempio:
<literal>le:toInt(Column("Count")) > 100</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>toDateTime</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converte una stringa in un valore timestamp. Supporta più formati
data/ora. Se la stringa non può essere analizzata restituisce
<literal>none</literal>. Esempio: <literal>toDateTime("2025-01-15") >
today()</literal></para>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_DateTimeFunctions">
          <title>Funzioni data/ora</title>
          <variablelist>
            <varlistentry>
              <term><function>now</function></term>
              <listitem><para>Restituisce la data e l'ora correnti come valore
<literal>Timestamp</literal>.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>today</function></term>
              <listitem><para>Restituisce la data odierna come valore <literal>Timestamp</literal> che
rappresenta <literal>00:00:00.000</literal> all'inizio della giornata.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>startOfWeek</function>(<replaceable>timestamp</replaceable>)</term>
              <listitem><para>Restituisce il primo giorno della settimana, che è sempre domenica,
indipendentemente dalle impostazioni locali.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>startOfMonth</function>(<replaceable>timestamp</replaceable>)</term>
              <listitem><para>Restituisce il primo giorno del mese.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>startOfYear</function>(<replaceable>timestamp</replaceable>)</term>
              <listitem><para>Restituisce il primo giorno dell'anno.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>toDateStr</function>(<replaceable>timestamp</replaceable>)</term>
              <listitem><para>Converte il timestamp specificato in una stringa di data nel formato
<literal>aaaa-MM-gg</literal>. Se <replaceable>timestamp</replaceable> è una
matrice di timestamp, il risultato è una matrice di stringhe.</para></listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_MathFunctions">
          <title>Funzioni matematiche e di confronto</title>
          <variablelist>
            <varlistentry>
              <term><function>abs</function>(<replaceable>valore</replaceable>)</term>
              <listitem><para>Restituisce il valore assoluto dell'<emphasis>intero o dell'array di
interi</emphasis>. Se <replaceable>value</replaceable> è una matrice di
numeri interi, il risultato è una matrice di numeri interi.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>isWithin</function>(<replaceable>valore</replaceable>,
<replaceable>min</replaceable>, <replaceable>max</replaceable>)</term>
              <listitem>
                <para>
Restituisce <literal>true</literal> se <replaceable>valore</replaceable> è
compreso nell'intervallo <literal>[min, max]</literal> (incluso su entrambe
le estremità). Supporta numeri interi, numeri a virgola mobile, timestamp e
stringhe (confronto senza distinzione tra maiuscole e minuscole). Se
<replaceable>value</replaceable> è una matrice, il risultato è una matrice
booleano con ogni elemento controllato individualmente.</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>isWithin(5, 1, 10)</literal> restituisce <literal>true</literal></para></listitem>
                  <listitem><para><literal>isWithin(Size, 1KB, 10MB)</literal> controlla se la dimensione del
file è compresa tra 1KB e 10MB</para></listitem>
                  <listitem><para><literal>isWithin(Date, today() - 7days, today())</literal> controlla se il
file è stato modificato nell'ultima settimana</para></listitem>
                  <listitem><para><literal>allof(isWithin(Size, 1KB, 10MB))</literal> controlla se tutte le
dimensioni dei file sono comprese tra 1KB e 10MB</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>inRange</function>(<replaceable>valore</replaceable>,
<replaceable>min</replaceable>, <replaceable>max</replaceable>)</term>
              <listitem>
                <para>
Restituisce <literal>true</literal> se <replaceable>value</replaceable> è
compreso nell'intervallo <literal>[min, max)</literal> (incluso nel limite
inferiore, escluso nel limite superiore). Supporta numeri interi, numeri a
virgola mobile, timestamp e stringhe (confronto senza distinzione tra
maiuscole e minuscole). Se <replaceable>value</replaceable> è una matrice,
il risultato è una matrice booleano con ogni elemento controllato
individualmente.</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>inRange(5, 1, 10)</literal> restituisce <literal>true</literal></para></listitem>
                  <listitem><para><literal>inRange(10, 1, 10)</literal> restituisce <literal>false</literal></para></listitem>
                  <listitem><para><literal>inRange(Size, 0, 1MB)</literal> controlla se la dimensione del file
è inferiore a 1 MB</para></listitem>
                  <listitem><para><literal>anyof(inRange(Date, startOfMonth(today()), today()))</literal>
controlla se qualche file è stato modificato questo mese (escluso oggi)</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_ArrayFunctions">
          <title>Funzioni matrice</title>
          <variablelist>
            <varlistentry>
              <term><function>array</function>(<replaceable>value1</replaceable>,
<replaceable>value2</replaceable>, ...)</term>
              <listitem><para>Crea una matrice dai valori specificati. Esempio:: <literal>array(1, 2,
3)</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>at</function>(<replaceable>array</replaceable>,
<replaceable>index</replaceable>)</term>
              <listitem><para>Restituisce l'elemento in corrispondenza dell'indice specificato (in base
0). Gli indici negativi contano dalla fine. Esempio: <literal>at(array(1, 2,
3), -1)</literal> restituisce 3</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>anyof</function>(<replaceable>booleans</replaceable>)</term>
              <listitem><para>Restituisce <literal>true</literal> se qualsiasi elemento
nell'<emphasis>array booleano</emphasis> soddisfa la condizione.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>allof</function>(<replaceable>booleani</replaceable>)</term>
              <listitem><para>Restituisce <literal>true</literal> se tutti gli elementi
nell'<emphasis>array booleano</emphasis> soddisfano la condizione.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>allequal</function>(<replaceable>array</replaceable>)</term>
              <listitem><para>Restituisce <literal>true</literal> se tutti i valori nell'array sono
uguali.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>len</function>(<replaceable>value</replaceable>)</term>
              <listitem>
                <para>Restituisce la lunghezza del valore come <literal>Intero</literal>.</para>
                <para>Comportamento:</para>
                <itemizedlist>
                  <listitem><para><emphasis>Array</emphasis>: Restituisce il numero di elementi nella matrice</para></listitem>
                  <listitem><para><emphasis>String</emphasis>: Restituisce il conteggio dei caratteri UTF-8</para></listitem>
                  <listitem><para><emphasis>None (monostate)</emphasis>: Restituisce 0</para></listitem>
                  <listitem><para><emphasis>Altri valori scalari</emphasis> (intero, reale, booleano
timestamp, ecc.): restituisce 1</para></listitem>
                </itemizedlist>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>len(array(1, 2, 3))</literal> - restituisce 3</para></listitem>
                  <listitem><para><literal>len("ciao")</literal> - restituisce 5</para></listitem>
                  <listitem><para><literal>len(123)</literal> - restituisce 1</para></listitem>
                  <listitem><para><literal>len(Size)</literal> - restituisce in un confronto cartelle il
numero di lati (2 o 3)</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_ConditionalFunctions">
          <title>Funzioni condizionali</title>
          <variablelist>
            <varlistentry>
              <term><function>if</function>(<replaceable>condizione</replaceable>,
<replaceable>trueValue</replaceable>, <replaceable>falseValue</replaceable>)</term>
              <listitem>
                <para>
Restituisce <replaceable>trueValue</replaceable> se
<replaceable>condizione</replaceable> restituisce true, altrimenti
restituisce <replaceable>falseValue</replaceable>. Questa funzione esegue la
valutazione del cortocircuito (valuta solo il ramo che verrà restituito).</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>if(Size > 1MB, "large", "small")</literal> - restituisce "large" o
"small" in base alla dimensione del file</para></listitem>
                  <listitem><para><literal>if(Extension = "txt", "text file", "other file")</literal> -
classifica i file per estensione</para></listitem>
                  <listitem><para><literal>if(Exists, Size, 0)</literal> - restituisce la dimensione del file
o 0 se il file non esiste</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>ifEach</function>(<replaceable>conditionArray</replaceable>,
<replaceable>trueValue</replaceable>, <replaceable>falseValue</replaceable>)</term>
              <listitem>
                <para>
Selezione condizionale per elemento. Per ogni elemento in
<replaceable>conditionArray</replaceable>, restituisce l'elemento
corrispondente da <replaceable>trueValue</replaceable> se la condizione è
vera, Altrimenti restituisce l'elemento corrispondente da
<replaceable>falseValue</replaceable>. Se
<replaceable>trueValue</replaceable> o <replaceable>falseValue</replaceable>
è uno scalare, viene trasmesso a tutti gli elementi.</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>ifEach(Size &gt; 1MB, "large", "small")</literal> - restituisce una
matrice di etichette "grande"/"piccolo" per ogni file</para></listitem>
                  <listitem><para><literal>ifEach(array(true, false, true), array("a", "b", "c"), array("x",
"y", "z"))</literal> - restituisce <literal>array("a", "y", "c")</literal></para></listitem>
                  <listitem><para><literal>anyof(ifEach(Size &gt; 100KB, Size &lt; 10MB, false))</literal> -
controlla se qualche file è compreso tra 100KB e 10MB</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>choose</function>(<replaceable>indice</replaceable>,
<replaceable>valore0</replaceable>, <replaceable>valore1</replaceable>, ...)</term>
              <listitem>
                <para>
Seleziona un valore dagli argomenti in base a
<replaceable>index</replaceable>. Se <replaceable>index</replaceable> è 0,
restituisce <replaceable>value0</replaceable>;se 1, restituisce
<replaceable>value1</replaceable>, ecc. Gli indici negativi sono limitati a
0. Gli indici oltre l'ultimo valore restituiscono l'ultimo valore.</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>scegli(0, "primo", "secondo", "terzo")</literal> - restituisce
"primo"</para></listitem>
                  <listitem><para><literal>choose(DiffCode % 3, "equal", "different", "unique")</literal> -
mappa i codici diff sulle etichette</para></listitem>
                  <listitem><para><literal>scegli(5, "a", "b", "c")</literal> - restituisce "c" (fuori dai
limiti, restituisce l'ultimo valore)</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>chooseEach</function>(<replaceable>indexArray</replaceable>,
<replaceable>value0</replaceable>, <replaceable>value1</replaceable>, ...)</term>
              <listitem>
                <para>
Selezione del valore in base agli elementi. Per ogni indice in
<replaceable>indexArray</replaceable>, seleziona il valore corrispondente
dagli argomenti rimanenti. Se <replaceable>indexArray</replaceable> è uno
scalare, si comporta come <literal>choose</literal>.</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>chooseEach(array(0, 1, 2), "a", "b", "c")</literal> - restituisce
<literal>array("a", "b", "c")</literal></para></listitem>
                  <listitem><para><literal>chooseEach(array(0, 0, 1), "x", "y")</literal> - restituisce
<literal>array("x", "x", "y")</literal></para></listitem>
                  <listitem><para><literal>chooseEach(array(2, 0, 1), "primo", "secondo", "terzo")</literal> -
restituisce <literal>array("terzo", "primo", "secondo")</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_LogicalFunctions">
          <title>Funzioni logiche per elemento</title>
          <variablelist>
            <varlistentry>
              <term><function>andEach</function>(<replaceable>valore1</replaceable>,
<replaceable>valore2</replaceable>),
orEach(<replaceable>valore1</replaceable>,
<replaceable>valore2</replaceable>),
notEach(<replaceable>valore</replaceable>)</term>
              <listitem>
                <para>
Operazioni logiche per elementi. Queste funzioni operano su booleani, array
booleani o una combinazione di entrambi:</para>
                <itemizedlist>
                  <listitem><para><literal>andEach</literal> - Operazione logica AND</para></listitem>
                  <listitem><para><literal>orEach</literal> - Operazione logica OR</para></listitem>
                  <listitem><para><literal>notEach</literal> - Operazione logica NOT (argomento singolo)</para></listitem>
                </itemizedlist>
                <para>
Quando gli argomenti sono scalari, restituisce un risultato booleano
scalare. Quando un argomento è una matrice e l'altro è uno scalare, lo
scalare viene trasmesso a tutti gli elementi. Quando entrambi gli argomenti
sono array, esegue l'operazione a livello di elemento.</para>
                <para>Esempi:</para>
                <itemizedlist>
                  <listitem><para><literal>andEach(Size &gt; 1KB, Size &lt; 1MB)</literal> - file tra 1KB e
1MB</para></listitem>
                  <listitem><para><literal>orEach(Extension = "txt", Extension = "log")</literal> - file txt o
di registro</para></listitem>
                  <listitem><para><literal>notEach(Exists)</literal> - file che non esistono</para></listitem>
                  <listitem><para><literal>allof(andEach(Exists, Size &gt; 0))</literal> - tutti i file
esistono con dimensione diversa da zero</para></listitem>
                  <listitem><para><literal>anyof(notEach(Size &gt; 1MB))</literal> - qualsiasi file di 1 MB o
inferiore</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_DiagnosticFunctions">
          <title>Funzioni diagnostiche e di registrazione</title>
          <variablelist>
            <varlistentry>
              <term><function>logError</function>(<replaceable>valore1</replaceable>,
<replaceable>value2</replaceable>, ...),
logWarn(<replaceable>value1</replaceable>,
<replaceable>value2</replaceable>, ...),
logInfo(<replaceable>value1</replaceable>,
<replaceable>value2</replaceable>, ...)</term>
              <listitem>
                <para>
Restituisce la rappresentazione di stringa concatenata di tutti gli
argomenti nel log (rispettivamente a livello di errore, avviso o
informazione), separati da spazi, e restituisce il valore dell'ultimo
argomento. Queste funzioni sono utili per il debug delle espressioni di
filtro.</para>
                <para>Esempi (usando il valore restituito):</para>
                <itemizedlist>
                  <listitem><para><literal>logInfo("File size:", Size) > 1MB</literal> - registra le
dimensioni del file e controlla se è maggiore di 1 MB</para></listitem>
                  <listitem><para><literal>logWarn("Processing:", Name) come "*.tmp"</literal> - registra i
nomi dei file e controlla se si tratta di un file temporaneo</para></listitem>
                  <listitem><para><literal>Size > 1KB and logInfo("Large file:", Name) contains
"test"</literal> - registra solo quando la condizione della dimensione è
vera, quindi controlla il nome</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>
      </section>

      <section id="FilterExpression_Units">
        <title>Unità</title>
        <para>Le dimensioni dei file supportano questi suffissi:</para>
        <simplelist type="inline">
          <member>KB</member>
          <member>MB</member>
          <member>GB</member>
          <member>TBC</member>
        </simplelist>
        <para>Le durate temporali supportano questi suffissi:</para>
        <simplelist type="inline">
          <member>settimane</member><member>settimana</member><member>w</member>
          <member>giorni</member><member>giorno</member><member>D</member>
          <member>ore</member><member>ora</member><member>ora</member><member>H</member>
          <member>minuti</member><member>minuto</member><member>min</member><member>M</member>
          <member>secondi</member><member>secondo</member><member>sez</member><member>S</member>
          <member>millisecondi</member><member>millisecondo</member><member>ms</member><member>ms</member>
        </simplelist>
      </section>

      <section id="FilterExpression_Examples">
        <title>Esempi</title>
        <itemizedlist>
          <listitem><para><literal>Dimensione &lt;10KB</literal>: la dimensione di qualsiasi lato è
inferiore a 10KB</para></listitem>
          <listitem><para><literal>LeftSize &gt;= 10MB</literal> - Il file del lato sinistro è di
almeno 10MB</para></listitem>
          <listitem><para><literal>allof(Size &lt; 1MB)</literal> - Tutti i lati sono inferiori a 1 MB</para></listitem>
          <listitem><para><literal>abs(LeftSize - RightSize) &lt;1KB</literal> - La differenza di
dimensioni è piccola</para></listitem>
          <listitem><para><literal>DateStr = "2025-07-20"</literal> - Il file è stato modificato
l'ultima volta in quella data</para></listitem>
          <listitem><para><literal>Data &gt;= today()</literal> - Modificato oggi o successivamente</para></listitem>
          <listitem><para><literal>Date &gt; d"2026-05-21 07:16:33"</literal> - Modificato dopo una
data e un'ora specifiche</para></listitem>
          <listitem><para><literal>isWithin(Date, d"2026-01-01", d"2026-12-31 23:59:59")</literal> -
Modificato nel corso dell'anno 2026</para></listitem>
          <listitem><para><literal>is Within(Date, today() - 7 days, today())</literal> - File
modificato nell'ultima settimana</para></listitem>
          <listitem><para><literal>inRange(Size, 1KB, 10MB)</literal>: la dimensione del file è
compresa tra 1 KB (incluso) e 10 MB (escluso)</para></listitem>
          <listitem><para><literal>allof(isWithin(Size, 100KB, 1MB))</literal> - Tutte le dimensioni
dei file sono comprese tra 100KB e 1MB</para></listitem>
          <listitem><para><literal>AttrStr contiene "R"</literal> - Il file è di sola lettura</para></listitem>
          <listitem><para><literal>Il nome corrisponde a "file[0-9]\.txt"</literal> - Regex sul nome
file</para></listitem>
          <listitem><para><literal>Il contenuto contiene "Test"</literal> - Il contenuto del file
include la parola chiave</para></listitem>
          <listitem><para><literal>sublines(Content, 0, 1) contiene "XML"</literal> - La prima riga
contiene "XML"</para></listitem>
          <listitem><para><literal>strCount(Content, "TODO") &gt; 5</literal> - Il file contiene più
di 5 commenti TODO</para></listitem>
          <listitem><para><literal>regexCount(Content, "\bFIXME\b") &gt; 0</literal> - Il file
contiene almeno un marcatore FIXME</para></listitem>
          <listitem><para><literal>strFind(Name, "_test") != none</literal> - File contenenti "_test"
nel nome</para></listitem>
          <listitem><para><literal>strFind(Name, ".", 1) &gt; 0</literal> - File con più punti nel
nome (esiste il secondo punto)</para></listitem>
          <listitem><para><literal>regexFind(Name, "\d{4}") &lt; 5</literal> - File in cui nei primi 5
caratteri appare un numero di 4 cifre</para></listitem>
          <listitem><para><literal>regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2"</literal> -
File con versione principale 2 (ad esempio "v2.16.48")</para></listitem>
          <listitem><para><literal>regexExtract(Name, "([^_]+)_([^_]+)\.txt", 2) like
"test*"</literal> - File in cui la seconda parte del nome inizia con "test"</para></listitem>
          <listitem><para><literal>le:regexExtract(Line, "(\d+)", 0, 1)</literal> - Estrae il secondo
numero in ogni riga (offset=1)</para></listitem>
          <listitem><para><literal>(Extension = "log" and Size > 10MB) or (Date &lt; today() -
7days)</literal> - File registro di grandi dimensioni o file più vecchi di
una settimana</para></listitem>
          <listitem><para><literal>AttrStr non contiene "H" e nome come "*.tmp"</literal> - File
temporanei non nascosti</para></listitem>
          <listitem><para><literal>isWithin(Extension, "a", "m") e inRange(Size, 0, 1MB)</literal> -
File con estensioni da 'a' a 'm' e dimensioni inferiori a 1 MB</para></listitem>
          <listitem><para><literal>toLower(Name) = "readme.txt"</literal> - Corrispondenza del nome
file senza distinzione tra maiuscole e minuscole</para></listitem>
          <listitem><para><literal>toHalfWidth(Name) come "*.txt"</literal> - Corrisponde dopo la
conversione da larghezza intera a mezza larghezza</para></listitem>
          <listitem><para><literal>trim(Name) = "readme.txt"</literal> - Corrispondenza nome del file
dopo aver rimosso gli spazi iniziali/finali</para></listitem>
          <listitem><para><literal>trimLeft(Column("Value")) = "123"</literal> - Corrisponde al valore
della colonna dopo aver rimosso gli spazi iniziali (modalità tabella)</para></listitem>
          <listitem><para><literal>trimRight(Line) contains "end"</literal> - Controlla se la riga
(senza spazi bianchi finali) contiene "end"</para></listitem>
          <listitem><para><literal>EOL = 3</literal> - File con terminazioni di riga CRLF (Windows)</para></listitem>
          <listitem><para><literal>EOLStr = "LF"</literal> - File con terminazioni di riga LF (Unix)</para></listitem>
          <listitem><para><literal>allof(EOL = 1)</literal> - Controlla se tutti i file confrontati
usano terminazioni di riga LF</para></listitem>
          <listitem><para><literal>leftprop("System.Title") != none</literal> - Il file sinistro ha
una proprietà titolo impostata</para></listitem>
          <listitem><para><literal>prop("System.Author") = none</literal> - Nessuna proprietà
dell'autore è impostata su nessun lato</para></listitem>
          <listitem><para><literal>if(LeftExists, LeftSize, 0) == 0</literal> - Controlla se il file a
sinistra è mancante o vuoto</para></listitem>
          <listitem><para><literal>Different</literal>: visualizza solo file/cartelle differenti (solo
filtro di visualizzazione)</para></listitem>
          <listitem><para><literal>Identical</literal>: visualizza solo file/cartelle identici (solo
filtro di visualizzazione)</para></listitem>
          <listitem><para><literal>allof(Binary)</literal> - Visualizza solo i file binari su tutti i
lati (solo filtro di visualizzazione)</para></listitem>
          <listitem><para><literal>DifferentLeftMiddle and not DifferentMiddleRight</literal> - Nel
confronto a 3 vie visualizza i file in cui differisce solo la coppia
sinistra-centrale (solo filtro di visualizzazione)</para></listitem>
        </itemizedlist>
      </section>
    </section>
  </section>

  <section id="Filters_FileFilter">
    <title>Uso dei filtri file<indexterm>
        <primary>filtri</primary>

        <secondary>filtri di file</secondary>
      </indexterm><indexterm>
        <primary>filtri</primary>

        <secondary>nei confronti delle cartelle</secondary>
      </indexterm></title>

    <para>I <glossterm>filtri file</glossterm> sono file di testo con estensione
<filename>flt</filename>. Consentono di applicare più regole di filtro a un
confronto di cartelle. A differenza delle maschere di file, i filtri di file
possono includere o escludere corrispondenze.</para>

    <para><indexterm>
        <primary>filtri di file</primary>

        <secondary>modello</secondary>
      </indexterm>WinMerge installa una serie di filtri
di file predefiniti. Se questi filtri di file non forniscono il filtraggio
necessario, puoi crearne uno tuo. Per semplificare questo compito, WinMerge
fornisce anche un file modello denominato
<filename>FileFilter.tmpl</filename>. Questa sezione descrive come applicare
i filtri di file ai confronti e documenta la sintassi del filtro di
file.<xref linkend="Filters_dlg" /> descrive come aggiungere, modificare e
gestire i filtri.</para>

    <section id="Filters_FileFilterLoc">
      <title>Posizioni filtro file<indexterm>
          <primary>Filtra le cartelle</primary>

          <secondary>posizioni</secondary>
        </indexterm><indexterm>
          <primary>filtri di file</primary>

          <secondary>posizioni</secondary>
        </indexterm></title>

      <para>WinMerge rileva automaticamente i filtri dei file in queste posizioni:</para>

      <variablelist>
        <varlistentry>
          <term>Sottocartella Filtri nella cartella di installazione di WinMerge</term>

          <listitem>
            <para>Qui è dove vengono installati i filtri di file predefiniti. Ad esempio,
<filename>C:\Programmi\WinMerge\Filters</filename>. Puoi creare o copiare
file di filtro in questa posizione per renderli disponibili a tutti gli
utenti del tuo sistema.</para>

            <para>Prima di creare un nuovo filtro file, verifica se quelli predefiniti
contengono già ciò che ti serve. In caso contrario, potresti trovare utili
esempi di regole nei file esistenti.</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term>Cartella di filtro privata predefinita</term>

          <listitem>
            <para>La posizione di questa cartella è definita nella pagina Sistema delle
opzioni WinMerge. Per impostazione predefinita, è specificata come
sottocartella nella cartella del profilo utente (ad esempio,
<filename>Documents</filename> in Windows 10). I filtri creati o copiati qui
sono normalmente visibili solo a te. Se crei nuovi filtri di file, puoi
copiarli qui per mantenerli privati.</para>
          </listitem>
        </varlistentry>
      </variablelist>

      <para>Prima di poter applicare i filtri di file esistenti in qualsiasi altra
cartella, devi prima installarli.</para>
    </section>

    <section id="Filters_FileFilterApply">
      <title>Applicazione dei filtri ai file<indexterm>
          <primary>filtri di file</primary>

          <secondary>applicando</secondary>
        </indexterm></title>

      <para>Puoi applicare un filtro file usando uno di questi metodi:</para>

      <itemizedlist>
        <listitem>
          <para>Quando avvii un confronto di cartelle dalla finestra di dialogo Seleziona
file o cartelle:</para>

          <orderedlist>
            <listitem>
              <para>Dopo aver scelto le cartelle <guilabel>1a</guilabel> e
<guilabel>2a</guilabel>, seleziona <guibutton>Seleziona</guibutton> accanto
al campo <guilabel>Filtro</guilabel>.</para>
            </listitem>

            <listitem>
              <para>Nella finestra di dialogo Filtri, usa la scheda Filtri di file per scegliere
un filtro di file e caricarlo nel campo <guilabel>Filtro</guilabel>.</para>

              <note>
                <para>Se un filtro file è attualmente abilitato, il filtro file selezionato è già
caricato nel campo <guilabel>Filtro</guilabel>.</para>
              </note>
              <para></para>
            </listitem>

            <listitem>
              <para>Procedere con l'operazione di confronto. Il file nel campo
<guilabel>Filtro</guilabel> viene applicato quando avvii l'operazione.</para>
            </listitem>
          </orderedlist>
        </listitem>

        <listitem>
          <para>Per modificare il filtro dei file dopo aver già avviato un'operazione di
confronto delle cartelle (ad esempio, applicando un filtro diverso o
disabilitando il filtro):</para>

          <orderedlist>
            <listitem>
              <para>Seleziona <menuchoice> <guimenu>Strumenti</guimenu>
<guimenuitem>Filtri</guimenuitem> </menuchoice>.</para>
            </listitem>

            <listitem>
              <para>Nella finestra di dialogo Filtri, configura la nuova impostazione del filtro
file e seleziona <guibutton>OK</guibutton>.</para>
            </listitem>

            <listitem>
              <para>Il nuovo filtro non viene applicato automaticamente quando chiudi la
finestra di dialogo Filtri: premi <keycap>F5</keycap> per visualizzare i
nuovi risultati nella finestra Confronto cartelle.</para>
            </listitem>
          </orderedlist>
        </listitem>

        <listitem>
          <para><indexterm>
              <primary>riga di comando</primary>

              <secondary>applicare filtri ai file</secondary>
            </indexterm>Quando avvii un confronto di cartelle
dalla riga di comando di WinMerge, usa il flag <option>-f</option> per
specificare un filtro file.</para>
        </listitem>
      </itemizedlist>
    </section>

    <section id="Filters_FileFilterSyntax">
      <title>Sintassi del filtro file<indexterm>
          <primary>regole</primary>

          <secondary>filtro file</secondary>
        </indexterm><indexterm>
          <primary>filtri di file</primary>

          <secondary>sintassi</secondary>
        </indexterm></title>

      <para>Questa sezione descrive la sintassi dei filtri di file WinMerge e fornisce
linee guida per scriverli.</para>

      <para>Il delimitatore del commento è <code>##</code>. Dopo un delimitatore di
commento, tutti i caratteri in una riga vengono ignorati. WinMerge ignora la
maggior parte dei caratteri di spazio bianco nelle regole. Tuttavia, un
commento deve essere sempre preceduto da uno o più caratteri di spazio
bianco (spazio o tabulazione). Per usare <code>##</code> come caratteri in
una regola, ometti il prefisso dello spazio bianco.</para>

      <para>Le prime due righe richieste di un filtro file sono:</para>

      <variablelist>
        <varlistentry>
          <term>nome</term>

          <listitem>
            <para>Il nome del filtro elencato nella finestra di dialogo File</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term>def</term>

          <listitem>
            <para>Il tipo di filtro da applicare. Specifica uno di questi valori:</para>

            <variablelist>
              <varlistentry>
                <term>includere</term>

                <listitem>
                  <para>Include tutto tranne gli elementi che corrispondono alla regola specificata.</para>
                </listitem>
              </varlistentry>

              <varlistentry>
                <term>escludere</term>

                <listitem>
                  <para>Esclude tutto tranne gli elementi che corrispondono alla regola specificata.</para>

                  <para>Quando scegli il metodo di esclusione, devi anche aggiungere una regola
<guilabel>d</guilabel> (cartella) che specifichi le sottocartelle. Di solito
è una buona idea specificare tutte le sottocartelle, in questo modo:</para>

                  <screen>d: \\*$ ## Sottocartelle</screen>
                </listitem>
              </varlistentry>
            </variablelist>

            <tip>
              <para>Non confondere questi termini. Ricorda, nei filtri dei file, una regola
<guilabel>include</guilabel> non specifica cosa includere, specifica cosa
<emphasis>non</emphasis> includere. Allo stesso modo,
<guilabel>exclude</guilabel> non specifica cosa escludere, specifica cosa
non escludere.</para>
            </tip>
          </listitem>
        </varlistentry>
      </variablelist>

      <para>Successivamente, il file dovrebbe contenere una o più regole di filtro. Puoi
aggiungere tutte le regole che vuoi. Deve esserci una regola per riga e
ciascuna regola deve essere interamente su una riga (in una regola non sono
consentite interruzioni di riga). Una regola inizia con un identificatore di
tipo, seguito da un'espressione regolare o da un'espressione di filtro. I
designatori di tipo supportati sono:</para>

      <variablelist>
        <varlistentry><term>f: <replaceable>regexp</replaceable></term><listitem><para>Abbina i nomi dei file usando le espressioni regolari</para></listitem></varlistentry>
        <varlistentry><term>f!: <replaceable>regexp</replaceable></term><listitem><para>Escludi file corrispondenti a regex (disponibile dalla versione 2.16.19)</para></listitem></varlistentry>
        <varlistentry><term>d: <replaceable>regexp</replaceable></term><listitem><para>Abbina i nomi delle cartelle usando regex</para></listitem></varlistentry>
        <varlistentry><term>d!: <replaceable>regexp</replaceable></term><listitem><para>Escludi cartelle corrispondenti a regex (disponibile dal 16.2.19)</para></listitem></varlistentry>
        <varlistentry><term>fe: <replaceable>espressione</replaceable></term><listitem><para>Espressione di filtro per file (ad esempio fe:Size &lt; 1KB) (disponibile
dal 16.2.49)</para></listitem></varlistentry>
        <varlistentry><term>fe!: <replaceable>expr</replaceable></term><listitem><para>Espressione di filtro per escludere file (disponibile dalla versione
2.16.49)</para></listitem></varlistentry>
        <varlistentry><term>de: <replaceable>espressione</replaceable></term><listitem><para>Espressione di filtro per cartelle (disponibile dalla versione 2.16.49)</para></listitem></varlistentry>
        <varlistentry><term>de!: <replaceable>espressione</replaceable></term><listitem><para>Espressione di filtro per escludere cartelle (disponibile dalla versione
2.16.49)</para></listitem></varlistentry>
        <varlistentry><term>e: <replaceable>espressione</replaceable></term><listitem><para>Espressione di filtro applicata sia a file che a cartelle (ad esempio e:Nome
come "Comune*.*") (disponibile dalla 2.16.56)</para></listitem></varlistentry>
        <varlistentry><term>e!: <replaceable>espressione</replaceable></term><listitem><para>Espressione di filtro per escludere sia file che cartelle (disponibile dalla
2.16.56)</para></listitem></varlistentry>
      </variablelist>

      <para>Tra i tanti caratteri speciali regexp, i seguenti sono particolarmente
importanti nelle regole di filtro dei file:<indexterm>
          <primary>espressioni regolari</primary>

          <secondary>caratteri speciali nei filtri</secondary>
        </indexterm><indexterm>
          <primary>espressioni regolari</primary>

          <secondary>nei filtri dei file</secondary>
        </indexterm></para>

      <variablelist>
        <varlistentry>
          <term>^ (inizio riga)</term>

          <listitem>
            <para>Spesso richiesto affinché le regole funzionino correttamente.</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term>$ (fine riga)</term>

          <listitem>
            <para>Spesso richiesto affinché le regole funzionino correttamente. Per esempio:</para>

            <screen>\.c$ ## corrisponde solo ai nomi di file con estensione <filename>c</filename>.
\.c ## corrisponde a qualsiasi estensione che inizia con <filename>c</filename>, come <filename>cpp</filename> e <filename>com</filename>.</screen>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term>\ (fuga)</term>

          <listitem>
            <para>Forza i caratteri speciali a corrispondere ai caratteri normali. Ad esempio,
per abbinare il nome di una cartella, anteporre al delimitatore della barra
rovesciata della cartella una barra rovesciata (<code>\\</code>). Per far
corrispondere il punto nel nome di un file, specificare una barra rovesciata
seguita da un punto (<code>\.</code>).</para>
          </listitem>
        </varlistentry>
      </variablelist>

      <para>Non vengono usati caratteri speciali o caratteri jolly per abbinare i nomi
dei file. Per abbinare tutti i nomi di file di un certo tipo, ometti
semplicemente il nome del file.</para>

      <para>Le regole non fanno distinzione tra maiuscole e minuscole. Ad esempio,
<code>f: \.bat$</code> corrisponde a <filename>winmerge.bat</filename> e
<filename>compare.BAT</filename>.</para>

      <example>
        <title>Esempi di regole di filtro file</title>

        <para>Alcune semplici regole di filtro dei file:</para>

<screen>f: \.cpp$ ## Trova i file <filename>*.cpp</filename>
f: \.h$ ## Trova i file <filename>*.h</filename>
f: ^My ## Corrisponde a <filename>My*.*</filename> file
f: Dlg\.## Corrisponde ai file <filename>*Dlg.*</filename>
d: \\test$ ## Trova le cartelle <filename>test</filename>
d: ^\\Build$ ## Corrisponde alle cartelle <filename>Build</filename>
d: Temp$ ## Corrisponde alle cartelle <filename>*Temp</filename> (ad esempio, <filename>FirstTemp</filename>)
d: Src ## Corrisponde alle cartelle <filename>*Src*</filename></screen><para>Alcune regole con espressioni regolari più complesse:</para>

<screen format="linespecific">f: ^\.#.*$ ## <filename>.#nomefile.versione</filename> file
f: Dlg\.c(pp)?$ ## File <filename>*Dlg.c</filename> e <filename>*Dlg.cpp</filename>
f: ^I.*\.h$ ## File <filename>I*.h</filename>
f: Srv[1-9]\.def$ ## da <filename>*Srv1.def</filename> a <filename>*Srv9.def</filename>
f: ^[h,k,m] ## File <filename>h*.*</filename>, <filename>k*.*</filename> e <filename>m*.*</filename></screen></example>
    </section>
  </section>

  <section id="Filters_LineFilter">
    <title>Uso dei filtri di linea<indexterm>
        <primary>filtri</primary>

        <secondary>linea</secondary>
      </indexterm><indexterm>
        <primary>filtri</primary>

        <secondary>nei confronti dei file</secondary>
      </indexterm></title>

    <para>In un confronto di file è possibile usare i filtri di riga per ignorare
singole righe. Ad esempio, potresti usare filtri di riga per ignorare i
commenti o determinati tipi di codice generato, come i timestamp del sistema
di controllo della versione.Ogni filtro di linea è una regola ed è possibile
applicare un numero qualsiasi di filtri di linea a un confronto di file.</para>

    <para>Per informazioni su come aggiungere, modificare e gestire i filtri, vedi
<xref linkend="Filters_dlg" />.</para>

    <section id="Filters_LineFilterApply">
      <title>Applicazione di filtri di linea</title>

      <para>È possibile applicare filtri di linea usando uno di questi metodi:</para>

      <itemizedlist>
        <listitem>
          <para>Quando si avvia un confronto di file dalla finestra di dialogo Seleziona
file o cartelle</para>

          <orderedlist>
            <listitem>
              <para>Dopo aver scelto il file <guilabel>primo</guilabel> e
<guilabel>secondo</guilabel>, seleziona <guibutton>Seleziona</guibutton>
accanto al campo <guilabel>Filtro</guilabel>.</para>
            </listitem>

            <listitem>
              <para>Nella finestra di dialogo Filtri, usare la scheda Filtri di linea per
abilitare i filtri di linea che si desidera usare (se presenti) o per
visualizzare quali filtri di linea sono attualmente abilitati.</para>

              <note>
                <para>Il campo <guilabel>Filtro</guilabel> non indica quali filtri di linea sono
abilitati.</para>
              </note>
              <para></para>
            </listitem>

            <listitem>
              <para>Procedere con l'operazione di confronto dei file. I filtri di linea
abilitati vengono applicati all'avvio dell'operazione.</para>
            </listitem>
          </orderedlist>
        </listitem>

        <listitem>
          <para>Dopo aver già avviato un'operazione di confronto dei file (ad esempio, per
applicare filtri diversi o disabilitare i filtri)</para>

          <orderedlist>
            <listitem>
              <para>Seleziona <menuchoice> <guimenu>Strumenti</guimenu>
<guimenuitem>Filtri</guimenuitem> </menuchoice>.</para>
            </listitem>

            <listitem>
              <para>Apri la scheda Filtri file.</para>
            </listitem>

            <listitem>
              <para>Seleziona i singoli filtri di linea che vuoi applicare e deseleziona i
filtri che non vuoi applicare.</para>

              <para>Puoi anche aggiungere, modificare e rimuovere filtri dall'elenco usando i
pulsanti <guibutton>Nuovo</guibutton>, <guibutton>Modifica</guibutton> e
<guibutton>Rimuovi</guibutton>.</para>
            </listitem>

            <listitem>
              <para>Per attivare i filtri di linea, seleziona <guilabel>Abilita filtri di
linea</guilabel>. Per disattivare il filtraggio della linea, deseleziona
l'opzione.</para>
            </listitem>

            <listitem>
              <para>Seleziona <guibutton>OK</guibutton> per chiudere la finestra di dialogo
Filtri file.</para>
            </listitem>

            <listitem>
              <para>Seleziona <keycap>F5</keycap> per applicare le modifiche e aggiornare la
finestra Confronta file.</para>
            </listitem>
          </orderedlist>
        </listitem>
      </itemizedlist>
    </section>

    <section id="Filters_LineFilterSyntax">
      <title>Sintassi del filtro di linea<indexterm>
          <primary>regole</primary>

          <secondary>filtro di linea</secondary>
        </indexterm><indexterm>
          <primary>filtri</primary>

          <secondary>linea</secondary>
        </indexterm><indexterm>
          <primary>espressioni regolari</primary>

          <secondary>filtri in linea</secondary>
        </indexterm></title>

      <para>Un filtro di riga è una regola che viene valutata rispetto a ogni differenza
di riga singola nei file confrontati, se le regole di filtro di riga sono
abilitate. Quando una regola corrisponde a una differenza di riga singola,
la differenza viene ignorata.</para>

      <para>Le differenze ignorate sono contrassegnate nella finestra Confronta file con
il colore <guilabel>Differenza ignorata</guilabel> (come definito nella
pagina Colori delle Opzioni di WinMerge). Ciò consente di distinguere le
differenze ignorate da altri tipi. Tuttavia, non è possibile selezionare o
unire la differenza ignorata.</para>

      <para>La corrispondenza del filtro di linea può essere descritta in termini di due
idee:</para>

      <itemizedlist>
        <listitem>
          <para>Quando una regola corrisponde a qualsiasi parte della linea, l'intera
differenza viene ignorata. Pertanto non è possibile filtrare solo parte di
una riga. Ad esempio, supponiamo che due file abbiano la seguente differenza
di una sola riga:</para>

          <formalpara>
            <title>File1:</title>

            <para><screen># Jean Sibelius</screen></para>
          </formalpara>

          <formalpara>
            <title>File2:</title>

            <para><screen>#Janne Sibelius</screen></para>
          </formalpara>

          <para>Senza filtraggio, la linea viene rilevata come differenza. Ma se applichiamo
una regola di filtro di riga con l'espressione <code>^#</code>, le righe
vengono riportate come identiche, poiché l'espressione specifica solo il
primo carattere, che corrisponde in entrambi i file.</para>
        </listitem>

        <listitem>
          <para>Una regola viene applicata a una differenza su più righe solo se tutte le
righe corrispondono. Ad esempio, considera questa differenza di due righe:</para>

          <formalpara>
            <title>File1:</title>

            <para><screen># Jean Sibelius
#Pekka Himanen</screen></para>
          </formalpara>

          <formalpara>
            <title>File2:</title>

            <para><screen>#Janne Sibelius
Pekka Himanen</screen></para>
          </formalpara>

          <para>La stessa regola <code>^#</code> corrisponde alla prima riga, ma non alla
seconda riga. Pertanto, la differenza non viene ignorata.</para>
        </listitem>
      </itemizedlist>

      <tip>
        <para>Di solito è buona norma usare i marcatori di inizio riga ( <code>^</code> )
e di fine riga ( <code>$</code> ) per controllare con precisione i modelli,
poiché la regola viene applicata se qualsiasi parte di una riga corrisponde
all'espressione.</para>
      </tip>

      <example>
        <title>Filtri della linea di campionamento</title>

<screen format="linespecific">^IL MIOTAG$</screen><para>Filtra le righe che corrispondono esattamente a <literal>MYTAG</literal></para>

<screen format="linespecific">^::</screen><para>Filtra le righe che iniziano con <literal>::</literal></para>

<screen format="linespecific">^/\*.*\*/$</screen><para>Filtra le righe che iniziano con <literal><constant>/*</constant></literal>
e finiscono con <literal>*/</literal></para>

<screen format="linespecific">^[1-5]00</screen><para>Filtra le righe che iniziano con i numeri 100, 200, 300, 400 e 500</para>
      </example>

      <example>
        <title>Regola del filtro di linea che corrisponde alle linee ID CVS</title>

        <para>Le linee ID CVS hanno questo aspetto:</para>

<screen>// $Id: Filters.xml 7591 20/01/2013 15:47:42Z christianlist $</screen><para>... e può essere filtrato con questa regola:</para>

<screen>^// \WId: .*\$</screen></example>

      <example>
        <title>Filtra i commenti sui numeri di riga nei file po</title>

        <para>i commenti sul numero di riga po assomigliano a questo:</para>

<screen>#: origine/nomefile.c:766</screen><para>... e può essere filtrato con questa regola:</para>

<screen>^#</screen></example>
    </section>
  </section>

  <section id="Filters_DisplayLineFilter">
    <title>Usando il filtro visualizza linea <indexterm>
        <primary>visualizza filtro linea</primary>
      </indexterm></title>

    <para>Il filtro della riga di visualizzazione controlla quali righe sono visibili
nella finestra Confronto file. Le righe che non corrispondono al filtro
vengono nascoste, ma il risultato del confronto stesso non viene
influenzato.</para>

    <section id="Filters_DisplayLineFilterApply">
      <title>Apertura barra filtri visualizzazione</title>

      <para>Usa uno dei seguenti metodi per aprire la barra filtri visualizzazione:</para>

      <itemizedlist>
        <listitem>
          <para>Seleziona <menuchoice> <guimenu>Visualizza</guimenu> <guimenuitem>Visualizza
barra filtri</guimenuitem> </menuchoice>, o premi
<keycombo><keycap>Ctrl</keycap><keycap>Maiusc</keycap>
<keycap>L</keycap></keycombo>.</para>
        </listitem>
        <listitem>
          <para>Fai clic con il pulsante destro del mouse sul testo selezionato nella
finestra Confronta file e scegli <menuchoice> <guimenu >Aggiungi ai
filtri</guimenu > <guimenuitem >Aggiungi ai filtri di
visualizzazione</guimenuitem > </menuchoice >. WinMerge creerà
automaticamente un'espressione <literal>La riga contiene "..."</literal> dal
testo selezionato e apre la barra filtri.</para>
        </listitem>
      </itemizedlist>

      <para>Per rimuovere il filtro, cancella il campo di input e premi
<keycap>Invio</keycap>. Per nascondere la barra del filtro mantenendo il
filtro attivo, fai clic sul pulsante di chiusura.</para>
    </section>

    <section id="Filters_DisplayLineFilterInput">
      <title>Inserisci un filtro</title>

      <para>La barra filtri visualizzazione accetta input in due forme, determinate dal
fatto che l'input inizi con il prefisso <literal>le:</literal>:</para>

      <variablelist>
        <varlistentry>
          <term>Stringa semplice (nessun prefisso)</term>
          <listitem>
            <para>L'input senza il prefisso <literal>le:</literal> viene trattato come una
stringa letterale. WinMerge visualizza solo le righe che contengono quella
stringa. Internamente, l'input è equivalente a <literal>le:Line contiene
"<replaceable>input</replaceable>"</literal>.</para>
            <para>Esempio: inserendo <userinput>TODO</userinput> vengono visualizzate tutte le
righe che contengono il testo <literal>TODO</literal>.</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><literal>le:</literal> prefisso (espressione filtro)</term>
          <listitem>
            <para>Se l'input inizia con <literal>le:</literal>, il resto viene interpretato
come un'espressione di filtro. È disponibile la sintassi completa
dell'espressione descritta in <xref
linkend="Filters_DisplayLineFilter_Syntax"/>.</para>
            <para>Esempio: <userinput>le:Different e la riga contiene "ERRORE"</userinput></para>

            <important>
              <para>Il prefisso <literal>le:</literal> deve apparire proprio all'inizio
dell'input. Se appare altrove, l'intero input viene trattato come una
semplice stringa.</para>
              <para>Ad esempio, <userinput>Hello o le:Line contiene "Hello"</userinput>
<emphasis>non</emphasis> contiene un'espressione di filtro. L'intero input
viene trattato come una ricerca di stringhe letterali per il testo
<literal>Hello o le:Line contiene "Hello"</literal>.</para>
            </important>
          </listitem>
        </varlistentry>
      </variablelist>
    </section>

    <section id="Filters_DisplayLineFilter_Syntax">
      <title>Sintassi espressione filtro</title>

      <para>Le espressioni di filtro di riga di visualizzazione usano lo stesso motore
delle espressioni di filtro di confronto di cartelle (vedi <xref
linkend="FilterExpression_Syntax"/>), con i seguenti attributi e funzioni
aggiuntivi che operano su singole righe.</para>

      <section id="Filters_DisplayLineFilter_Attrs">
        <title>Attributi linea</title>

        <para>Gli attributi contrassegnati come supporto di prefissi specifici del lato
accettati sono <literal>Left</literal>, <literal>Middle</literal>, and
<literal>Right</literal> (es., <literal>LeftLine</literal>,
<literal>RightLineLength</literal>). Gli attributi senza prefisso vengono
valutati in tutti i riquadri.</para>

        <variablelist>
          <varlistentry>
            <term><varname>Line</varname></term>
            <listitem><para>Contenuto del testo della riga attuale. Supporta prefissi specifici del
lato. Esempio: <literal>La riga contiene "TODO"</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>LineLength</varname></term>
            <listitem><para>Lunghezza della riga attuale in caratteri. Supporta prefissi specifici del
lato. Esempio: <literal>LineLength> 120</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>LineNumber</varname></term>
            <listitem><para>Numero di riga reale nel file (in base 1), senza contare le righe
fantasma. Supporta prefissi specifici del lato. Esempio: <literal>LineNumber
&lt;= 50</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>ViewLineNumber</varname></term>
            <listitem><para>Visualizza il numero di riga incluse le linee fantasma (in base
1). Attributo globale (nessun prefisso laterale). Esempio:
<literal>ViewLineNumber &lt;= 100</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Different</varname></term>
            <listitem><para>Vero se la linea fa parte di un blocco differenza. Attributo
globale. Esempio: <literal>Different</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Identical</varname></term>
            <listitem><para>Vero se la linea è identica in tutti i riquadri. Attributo globale.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Trivial</varname></term>
            <listitem><para>Vero se la riga differisce solo negli spazi bianchi o in altro contenuto
ignorato. Attributo globale. Esempio: <literal>Different o Trivial</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Exists</varname></term>
            <listitem><para>Vero se la linea esiste nel riquadro (non una linea fantasma). Supporta
prefissi specifici del lato. Esempio: <literal>LeftExists e non
RightExists</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Missing</varname></term>
            <listitem><para>Vero se la linea è una linea fantasma nel riquadro. L'opposto di
<varname>Exists</varname>. Supporta prefissi specifici del lato.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Moved</varname></term>
            <listitem><para>Vero se la linea viene rilevata come linea spostata. Supporta prefissi
specifici del lato.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Bookmarked</varname></term>
            <listitem><para>Vero se la riga ha un segnalibro. Supporta prefissi specifici del lato.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>DifferentLeftMiddle</varname>,
<varname>DifferentMiddleRight</varname>,
<varname>DifferentLeftRight</varname></term>
            <listitem><para>Vero se la coppia di riquadri indicata differisce su questa riga. Solo
confronti a 3 vie (eccetto <varname>DifferentLeftRight</varname> che
funziona anche a 2 vie). Attributi globali. Esempio:
<literal>DifferentLeftMiddle e non DifferentMiddleRight</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>EOL</varname></term>
            <listitem><para>Stile di fine riga per la riga attuale come valore intero. Supporta prefissi
specifici del lato. Valori: 0 = Nessuno, 1 = LF, 2 = CR, 3 = CRLF Esempio:
<literal>le:EOL = 3</literal> visualizza solo le righe con terminazioni CRLF</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>EOLStr</varname></term>
            <listitem><para>Stile di fine riga per la riga attuale come stringa. Supporta prefissi
specifici del lato. Valori: "None", "LF", "CR", "CRLF" Esempio:
<literal>le:EOLStr = "LF"</literal> visualizza solo le righe con
terminazioni LF</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Column</varname>, <varname>ColumnCount</varname> (solo modalità
tabella)</term>
            <listitem><para>Contenuto delle celle e conteggio delle colonne in modalità
CSV/tabella. Supporta prefissi specifici del lato. Esempio:
<literal>Column("Stato") = "FAIL"</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>LineAt</function>(<replaceable>lineNumber</replaceable>),
<function>LineOffsetAt</function>(<replaceable>offset</replaceable>)</term>
            <listitem><para>Testo della riga in corrispondenza di un numero di riga assoluto o di un
offset relativo rispetto alla riga attuale. Supporta funzioni di prefisso
specifiche del lato. Esempio: <literal>le:Different e RightLineOffsetAt(-1)
corrisponde a "^//"</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>Column</function>(<replaceable>indexOrName</replaceable>),
<function>ColumnAt</function>(<replaceable>line</replaceable>,
<replaceable>indexOrName</replaceable>),
<function>ColumnOffsetAt</function>(<replaceable>offset</replaceable>,
<replaceable>indexOrName</replaceable>) (solo modalità tabella)</term>
            <listitem><para>Contenuto della cella per indice o nome, alla riga attuale, assoluta o
relativa. Esempio: <literal>le:RightColumn("Category") != ColumnOffsetAt(-1,
"Category")</literal></para></listitem>
          </varlistentry>
        </variablelist>
      </section>

      <section id="Filters_DisplayLineFilter_Funcs">
        <title>Funzioni linea</title>

        <para>
Le espressioni di filtro della visualizzazione riga possono anche usare le
funzioni descritte in <xref linkend="FilterExpression_Functions"/>.</para>

        <variablelist>
          <varlistentry>
            <term><function>matchContext</function>(<replaceable>expr</replaceable>,
<replaceable>linesBefore</replaceable>,
<replaceable>linesAfter</replaceable>)</term>
            <listitem><para>Vero se la riga attuale si trova all'interno delle righe
<replaceable>linesBefore</replaceable> prima o tra le righe
<replaceable>linesAfter</replaceable> dopo qualsiasi riga corrispondente a
<replaceable>expr</replaceable>. Esempio:
<literal>le:matchContext(Different, 3, 3)</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchNumber</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Indice in base 1 della riga attuale all'interno di tutte le righe
corrispondenti. Restituisce <literal>none</literal>se la linea non
corrisponde. Esempio: <literal>le:matchNumber(Different) = 1</literal>
visualizza solo la prima riga che corrisponde (la prima riga differenza)</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchCount</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Numero totale di righe che corrispondono a <replaceable>expr</replaceable>
nell'intero file. Esempio: <literal>le:matchNumber(Different) =
matchCount(Different)</literal> visualizza solo l'ultima riga che
corrisponde (l'ultima riga della differenza).</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchBlockNumber</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Restituisce il numero di blocco in base 1 del blocco corrispondente
contenente la riga attuale. Restituisce <literal>none</literal> se la riga
attuale non si trova in nessun blocco corrispondente. Esempio:
<literal>le:matchBlockNumber(Different) = 1</literal> visualizza solo le
righe nel primo blocco differenza.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchBlockOffset</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Restituisce l'offset in base 1 della riga attuale all'interno del blocco
corrispondente. Se la riga attuale non si trova in nessun blocco
corrispondente restituisce <literal>none</literal>. Esempio:
<literal>le:matchBlockOffset(Different) = 1</literal> visualizza solo la
prima riga di ciascun blocco differenza.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchBlockSize</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Restituisce la dimensione (numero di righe) del blocco corrispondente
contenente la riga attuale. Se la riga attuale on si trova in nessun blocco
corrispondente restituisce <literal>none</literal>. Esempio:
<literal>le:matchBlockSize(Different) > 5</literal> visualizza solo le righe
nei blocchi di differenza più grandi di 5 righe.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchBlockCount</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Numero totale di blocchi corrispondenti nel file. Esempio:
<literal>le:matchBlockNumber(Different) =
matchBlockCount(Different)</literal> visualizza solo le righe nell'ultimo
blocco differenza.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchDistance</function>(<replaceable>expr</replaceable>),
<function>matchDistanceBefore</function>(<replaceable>expr</replaceable>),
<function>matchDistanceAfter</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Distanza in linee dall'intervallo di corrispondenza più vicino (entrambe le
direzioni, solo prima o solo dopo). Esempio:
<literal>le:matchDistance(Different) &lt;= 5</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchInside</function>(<replaceable>beginExpr</replaceable>,
<replaceable>endExpr</replaceable>)</term>
            <listitem><para>Vero se la riga attuale cade tra una riga che corrisponde a
<replaceable>beginExpr</replaceable> e la riga successiva che corrisponde a
<replaceable>endExpr</replaceable> (inclusa). Esempio:
<literal>le:matchInside (la riga corrisponde a "^#ifdef", la riga
corrisponde a "^#endif")</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>media</function>(<replaceable>expr</replaceable>),
<function>average</function>(<replaceable>expr</replaceable>,
<replaceable>condizione</replaceable>)</term>
            <listitem><para>Calcola la media (media aritmetica) dei valori numerici prodotti valutando
<replaceable>expr</replaceable> per tutte le righe nel file. Se viene
fornita <replaceable>condition</replaceable>, solo le righe in cui
<replaceable>condition</replaceable> restituisce true vengono incluse nel
calcolo. I risultati non numerici vengono ignorati. Restituisce
<literal>none</literal>se non viene trovato alcun valore numerico. Esempio:
<literal>le:toInt(Column("Prezzo"))>
Average(toInt(Column("Prezzo")))</literal> visualizza le righe in cui il
prezzo supera il prezzo medio. Esempio con condizione:
<literal>le:average(toInt(Column("Punteggio")), Column("Stato") =
"PASS")</literal> calcola il punteggio medio per le righe con stato "PASS".</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>maximum</function>(<replaceable>expr</replaceable>),
<function>maximum</function>(<replaceable>expr</replaceable>,
<replaceable>condition</replaceable>)</term>
            <listitem><para>Restituisce il valore massimo tra tutti i risultati prodotti valutando
<replaceable>expr</replaceable> per tutte le righe nel file. Se viene
fornita <replaceable>condizione</replaceable>, vengono considerate solo le
righe in cui <replaceable>condizione</replaceable> restituisce
vero. Funziona con valori numerici, stringhe (confronto alfabetico) e
timestamp. Se non viene trovato alcun valore restituisce
<literal>none</literal>. Esempio: <literal>le:toInt(Column("Quantity")) =
maxim(toInt(Column("Quantity")))</literal> visualizza le righe con la
quantità più alta.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>minimum</function>(<replaceable>expr</replaceable>),
<function>minimum</function>(<replaceable>expr</replaceable>,
<replaceable>condition</replaceable>)</term>
            <listitem><para>Restituisce il valore minimo tra tutti i risultati prodotti valutando
<replaceable>expr</replaceable> per tutte le righe nel file. Se viene
fornita <replaceable>condizione</replaceable>, vengono considerate solo le
righe in cui <replaceable>condizione</replaceable> restituisce
vero. Funziona con valori numerici, stringhe (confronto alfabetico) e
timestamp. Se non viene trovato alcun valore restituisce
<literal>none</literal>. Esempio: <literal>le:Column("Status") =
Minimum(Column("Status"))</literal> visualizza le righe con il primo valore
di stato in ordine alfabetico.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>sum</function>(<replaceable>expr</replaceable>),
<function>sum</function>(<replaceable>expr</replaceable>,
<replaceable>condition</replaceable>)</term>
            <listitem><para>Calcola la somma di tutti i valori numerici prodotti valutando
<replaceable>expr</replaceable> per tutte le righe nel file. Se viene
fornita <replaceable>condition</replaceable>, solo le righe in cui
<replaceable>condition</replaceable> restituisce true vengono incluse nel
calcolo. I risultati non numerici vengono ignorati. Restituisce
<literal>none</literal>se non viene trovato alcun valore numerico. Esempio:
<literal>le:toInt(Column("Quantity")) / sum(toInt(Column("Quantity"))) *
100</literal> calcola la percentuale di ciascuna riga della quantità
totale. Esempio con condizione: <literal>le:sum(toInt(Column("Sales")),
Column("Region") = "East")</literal> calcola le vendite totali per la
regione "East".</para></listitem>
          </varlistentry>
        </variablelist>
      </section>

      <section id="Filters_DisplayLineFilter_Examples">
        <title>Esempi</title>

        <informaltable>
          <tgroup cols="2">
            <thead>
              <row>
                <entry>Ingresso</entry>
                <entry>Effetto</entry>
              </row>
            </thead>
            <tbody>
              <row>
                <entry><userinput>TODO</userinput></entry>
                <entry>Visualizza le righe contenenti il testo "TODO" (stringa semplice)</entry>
              </row>
              <row>
                <entry><userinput>le:Different</userinput></entry>
                <entry>Visualizza solo le righe nei blocchi differenza</entry>
              </row>
              <row>
                <entry><userinput>le:Different o Trivial</userinput></entry>
                <entry>Visualizza tutte le differenze, comprese le differenze ignorate</entry>
              </row>
              <row>
                <entry><userinput>le:matchContext(Different, 3, 3)</userinput></entry>
                <entry>Visualizza blocchi differenza con 3 righe di contesto in ciascun lato</entry>
              </row>
              <row>
                <entry><userinput>le:matchNumber(Different) = 1</userinput></entry>
                <entry>Visualizza solo la prima linea differenza</entry>
              </row>
              <row>
                <entry><userinput>le:matchBlockNumber(Different) &lt;= 3</userinput></entry>
                <entry>Visualizza solo le righe nei primi 3 blocchi differenza</entry>
              </row>
              <row>
                <entry><userinput>le:matchBlockOffset(Different) = 1</userinput></entry>
                <entry>Visualizza solo la prima riga di ciascun blocco differenze</entry>
              </row>
              <row>
                <entry><userinput>le:matchBlockSize(Different) &gt; 10</userinput></entry>
                <entry>Visualizza solo le righe nei blocchi differenza più grandi di 10 righe</entry>
              </row>
              <row>
                <entry><userinput>le:Different e Linea contengono "ERROR"</userinput></entry>
                <entry>Visualizza le righe che sono diverse e contengono "ERRORE"</entry>
              </row>
              <row>
                <entry><userinput>le:strFind(Line, "TODO") &lt; 10</userinput></entry>
                <entry>Visualizza le righe in cui appare "TODO" tra i primi 10 caratteri</entry>
              </row>
              <row>
                <entry><userinput>le:regexFind(Line, "\d{4}") != none</userinput></entry>
                <entry>Visualizza le righe contenenti un numero di 4 cifre</entry>
              </row>
              <row>
                <entry><userinput>le:matchContext(Bookmarked, 2, 2)</userinput></entry>
                <entry>Visualizza le righe contrassegnate con 2 righe di contesto</entry>
              </row>
              <row>
                <entry><userinput>le:LineNumber &lt;= 50</userinput></entry>
                <entry>Visualizza solo le prime 50 righe</entry>
              </row>
              <row>
                <entry><userinput>le:EOL = 3</userinput></entry>
                <entry>Visualizza solo le righe con terminazioni di riga CRLF (Windows)</entry>
              </row>
              <row>
                <entry><userinput>le:EOLStr = "LF"</userinput></entry>
                <entry>Visualizza solo le righe con terminazioni di riga LF (Unix)</entry>
              </row>
              <row>
                <entry><userinput>le:allof(EOL = 1)</userinput></entry>
                <entry>Visualizza le righe in cui tutti i riquadri usano terminazioni di riga LF</entry>
              </row>
              <row>
                <entry><userinput>le:toInt(Column("Count")) &gt; 100</userinput></entry>
                <entry>Visualizza le righe in cui il valore della colonna "Conteggio" supera 100
(modalità tabella)</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
      </section>
    </section>
  </section>

  <section id="Filters_DisplayFileFolderFilter">
    <title>Usando il filtro visualizza file/cartella<indexterm>
        <primary>visualizza filtro file/cartella</primary>
      </indexterm></title>

    <para>Il filtro visualizzazione file/cartelle nella finestra Confronto cartelle
funziona allo stesso modo del filtro visualizzazione riga nella finestra
'Confronto file', ma opera su file e cartelle anziché su righe. Controlla
quali elementi sono visibili senza influenzare il risultato del confronto.</para>

    <para>Per aprire la barra dei filtri visualizzazione, seleziona <menuchoice>
<guimenu>Visualizza</guimenu> <guimenuitem>Barra filtri
visualizzazione</guimenuitem> </menuchoice>, o premi
<keycombo><keycap>Ctrl</keycap><keycap>Maiusc</keycap>
<keycap>L</keycap></keycombo>.</para>

    <para>La barra dei filtri accetta la stessa sintassi del campo
<guilabel>Filtro</guilabel> nella finestra di dialogo 'Seleziona file o
cartelle'. Per i dettagli vedi <xref linkend="Filters_MaskSyntax"/> e <xref
linkend="FilterExpression_Syntax"/>.</para>

    <para>Per rimuovere il filtro, cancella il campo di input e premi
<keycap>Invio</keycap>. Per nascondere la barra del filtro mantenendo il
filtro attivo, fai clic sul pulsante di chiusura.</para>

    <para>Esempi:</para>
    <itemizedlist>
      <listitem><para><userinput>*.cpp;*.h</userinput> - visualizza i file sorgente e intestazione
C++</para></listitem>
      <listitem><para><userinput>!.git\;!.vs\</userinput> - esclude le cartelle .git e .vs</para></listitem>
      <listitem><para><userinput>fe:Different</userinput> - visualizza solo file diversi</para></listitem>
      <listitem><para><userinput>de:Items &gt; 10</userinput> - visualizza le cartelle con più di
10 elementi</para></listitem>
      <listitem><para><userinput>e:Date> today() - 7 giorni</userinput> - visualizza gli elementi
modificati nell'ultima settimana</para></listitem>
    </itemizedlist>
  </section>

  <section id="Filters_SubstitutionFilter">
    <title>Uso dei filtri di sostituzione<indexterm>
        <primary>filtri</primary>

        <secondary>sostituzione</secondary>
      </indexterm><indexterm>
        <primary>filtri</primary>

        <secondary>nei confronti dei file</secondary>
      </indexterm></title>

    <para>Da definire</para>
  </section>

  <section id="Filters_dlg">
    <title>Uso della finestra di dialogo Filtri<indexterm>
        <primary>Finestra di dialogo Filtri</primary>
      </indexterm><indexterm>
        <primary>filtri</primary>

        <secondary>gestire e abilitare</secondary>
      </indexterm></title>

    <para>Questa sezione descrive la finestra di dialogo Filtri, che fornisce funzioni
per creare e gestire filtri di file e filtri di linea.</para>

    <para>Per aprire la finestra di dialogo Filtri, usare uno di questi metodi:</para>

    <itemizedlist>
      <listitem>
        <para>Nella finestra di dialogo Seleziona file o cartelle, seleziona
<guibutton>Seleziona</guibutton> a destra del campo
<guilabel>Filtro</guilabel >. Usa questo metodo quando vuoi applicare un
filtro di file a un'operazione di confronto di cartelle.</para>
      </listitem>

      <listitem>
        <para>Seleziona <menuchoice> <guimenu>Strumenti</guimenu>
<guimenuitem>Filtri</guimenuitem> </menuchoice>. Questo metodo può essere
usato in qualsiasi momento, tranne quando è aperta la finestra di dialogo
Seleziona file o cartelle.</para>
      </listitem>
    </itemizedlist>

    <para>La finestra di dialogo Filtri dispone di una scheda per ciascun tipo di
filtro WinMerge:</para>

    <variablelist>
      <varlistentry>
        <term>Filtri di file</term>

        <listitem>
          <para>Scegli questa scheda per usare i filtri dei file per le operazioni di
confronto delle cartelle.</para>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>Filtri di linea</term>

        <listitem>
          <para>Scegli questa scheda per lavorare con i filtri di riga per le operazioni di
confronto dei file.</para>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>Filtri di sostituzione</term>

        <listitem>
          <para>Scegli questa scheda per lavorare con i filtri di sostituzione per le
operazioni di confronto dei file.</para>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>Visualizza filtro linea</term>

        <listitem>
          <para>Il filtro della riga di visualizzazione non viene configurato tramite questa
finestra di dialogo. Aprilo tramite
<menuchoice><guimenu>Visualizza</guimenu> <guimenuitem>Visualizza barra
filtri</guimenuitem></menuchoice>. Vedi <xref
linkend="Filters_DisplayLineFilter"/>.</para>
        </listitem>
      </varlistentry>
    </variablelist>

    <section id="Filters_FileFiltersTab">
      <title>Usando la scheda Filtri file<indexterm>
          <primary>filtri di file</primary>

          <secondary>abilitante</secondary>
        </indexterm></title>

      <para>La parte principale di questa scheda è un elenco di filtri di file
disponibili per le operazioni di confronto delle cartelle. L'elenco include
filtri di file condivisi, privati e installati conosciuti da WinMerge, come
descritto in <xref linkend="Filters_FileFilterLoc" />.</para>

      <section id="Filters_FileFilterEnabling">
        <title>Abilitazione e disabilitazione dei filtri file</title>

        <para>È necessario abilitare un filtro file per renderlo disponibile in
un'operazione di confronto di cartelle o disabilitare un filtro attuale per
impedirne l'uso:</para>

        <orderedlist>
          <listitem>
            <para>Apri la finestra di dialogo Filtri, se non è già aperta.</para>
          </listitem>

          <listitem>
            <para>Seleziona un filtro file o <guimenuitem>&lt;Nessuno&gt;</guimenuitem>
dall'elenco.</para>
          </listitem>

          <listitem>
            <para>Seleziona <guibutton>OK</guibutton> per chiudere la finestra di dialogo
Filtri.</para>
          </listitem>
        </orderedlist>

        <para>Esistono diversi modi per applicare i filtri dei file dopo averli
abilitati. Per i dettagli, vedi <xref linkend="Filters_FileFilterApply" />.</para>
      </section>

      <section id="Filters_FileFilterCfg">
        <title>Configurazione dei filtri dei file</title>

        <para>Usa questi pulsanti per gestire l'elenco dei <guilabel>filtri
file</guilabel> e creare nuovi filtri file:</para>

        <variablelist>
          <varlistentry>
            <term>Test</term>

            <listitem>
              <para>Seleziona un filtro di file nell'elenco e seleziona
<guibutton>Prova</guibutton> per visualizzare rapidamente come funziona il
filtro. Per i dettagli vedi <xref linkend="Filters_TestingDlg" />.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>Installare</term>

            <listitem>
              <para>Consente di individuare un filtro file e di aggiungerlo all'elenco Filtri. I
filtri dei file che non si trovano nella cartella condivisa o privata
predefinita non vengono rilevati a meno che non li installi.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>Nuovo</term>

            <listitem>
              <para>Crea una nuova copia di un modello di file nelle cartelle dei filtri
condivise o private e la apre nell'editor predefinito. Modifica il modello e
aggiungi le regole, come descritto in <xref linkend="Filters_CreatingFile"
/>.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>Modificare</term>

            <listitem>
              <para>Seleziona un filtro file nell'elenco e seleziona
<guibutton>Modifica</guibutton> per aprire il file nel tuo editor
predefinito.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>Eliminare</term>

            <listitem>
              <para>Seleziona un filtro file nell'elenco e seleziona
<guibutton>Elimina</guibutton> per eliminare il file e rimuoverlo
dall'elenco. Sì, il file è stato davvero eliminato!</para>
            </listitem>
          </varlistentry>
        </variablelist>

        <para>Le modifiche vengono salvate quando selezioni <guibutton>OK</guibutton> per
chiudere la finestra di dialogo Filtri. I filtri di linea sono memorizzati
nel registro di Windows.</para>
      </section>

      <section id="Filters_CreatingFile">
        <title>Creazione di un filtro di file</title>

        <para>Se i filtri file installati con WinMerge non forniscono il filtro
necessario, puoi crearne uno tuo:</para>

        <orderedlist>
          <listitem>
            <para>Seleziona <menuchoice> <guimenu>Strumenti</guimenu>
<guimenuitem>Filtri</guimenuitem> </menuchoice>.Oppure, dalla finestra di
dialogo Seleziona file o cartelle, seleziona
<guibutton>Seleziona</guibutton> a destra del campo
<guilabel>Filtro</guilabel>.</para>
          </listitem>

          <listitem id="Filters_New_step">
            <para>Nella scheda Filtri file della finestra di dialogo Filtri, seleziona
<guibutton>Nuovo</guibutton>.</para>
          </listitem>

          <listitem>
            <para>Nella finestra di dialogo Filtro condiviso o privato, scegli
<guilabel>Filtro condiviso</guilabel> o <guilabel>Filtro privato</guilabel>
(vedi <xref linkend="Filters_FileFilterLoc" /> per i loro usi) e seleziona
<keycap>OK</keycap>.</para>

            <para>La finestra di dialogo Seleziona nome file per nuovo filtro si apre nella
cartella dei file condivisi o privati sul sistema (se la cartella privata
non esiste, WinMerge la crea).</para>
          </listitem>

          <listitem>
            <para>Nella finestra di dialogo Seleziona nome file per nuovo filtro, inserisci un
nuovo nome file e seleziona <guibutton>Salva</guibutton>.</para>

            <note>
              <para>Non scegliere un nome di file esistente: per modificare un file esistente,
torna al passaggio <xref linkend="Filters_New_step" /> e seleziona Modifica
invece che su Nuovo.</para>
            </note>

            <para>WinMerge inizializza il nuovo file con il contenuto del modello
<filename>FileFilter.tmpl</filename> e lo apre nel tuo editor di testo
predefinito.</para>
          </listitem>

          <listitem>
            <para>Segui le istruzioni del modello per modificare il modello, aggiornando il
nome e la descrizione del segnaposto e aggiungendo regole di filtro come
descritto in <xref linkend="Filters_FileFilterSyntax" />. Salva il file nel
tuo editor di testo.</para>

            <tip>
              <para>Se vuoi testare rapidamente una regola che stai definendo, prova a fare clic
su Test nella finestra di dialogo Filtri. Per i dettagli vedi <xref
linkend="Filters_TestingDlg" />.</para>
            </tip>
            <para></para>
          </listitem>

          <listitem>
            <para>Se hai creato il tuo filtro di file in una delle cartelle standard
<filename>Filtri</filename> e la finestra di dialogo Filtri non elenca il
tuo nuovo filtro di file, prova a fare clic su <guibutton>OK</guibutton> per
chiuderlo, quindi fai di nuovo clic su <menuchoice>
<guimenu>Strumenti</guimenu> <guimenuitem>Filtri</guimenuitem> </menuchoice>
per riaprirlo. L'elenco <guilabel>Filtri file</guilabel> ora dovrebbe
includere il nuovo filtro file.</para>

            <para>Se hai salvato il file in una posizione alternativa sul tuo file system),
WinMerge non potrà rilevarlo a meno che non lo installi. Per rendere un
filtro file rilevabile ovunque sul tuo sistema:</para>

            <orderedlist numeration="loweralpha">
              <listitem>
                <para>Seleziona <guibutton>Installa</guibutton> nella finestra di dialogo Filtri.</para>
              </listitem>

              <listitem>
                <para>Nella finestra di dialogo Individua il file del filtro da installare, vai al
file <filename>flt</filename> sul tuo sistema e seleziona <guibutton
>Apri</guibutton>. L'elenco Filtri file ora dovrebbe includere il filtro
file installato.</para>
              </listitem>
            </orderedlist>
          </listitem>
        </orderedlist>
      </section>

      <section id="Filters_TestingDlg">
        <title>Test delle regole di filtro dei file<indexterm>
            <primary>filtri di file</primary>

            <secondary>test</secondary>
          </indexterm><indexterm>
            <primary>testare i filtri dei file</primary>
          </indexterm></title>

        <para>Usa la finestra di dialogo Prova filtro per testare rapidamente un filtro di
file rispetto a dati di esempio, per sviluppare nuove regole o per
comprendere come funzionano le regole esistenti. Può essere più semplice che
eseguire un'operazione di confronto completa.</para>

        <para>A partire dalla finestra di dialogo Filtri:</para>

        <orderedlist>
          <listitem>
            <para>Nella scheda Filtri file, scegli il filtro file che vuoi testare.</para>
          </listitem>

          <listitem>
            <para>Se vuoi visualizzare le regole che testerai, seleziona
<guibutton>Modifica</guibutton> ora per aprire il file in modo da poterlo
visualizzare durante i passaggi successivi.</para>
          </listitem>

          <listitem>
            <para>Seleziona <guibutton>Prova</guibutton>.</para>
          </listitem>

          <listitem>
            <para>Nella finestra di dialogo Filtro test, scegli il tipo di regola da testare:</para>

            <itemizedlist>
              <listitem>
                <para>Per testare una regola di file <guilabel>f:</guilabel> nel tuo filtro file,
deseleziona l'opzione <guilabel>Nome cartella</guilabel>.</para>
              </listitem>

              <listitem>
                <para>Per testare una regola della cartella <guilabel>d:</guilabel>, seleziona
l'opzione <guilabel>Nome cartella</guilabel>.</para>
              </listitem>
            </itemizedlist>
          </listitem>

          <listitem>
            <para>Inserisci il testo da testare.</para>

            <para>Il testo deve essere appropriato per il tipo di regola che stai testando. Ad
esempio, se hai selezionato l'opzione <guilabel>Nome cartella</guilabel>,
probabilmente vorrai inserire il nome di una cartella, come \temp.</para>

            <para>La casella <guilabel>Risultato</guilabel>visualizza la voce, seguita dal suo
stato: <computeroutput>superato</computeroutput> o <computeroutput>non
riuscito</computeroutput>.</para>
          </listitem>
        </orderedlist>
      </section>
    </section>

    <section id="Filters_LineFiltersTab">
      <title>Usando la scheda Filtri di linea<indexterm>
          <primary>filtri di linea</primary>

          <secondary>abilitante</secondary>
        </indexterm></title>

      <para>Usa questa scheda per configurare e abilitare i filtri di riga per le
operazioni di confronto dei file. La scheda presenta un elenco di
regole.Ogni regola contiene una singola espressione regolare. È possibile
applicare qualsiasi combinazione di regole dall'elenco a un confronto di
file.</para>

      <section id="Filters_LineFilterCfg">
        <title>Configurazione dei filtri di linea</title>

        <para>Sotto l'elenco delle <guilabel>Espressioni regolari</guilabel> c'è una
casella di modifica e dei pulsanti che puoi usare per mantenere l'elenco in
qualsiasi momento aggiungendo, modificando e rimuovendo regole.</para>

        <para>Per aggiungere una nuova regola:</para>

        <orderedlist>
          <listitem>
            <para>Seleziona <guibutton>Nuovo</guibutton>. Il cursore di modifica viene
automaticamente abilitato nella casella di modifica.</para>
          </listitem>

          <listitem>
            <para>Inserisci un'espressione nella casella di modifica sotto l'elenco
<guilabel>Espressioni regolari</guilabel>.</para>
          </listitem>

          <listitem>
            <para>Seleziona <guibutton>Salva</guibutton> per caricare l'espressione in una
nuova riga nell'elenco.</para>
          </listitem>
        </orderedlist>

        <para>Per modificare una regola esistente:</para>

        <orderedlist>
          <listitem>
            <para>Seleziona la riga e seleziona <guibutton>Modifica</guibutton>.</para>
          </listitem>

          <listitem>
            <para>Modifica l'espressione nella casella di modifica.</para>
          </listitem>

          <listitem>
            <para>Seleziona <guibutton>Salva</guibutton><guibutton> </guibutton>quando hai
finito.</para>
          </listitem>
        </orderedlist>

        <para>Per eliminare una regola esistente, seleziona (spunta) la regola e seleziona
<guibutton>Rimuovi</guibutton>.</para>
      </section>

      <section id="Filters_LineFilterEnabling">
        <title>Abilitazione e disabilitazione dei filtri di linea<indexterm>
            <primary>filtri di linea</primary>

            <secondary>elenco dei disponibili</secondary>
          </indexterm></title>

        <orderedlist>
          <listitem>
            <para>Nell'elenco <guilabel>Espressioni regolari</guilabel>, seleziona solo i
filtri che vuoi applicare e deseleziona tutti i filtri che non vuoi
applicare.</para>
          </listitem>

          <listitem>
            <para>Seleziona o deseleziona l'opzione <guilabel>Abilita filtri di
linea</guilabel>. Se attivi il filtro, verranno usate tutte le regole
attualmente selezionate nell'elenco <guilabel>Espressione
regolare</guilabel>. Se il filtro è disattivato, non verrà usata alcuna
regola anche se selezionata.</para>
          </listitem>

          <listitem>
            <para>Seleziona <guibutton>OK</guibutton> per chiudere la finestra di dialogo
Filtri e salvare le impostazioni.</para>
          </listitem>
        </orderedlist>

        <para>Esistono diversi modi per applicare i filtri dei file dopo averli
abilitati. Per i dettagli, vedi <xref linkend="Filters_LineFilterApply" />.</para>
      </section>
    </section>

    <section id="Filters_SubstitutionFiltersTab">
      <title>Usando la scheda Filtri di sostituzione<indexterm>
          <primary>filtri sostitutivi</primary>

          <secondary>abilitante</secondary>
        </indexterm></title>

        <para>Da definire</para>

      <section id="Filters_SubstitutionFilterCfg">
        <title>Configurazione dei filtri di sostituzione</title>

        <para>Da definire</para>

      </section>

      <section id="Filters_SubstitutionFilterEnabling">
        <title>Abilitazione e disabilitazione dei filtri di sostituzione<indexterm>
            <primary>filtri sostitutivi</primary>

            <secondary>elenco dei disponibili</secondary>
          </indexterm></title>

        <para>Da definire</para>
      </section>
    </section>
  </section>

  <section id="AboutFilters_regexp">
    <title>Ottieni assistenza con le espressioni regolari<indexterm>
        <primary>espressioni regolari</primary>

        <secondary>ottenere aiuto</secondary>
      </indexterm></title>

    <para>Le espressioni regolari possono essere molto complesse. Fortunatamente, la
maggior parte dei filtri di file in WinMerge coinvolge semplici espressioni
di estensione, comevisualizzato negli esempi in questo argomento. I file
filtro installati con WinMerge includono molti altri esempi utili.</para>

    <para>Infine, ci sono molte risorse sul Web per assistenza con le espressioni
regolari, inclusi questi siti:</para>

    <variablelist>
      <varlistentry>
        <term>Buon sito dedicato alle espressioni regolari:</term>

        <listitem>
          <simpara><ulink
url="https://www.regular-expressions.info/">https://www.regular-expressions.info/</ulink></simpara>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>Esercitazione:</term>

        <listitem>
          <simpara><ulink
url="http://www.zvon.org/comp/r/tut-Regexp.html">http://www.zvon.org/comp/r/tut-Regexp.html</ulink></simpara>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>Riferimento rapido PDF:</term>

        <listitem>
          <simpara><ulink
url="https://github.com/GordonMcKinney/gist-assets/raw/master/regex.pdf">
https://github.com/GordonMcKinney/gist-assets/raw/master/regex.pdf</ulink></simpara>
        </listitem>
      </varlistentry>
    </variablelist>
  </section>
</article>
