Uso dei filtri


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).

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.

Esistono diversi filtri WinMerge per le operazioni di confronto di cartelle e file:

Confronto cartelle: maschere di file e filtri di file

È 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.

I file e le cartelle filtrati vengono nascosti nel risultato per impostazione predefinita, che in genere è ciò che vuoi. Puoi fare clic su VisualizzaVisualizza elementi saltati 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.

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 Usando il filtro visualizza file/cartella.

Confronti di file: filtri di riga e filtri di sostituzione

I filtri di riga vengono applicati solo alle operazioni di confronto dei file. Ti consentono di ignorare le differenze su una singola riga.

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.

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 Usando il filtro visualizza linea .

1. Uso delle maschere dei file

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

1.1. Definizione e applicazione di maschere di file

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

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

  • Se stai usando la riga di comando di WinMerge, usa il flag -f per specificare le maschere dei file (vedi l'esempio nella prossima sezione).

1.2. Sintassi ed esempio della maschera file

Puoi specificare maschere file e filtri estesi usando questo formato:

        Filtro1 Gruppo1;Filtro2 ...|Filtro1 Gruppo2;Filtro2 ...|...
      
  • Il carattere | separa i gruppi di filtri e funge da AND logico.

  • I filtri all'interno dello stesso gruppo sono separati da ; e vengono interpretati con un OR logico.

  • Un file viene incluso solo se corrisponde ad almeno un filtro in ciascun gruppo.

  • Per includere un carattere letterale | (pipe) in un'espressione regolare che non è racchiusa tra virgolette doppie (come nei filtri f: o f!:), usare invece ||.

    Esempio: f:(abc||def)\.txt$

  • Ciascun filtro (ad esempio, Filtro1, Filtro2) può essere uno dei seguenti tipi:

    *.ext

    Maschera file per estensione (ad es. *.txt)

    *.

    File senza estensione (ad esempio README)

    !*.ext

    Escludi file corrispondenti all'estensione (disponibile dalla versione 2.16.19)

    cartella\

    Cartelle di destinazione (devono terminare con \) (disponibile dal 16.2.19)

    !cartella\

    Escludi cartelle corrispondenti (disponibile dal 16.2.19)

    f: regexp

    Abbina i nomi dei file usando le espressioni regolari (disponibile dalla versione 2.16.49)

    f!: regexp

    Escludi file corrispondenti a regex (disponibile dalla versione 2.16.49)

    d: regexp

    Abbina i nomi delle cartelle usando regex (disponibile dalla versione 2.16.49)

    d!: regexp

    Escludi cartelle corrispondenti a regex (disponibile dal 2.16.49)

    fe: espressione

    Espressione di filtro per file (ad esempio fe:Size < 1KB) (disponibile dal 16.2.49)

    fe!: expr

    Espressione di filtro per escludere file (disponibile dalla versione 2.16.49)

    de: espressione

    Espressione di filtro per cartelle (disponibile dalla versione 2.16.49)

    de!: espressione

    Espressione di filtro per escludere cartelle (disponibile dalla versione 2.16.49)

    pf: nome filtro file

    Applica un filtro file per nome (disponibile dalla versione 2.16.49)

Example 1. Maschera di archivio

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

WinMergeU c:\project\docs c:\temp /f *.xml;*.txt


Example 2. Escluse le cartelle (dalla versione 2.16.19)

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

WinMergeU c:\project\docs c:\temp /f !.git\;!.vs\


Example 3. Espressione filtro (dalla versione 2.16.49)

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

WinMergeU c:\project\docs c:\temp /f "*.cpp;*.h|fe:Dimensione < 1KB"


1.3. Sintassi dell'espressione di filtro

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.

1.3.1. Letterali e tipi

I tipi letterali supportati includono:

  • Booleano: vero, falso

  • Null: none (rappresenta un valore nullo o mancante)

  • Intero: interi con segno a 64 bit (ad esempio, 1024 o con unità come 100KB, 7 giorni)

  • Reale (doppio): numeri in virgola mobile con decimale o esponente opzionale (ad esempio, 3.14, .5, 1e6)

  • Stringa: racchiusa tra virgolette doppie (ad esempio, "esempio")

  • Data/Ora: preceduto da d e racchiuso tra virgolette doppie (ad esempio, d"2026-05-21 07:16:33", d"2026-05-21")

Internamente, i valori possono essere dei seguenti tipi: booleano, intero, reale, timestamp, stringa, contenuto file, array o nessuno.

1.3.2. Direttive

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 @ e separate dall'espressione da spazi bianchi.

1.3.2.1. Direttive sulla distinzione tra maiuscole e minuscole

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

@cs, @casesensitive

Abilita il confronto con distinzione tra maiuscole e minuscole. Con queste direttive, "ABC" e "abc" sono considerati diversi.

@ci, @caseinsensitive

Abilita il confronto senza distinzione tra maiuscole e minuscole (comportamento predefinito). Con queste direttive, "ABC" e "abc" sono considerati identici.

Example 4. Esempi di distinzione tra maiuscole e minuscole

@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.

1.3.2.2. Direttive di ottimizzazione

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

@ottimizzare, @opt

Abilita l'ottimizzazione dell'espressione del filtro (comportamento predefinito). Ciò potrebbe migliorare le prestazioni per le espressioni complesse.

@nooptimize, @noopt

Disabilita l'ottimizzazione dell'espressione del filtro. Ciò è utile per il debug o quando l'ottimizzazione provoca risultati imprevisti.

Example 5. Esempi di ottimizzazione

@ottimizza dimensioni >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

1.3.2.3. Direttiva sui nomi

La direttiva @name 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.

@name="Nome filtro", @name=Nome filtro

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.

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.

Example 6. Esempi di direttive sui nomi

@name="Dimensioni file immagine di grandi dimensioni" >10 MB ed estensione = "png"
@name=Dimensione SmallTextFiles <1KB ed estensione = "txt"
@name="Data modificata oggi" >= oggi()
@name="Test Filter" @cs Nome come "test_*.cpp"

Note

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

1.3.3. Attributi

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.

1.3.3.1. Attributi fondamentali
Exists

Restituisce true se il file esiste, false altrimenti

Name

Nome del file

BaseName

Restituisce il nome del file senza estensione. Ad esempio, "document.txt" restituisce "documento".

Extension

Estensione file

IsFolder

Restituisce vero se l'elemento è una cartella/cartella, falso se è un file.

Folder

Restituisce il percorso relativo escludendo il nome del file e la cartella di base

RelPath

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".

FullPath

Restituisce il percorso completo del file

Size

Dimensioni del file

Date

Ultima data e ora modificata

DateStr

Stringa della data dell'ultima modifica nel formato aaaa-MM-gg

CreationTime

Timestamp della data di creazione

Attributes

Restituisce gli attributi del file come valore intero

AttrStr

Restituisce la stringa dell'attributo del file. Esempi: "R" per sola lettura, "H" per nascosto, "A" per archivio, "S" per file di sistema.

1.3.3.2. Attributi solo file

I seguenti attributi sono disponibili solo per gli elementi di confronto file. Se usato con elementi di cartelle, il comportamento non è definito.

Content

Contenuto del file. Restituisce un valore di tipo FileContent. Con questo tipo è possibile usare solo contains e recontains.

1.3.3.3. Attributi solo cartella

I seguenti attributi sono disponibili solo per gli elementi di confronto delle cartelle. Se usato con elementi file, il comportamento non è definito.

Files

Numero di file direttamente contenuti nella cartella.

RecursiveFiles

Numero di file contenuti nella cartella, incluse tutte le sottocartelle.

Items

Numero di elementi (file e sottocartelle) contenuti direttamente nella cartella.

RecursiveItems

Numero di elementi (file e sottocartelle) contenuti nella cartella, incluse tutte le sottocartelle.

TotalSize

Dimensione totale di tutti i file direttamente contenuti nella cartella, in byte.

RecursiveTotalSize

Dimensione totale di tutti i file contenuti nella cartella, incluse tutte le sottocartelle, in byte.

1.3.3.4. Prefissi specifici del lato

È possibile aggiungere prefissi per specificare il lato di confronto:

  • Sinistra: si applica al file sul lato sinistro (ad esempio, LeftSize)

  • Destra: si applica al file sul lato destro (ad esempio, RightDate)

  • Medio: si applica al file centrale nel confronto a 3 vie (ad esempio, MiddleName)

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

1.3.3.5. Attributi delle proprietà di Windows

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, System.Title, System.FileOwner, System. Image.HorizontalResolution).

Prop

Restituisce una matrice di valori di proprietà (Sinistra, Centro, Destra) per il nome della proprietà canonica specificata. Esempio: prop("System.Title")

LeftProp

Valore della proprietà del file sul lato sinistro. Esempio: leftprop("System.FileOwner")

MiddleProp

Valore della proprietà del file centrale (nel confronto a 3 vie).

RightProp

Valore della proprietà del file sul lato destro.

1.3.3.6. Display Filters Only Attributes

I seguenti attributi sono progettati per essere usati solo nei filtri Display fileters only (specificati tramite i prefissi e:, e!:, fe:, fe!:, de: o de!: in il campo Filtro). Non devono essere usati nelle regole di inclusione/esclusione del filtro file (.flt), poiché richiedono che il confronto venga prima completato e potrebbero causare comportamenti imprevisti.

Identical

Restituisce true se il risultato del confronto indica che gli elementi sono identici, false se non sono identici. Questo è un attributo globale (non supporta prefissi specifici del lato). Esempio: Identical visualizzare solo file identici.

Different

Restituisce true se il risultato del confronto indica che gli elementi sono diversi, falsese non sono diversi. Questo è un attributo globale (non supporta prefissi specifici del lato). Esempio: Different per visualizzare solo file diversi.

Skipped

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

Binary

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

DifferentLeftMiddle

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

DifferentMiddleRight

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

DifferentLeftRight

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

Differences

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: Differences> 0 per visualizzare file con differenze, o Differences> 10 per visualizzare file con più di 10 differenze.

IgnoredDiffs

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: IgnoredDiffs> 0 per visualizzare file con differenze ignorate, o Differences = 0 e IgnoredDiffs> 0 per visualizzare file identici tranne che per le differenze ignorate.

Unpacker

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: Unpacker = "CompareMSExcelFiles" per visualizzare i file confrontati usando il decompressore di Excel o Unpacker != "" per visualizzare tutti i file in cui è stato usato un decompressore.

Prediffer

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: Prediffer = "IgnoreColumns" per visualizzare i file confrontati usando il prediffer IgnoreColumns, o Prediffer != "" per visualizzare tutti i file in cui è stato usato prediffer.

EOL

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.

Valori: 0 = None, 1 = LF (Unix), 2 = CR (Mac), 3 = CRLF (Windows), 4 = Mixed (più stili EOL nel file)

EOLStr

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.

Valori: "None", "LF", "CR", "CRLF", "Mixed"

Codepage

Restituisce la pagina codici del file (codifica dei caratteri) come valore intero. Questo attributo supporta prefissi specifici del lato (ad esempio, LeftCodepage, RightCodepage). Esempio: Codepage = 65001 per visualizzare file UTF-8 o allof(Codepage = 65001) per visualizzare file UTF-8 in tutti i lati.

HasBOM

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

1.3.3.7. Valutazione della matrice

Gli attributi senza prefisso laterale (ad esempio, Size) 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.

1.3.3.7.1. Array vs scalare

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 è true, l'espressione complessiva restituisce true. Altrimenti, restituisce false.

Example 7. Esempio

[3, 5, 8] >6 -> [falso, falso, vero] -> vero

1.3.3.7.2. Array contro array

Quando si confrontano due array, il comportamento dipende dall'operatore:

  • Per = e !=: gli array devono avere la stessa lunghezza. Il risultato è un singolo valore booleano, non una matrice.= restituisce true solo se tutti gli elementi sono uguali.!= restituisce true se qualche elemento è diverso.

  • Per tutti gli altri operatori (ad esempio, >, <): l'operazione viene applicata per elemento, producendo una matrice booleana. Il risultato finale dell'espressione è true se qualsiasi elemento nell'array booleano è true e false se tutti gli elementi sono false.

Example 8. Esempi

[2, 4] = [2, 4] -> vero
[2, 4] != [2, 5] -> vero (perché 4 != 5)
[3, 5, 8] >[6, 4, 2]
-> [falso, vero, vero]
-> vero (perché almeno un confronto è vero)
              

1.3.3.7.3. Riepilogo
  • I confronti tra array e scalari producono una matrice booleano. Il risultato complessivo dell'espressione è true se almeno un elemento è true.

  • Array vs array con = o != restituisce un singolo valore booleano.

  • Array vs array con altri operatori produce una matrice booleano. Il risultato finale è true se qualsiasi elemento è true.

1.3.4. Operatori

Per impostazione predefinita, tutti gli operatori di confronto di stringhe (come =, !=, <, <=, >, >=, like, match, contains erecontains) non fanno distinzione tra maiuscole e minuscole. Puoi controllare questo comportamento usando le direttive (vedi Direttive sulla distinzione tra maiuscole e minuscole).

<, <=, >, >=

Confronto numerico, timestamp o stringa

=

Confronto sull'uguaglianza

!=

Confronto delle disuguaglianze

+, -, *, /, %

Operatori aritmetici.+ e - eseguono addizioni e sottrazioni.* e / eseguono moltiplicazioni e divisioni.% è l'operatore modulo (resto).

e, o, non

Operatori logici

mi piace

Corrispondenza di stringhe di caratteri jolly

Puoi anche usare not like per eseguire la corrispondenza inversa.

corrisponde

Corrisponde alle espressioni regolari

Puoi anche usare notmatch per eseguire la corrispondenza inversa.

contiene

Controlla se una stringa contiene una sottostringa

Puoi anche usare not contiene per verificare l'assenza della sottostringa.

contiene

Controlla se qualche sottostringa corrisponde a un'espressione regolare

Puoi anche usare not recontains per assicurarti che non esista alcuna corrispondenza.

1.3.5. Funzioni

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.

1.3.5.1. Funzioni stringa
strlen(fonte)

Restituisce la lunghezza della stringa come Intero. Se source è una matrice di stringhe, il risultato è una matrice di numeri interi. Esempio: strlen(Nome)

strCount(str, substr)

Conta quante volte la sottostringa substr appare in str. Per impostazione predefinita, la ricerca non fa distinzione tra maiuscole e minuscole (rispetta le direttive @cs/@ci). Se str è una matrice, il risultato è una matrice di numeri interi con conteggi per ciascun elemento. Le corrispondenze sovrapposte vengono conteggiate separatamente (ad esempio, strCount("aaaa", "aa") restituisce 2).

Esempi:

  • strCount("ciao ciao mondo", "ciao") restituisce 2

  • strCount("Test TEST test", "test") restituisce 3 (senza distinzione maiuscole/minuscole)

  • @cs strCount("Test TEST test", "test") restituisce 1 (con distinzione tra maiuscole e minuscole)

  • le:strCount(Line, "ERROR") > 2 visualizza le righe contenenti "ERROR" più di due volte

regexCount(str, pattern)

Conta quante volte l'espressione regolare pattern corrisponde a str. Per impostazione predefinita, la ricerca non fa distinzione tra maiuscole e minuscole (rispetta le direttive @cs/@ci). Se str è 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.

Esempi:

  • regexCount("test123abc456", "\d+") restituisce 2

  • regexCount("AAA BBB CCC", "[A-Z]+") restituisce 3

  • @cs regexCount("Test TEST", "TEST") restutuisce 1

  • le:regexCount(Line, "\b(error|warning)\b") > 0 visualizza righe con parole chiave errore o avviso

strFind(str, substr[, occurrence])

Trova la posizione (in base 0) dell'ennesima occorrenza della sottostringa substr in str. Il parametro facoltativo occurrence 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 @cs/@ci). Se la sottostringa non viene trovata o se l'indice delle occorrenze è fuori intervallo restituisce none. Se str è una matrice, il risultato è una matrice di posizioni (o nessun valore).

Esempi:

  • strFind("ciao mondo", "o") restituisce 4 (prima 'o')

  • strFind("hello world", "o", 1) restituisce 7 (seconda 'o')

  • @cs strFind("Test TEST test", "test") restituisce 10 (con distinzione tra maiuscole e minuscole)

  • strFind(array("abc", "def"), "b") restituisce array(1, none)

regexFind(str, pattern[, group[, occurrence]])

Trova la posizione (in base 0) dell'ennesima occorrenza di una corrispondenza di espressione regolare in str. Il parametro facoltativo group specifica quale gruppo di acquisizione individuare (in base 0, il valore predefinito è 0 per l'intera corrispondenza). Il parametro facoltativo occurrence 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 @cs/@ci). Se il modello non corrisponde, l'indice del gruppo è fuori intervallo o l'indice delle occorrenze è fuori intervallo restituisce none . Se str è una matrive, il risultato è una matrice di posizioni (o nessun valore).

Esempi:

  • regexFind("test123abc456", "\d+") restituisce 4 (posizione di "123")

  • regexFind("test123abc456", "\d+", 0, 1) restituisce 10 (posizione di "456", seconda corrispondenza)

  • regexFind("abc-def-ghi", "([a-z]+)-([a-z]+)", 1) restituisce 0 (posizione del primo gruppo acquisizione "abc")

  • regexFind("v1.0 and v2.5", "v(\d+)\.(\d+)", 1, 1) restituisce 10 (versione principale "2" nella seconda occorrenza)

  • regexFind(array("test123", "abc"), "\d+") restituisce array(4, none)

substr(sorgente, inizio, conteggio)

Restituisce un intervallo specifico di testo dalla stringa o dall'array di stringhe come Stringa. Se source è una matrice di stringhe, il risultato è una matrice di stringhe. Esempio: substr(Nome, 0, 3)

replace (da, a, in)

Sostituisce tutte le occorrenze della stringa from con to. Se str è una matrice, il risultato è una matrice di stringhe a cui sono applicate le sostituzioni. Esempio: sostituisci(nome, ".bak", ".txt")

regexReplace(str, modello, sostituzione)

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 str è una matrice, il risultato è una matrice di stringhe a cui sono applicate le sostituzioni. Esempio: regexReplace(name, "^(\w+)_(\w+)$", "$2_$1") scambia le parole separate da un carattere di sottolineatura.

replaceWithList(str, percorsofile)

Sostituisce più stringhe in str usando le regole di sostituzione caricate da un file separato da tabulazioni. Il formato del file è una regola di sostituzione per riga: search_string<TAB>replacement_string. Le righe che iniziano con # vengono trattate come commenti e ignorate. Anche le righe vuote vengono ignorate. Se str è una matrice, il risultato è una matrice di stringhe a cui sono applicate le sostituzioni.

Esempio di formato file:

# Riga di commento
mela arancia
cane gatto
vecchio nuovo

Esempi:

  • replaceWithList(Name, "C:\Filters\replacements.txt") - applica le sostituzioni dal file al nome del file

regexReplaceWithList(str, percorsofile)

Sostituisce le stringhe in str usando modelli di espressioni regolari caricati da un file separato da tabulazioni. Il formato del file è un modello per riga: regex_pattern<TAB>replacement_string. La stringa di sostituzione può includere riferimenti all'indietro ($1, $2 e così via) ai gruppi acquisiti. Le righe che iniziano con # vengono trattate come commenti e ignorate. Anche le righe vuote vengono ignorate. Se str è una matrice, il risultato è una matrice di stringhe a cui sono applicate le sostituzioni.

Esempio di formato file:

# Riga di commento
\d+ NUMERO
(\d{4})-(\d{2})-(\d{2}) $1_$2_$3

Esempi:

  • regexReplaceWithList(Name, "C:\Filters\regex_replacements.txt") - applica sostituzioni regex al nome del file

regexExtract(str, pattern[, group[, offset]])

Cattura il testo che corrisponde a un modello di espressione regolare dalla stringa. Il parametro facoltativo group 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 offset 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 none se il modello non corrisponde, l'indice del gruppo è fuori intervallo o l'offset supera il numero di corrispondenze. Se str è 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 @cs/@ci).

Esempi:

  • regexExtract("abc123", "[a-z]+\d+") restituisce "abc123" (intera corrispondenza)

  • regexExtract("abc123", "([a-z]+)(\d+)", 1) restituisce "abc" (primo gruppo acquisizione)

  • regexExtract("abc123", "([a-z]+)(\d+)", 2) restituisce "123" (secondo gruppo acquisizione)

  • regexExtract("2025-05-16", "(\d{4})-(\d{2})-(\d{2})", 1) restituisce "2025"

  • regexExtract("utente@esempio.com", "([^@]+)@([^@]+)", 1) restituisce "utente"

  • regexExtract("utente@esempio.com", "([^@]+)@([^@]+)", 2) restituisce "esempio.com"

  • regexExtract("valore 123 e valore 456", "(\d+)", 0, 0) restituisce "123" (primo numero)

  • regexExtract("valore 123 e valore 456", "(\d+)", 0, 1) restituisce "456" (secondo numero)

  • regexExtract("v1.0.0 and v2.0.0", "v(\d+)\.(\d+)\.(\d+)", 1, 1) restituisce "2" (versione principale seconda occorrenza)

  • regexExtract("test", "\d+") restituisce none (nessuna corrispondenza)

  • regexExtract("abc", "([a-z])", 5) restituisce none (gruppo fuori intervallo)

  • regexExtract(array("abc123", "def456"), "([a-z]+)(\d+)", 1) restituisce matrice("abc", "def")

  • @cs regexExtract("ABC123", "([a-z]+)", 1) restitusce none (sensibile maiuscolo/minuscolo, nessuna corrispndenza)

  • le:regexExtract(Line, "error:\s+(\w+)", 1) estrae il tipo di errore dalle righe del registro

  • fe:regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2" filtra i file con la versione principale 2

normalizeUnicode(str[, modulo])

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 str è una matrice, il risultato è una matrice di stringhe normalizzate. Esempio: normalizeUnicode(name, "NFC")

toLower(str)

Converte tutti i caratteri della stringa in minuscolo. Se str è una matrice, il risultato è una matrice di stringhe minuscole. Esempio: toLower("Hello World") restituisce "hello world"

toUpper(str)

Converte tutti i caratteri della stringa in maiuscolo. Se str è una matrice, il risultato è una matrice di stringhe maiuscole. Esempio: toUpper("Hello World") restituisce "HELLO WORLD"

toHalfWidth(str)

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 str è una matrice, il risultato è una matrice di stringhe convertite.

toFullWidth(str)

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 str è una matrice, il risultato è una matrice di stringhe convertite.

toKatakana(str)

Converte i caratteri hiragana in katakana. I caratteri non hiragana rimangono invariati. Se str è una matrice, il risultato è una matrice di stringhe convertite.

toHiragana(str)

Converte i caratteri katakana in hiragana. I caratteri non katakana rimangono invariati. Se str è una matrice, il risultato è una matrice di stringhe convertite.

toSimplifiedChinese(str)

Converte i caratteri cinesi tradizionali in caratteri cinesi semplificati. I caratteri che non hanno una forma semplificata rimangono invariati. Se str è una matrice, il risultato è una matrice di stringhe convertite.

toTraditionalChinese(str)

Converte i caratteri cinesi semplificati in caratteri cinesi tradizionali. I caratteri che non hanno una forma tradizionale rimangono invariati. Se str è una matrice, il risultato è una matrice di stringhe convertite.

trim(str)

Rimuove gli spazi bianchi iniziali e finali (spazio, tabulazione, nuova riga, ritorno a capo) dalla stringa. Se str è una matrice, il risultato è una matrice di stringhe tagliate.

Esempi:

  • trim(" ciao ") restituisce "ciao"

  • trim(array(" test ", " data ")) restituisce array("test", "data")

trimLeft(str)

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 str è una matrice, il risultato è una matrice di stringhe tagliate a sinistra.

Esempi:

  • trimLeft(" ciao ") restituisce "ciao "

trimRight(str)

Rimuove gli spazi bianchi finali (spazio, tabulazione, nuova riga, ritorno a capo) dalla fine della stringa. Gli spazi iniziali vengono mantenuti. Se str è una matrice, il risultato è una matrice di stringhe tagliate a destra.

Esempi:

  • trimRight(" ciao ") restituisce " ciao"

1.3.5.2. Funzioni contenuto file
lineCount(contenuto)

Restituisce il numero di righe nel contenuto del file o nell'array del contenuto del file come Intero. Se content è una matrice, il risultato è una matrice di numeri interi. Esempio: lineCount(Content)

sublines(contenuto, inizio, conteggio)

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 content è una matrice, il risultato è una matrice di stringhe.

1.3.5.3. Funzioni conversione tipo
toNumber(str), toInt(str), toDouble(str)

Converte una stringa in un numero. toNumber restituisce un numero intero o in virgola mobile a seconda del formato sorgente; toInt restituisce solo numeri interi; toDouble restituisce solo numeri a virgola mobile. Le virgole nel dato sorgente vengono ignorate. In caso di errore di analisi restituisce none. Esempio: le:toInt(Column("Count")) > 100

toDateTime(str)

Converte una stringa in un valore timestamp. Supporta più formati data/ora. Se la stringa non può essere analizzata restituisce none. Esempio: toDateTime("2025-01-15") > today()

1.3.5.4. Funzioni data/ora
now

Restituisce la data e l'ora correnti come valore Timestamp.

today

Restituisce la data odierna come valore Timestamp che rappresenta 00:00:00.000 all'inizio della giornata.

startOfWeek(timestamp)

Restituisce il primo giorno della settimana, che è sempre domenica, indipendentemente dalle impostazioni locali.

startOfMonth(timestamp)

Restituisce il primo giorno del mese.

startOfYear(timestamp)

Restituisce il primo giorno dell'anno.

toDateStr(timestamp)

Converte il timestamp specificato in una stringa di data nel formato aaaa-MM-gg. Se timestamp è una matrice di timestamp, il risultato è una matrice di stringhe.

1.3.5.5. Funzioni matematiche e di confronto
abs(valore)

Restituisce il valore assoluto dell'intero o dell'array di interi. Se value è una matrice di numeri interi, il risultato è una matrice di numeri interi.

isWithin(valore, min, max)

Restituisce true se valore è compreso nell'intervallo [min, max] (incluso su entrambe le estremità). Supporta numeri interi, numeri a virgola mobile, timestamp e stringhe (confronto senza distinzione tra maiuscole e minuscole). Se value è una matrice, il risultato è una matrice booleano con ogni elemento controllato individualmente.

Esempi:

  • isWithin(5, 1, 10) restituisce true

  • isWithin(Size, 1KB, 10MB) controlla se la dimensione del file è compresa tra 1KB e 10MB

  • isWithin(Date, today() - 7days, today()) controlla se il file è stato modificato nell'ultima settimana

  • allof(isWithin(Size, 1KB, 10MB)) controlla se tutte le dimensioni dei file sono comprese tra 1KB e 10MB

inRange(valore, min, max)

Restituisce true se value è compreso nell'intervallo [min, max) (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 value è una matrice, il risultato è una matrice booleano con ogni elemento controllato individualmente.

Esempi:

  • inRange(5, 1, 10) restituisce true

  • inRange(10, 1, 10) restituisce false

  • inRange(Size, 0, 1MB) controlla se la dimensione del file è inferiore a 1 MB

  • anyof(inRange(Date, startOfMonth(today()), today())) controlla se qualche file è stato modificato questo mese (escluso oggi)

1.3.5.6. Funzioni matrice
array(value1, value2, ...)

Crea una matrice dai valori specificati. Esempio:: array(1, 2, 3)

at(array, index)

Restituisce l'elemento in corrispondenza dell'indice specificato (in base 0). Gli indici negativi contano dalla fine. Esempio: at(array(1, 2, 3), -1) restituisce 3

anyof(booleans)

Restituisce true se qualsiasi elemento nell'array booleano soddisfa la condizione.

allof(booleani)

Restituisce true se tutti gli elementi nell'array booleano soddisfano la condizione.

allequal(array)

Restituisce true se tutti i valori nell'array sono uguali.

len(value)

Restituisce la lunghezza del valore come Intero.

Comportamento:

  • Array: Restituisce il numero di elementi nella matrice

  • String: Restituisce il conteggio dei caratteri UTF-8

  • None (monostate): Restituisce 0

  • Altri valori scalari (intero, reale, booleano timestamp, ecc.): restituisce 1

Esempi:

  • len(array(1, 2, 3)) - restituisce 3

  • len("ciao") - restituisce 5

  • len(123) - restituisce 1

  • len(Size) - restituisce in un confronto cartelle il numero di lati (2 o 3)

1.3.5.7. Funzioni condizionali
if(condizione, trueValue, falseValue)

Restituisce trueValue se condizione restituisce true, altrimenti restituisce falseValue. Questa funzione esegue la valutazione del cortocircuito (valuta solo il ramo che verrà restituito).

Esempi:

  • if(Size > 1MB, "large", "small") - restituisce "large" o "small" in base alla dimensione del file

  • if(Extension = "txt", "text file", "other file") - classifica i file per estensione

  • if(Exists, Size, 0) - restituisce la dimensione del file o 0 se il file non esiste

ifEach(conditionArray, trueValue, falseValue)

Selezione condizionale per elemento. Per ogni elemento in conditionArray, restituisce l'elemento corrispondente da trueValue se la condizione è vera, Altrimenti restituisce l'elemento corrispondente da falseValue. Se trueValue o falseValue è uno scalare, viene trasmesso a tutti gli elementi.

Esempi:

  • ifEach(Size > 1MB, "large", "small") - restituisce una matrice di etichette "grande"/"piccolo" per ogni file

  • ifEach(array(true, false, true), array("a", "b", "c"), array("x", "y", "z")) - restituisce array("a", "y", "c")

  • anyof(ifEach(Size > 100KB, Size < 10MB, false)) - controlla se qualche file è compreso tra 100KB e 10MB

choose(indice, valore0, valore1, ...)

Seleziona un valore dagli argomenti in base a index. Se index è 0, restituisce value0;se 1, restituisce value1, ecc. Gli indici negativi sono limitati a 0. Gli indici oltre l'ultimo valore restituiscono l'ultimo valore.

Esempi:

  • scegli(0, "primo", "secondo", "terzo") - restituisce "primo"

  • choose(DiffCode % 3, "equal", "different", "unique") - mappa i codici diff sulle etichette

  • scegli(5, "a", "b", "c") - restituisce "c" (fuori dai limiti, restituisce l'ultimo valore)

chooseEach(indexArray, value0, value1, ...)

Selezione del valore in base agli elementi. Per ogni indice in indexArray, seleziona il valore corrispondente dagli argomenti rimanenti. Se indexArray è uno scalare, si comporta come choose.

Esempi:

  • chooseEach(array(0, 1, 2), "a", "b", "c") - restituisce array("a", "b", "c")

  • chooseEach(array(0, 0, 1), "x", "y") - restituisce array("x", "x", "y")

  • chooseEach(array(2, 0, 1), "primo", "secondo", "terzo") - restituisce array("terzo", "primo", "secondo")

1.3.5.8. Funzioni logiche per elemento
andEach(valore1, valore2), orEach(valore1, valore2), notEach(valore)

Operazioni logiche per elementi. Queste funzioni operano su booleani, array booleani o una combinazione di entrambi:

  • andEach - Operazione logica AND

  • orEach - Operazione logica OR

  • notEach - Operazione logica NOT (argomento singolo)

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.

Esempi:

  • andEach(Size > 1KB, Size < 1MB) - file tra 1KB e 1MB

  • orEach(Extension = "txt", Extension = "log") - file txt o di registro

  • notEach(Exists) - file che non esistono

  • allof(andEach(Exists, Size > 0)) - tutti i file esistono con dimensione diversa da zero

  • anyof(notEach(Size > 1MB)) - qualsiasi file di 1 MB o inferiore

1.3.5.9. Funzioni diagnostiche e di registrazione
logError(valore1, value2, ...), logWarn(value1, value2, ...), logInfo(value1, value2, ...)

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.

Esempi (usando il valore restituito):

  • logInfo("File size:", Size) > 1MB - registra le dimensioni del file e controlla se è maggiore di 1 MB

  • logWarn("Processing:", Name) come "*.tmp" - registra i nomi dei file e controlla se si tratta di un file temporaneo

  • Size > 1KB and logInfo("Large file:", Name) contains "test" - registra solo quando la condizione della dimensione è vera, quindi controlla il nome

1.3.6. Unità

Le dimensioni dei file supportano questi suffissi:

KB, MB, GB, TBC

Le durate temporali supportano questi suffissi:

settimane, settimana, w, giorni, giorno, D, ore, ora, ora, H, minuti, minuto, min, M, secondi, secondo, sez, S, millisecondi, millisecondo, ms, ms

1.3.7. Esempi

  • Dimensione <10KB: la dimensione di qualsiasi lato è inferiore a 10KB

  • LeftSize >= 10MB - Il file del lato sinistro è di almeno 10MB

  • allof(Size < 1MB) - Tutti i lati sono inferiori a 1 MB

  • abs(LeftSize - RightSize) <1KB - La differenza di dimensioni è piccola

  • DateStr = "2025-07-20" - Il file è stato modificato l'ultima volta in quella data

  • Data >= today() - Modificato oggi o successivamente

  • Date > d"2026-05-21 07:16:33" - Modificato dopo una data e un'ora specifiche

  • isWithin(Date, d"2026-01-01", d"2026-12-31 23:59:59") - Modificato nel corso dell'anno 2026

  • is Within(Date, today() - 7 days, today()) - File modificato nell'ultima settimana

  • inRange(Size, 1KB, 10MB): la dimensione del file è compresa tra 1 KB (incluso) e 10 MB (escluso)

  • allof(isWithin(Size, 100KB, 1MB)) - Tutte le dimensioni dei file sono comprese tra 100KB e 1MB

  • AttrStr contiene "R" - Il file è di sola lettura

  • Il nome corrisponde a "file[0-9]\.txt" - Regex sul nome file

  • Il contenuto contiene "Test" - Il contenuto del file include la parola chiave

  • sublines(Content, 0, 1) contiene "XML" - La prima riga contiene "XML"

  • strCount(Content, "TODO") > 5 - Il file contiene più di 5 commenti TODO

  • regexCount(Content, "\bFIXME\b") > 0 - Il file contiene almeno un marcatore FIXME

  • strFind(Name, "_test") != none - File contenenti "_test" nel nome

  • strFind(Name, ".", 1) > 0 - File con più punti nel nome (esiste il secondo punto)

  • regexFind(Name, "\d{4}") < 5 - File in cui nei primi 5 caratteri appare un numero di 4 cifre

  • regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2" - File con versione principale 2 (ad esempio "v2.16.48")

  • regexExtract(Name, "([^_]+)_([^_]+)\.txt", 2) like "test*" - File in cui la seconda parte del nome inizia con "test"

  • le:regexExtract(Line, "(\d+)", 0, 1) - Estrae il secondo numero in ogni riga (offset=1)

  • (Extension = "log" and Size > 10MB) or (Date < today() - 7days) - File registro di grandi dimensioni o file più vecchi di una settimana

  • AttrStr non contiene "H" e nome come "*.tmp" - File temporanei non nascosti

  • isWithin(Extension, "a", "m") e inRange(Size, 0, 1MB) - File con estensioni da 'a' a 'm' e dimensioni inferiori a 1 MB

  • toLower(Name) = "readme.txt" - Corrispondenza del nome file senza distinzione tra maiuscole e minuscole

  • toHalfWidth(Name) come "*.txt" - Corrisponde dopo la conversione da larghezza intera a mezza larghezza

  • trim(Name) = "readme.txt" - Corrispondenza nome del file dopo aver rimosso gli spazi iniziali/finali

  • trimLeft(Column("Value")) = "123" - Corrisponde al valore della colonna dopo aver rimosso gli spazi iniziali (modalità tabella)

  • trimRight(Line) contains "end" - Controlla se la riga (senza spazi bianchi finali) contiene "end"

  • EOL = 3 - File con terminazioni di riga CRLF (Windows)

  • EOLStr = "LF" - File con terminazioni di riga LF (Unix)

  • allof(EOL = 1) - Controlla se tutti i file confrontati usano terminazioni di riga LF

  • leftprop("System.Title") != none - Il file sinistro ha una proprietà titolo impostata

  • prop("System.Author") = none - Nessuna proprietà dell'autore è impostata su nessun lato

  • if(LeftExists, LeftSize, 0) == 0 - Controlla se il file a sinistra è mancante o vuoto

  • Different: visualizza solo file/cartelle differenti (solo filtro di visualizzazione)

  • Identical: visualizza solo file/cartelle identici (solo filtro di visualizzazione)

  • allof(Binary) - Visualizza solo i file binari su tutti i lati (solo filtro di visualizzazione)

  • DifferentLeftMiddle and not DifferentMiddleRight - Nel confronto a 3 vie visualizza i file in cui differisce solo la coppia sinistra-centrale (solo filtro di visualizzazione)

2. Uso dei filtri file

I filtri file sono file di testo con estensione flt. 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.

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 FileFilter.tmpl. Questa sezione descrive come applicare i filtri di file ai confronti e documenta la sintassi del filtro di file.Uso della finestra di dialogo Filtri descrive come aggiungere, modificare e gestire i filtri.

2.1. Posizioni filtro file

WinMerge rileva automaticamente i filtri dei file in queste posizioni:

Sottocartella Filtri nella cartella di installazione di WinMerge

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

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.

Cartella di filtro privata predefinita

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, Documents 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.

Prima di poter applicare i filtri di file esistenti in qualsiasi altra cartella, devi prima installarli.

2.2. Applicazione dei filtri ai file

Puoi applicare un filtro file usando uno di questi metodi:

  • Quando avvii un confronto di cartelle dalla finestra di dialogo Seleziona file o cartelle:

    1. Dopo aver scelto le cartelle 1a e 2a, seleziona Seleziona accanto al campo Filtro.

    2. Nella finestra di dialogo Filtri, usa la scheda Filtri di file per scegliere un filtro di file e caricarlo nel campo Filtro.

      Note

      Se un filtro file è attualmente abilitato, il filtro file selezionato è già caricato nel campo Filtro.

    3. Procedere con l'operazione di confronto. Il file nel campo Filtro viene applicato quando avvii l'operazione.

  • 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):

    1. Seleziona StrumentiFiltri.

    2. Nella finestra di dialogo Filtri, configura la nuova impostazione del filtro file e seleziona OK.

    3. Il nuovo filtro non viene applicato automaticamente quando chiudi la finestra di dialogo Filtri: premi F5 per visualizzare i nuovi risultati nella finestra Confronto cartelle.

  • Quando avvii un confronto di cartelle dalla riga di comando di WinMerge, usa il flag -f per specificare un filtro file.

2.3. Sintassi del filtro file

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

Il delimitatore del commento è ##. 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 ## come caratteri in una regola, ometti il prefisso dello spazio bianco.

Le prime due righe richieste di un filtro file sono:

nome

Il nome del filtro elencato nella finestra di dialogo File

def

Il tipo di filtro da applicare. Specifica uno di questi valori:

includere

Include tutto tranne gli elementi che corrispondono alla regola specificata.

escludere

Esclude tutto tranne gli elementi che corrispondono alla regola specificata.

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

d: \\*$ ## Sottocartelle

Tip

Non confondere questi termini. Ricorda, nei filtri dei file, una regola include non specifica cosa includere, specifica cosa non includere. Allo stesso modo, exclude non specifica cosa escludere, specifica cosa non escludere.

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:

f: regexp

Abbina i nomi dei file usando le espressioni regolari

f!: regexp

Escludi file corrispondenti a regex (disponibile dalla versione 2.16.19)

d: regexp

Abbina i nomi delle cartelle usando regex

d!: regexp

Escludi cartelle corrispondenti a regex (disponibile dal 16.2.19)

fe: espressione

Espressione di filtro per file (ad esempio fe:Size < 1KB) (disponibile dal 16.2.49)

fe!: expr

Espressione di filtro per escludere file (disponibile dalla versione 2.16.49)

de: espressione

Espressione di filtro per cartelle (disponibile dalla versione 2.16.49)

de!: espressione

Espressione di filtro per escludere cartelle (disponibile dalla versione 2.16.49)

e: espressione

Espressione di filtro applicata sia a file che a cartelle (ad esempio e:Nome come "Comune*.*") (disponibile dalla 2.16.56)

e!: espressione

Espressione di filtro per escludere sia file che cartelle (disponibile dalla 2.16.56)

Tra i tanti caratteri speciali regexp, i seguenti sono particolarmente importanti nelle regole di filtro dei file:

^ (inizio riga)

Spesso richiesto affinché le regole funzionino correttamente.

$ (fine riga)

Spesso richiesto affinché le regole funzionino correttamente. Per esempio:

\.c$ ## corrisponde solo ai nomi di file con estensione c.
\.c ## corrisponde a qualsiasi estensione che inizia con c, come cpp e com.
\ (fuga)

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 (\\). Per far corrispondere il punto nel nome di un file, specificare una barra rovesciata seguita da un punto (\.).

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.

Le regole non fanno distinzione tra maiuscole e minuscole. Ad esempio, f: \.bat$ corrisponde a winmerge.bat e compare.BAT.

Example 9. Esempi di regole di filtro file

Alcune semplici regole di filtro dei file:

f: \.cpp$ ## Trova i file *.cpp
f: \.h$ ## Trova i file *.h
f: ^My ## Corrisponde a My*.* file
f: Dlg\.## Corrisponde ai file *Dlg.*
d: \\test$ ## Trova le cartelle test
d: ^\\Build$ ## Corrisponde alle cartelle Build
d: Temp$ ## Corrisponde alle cartelle *Temp (ad esempio, FirstTemp)
d: Src ## Corrisponde alle cartelle *Src*

Alcune regole con espressioni regolari più complesse:

f: ^\.#.*$ ## .#nomefile.versione file
f: Dlg\.c(pp)?$ ## File *Dlg.c e *Dlg.cpp
f: ^I.*\.h$ ## File I*.h
f: Srv[1-9]\.def$ ## da *Srv1.def a *Srv9.def
f: ^[h,k,m] ## File h*.*, k*.* e m*.*

3. Uso dei filtri di linea

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.

Per informazioni su come aggiungere, modificare e gestire i filtri, vedi Uso della finestra di dialogo Filtri.

3.1. Applicazione di filtri di linea

È possibile applicare filtri di linea usando uno di questi metodi:

  • Quando si avvia un confronto di file dalla finestra di dialogo Seleziona file o cartelle

    1. Dopo aver scelto il file primo e secondo, seleziona Seleziona accanto al campo Filtro.

    2. 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.

      Note

      Il campo Filtro non indica quali filtri di linea sono abilitati.

    3. Procedere con l'operazione di confronto dei file. I filtri di linea abilitati vengono applicati all'avvio dell'operazione.

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

    1. Seleziona StrumentiFiltri.

    2. Apri la scheda Filtri file.

    3. Seleziona i singoli filtri di linea che vuoi applicare e deseleziona i filtri che non vuoi applicare.

      Puoi anche aggiungere, modificare e rimuovere filtri dall'elenco usando i pulsanti Nuovo, Modifica e Rimuovi.

    4. Per attivare i filtri di linea, seleziona Abilita filtri di linea. Per disattivare il filtraggio della linea, deseleziona l'opzione.

    5. Seleziona OK per chiudere la finestra di dialogo Filtri file.

    6. Seleziona F5 per applicare le modifiche e aggiornare la finestra Confronta file.

3.2. Sintassi del filtro di linea

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.

Le differenze ignorate sono contrassegnate nella finestra Confronta file con il colore Differenza ignorata (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.

La corrispondenza del filtro di linea può essere descritta in termini di due idee:

  • 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:

    File1: 

    # Jean Sibelius

    File2: 

    #Janne Sibelius

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

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

    File1: 

    # Jean Sibelius
    #Pekka Himanen

    File2: 

    #Janne Sibelius
    Pekka Himanen

    La stessa regola ^# corrisponde alla prima riga, ma non alla seconda riga. Pertanto, la differenza non viene ignorata.

Tip

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

Example 10. Filtri della linea di campionamento

^IL MIOTAG$

Filtra le righe che corrispondono esattamente a MYTAG

^::

Filtra le righe che iniziano con ::

^/\*.*\*/$

Filtra le righe che iniziano con /* e finiscono con */

^[1-5]00

Filtra le righe che iniziano con i numeri 100, 200, 300, 400 e 500


Example 11. Regola del filtro di linea che corrisponde alle linee ID CVS

Le linee ID CVS hanno questo aspetto:

// $Id: Filters.xml 7591 20/01/2013 15:47:42Z christianlist $

... e può essere filtrato con questa regola:

^// \WId: .*\$

Example 12. Filtra i commenti sui numeri di riga nei file po

i commenti sul numero di riga po assomigliano a questo:

#: origine/nomefile.c:766

... e può essere filtrato con questa regola:

^#

4. Usando il filtro visualizza linea

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.

4.1. Apertura barra filtri visualizzazione

Usa uno dei seguenti metodi per aprire la barra filtri visualizzazione:

  • Seleziona VisualizzaVisualizza barra filtri, o premi Ctrl+Maiusc+L.

  • Fai clic con il pulsante destro del mouse sul testo selezionato nella finestra Confronta file e scegli Aggiungi ai filtriAggiungi ai filtri di visualizzazione. WinMerge creerà automaticamente un'espressione La riga contiene "..." dal testo selezionato e apre la barra filtri.

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

4.2. Inserisci un filtro

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

Stringa semplice (nessun prefisso)

L'input senza il prefisso le: viene trattato come una stringa letterale. WinMerge visualizza solo le righe che contengono quella stringa. Internamente, l'input è equivalente a le:Line contiene "input".

Esempio: inserendo TODO vengono visualizzate tutte le righe che contengono il testo TODO.

le: prefisso (espressione filtro)

Se l'input inizia con le:, il resto viene interpretato come un'espressione di filtro. È disponibile la sintassi completa dell'espressione descritta in Sintassi espressione filtro.

Esempio: le:Different e la riga contiene "ERRORE"

Important

Il prefisso le: deve apparire proprio all'inizio dell'input. Se appare altrove, l'intero input viene trattato come una semplice stringa.

Ad esempio, Hello o le:Line contiene "Hello" non contiene un'espressione di filtro. L'intero input viene trattato come una ricerca di stringhe letterali per il testo Hello o le:Line contiene "Hello".

4.3. Sintassi espressione filtro

Le espressioni di filtro di riga di visualizzazione usano lo stesso motore delle espressioni di filtro di confronto di cartelle (vedi Sintassi dell'espressione di filtro), con i seguenti attributi e funzioni aggiuntivi che operano su singole righe.

4.3.1. Attributi linea

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

Line

Contenuto del testo della riga attuale. Supporta prefissi specifici del lato. Esempio: La riga contiene "TODO"

LineLength

Lunghezza della riga attuale in caratteri. Supporta prefissi specifici del lato. Esempio: LineLength> 120

LineNumber

Numero di riga reale nel file (in base 1), senza contare le righe fantasma. Supporta prefissi specifici del lato. Esempio: LineNumber <= 50

ViewLineNumber

Visualizza il numero di riga incluse le linee fantasma (in base 1). Attributo globale (nessun prefisso laterale). Esempio: ViewLineNumber <= 100

Different

Vero se la linea fa parte di un blocco differenza. Attributo globale. Esempio: Different

Identical

Vero se la linea è identica in tutti i riquadri. Attributo globale.

Trivial

Vero se la riga differisce solo negli spazi bianchi o in altro contenuto ignorato. Attributo globale. Esempio: Different o Trivial

Exists

Vero se la linea esiste nel riquadro (non una linea fantasma). Supporta prefissi specifici del lato. Esempio: LeftExists e non RightExists

Missing

Vero se la linea è una linea fantasma nel riquadro. L'opposto di Exists. Supporta prefissi specifici del lato.

Moved

Vero se la linea viene rilevata come linea spostata. Supporta prefissi specifici del lato.

Bookmarked

Vero se la riga ha un segnalibro. Supporta prefissi specifici del lato.

DifferentLeftMiddle, DifferentMiddleRight, DifferentLeftRight

Vero se la coppia di riquadri indicata differisce su questa riga. Solo confronti a 3 vie (eccetto DifferentLeftRight che funziona anche a 2 vie). Attributi globali. Esempio: DifferentLeftMiddle e non DifferentMiddleRight

EOL

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: le:EOL = 3 visualizza solo le righe con terminazioni CRLF

EOLStr

Stile di fine riga per la riga attuale come stringa. Supporta prefissi specifici del lato. Valori: "None", "LF", "CR", "CRLF" Esempio: le:EOLStr = "LF" visualizza solo le righe con terminazioni LF

Column, ColumnCount (solo modalità tabella)

Contenuto delle celle e conteggio delle colonne in modalità CSV/tabella. Supporta prefissi specifici del lato. Esempio: Column("Stato") = "FAIL"

LineAt(lineNumber), LineOffsetAt(offset)

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: le:Different e RightLineOffsetAt(-1) corrisponde a "^//"

Column(indexOrName), ColumnAt(line, indexOrName), ColumnOffsetAt(offset, indexOrName) (solo modalità tabella)

Contenuto della cella per indice o nome, alla riga attuale, assoluta o relativa. Esempio: le:RightColumn("Category") != ColumnOffsetAt(-1, "Category")

4.3.2. Funzioni linea

Le espressioni di filtro della visualizzazione riga possono anche usare le funzioni descritte in Funzioni.

matchContext(expr, linesBefore, linesAfter)

Vero se la riga attuale si trova all'interno delle righe linesBefore prima o tra le righe linesAfter dopo qualsiasi riga corrispondente a expr. Esempio: le:matchContext(Different, 3, 3)

matchNumber(expr)

Indice in base 1 della riga attuale all'interno di tutte le righe corrispondenti. Restituisce nonese la linea non corrisponde. Esempio: le:matchNumber(Different) = 1 visualizza solo la prima riga che corrisponde (la prima riga differenza)

matchCount(expr)

Numero totale di righe che corrispondono a expr nell'intero file. Esempio: le:matchNumber(Different) = matchCount(Different) visualizza solo l'ultima riga che corrisponde (l'ultima riga della differenza).

matchBlockNumber(expr)

Restituisce il numero di blocco in base 1 del blocco corrispondente contenente la riga attuale. Restituisce none se la riga attuale non si trova in nessun blocco corrispondente. Esempio: le:matchBlockNumber(Different) = 1 visualizza solo le righe nel primo blocco differenza.

matchBlockOffset(expr)

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 none. Esempio: le:matchBlockOffset(Different) = 1 visualizza solo la prima riga di ciascun blocco differenza.

matchBlockSize(expr)

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 none. Esempio: le:matchBlockSize(Different) > 5 visualizza solo le righe nei blocchi di differenza più grandi di 5 righe.

matchBlockCount(expr)

Numero totale di blocchi corrispondenti nel file. Esempio: le:matchBlockNumber(Different) = matchBlockCount(Different) visualizza solo le righe nell'ultimo blocco differenza.

matchDistance(expr), matchDistanceBefore(expr), matchDistanceAfter(expr)

Distanza in linee dall'intervallo di corrispondenza più vicino (entrambe le direzioni, solo prima o solo dopo). Esempio: le:matchDistance(Different) <= 5

matchInside(beginExpr, endExpr)

Vero se la riga attuale cade tra una riga che corrisponde a beginExpr e la riga successiva che corrisponde a endExpr (inclusa). Esempio: le:matchInside (la riga corrisponde a "^#ifdef", la riga corrisponde a "^#endif")

media(expr), average(expr, condizione)

Calcola la media (media aritmetica) dei valori numerici prodotti valutando expr per tutte le righe nel file. Se viene fornita condition, solo le righe in cui condition restituisce true vengono incluse nel calcolo. I risultati non numerici vengono ignorati. Restituisce nonese non viene trovato alcun valore numerico. Esempio: le:toInt(Column("Prezzo"))> Average(toInt(Column("Prezzo"))) visualizza le righe in cui il prezzo supera il prezzo medio. Esempio con condizione: le:average(toInt(Column("Punteggio")), Column("Stato") = "PASS") calcola il punteggio medio per le righe con stato "PASS".

maximum(expr), maximum(expr, condition)

Restituisce il valore massimo tra tutti i risultati prodotti valutando expr per tutte le righe nel file. Se viene fornita condizione, vengono considerate solo le righe in cui condizione restituisce vero. Funziona con valori numerici, stringhe (confronto alfabetico) e timestamp. Se non viene trovato alcun valore restituisce none. Esempio: le:toInt(Column("Quantity")) = maxim(toInt(Column("Quantity"))) visualizza le righe con la quantità più alta.

minimum(expr), minimum(expr, condition)

Restituisce il valore minimo tra tutti i risultati prodotti valutando expr per tutte le righe nel file. Se viene fornita condizione, vengono considerate solo le righe in cui condizione restituisce vero. Funziona con valori numerici, stringhe (confronto alfabetico) e timestamp. Se non viene trovato alcun valore restituisce none. Esempio: le:Column("Status") = Minimum(Column("Status")) visualizza le righe con il primo valore di stato in ordine alfabetico.

sum(expr), sum(expr, condition)

Calcola la somma di tutti i valori numerici prodotti valutando expr per tutte le righe nel file. Se viene fornita condition, solo le righe in cui condition restituisce true vengono incluse nel calcolo. I risultati non numerici vengono ignorati. Restituisce nonese non viene trovato alcun valore numerico. Esempio: le:toInt(Column("Quantity")) / sum(toInt(Column("Quantity"))) * 100 calcola la percentuale di ciascuna riga della quantità totale. Esempio con condizione: le:sum(toInt(Column("Sales")), Column("Region") = "East") calcola le vendite totali per la regione "East".

4.3.3. Esempi

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

5. Usando il filtro visualizza file/cartella

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.

Per aprire la barra dei filtri visualizzazione, seleziona VisualizzaBarra filtri visualizzazione, o premi Ctrl+Maiusc+L.

La barra dei filtri accetta la stessa sintassi del campo Filtro nella finestra di dialogo 'Seleziona file o cartelle'. Per i dettagli vedi Sintassi ed esempio della maschera file e Sintassi dell'espressione di filtro.

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

Esempi:

  • *.cpp;*.h - visualizza i file sorgente e intestazione C++

  • !.git\;!.vs\ - esclude le cartelle .git e .vs

  • fe:Different - visualizza solo file diversi

  • de:Items > 10 - visualizza le cartelle con più di 10 elementi

  • e:Date> today() - 7 giorni - visualizza gli elementi modificati nell'ultima settimana

6. Uso dei filtri di sostituzione

Da definire

7. Uso della finestra di dialogo Filtri

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

Per aprire la finestra di dialogo Filtri, usare uno di questi metodi:

  • Nella finestra di dialogo Seleziona file o cartelle, seleziona Seleziona a destra del campo Filtro. Usa questo metodo quando vuoi applicare un filtro di file a un'operazione di confronto di cartelle.

  • Seleziona StrumentiFiltri. Questo metodo può essere usato in qualsiasi momento, tranne quando è aperta la finestra di dialogo Seleziona file o cartelle.

La finestra di dialogo Filtri dispone di una scheda per ciascun tipo di filtro WinMerge:

Filtri di file

Scegli questa scheda per usare i filtri dei file per le operazioni di confronto delle cartelle.

Filtri di linea

Scegli questa scheda per lavorare con i filtri di riga per le operazioni di confronto dei file.

Filtri di sostituzione

Scegli questa scheda per lavorare con i filtri di sostituzione per le operazioni di confronto dei file.

Visualizza filtro linea

Il filtro della riga di visualizzazione non viene configurato tramite questa finestra di dialogo. Aprilo tramite VisualizzaVisualizza barra filtri. Vedi Usando il filtro visualizza linea .

7.1. Usando la scheda Filtri file

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 Posizioni filtro file.

7.1.1. Abilitazione e disabilitazione dei filtri file

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

  1. Apri la finestra di dialogo Filtri, se non è già aperta.

  2. Seleziona un filtro file o <Nessuno> dall'elenco.

  3. Seleziona OK per chiudere la finestra di dialogo Filtri.

Esistono diversi modi per applicare i filtri dei file dopo averli abilitati. Per i dettagli, vedi Applicazione dei filtri ai file.

7.1.2. Configurazione dei filtri dei file

Usa questi pulsanti per gestire l'elenco dei filtri file e creare nuovi filtri file:

Test

Seleziona un filtro di file nell'elenco e seleziona Prova per visualizzare rapidamente come funziona il filtro. Per i dettagli vedi Test delle regole di filtro dei file.

Installare

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.

Nuovo

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 Creazione di un filtro di file.

Modificare

Seleziona un filtro file nell'elenco e seleziona Modifica per aprire il file nel tuo editor predefinito.

Eliminare

Seleziona un filtro file nell'elenco e seleziona Elimina per eliminare il file e rimuoverlo dall'elenco. Sì, il file è stato davvero eliminato!

Le modifiche vengono salvate quando selezioni OK per chiudere la finestra di dialogo Filtri. I filtri di linea sono memorizzati nel registro di Windows.

7.1.3. Creazione di un filtro di file

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

  1. Seleziona StrumentiFiltri.Oppure, dalla finestra di dialogo Seleziona file o cartelle, seleziona Seleziona a destra del campo Filtro.

  2. Nella scheda Filtri file della finestra di dialogo Filtri, seleziona Nuovo.

  3. Nella finestra di dialogo Filtro condiviso o privato, scegli Filtro condiviso o Filtro privato (vedi Posizioni filtro file per i loro usi) e seleziona OK.

    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).

  4. Nella finestra di dialogo Seleziona nome file per nuovo filtro, inserisci un nuovo nome file e seleziona Salva.

    Note

    Non scegliere un nome di file esistente: per modificare un file esistente, torna al passaggio 2 e seleziona Modifica invece che su Nuovo.

    WinMerge inizializza il nuovo file con il contenuto del modello FileFilter.tmpl e lo apre nel tuo editor di testo predefinito.

  5. 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 Sintassi del filtro file. Salva il file nel tuo editor di testo.

    Tip

    Se vuoi testare rapidamente una regola che stai definendo, prova a fare clic su Test nella finestra di dialogo Filtri. Per i dettagli vedi Test delle regole di filtro dei file.

  6. Se hai creato il tuo filtro di file in una delle cartelle standard Filtri e la finestra di dialogo Filtri non elenca il tuo nuovo filtro di file, prova a fare clic su OK per chiuderlo, quindi fai di nuovo clic su StrumentiFiltri per riaprirlo. L'elenco Filtri file ora dovrebbe includere il nuovo filtro file.

    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:

    1. Seleziona Installa nella finestra di dialogo Filtri.

    2. Nella finestra di dialogo Individua il file del filtro da installare, vai al file flt sul tuo sistema e seleziona Apri. L'elenco Filtri file ora dovrebbe includere il filtro file installato.

7.1.4. Test delle regole di filtro dei file

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.

A partire dalla finestra di dialogo Filtri:

  1. Nella scheda Filtri file, scegli il filtro file che vuoi testare.

  2. Se vuoi visualizzare le regole che testerai, seleziona Modifica ora per aprire il file in modo da poterlo visualizzare durante i passaggi successivi.

  3. Seleziona Prova.

  4. Nella finestra di dialogo Filtro test, scegli il tipo di regola da testare:

    • Per testare una regola di file f: nel tuo filtro file, deseleziona l'opzione Nome cartella.

    • Per testare una regola della cartella d:, seleziona l'opzione Nome cartella.

  5. Inserisci il testo da testare.

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

    La casella Risultatovisualizza la voce, seguita dal suo stato: superato o non riuscito.

7.2. Usando la scheda Filtri di linea

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.

7.2.1. Configurazione dei filtri di linea

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

Per aggiungere una nuova regola:

  1. Seleziona Nuovo. Il cursore di modifica viene automaticamente abilitato nella casella di modifica.

  2. Inserisci un'espressione nella casella di modifica sotto l'elenco Espressioni regolari.

  3. Seleziona Salva per caricare l'espressione in una nuova riga nell'elenco.

Per modificare una regola esistente:

  1. Seleziona la riga e seleziona Modifica.

  2. Modifica l'espressione nella casella di modifica.

  3. Seleziona Salva quando hai finito.

Per eliminare una regola esistente, seleziona (spunta) la regola e seleziona Rimuovi.

7.2.2. Abilitazione e disabilitazione dei filtri di linea

  1. Nell'elenco Espressioni regolari, seleziona solo i filtri che vuoi applicare e deseleziona tutti i filtri che non vuoi applicare.

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

  3. Seleziona OK per chiudere la finestra di dialogo Filtri e salvare le impostazioni.

Esistono diversi modi per applicare i filtri dei file dopo averli abilitati. Per i dettagli, vedi Applicazione di filtri di linea.

7.3. Usando la scheda Filtri di sostituzione

Da definire

7.3.1. Configurazione dei filtri di sostituzione

Da definire

7.3.2. Abilitazione e disabilitazione dei filtri di sostituzione

Da definire

8. Ottieni assistenza con le espressioni regolari

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.

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