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:
È 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 → 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.
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 .
È 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.
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).
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:
*.extMaschera file per estensione (ad es. *.txt)
*.File senza estensione (ad esempio README)
*.extEscludi 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)
regexpAbbina i nomi dei file usando le espressioni regolari (disponibile dalla versione 2.16.49)
regexpEscludi file corrispondenti a regex (disponibile dalla versione 2.16.49)
regexpAbbina i nomi delle cartelle usando regex (disponibile dalla versione 2.16.49)
regexpEscludi cartelle corrispondenti a regex (disponibile dal 2.16.49)
espressioneEspressione di filtro per file (ad esempio fe:Size < 1KB) (disponibile dal 16.2.49)
exprEspressione di filtro per escludere file (disponibile dalla versione 2.16.49)
espressioneEspressione di filtro per cartelle (disponibile dalla versione 2.16.49)
espressioneEspressione di filtro per escludere cartelle (disponibile dalla versione 2.16.49)
nome filtro fileApplica 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"
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.
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.
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.
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.
Per impostazione predefinita, le espressioni di filtro sono ottimizzate per migliorare le prestazioni. Puoi controllare questo comportamento usando le seguenti direttive:
@ottimizzare, @optAbilita l'ottimizzazione dell'espressione del filtro (comportamento predefinito). Ciò potrebbe migliorare le prestazioni per le espressioni complesse.
@nooptimize, @nooptDisabilita 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
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 filtroAssegna 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"
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.
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.
ExistsRestituisce true se il file esiste,
false altrimenti
NameNome del file
BaseNameRestituisce il nome del file senza estensione. Ad esempio, "document.txt" restituisce "documento".
ExtensionEstensione file
IsFolderRestituisce vero se l'elemento è una cartella/cartella, falso se è un file.
FolderRestituisce il percorso relativo escludendo il nome del file e la cartella di base
RelPathRestituisce 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".
FullPathRestituisce il percorso completo del file
SizeDimensioni del file
DateUltima data e ora modificata
DateStrStringa della data dell'ultima modifica nel formato
aaaa-MM-gg
CreationTimeTimestamp della data di creazione
AttributesRestituisce gli attributi del file come valore intero
AttrStrRestituisce la stringa dell'attributo del file. Esempi:
"R" per sola lettura, "H" per
nascosto, "A" per archivio, "S" per
file di sistema.
I seguenti attributi sono disponibili solo per gli elementi di confronto file. Se usato con elementi di cartelle, il comportamento non è definito.
ContentContenuto del file. Restituisce un valore di tipo FileContent. Con questo
tipo è possibile usare solo contains e
recontains.
I seguenti attributi sono disponibili solo per gli elementi di confronto delle cartelle. Se usato con elementi file, il comportamento non è definito.
FilesNumero di file direttamente contenuti nella cartella.
RecursiveFilesNumero di file contenuti nella cartella, incluse tutte le sottocartelle.
ItemsNumero di elementi (file e sottocartelle) contenuti direttamente nella cartella.
RecursiveItemsNumero di elementi (file e sottocartelle) contenuti nella cartella, incluse tutte le sottocartelle.
TotalSizeDimensione totale di tutti i file direttamente contenuti nella cartella, in byte.
RecursiveTotalSizeDimensione totale di tutti i file contenuti nella cartella, incluse tutte le sottocartelle, in byte.
È 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).
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")
MiddlePropValore della proprietà del file centrale (nel confronto a 3 vie).
RightPropValore della proprietà del file sul lato destro.
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.
EOLRestituisce 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)
EOLStrRestituisce 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.
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.
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.
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)
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.
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, nonOperatori logici
mi piaceCorrispondenza di stringhe di caratteri jolly
Puoi anche usare not like per eseguire la corrispondenza
inversa.
corrispondeCorrisponde alle espressioni regolari
Puoi anche usare notmatch per eseguire la corrispondenza
inversa.
contieneControlla se una stringa contiene una sottostringa
Puoi anche usare not contiene per verificare l'assenza
della sottostringa.
contieneControlla se qualche sottostringa corrisponde a un'espressione regolare
Puoi anche usare not recontains per assicurarti che non
esista alcuna corrispondenza.
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.
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"
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.
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()
nowRestituisce la data e l'ora correnti come valore
Timestamp.
todayRestituisce 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.
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)
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)
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")
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
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
Le dimensioni dei file supportano questi suffissi:
KB, MB, GB, TBCLe 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, msDimensione <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)
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.
WinMerge rileva automaticamente i filtri dei file in queste posizioni:
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.
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.
Puoi applicare un filtro file usando uno di questi metodi:
Quando avvii un confronto di cartelle dalla finestra di dialogo Seleziona file o cartelle:
Dopo aver scelto le cartelle 1a e 2a, seleziona accanto al campo Filtro.
Nella finestra di dialogo Filtri, usa la scheda Filtri di file per scegliere un filtro di file e caricarlo nel campo Filtro.
Se un filtro file è attualmente abilitato, il filtro file selezionato è già caricato nel campo Filtro.
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):
Seleziona → .
Nella finestra di dialogo Filtri, configura la nuova impostazione del filtro file e seleziona .
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.
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:
Il nome del filtro elencato nella finestra di dialogo File
Il tipo di filtro da applicare. Specifica uno di questi valori:
Include tutto tranne gli elementi che corrispondono alla regola specificata.
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
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:
regexpAbbina i nomi dei file usando le espressioni regolari
regexpEscludi file corrispondenti a regex (disponibile dalla versione 2.16.19)
regexpAbbina i nomi delle cartelle usando regex
regexpEscludi cartelle corrispondenti a regex (disponibile dal 16.2.19)
espressioneEspressione di filtro per file (ad esempio fe:Size < 1KB) (disponibile dal 16.2.49)
exprEspressione di filtro per escludere file (disponibile dalla versione 2.16.49)
espressioneEspressione di filtro per cartelle (disponibile dalla versione 2.16.49)
espressioneEspressione di filtro per escludere cartelle (disponibile dalla versione 2.16.49)
espressioneEspressione di filtro applicata sia a file che a cartelle (ad esempio e:Nome come "Comune*.*") (disponibile dalla 2.16.56)
espressioneEspressione 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:
Spesso richiesto affinché le regole funzionino correttamente.
Spesso richiesto affinché le regole funzionino correttamente. Per esempio:
\.c$ ## corrisponde solo ai nomi di file con estensionec. \.c ## corrisponde a qualsiasi estensione che inizia conc, comecppecom.
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*.cppf: \.h$ ## Trova i file*.hf: ^My ## Corrisponde aMy*.*file f: Dlg\.## Corrisponde ai file*Dlg.*d: \\test$ ## Trova le cartelletestd: ^\\Build$ ## Corrisponde alle cartelleBuildd: Temp$ ## Corrisponde alle cartelle*Temp(ad esempio,FirstTemp) d: Src ## Corrisponde alle cartelle*Src*
Alcune regole con espressioni regolari più complesse:
f: ^\.#.*$ ##.#nomefile.versionefile f: Dlg\.c(pp)?$ ## File*Dlg.ce*Dlg.cppf: ^I.*\.h$ ## FileI*.hf: Srv[1-9]\.def$ ## da*Srv1.defa*Srv9.deff: ^[h,k,m] ## Fileh*.*,k*.*em*.*
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.
È 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
Dopo aver scelto il file primo e secondo, seleziona accanto al campo Filtro.
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.
Il campo Filtro non indica quali filtri di linea sono abilitati.
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)
Seleziona → .
Apri la scheda Filtri file.
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 , e .
Per attivare i filtri di linea, seleziona Abilita filtri di linea. Per disattivare il filtraggio della linea, deseleziona l'opzione.
Seleziona per chiudere la finestra di dialogo Filtri file.
Seleziona F5 per applicare le modifiche e aggiornare la finestra Confronta file.
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.
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:
^#
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.
Usa uno dei seguenti metodi per aprire la barra filtri visualizzazione:
Seleziona → , o premi Ctrl+Maiusc+L.
Fai clic con il pulsante destro del mouse sul testo selezionato nella
finestra Confronta file e scegli → . 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.
La barra filtri visualizzazione accetta input in due forme, determinate dal
fatto che l'input inizi con il prefisso le::
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"
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".
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.
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.
LineContenuto del testo della riga attuale. Supporta prefissi specifici del
lato. Esempio: La riga contiene "TODO"
LineLengthLunghezza della riga attuale in caratteri. Supporta prefissi specifici del
lato. Esempio: LineLength> 120
LineNumberNumero di riga reale nel file (in base 1), senza contare le righe
fantasma. Supporta prefissi specifici del lato. Esempio: LineNumber
<= 50
ViewLineNumberVisualizza il numero di riga incluse le linee fantasma (in base
1). Attributo globale (nessun prefisso laterale). Esempio:
ViewLineNumber <= 100
DifferentVero se la linea fa parte di un blocco differenza. Attributo
globale. Esempio: Different
IdenticalVero se la linea è identica in tutti i riquadri. Attributo globale.
TrivialVero se la riga differisce solo negli spazi bianchi o in altro contenuto
ignorato. Attributo globale. Esempio: Different o Trivial
ExistsVero se la linea esiste nel riquadro (non una linea fantasma). Supporta
prefissi specifici del lato. Esempio: LeftExists e non
RightExists
MissingVero se la linea è una linea fantasma nel riquadro. L'opposto di
Exists. Supporta prefissi specifici del lato.
MovedVero se la linea viene rilevata come linea spostata. Supporta prefissi specifici del lato.
BookmarkedVero se la riga ha un segnalibro. Supporta prefissi specifici del lato.
DifferentLeftMiddle,
DifferentMiddleRight,
DifferentLeftRightVero 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
EOLStile 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
EOLStrStile 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")
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".
| 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) |
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 → , 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
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 a destra del campo Filtro. Usa questo metodo quando vuoi applicare un filtro di file a un'operazione di confronto di cartelle.
Seleziona → . 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:
Scegli questa scheda per usare i filtri dei file per le operazioni di confronto delle cartelle.
Scegli questa scheda per lavorare con i filtri di riga per le operazioni di confronto dei file.
Scegli questa scheda per lavorare con i filtri di sostituzione per le operazioni di confronto dei file.
Il filtro della riga di visualizzazione non viene configurato tramite questa finestra di dialogo. Aprilo tramite → . Vedi Usando il filtro visualizza linea .
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.
È necessario abilitare un filtro file per renderlo disponibile in un'operazione di confronto di cartelle o disabilitare un filtro attuale per impedirne l'uso:
Apri la finestra di dialogo Filtri, se non è già aperta.
Seleziona un filtro file o dall'elenco.
Seleziona 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.
Usa questi pulsanti per gestire l'elenco dei filtri file e creare nuovi filtri file:
Seleziona un filtro di file nell'elenco e seleziona per visualizzare rapidamente come funziona il filtro. Per i dettagli vedi Test delle regole di filtro dei file.
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.
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.
Seleziona un filtro file nell'elenco e seleziona per aprire il file nel tuo editor predefinito.
Seleziona un filtro file nell'elenco e seleziona per eliminare il file e rimuoverlo dall'elenco. Sì, il file è stato davvero eliminato!
Le modifiche vengono salvate quando selezioni per chiudere la finestra di dialogo Filtri. I filtri di linea sono memorizzati nel registro di Windows.
Se i filtri file installati con WinMerge non forniscono il filtro necessario, puoi crearne uno tuo:
Seleziona → .Oppure, dalla finestra di dialogo Seleziona file o cartelle, seleziona a destra del campo Filtro.
Nella scheda Filtri file della finestra di dialogo Filtri, seleziona .
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).
Nella finestra di dialogo Seleziona nome file per nuovo filtro, inserisci un nuovo nome file e seleziona .
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.
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.
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.
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 per
chiuderlo, quindi fai di nuovo clic su →
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:
Seleziona nella finestra di dialogo Filtri.
Nella finestra di dialogo Individua il file del filtro da installare, vai al
file flt sul tuo sistema e seleziona . L'elenco Filtri file ora dovrebbe includere il filtro
file installato.
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:
Nella scheda Filtri file, scegli il filtro file che vuoi testare.
Se vuoi visualizzare le regole che testerai, seleziona ora per aprire il file in modo da poterlo visualizzare durante i passaggi successivi.
Seleziona .
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.
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.
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.
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:
Seleziona . Il cursore di modifica viene automaticamente abilitato nella casella di modifica.
Inserisci un'espressione nella casella di modifica sotto l'elenco Espressioni regolari.
Seleziona per caricare l'espressione in una nuova riga nell'elenco.
Per modificare una regola esistente:
Seleziona la riga e seleziona .
Modifica l'espressione nella casella di modifica.
Seleziona quando hai finito.
Per eliminare una regola esistente, seleziona (spunta) la regola e seleziona .
Nell'elenco Espressioni regolari, seleziona solo i filtri che vuoi applicare e deseleziona tutti i filtri che non vuoi applicare.
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.
Seleziona 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.
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: