Al comparar archivos o carpetas, puede utilizar filtros para limitar el alcance de la comparación. Esto puede resultar útil cuando desee simplificar el resultado de la comparación eliminando las diferencias que no le interesan. Los filtros son reglas basadas en expresiones regulares. WinMerge utiliza el popular motor de expresiones regulares PCRE (Perl Compatible Regular Expressions).
La función básica del filtrado es sencilla: evaluar cada elemento que normalmente se compararía (una carpeta, un archivo o una línea dentro de un archivo) y, si la expresión del filtro coincide con el elemento en cuestión, aplicar el filtro. Dependiendo del tipo de filtro, el elemento se incluye o se excluye de la comparación.
Existen diferentes filtros de WinMerge para las operaciones de comparación de carpetas y de archivos:
Puede especificar los archivos que desea incluir en una comparación de carpetas utilizando máscaras de archivo sencillas o, para un filtrado más complejo, aplicando varias reglas especificadas en un filtro de archivos.
Los archivos y carpetas que se han filtrado aparecen ocultos en los resultados de forma predeterminada, lo cual suele ser lo que se desea. Puede hacer clic en → para mostrar los elementos filtrados, pero la ventana de comparación de carpetas solo muestra información mínima sobre ellos. Por ejemplo, no se puede saber si un archivo omitido es un archivo de texto o binario.
The display file/folder filter is also available for folder compare operations. Unlike file filters, it does not affect the comparison result; it only controls which items are visible in the Folder Compare window. See Using the display file/folder filter.
Los filtros de línea solo se aplican a las operaciones de comparación de archivos. Permiten ignorar las diferencias de una sola línea.
Los filtros de sustitución solo se aplican a las operaciones de comparación de archivos. Sustituyen las cadenas del bloque de diferencias por las cadenas especificadas, las comparan e ignoran el bloque de diferencias si los resultados de la sustitución coinciden. Son útiles para ignorar un gran número de cambios irrelevantes.
The display line filter is also applied only to file compare operations. Unlike line filters, it does not affect the comparison result; it only controls which lines are visible in the File Compare window. See Using the display line filter.
Puede utilizar una o varias máscaras de archivo que especifiquen las extensiones de archivo que desea incluir en una comparación de carpetas. El resto de archivos quedarán excluidos de la selección.
Define y aplica una máscara de archivos al iniciar la operación de comparación de carpetas:
Si utiliza el cuadro de diálogo "Seleccione archivos o carpetas", después de seleccionar la 1ª y la 2ª carpeta, introduzca una o varias máscaras de archivo en el campo Filtro. Las máscaras se aplicarán al iniciar la operación de comparación de carpetas.
Si utiliza la línea de comandos de WinMerge, utilice el modificador
-f para especificar máscaras de archivo (consulte el
ejemplo de la siguiente sección).
Puede especificar máscaras de archivo y filtros ampliados utilizando este formato:
Filtro1 del Grupo1;Filtro2 ...|Filtro1 del Grupo2;Filtrop2 ...|...
El carácter| separa los grupos de filtros y actúa como
un AND lógico.
Los filtros de un mismo grupo se separan mediante un ;
y se interpretan como un OR lógico.
Un archivo solo se incluye si cumple al menos uno de los criterios de filtrado de cada grupo.
Para incluir el carácter literal | (barra vertical) en
una expresión regular que no esté entre comillas dobles (como en los filtros
f: o f!:), use
|| en su lugar.
Ejemplo: f:(abc||def)\.txt$
Cada filtro (por ejemplo, Filtro1, Filtro2) puede ser de uno de los siguientes tipos:
*.extMáscara de archivo por extensión (ej., *.txt)
*.Archivos sin extensión (ej., README)
*.extExcluir los archivos que tengan esa extensión (disponible desde la versión 2.16.19)
carpeta\Carpetas de destino (deben terminar con \) (disponible desde la versión 2.16.19)
carpeta\Excluir las carpetas coincidentes (disponible desde la versión 2.16.19)
regexpComparar nombres de archivos mediante expresiones regulares (disponible desde la versión 2.16.49)
regexpExcluir los archivos que coincidan con la expresión regular (disponible desde la versión 2.16.49)
regexpBuscar nombres de carpetas mediante expresiones regulares (disponible desde la versión 2.16.49)
regexpExcluir carpetas que coincidan con la expresión regular (disponible desde la versión 2.16.49)
exprExpresión de filtro para archivos (ej. fe:Size < 1KB) (disponible desde la versión 2.16.49)
exprExpresión de filtro para excluir archivos (disponible desde la versión 2.16.49)
exprExpresión de filtro para carpetas (disponible desde la versión 2.16.49)
exprExpresión de filtro para excluir carpetas (disponible desde la versión 2.16.49)
nombre del filtro de archivosAplicar un filtro de archivos por nombre (disponible desde la versión 2.16.49)
Example 1. Máscara de archivo
En este ejemplo de línea de comandos, la operación de comparación de
carpetas incluye únicamente los archivos con extensiones
xml o txt. Se omiten todos los
demás archivos:
WinMergeU c:\project\docs c:\temp /f *.xml;*.txt
Example 2. Excluir carpetas (desde la versión 2.16.19)
En este ejemplo de línea de comandos, la operación de comparación de
carpetas excluye las carpetas .git y
.vs:
WinMergeU c:\project\docs c:\temp /f !.git\;!.vs\
Example 3. Expresión de filtro (desde la versión 2.16.49)
En este ejemplo de línea de comandos, la operación de comparación de
carpetas incluye únicamente archivos con extensiones
cpp o h y un tamaño inferior a 1
KB:
WinMergeU c:\project\docs c:\temp /f "*.cpp;*.h|fe:tamaño <
1KB"
WinMerge permite aplicar potentes filtros mediante expresiones que operan sobre los metadatos de los archivos, su contenido y el contexto de comparación. En esta sección se describen los atributos, operadores, funciones, tipos de datos y reglas de evaluación compatibles.
Los tipos literales admitidos son:
Boolean: true,
false
Null: none (represents a null or
missing value)
Integer: enteros con signo de 64 bits (ej.,
1024, o con unidades como 100 KB,
7días)
Real (Double): números de coma flotante con decimal o
exponente opcionales (ej., 3.14, .5,
1e6)
String: entre comillas dobles (ej.,
"ejemplo")
Date/Time: Prefixed with d and
enclosed in double quotes (e.g., d"2026-05-21 07:16:33",
d"2026-05-21")
Internally, values may be of the following types: Boolean, Integer, Real,
Timestamp, String, File Content, Array, or none.
Las expresiones de filtro admiten directivas que controlan cómo se evalúa la
expresión. Las directivas se especifican al principio de la expresión,
precedidas por @ y separadas de la expresión por un
espacio en blanco.
Por defecto, todos los operadores de comparación de cadenas
(=, !=, <,
<=, >, >=,
contains, recontains,
like, matches) no distinguen entre
mayúsculas y minúsculas. Puede controlar este comportamiento utilizando las
siguientes directivas:
@cs, @casesensitive
Habilitar la comparación que distingue entre mayúsculas y minúsculas. Con
estas directivas, "ABC" y "abc" se
consideran diferentes.
@ci, @caseinsensitive
Habilitar la comparación sin distinción entre mayúsculas y minúsculas
(comportamiento predeterminado). Con estas directivas,
"ABC" y "abc" se consideran idénticas.
Example 4. Ejemplos de distinción entre mayúsculas y minúsculas
@cs Name = "README.txt" ## Distingue entre mayúsculas y minúsculas: solo coincide con "README.txt" @ci Name = "readme.txt" ## Sin distinción entre mayúsculas y minúsculas: coincide "README.txt", "readme.txt", "ReadMe.TXT", etc. @casesensitive Extension = "TXT" ## Distingue entre mayúsculas y minúsculas: solo busca archivos con la extensión ".TXT" @caseinsensitive Content contains "error" ## Sin distinción entre mayúsculas y minúsculas: coincide con "Error", "ERROR", "error", etc.
De forma predeterminada, las expresiones de filtro se optimizan para mejorar el rendimiento. Puede controlar este comportamiento utilizando las siguientes directivas:
@optimize, @optHabilitar la optimización de expresiones de filtro (comportamiento predeterminado). Esto puede mejorar el rendimiento en el caso de expresiones complejas.
@nooptimize, @nooptDesactivar la optimización de expresiones de filtro. Esto resulta útil para la depuración o cuando la optimización da lugar a resultados inesperados.
Example 5. Ejemplos de optimización
@optimize Size > 10MB and Extension = "log" ## Habilitar optimización (predeterminado) @noopt Name matches "complex[0-9]+pattern" ## Desactivar la optimización para la depuración @nooptimize Content contains "special-case" ## Desactivar la optimización
La directiva @name permite asignar un nombre descriptivo
a una expresión de filtro. Este nombre está pensado para utilizarse en
mensajes de error y registros, con el fin de ayudar a identificar qué
expresión de filtro ha provocado el problema.
@name="Nombre del filtro",
@name=NombredelfiltroAsigna un nombre a la expresión del filtro. Si el nombre contiene espacios o caracteres especiales, debe escribirse entre comillas dobles. Los nombres sin espacios pueden escribirse sin comillas.
El nombre especificado se utilizará en los mensajes de error y en la información de diagnóstico para identificar el filtro. Esto resulta especialmente útil cuando se trabaja con varias expresiones de filtro complejas.
Example 6. Ejemplos de directivas de nombres
@name="Large Image Files" Size > 10MB and Extension = "png" @name=SmallTextFiles Size < 1KB and Extension = "txt" @name="Modified Today" Date >= today() @name="Test Filter" @cs Name like "test_*.cpp"
La directiva @name se puede combinar con otras
directivas. Cuando se utilizan varias directivas, todas deben aparecer al
principio de la expresión, separadas por espacios en blanco.
Las expresiones de filtro admiten diversos atributos relacionados con los metadatos y el contenido de los archivos. Los nombres de los atributos no distinguen entre mayúsculas y minúsculas. Opcionalmente, se puede especificar a qué lado de la comparación (izquierdo, derecho o central) se aplica un atributo utilizando un prefijo.
ExistsDevuelve true si el archivo existe, en caso contrario,
devuelve false
NameNombre del archivo
BaseNameDevuelve el nombre del archivo sin la extensión. Por ejemplo, "document.txt" devuelve "document".
ExtensionExtensión de archivo
IsFolderDevuelve "true" si el elemento es una carpeta o un directorio y "false" si es un archivo.
FolderDevuelve la ruta relativa sin el nombre del archivo ni la carpeta base
RelPathDevuelve la ruta relativa desde el directorio raíz de la comparación, incluyendo tanto la ruta de la carpeta como el nombre del archivo. Por ejemplo, si se comparan "C:\Project" y el archivo está en "C:\Project\src\main.cpp", RelPath devuelve "src\main.cpp".
FullPathDevuelve la ruta completa del archivo
SizeTamaño del archivo
DateFecha y hora de la última modificación
DateStrCadena de fecha de última modificación en formato
yyyy-MM-dd
CreationTimeFecha y hora de creación
AttributesDevuelve los atributos del archivo como un valor entero
AttrStrDevuelve una cadena que describe el atributo del archivo. Ejemplos:
"R" para solo lectura, "H" para
oculto, "A" para archivo, "S" para
archivos del sistema.
Los siguientes atributos solo están disponibles para los elementos de comparación de archivos. Si se utiliza con elementos de carpeta, el comportamiento es indefinido.
ContentContenido del archivo. Devuelve un valor de tipo "FileContent". Solo se
pueden utilizar contains y recontains
con este tipo.
Los siguientes atributos solo están disponibles para los elementos de comparación de carpetas. Si se utiliza con elementos de archivo, el comportamiento es indefinido.
FilesNúmero de archivos que contiene directamente la carpeta.
RecursiveFilesNúmero de archivos que contiene la carpeta, incluidas todas las subcarpetas.
ItemsNúmero de elementos (archivos y subcarpetas) que contiene directamente la carpeta.
RecursiveItemsNúmero de elementos (archivos y subcarpetas) que contiene la carpeta, incluidas todas las subcarpetas.
TotalSizeTamaño total de todos los archivos que contiene directamente la carpeta, en bytes.
RecursiveTotalSizeTamaño total en bytes de todos los archivos contenidos en la carpeta, incluidas todas las subcarpetas.
Se pueden añadir prefijos para especificar el lado de la comparación:
Left: se aplica al archivo izquierdo (ej.,
LeftSize)
Right: se aplica al archivo derecho (ej.,
RightDate)
Middle: se aplica al archivo central en la comparación
a tres bandas (ej., MiddleName)
Los atributos sin prefijo (ej., Size) devuelven una
matriz con los valores de todos los lados disponibles (izquierdo, central,
derecho).
Estos atributos permiten acceder a los valores del sistema de propiedades de
Windows, como los metadatos definidos por el esquema del sistema de
propiedades de Windows (ej., System.Title,
System.FileOwner,
System.Image.HorizontalResolution).
Prop
Devuelve una matriz con los valores de las propiedades (izquierdo, central,
derecho) correspondientes al nombre de propiedad canónica
especificado. Ejemplo: prop("System.Title")
LeftProp
Valor de la propiedad del archivo del izquierdo. Ejemplo:
leftprop("System.FileOwner")
MiddlePropValor de la propiedad del archivo del central (en una comparación a tres bandas).
RightPropValor de la propiedad del archivo del derecho.
Los siguientes atributos están diseñados para utilizarse únicamente en filtros de visualización (especificados
mediante los prefijos e:, e!:,
fe:, fe!:,
de:, o de!: en el campo Filtro).
No deben utilizarse en reglas de inclusión/exclusión de filtros de archivos
(.flt), ya que requieren que la comparación se complete
primero y pueden provocar un comportamiento inesperado.
Identical
Devuelve true si el resultado de la comparación indica
que los elementos son idénticos, en caso contrario, devuelve
false. Este es un atributo global (no admite prefijos
específicos de ningún lado). Ejemplo: Identical para
mostrar solo los archivos idénticos.
Different
Devuelve true si el resultado de la comparación indica
que los elementos son diferentes, en caso contrario, devuelve
false. Este es un atributo global (no admite prefijos
específicos de ningún lado). Ejemplo: Different para
mostrar solo los archivos diferentes.
Skipped
Devuelve true si la comparación se omitió debido a un
error o a una regla de filtrado, en caso contrario, devuelve
false. Este es un atributo global (no admite prefijos
específicos de ningún lado). Ejemplo: Skipped para
mostrar solo los elementos omitidos.
Binary
Returns true if the file is detected as binary,
false if it's text, or none if the
file doesn't exist. This attribute supports side-specific prefixes (e.g.,
LeftBinary, RightBinary). Example:
allof(Binary) to show files that are binary on all sides.
DifferentLeftMiddle
Returns true if the left and middle files are different
in a 3-way comparison, false otherwise. Returns
none in 2-way comparisons. This is a global attribute
(does not support side-specific prefixes). Example:
DifferentLeftMiddle and not DifferentMiddleRight to find
files where only left differs from middle.
DifferentMiddleRight
Returns true if the middle and right files are different
in a 3-way comparison, false otherwise. Returns
none in 2-way comparisons. This is a global attribute
(does not support side-specific prefixes). Example:
DifferentMiddleRight to show files where middle and right
differ.
DifferentLeftRight
En comparaciones a tres bandas, devuelve true si los
archivos izquierdo y derecho son diferentes, false en
caso contrario. En comparaciones a dos bandas, devuelve
true si ambos archivos existen y son diferentes. Este es
un atributo global (no admite prefijos específicos de ningún lado).
Ejemplo: DifferentLeftRight para mostrar los archivos en
los que hay diferencias entre el izquierdo y el derecho.
Differences
Devuelve el número de diferencias de texto en la comparación de archivos.
Este atributo solo tiene sentido en el caso de los archivos de texto que han
sido comparados. Este es un atributo global (no admite prefijos específicos
de ningún lado). Ejemplo: Differences > 0 para
mostrar los archivos con diferencias, o Differences >
10 para mostrar los archivos con más de 10 diferencias.
IgnoredDiffs
Devuelve el número de diferencias ignoradas en la comparación de archivos
(diferencias filtradas por filtros de línea o ajustes de espacios en
blanco). Este atributo solo tiene sentido en el caso de los archivos de
texto que han sido comparados. Este es un atributo global (no admite
prefijos específicos de ningún lado). Ejemplo: IgnoredDiffs >
0 para mostrar los archivos con diferencias ignoradas, o
Differences = 0 and IgnoredDiffs > 0 para mostrar los
archivos que son idénticos, salvo por las diferencias ignoradas.
Unpacker
Devuelve el nombre del complemento de descompresión utilizado para la
comparación de archivos o una cadena vacía si no se ha utilizado ningún
complemento de descompresión. Este es un atributo global (no admite
prefijos específicos de ningún lado). Ejemplo: Unpacker =
"CompareMSExcelFiles" para mostrar los archivos comparados con el
descompresor de Excel, o Unpacker != "" para mostrar
todos los archivos en los que se ha utilizado un descompresor.
Prediffer
Devuelve el nombre del complemento prediferenciador utilizado para la
comparación de archivos, o una cadena vacía si no se ha utilizado ningún
complemento prediferenciador. Este es un atributo global (no admite
prefijos específicos de ningún lado). Ejemplo: Prediffer =
"IgnoreColumns" para mostrar los archivos comparados utilizando el
prediferenciador IgnoreColumns, o Prediffer != "" para
mostrar todos los archivos en los que se ha utilizado un prediferenciador.
EOLReturns the end-of-line (EOL) style as an integer value. For files, returns the predominant EOL style; for lines, returns the EOL style of that specific line.
Values: 0 = None, 1 = LF (Unix), 2 = CR (Mac), 3 = CRLF (Windows), 4 = Mixed (multiple EOL styles in file)
EOLStrReturns the end-of-line (EOL) style as a string. For files, returns the predominant EOL style; for lines, returns the EOL style of that specific line.
Values: "None", "LF", "CR", "CRLF", "Mixed"
Codepage
Devuelve la página de códigos (codificación de caracteres) del archivo como
un valor entero. Este atributo admite prefijos específicos para cada lado
(ej., LeftCodepage, RightCodepage).
Ejemplo: Codepage = 65001 para mostrar archivos UTF-8, o
allof(Codepage = 65001) para mostrar archivos que estén
en UTF-8 en todos los lados.
HasBOM
Devuelve true si el archivo tiene una marca de orden de
bytes (BOM), false en caso contrario, devuelve. Este
atributo admite prefijos específicos para cada lado (ej.,
LeftHasBOM, RightHasBOM). Ejemplo:
HasBOM para mostrar los archivos con BOM, o not
HasBOM para mostrar los archivos sin BOM.
Los atributos sin prefijo de lado (ej., Size) devuelven
una matriz con los valores de todos los lados disponibles (izquierdo,
central, derecho). Al aplicar un operador a estas matrices, el
comportamiento varía dependiendo de si la comparación se realiza con un
valor escalar o con otra matriz.
Al comparar una matriz con un valor escalar, la operación se aplica a cada
elemento de la matriz por separado. El resultado es una matriz booleana. Si
algún elemento de esta matriz booleana es true, la
expresión global se evalúa como true. De lo contrario, se
evalúa como false.
Al comparar dos matrices, el comportamiento depende del operador:
Para = y !=: Las matrices deben tener
la misma longitud. El resultado es un único valor booleano, no una matriz.
= devuelve true solo si todos los
elementos son iguales. != devuelve
true si hay algún elemento diferente.
Para el resto de operadores (ej., >,
<): la operación se aplica elemento por elemento,
generando una matriz booleana. El resultado final de la expresión es
true si al menos un elemento de la matriz booleana es
true, y false si todos los elementos
son false.
Example 8. Ejemplos
[2, 4] = [2, 4] -> true
[2, 4] != [2, 5] -> true (ya que 4 != 5)
[3, 5, 8] > [6, 4, 2]
-> [false, true, true]
-> true (porque al menos una de las comparaciones es cierta)
Las comparaciones entre matrices y valores escalares dan como resultado una
matriz booleana. La expresión en su conjunto es true si
al menos un elemento es true.
La comparación de matrices con = o !=
devuelve un único valor booleano.
La comparación de matrices con otros operadores da como resultado una matriz
booleana. El resultado final es true si al menos un
elemento es true.
Por defecto, todos los operadores de comparación de cadenas (como
=, !=, <,
<=, >, >=,
like, matches,
contains y recontains) no distinguen
entre mayúsculas y minúsculas. Puede controlar este comportamiento mediante
directivas (consulte Directivas sobre el uso de mayúsculas y minúsculas).
<, <=, >,
>=Comparación de valores numéricos, marcas de tiempo o cadenas de caracteres
=Comparación de igualdad
!=Comparación de desigualdad
+, -, *,
/, %
Operadores aritméticos. + y - realizan
la suma y la resta. * y /* realizan la
multiplicación y la división. % es el operador módulo (resto).
and, or, notOperadores lógicos
likeCoincidencia de cadenas con comodines
También puede utilizar not like para realizar la búsqueda
inversa.
matchesCoincidencia de expresiones regulares
También puede utilizar not matches para realizar la
búsqueda inversa.
containsComprueba si una cadena contiene una subcadena
También puede utilizar not contains para comprobar que no
contiene la subcadena.
recontainsComprueba si alguna subcadena coincide con una expresión regular
También puede utilizar not recontains para asegurarse de
que no haya coincidencias.
Filter expressions support various functions for manipulating and analyzing data. Functions are organized by category for easier reference.
strlen(source)Devuelve la longitud de la cadena como un Integer. Si
source es una matriz de cadenas, el resultado es
una matriz de enteros. Ejemplo: strlen(Name)
strCount(str,
substr)
Counts how many times the substring substr
appears in str. The search is case-insensitive
by default (respects @cs/@ci
directives). If str is an array, the result is
an integer array with counts for each element. Overlapping matches are
counted separately (e.g., strCount("aaaa", "aa") returns
2).
Ejemplos:
strCount("hello hello world", "hello") returns 2
strCount("Test TEST test", "test") returns 3
(case-insensitive)
@cs strCount("Test TEST test", "test") returns 1
(case-sensitive)
le:strCount(Line, "ERROR") > 2 shows lines containing
"ERROR" more than twice
regexCount(str,
pattern)
Counts how many times the regular expression
pattern matches in
str. The search is case-insensitive by default
(respects @cs/@ci directives). If
str is an array, the result is an integer array
with counts for each element. Zero-length matches are handled gracefully to
avoid infinite loops.
Ejemplos:
regexCount("test123abc456", "\d+") returns 2
regexCount("AAA BBB CCC", "[A-Z]+") returns 3
@cs regexCount("Test TEST", "TEST") returns 1
le:regexCount(Line, "\b(error|warning)\b") > 0 shows
lines with error or warning keywords
strFind(str,
substr[, occurrence])
Finds the position (0-based) of the Nth occurrence of substring
substr in str. The
optional occurrence parameter specifies which
occurrence to find (0-based, default is 0 for the first occurrence). The
search is case-insensitive by default (respects
@cs/@ci directives). Returns
none if the substring is not found or if the occurrence
index is out of range. If str is an array, the
result is an array of positions (or none values).
Ejemplos:
strFind("hello world", "o") returns 4 (first 'o')
strFind("hello world", "o", 1) returns 7 (second 'o')
@cs strFind("Test TEST test", "test") returns 10
(case-sensitive)
strFind(array("abc", "def"), "b") returns
array(1, none)
regexFind(str,
pattern[, group[,
occurrence]])
Finds the position (0-based) of the Nth occurrence of a regular expression
match in str. The optional
group parameter specifies which capture group to
locate (0-based, default is 0 for the entire match). The optional
occurrence parameter specifies which occurrence
of the pattern to find (0-based, default is 0 for the first occurrence).
The search is case-insensitive by default (respects
@cs/@ci directives). Returns
none if the pattern doesn't match, the group index is out
of range, or the occurrence index is out of range. If
str is an array, the result is an array of
positions (or none values).
Ejemplos:
regexFind("test123abc456", "\d+") returns 4 (position of
"123")
regexFind("test123abc456", "\d+", 0, 1) returns 10
(position of "456", second match)
regexFind("abc-def-ghi", "([a-z]+)-([a-z]+)", 1) returns
0 (position of first capture group "abc")
regexFind("v1.0 and v2.5", "v(\d+)\.(\d+)", 1, 1) returns
10 (major version "2" in second occurrence)
regexFind(array("test123", "abc"), "\d+") returns
array(4, none)
substr(source,
start, count)Devuelve un fragmento específico de texto de la cadena o de la
matriz de cadenas como una cadena. Si
source es una matriz de cadenas, el resultado es
una matriz de cadenas. Ejemplo: substr(Name, 0, 3)
replace(str, from, to)
Sustituye todas las coincidencias de la cadena
from por to.
Sistr es una matriz, el resultado es una matriz
de cadenas con las sustituciones aplicadas. Ejemplo: replace(name,
".bak", ".txt")
regexReplace(str, pattern, replacement)
Sustituye todas las coincidencias del modelo de expresión regular por la
cadena de sustitución Admite referencias hacia atrás ($1, $2, etc.) en la
cadena de sustitución. Si str es una matriz, el
resultado es una matriz de cadenas con las sustituciones aplicadas.
Ejemplo: regexReplace(name, "^(\w+)_(\w+)$", "$2_$1")
intercambia las palabras separadas por un guion bajo.
replaceWithList(str, filepath)
Sustituye varias cadenas en str utilizando reglas
de sustitución cargadas desde un archivo separado por tabulaciones El
formato del archivo es de una regla de sustitución por línea:
search_string<TAB>replacement_string. Las líneas
que comienzan por # se consideran comentarios y se
ignoran. Las líneas vacías también se ignoran. Si
str es una matriz, el resultado es una matriz de
cadenas con las sustituciones aplicadas.
Ejemplo de formato de archivo:
# Línea de comentarios manzana naranja gato perro viejo nuevo
Ejemplos:
replaceWithList(Name, "C:\Filters\replacements.txt") -
Aplica las sustituciones del archivo al nombre del archivo.
regexReplaceWithList(str, filepath)
Reemplaza las cadenas de str utilizando patrones
de expresiones regulares cargados desde un archivo separado por
tabulaciones. El formato del archivo es de un patrón por línea:
patrón_regex<TAB>cadena_de_sustitución. La cadena
de sustitución puede incluir referencias hacia atrás ($1, $2, etc.) a los
grupos capturados. Las líneas que comienzan por # se
consideran comentarios y se ignoran. Las líneas vacías también se ignoran.
Si str es una matriz, el resultado es una matriz
de cadenas con las sustituciones aplicadas.
Ejemplo de formato de archivo:
# Línea de comentarios
\d+ NUMBER
(\d{4})-(\d{2})-(\d{2}) $1_$2_$3
Ejemplos:
regexReplaceWithList(Name,
"C:\Filters\regex_replacements.txt") - Aplica sustituciones con
expresiones regulares al nombre del archivo.
regexExtract(str,
pattern[, group[,
offset]])
Captures text matching a regular expression pattern from the string. The
optional group parameter specifies which capture
group to extract (0-based). Group 0 (default) returns the entire match;
groups 1, 2, etc. return the corresponding capture groups defined by
parentheses in the pattern. The optional offset
parameter specifies which occurrence of the pattern to capture (0-based).
Offset 0 (default) returns the first match; offset 1 returns the second
match, etc. This is useful for capturing the Nth occurrence in a line, such
as the second number in a string. Returns none if the
pattern doesn't match, the group index is out of range, or the offset
exceeds the number of matches. If str is an
array, the result is an array with captures for each element. The search is
case-insensitive by default (respects
@cs/@ci directives).
Ejemplos:
regexExtract("abc123", "[a-z]+\d+") returns
"abc123" (entire match)
regexExtract("abc123", "([a-z]+)(\d+)", 1) returns
"abc" (first capture group)
regexExtract("abc123", "([a-z]+)(\d+)", 2) returns
"123" (second capture group)
regexExtract("2025-05-16", "(\d{4})-(\d{2})-(\d{2})", 1)
returns "2025"
regexExtract("user@example.com", "([^@]+)@([^@]+)", 1)
returns "user"
regexExtract("user@example.com", "([^@]+)@([^@]+)", 2)
returns "example.com"
regexExtract("value 123 and value 456", "(\d+)", 0, 0)
returns "123" (first number)
regexExtract("value 123 and value 456", "(\d+)", 0, 1)
returns "456" (second number)
regexExtract("v1.0.0 and v2.0.0", "v(\d+)\.(\d+)\.(\d+)", 1,
1) returns "2" (major version of second
occurrence)
regexExtract("test", "\d+") returns
none (no match)
regexExtract("abc", "([a-z])", 5) returns
none (group out of range)
regexExtract(array("abc123", "def456"), "([a-z]+)(\d+)",
1) returns array("abc", "def")
@cs regexExtract("ABC123", "([a-z]+)", 1) returns
none (case-sensitive, no match)
le:regexExtract(Line, "error:\s+(\w+)", 1) extracts error
type from log lines
fe:regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2"
filters files with major version 2
normalizeUnicode(str[, form])
Normalizar una cadena Unicode. El parámetro opcional "form" especifica la
forma de normalización: "NFC" o "C" (predeterminado), "NFD" o "D", "NFKC" o
"KC", "NFKD" o "KD". También se pueden utilizar formatos numéricos: 1=NFC,
2=NFD, 5=NFKC, 6=NFKD. Si str se trata de una
matriz, el resultado es una matriz de cadenas normalizadas. Ejemplo:
normalizeUnicode(name, "NFC")
toLower(str)
Convierte todos los caracteres de la cadena a minúsculas. Si
str es una matriz, el resultado es una matriz de
cadenas en minúsculas. Ejemplo: toLower("Hola Mundo")
devuelve "hola mundo"
toUpper(str)
Convierte todos los caracteres de la cadena a mayúsculas. Si
str es una matriz, el resultado es una matriz de
cadenas en mayúsculas. Ejemplo: toUpper("Hola Mundo")
devuelve "HOLA MUNDO"
toHalfWidth(str)
Convierte los caracteres de ancho completo en caracteres de ancho medio. Se
utiliza principalmente para convertir caracteres alfanuméricos y katakana de
ancho completo a ancho medio. Si str es una
matriz, el resultado es una matriz de cadenas convertidas.
toFullWidth(str)
Convierte los caracteres de ancho medio en caracteres de ancho completo. Se
utiliza principalmente para convertir caracteres alfanuméricos y katakana de
ancho medio a ancho completo. Si str es una
matriz, el resultado es una matriz de cadenas convertidas.
toKatakana(str)
Convierte los caracteres hiragana a katakana. Los caracteres que no son
hiragana no se modifican. Si str es una matriz,
el resultado es una matriz de cadenas convertidas.
toHiragana(str)
Convierte los caracteres katakana a hiragana. Los caracteres que no son
katakana no se modifican. Si str es una matriz,
el resultado es una matriz de cadenas convertidas.
toSimplifiedChinese(str)
Convierte los caracteres chinos tradicionales en caracteres chinos
simplificados. Los caracteres que no tienen una forma simplificada no se
modifican. Si str es una matriz, el resultado es
una matriz de cadenas convertidas.
toTraditionalChinese(str)
Convierte los caracteres chinos simplificados en caracteres chinos
tradicionales. Los caracteres que no tienen una forma tradicional no se
modifican. Si str es una matriz, el resultado es
una matriz de cadenas convertidas.
trim(str)
Removes leading and trailing whitespace characters (space, tab, newline,
carriage return) from the string. If str is an
array, the result is an array of trimmed strings.
Ejemplos:
trim(" hello ") returns "hello"
trim(array(" test ", " data ")) returns
array("test", "data")
trimLeft(str)
Removes leading whitespace characters (space, tab, newline, carriage return)
from the beginning of the string. Trailing whitespace is preserved. If
str is an array, the result is an array of
left-trimmed strings.
Ejemplos:
trimLeft(" hello ") returns "hello "
trimRight(str)
Removes trailing whitespace characters (space, tab, newline, carriage
return) from the end of the string. Leading whitespace is preserved. If
str is an array, the result is an array of
right-trimmed strings.
Ejemplos:
trimRight(" hello ") returns " hello"
lineCount(content)Devuelve el número de líneas del contenido del archivo o de la matriz de
contenido del archivo como un Integer. Si
content es una matriz, el resultado es una matriz
de enteros. Ejemplo: lineCount(Content)
sublines(content,
start, count)
Extrae el número de líneas especificado a partir del índice de línea
indicado en el contenido del archivo o en la matriz de contenido del archivo
y las devuelve como una única cadena concatenada. Si
content es una matriz, el resultado es una matriz
de cadenas.
toNumber(str),
toInt(str),
toDouble(str)Convert a string to a number. toNumber returns an
integer or floating-point number depending on the input format;
toInt returns only integers;
toDouble returns only floating-point numbers. Commas
in the input are ignored. Returns noneon parse failure.
Example: le:toInt(Column("Count")) > 100
toDateTime(str)
Converts a string to a timestamp value. Supports multiple date/time
formats. Returns noneif the string cannot be parsed.
Example: toDateTime("2025-01-15") > today()
now()Devuelve la fecha y la hora actuales como un valor de
Timestamp.
today()Devuelve la fecha de hoy como un valor de Timestamp que
representa las 00:00:00.000 al comienzo del día.
startOfWeek(timestamp)Devuelve el primer día de la semana, que siempre es el domingo, independientemente de la configuración regional.
startOfMonth(timestamp)Devuelve el primer día del mes.
startOfYear(timestamp)Devuelve el primer día del año.
toDateStr(timestamp)Convierte la marca de tiempo indicada en una cadena de fecha en
yyyy-MM-dd format. Si
timestamp es una matriz de marcas de tiempo, el
resultado es una matriz de cadenas.
abs(value)Devuelve el valor absoluto del número entero o de la matriz de
números enteros. Si value es una
matriz de números enteros, el resultado es una matriz de números enteros.
isWithin(value,
min, max)
Devuelve true si value está
dentro del intervalo [min, max] (ambos lados incluidos).
Admite números enteros, números de coma flotante, marcas de tiempo y cadenas
de caracteres (comparación sin distinción entre mayúsculas y minúsculas).
Si value si es una matriz, el resultado es una
matriz booleana en la que cada elemento se comprueba por separado.
Ejemplos:
isWithin(5, 1, 10) devuelve true
isWithin(Size, 1KB, 10MB) comprueba si hay algún archivo
cuyo tamaño esté comprendido entre 1 KB y 10 MB
isWithin(Date, today() - 7days, today()) comprueba si el
archivo fue modificado en la última semana
allof(isWithin(Size, 1KB, 10MB)) comprueba si todos los
tamaños de los archivos están comprendidos entre 1 KB y 10 MB
inRange(value,
min, max)
Devuelve true isi value está
comprendido en el intervalo [min, max) (incluido el
límite inferior y excluido el límite superior). Admite números enteros,
números de coma flotante, marcas de tiempo y cadenas de caracteres
(comparación sin distinción entre mayúsculas y minúsculas) Si
value es una matriz, el resultado es una matriz
booleana en la que cada elemento se comprueba por separado.
Ejemplos:
inRange(5, 1, 10) devuelve true
inRange(10, 1, 10) devuelve false
inRange(Size, 0, 1MB) comprueba si hay algún archivo cuyo
tamaño sea inferior a 1 MB
anyof(inRange(Date, startOfMonth(today()), today()))
comprueba si fue modificado algún archivo este mes (excluyendo hoy)
array(value1,
value2, ...)Creates an array from the given values. Example: array(1, 2,
3)
at(array,
index)Returns the element at the specified index (0-based). Negative indices count
from the end. Example: at(array(1, 2, 3), -1) returns 3
anyof(booleans)Returns true if any element in the boolean
array satisfies the condition.
allof(booleans)Devuelve true si todos los elementos de la matriz
booleana cumplen la condición.
allequal(array)Devuelve true si todos los valores de la matriz son
iguales.
len(value)Returns the length of the value as an Integer.
Behavior:
Array: Returns the number of elements in the array
String: Returns the UTF-8 character count
None (monostate): Returns 0
Other scalar values (Integer, Real, Boolean, Timestamp, etc.): Returns 1
Ejemplos:
len(array(1, 2, 3)) - returns 3
len("hello") - returns 5
len(123) - returns 1
len(Size) - returns the number of sides (2 or 3) in a
folder comparison
if(condition,
trueValue, falseValue)
Devuelve trueValue si
condition es verdadera, en caso contrario
devuelvefalseValue. si la condición es
verdadera, devuelve true; en caso contrario, devuelve falseValue. Esta
función realiza una evaluación de cortocircuito (solo evalúa la rama que se
va a devolver).
Ejemplos:
if(Size > 1MB, "large", "small") - devuelve "large" o
"small" en función del tamaño del archivo
if(Extension = "txt", "text file", "other file") -
clasifica los archivos por extensión
if(Exists, Size, 0) - devuelve tamaño del archivo o 0 si
el archivo no existe
ifEach(conditionArray,
trueValue, falseValue)
Selección condicional elemento por elemento. Para cada elemento en
conditionArray, devuelve el elemento
correspondiente de trueValue si la condición es
verdadera, en caso contrario, devuelve el elemento correspondiente de
falseValue. Si
trueValue o falseValue
es un valor escalar, se aplica a todos los elementos.
Ejemplos:
ifEach(Size > 1MB, "large", "small") - devuelve una
matriz con etiquetas "large"/"small" labels para cada archivo
ifEach(array(true, false, true), array("a", "b", "c"), array("x",
"y", "z")) - devuelve array("a", "y", "c")
anyof(ifEach(Size > 100KB, Size < 10MB, false)) -
comprueba si hay algún archivo que tenga un tamaño comprendido entre 100 KB
y 10 MB
choose(index,
value0, value1, ...)
Selecciona un valor de entre los argumentos en función de
index. Si index es 0,
devuelve value0; si es 1, devuelve
value1, etc. Los índices negativos se limitan a
0. Los índices que superan el último valor devuelven el último valor.
Ejemplos:
choose(0, "first", "second", "third") - devuelve "first"
choose(DiffCode % 3, "equal", "different", "unique") -
asigna códigos de diferencia a las etiquetas
choose(5, "a", "b", "c") - devuelve "c" (fuera de
límites, devuelve el último valor)
chooseEach(indexArray,
value0, value1, ...)
Selección de valores elemento por elemento. Para cada índice en
indexArray, selecciona el valor correspondiente
de entre los argumentos restantes. Si indexArray
es un valor escalar, se comporta como choose.
Ejemplos:
chooseEach(array(0, 1, 2), "a", "b", "c") - devuelve
array("a", "b", "c")
chooseEach(array(0, 0, 1), "x", "y") - devuelve
array("x", "x", "y")
chooseEach(array(2, 0, 1), "first", "second", "third") -
devuelve array("third", "first", "second")
andEach(value1,
value2),
orEach(value1,
value2),
notEach(value)Operaciones lógicas elemento por elemento. Estas funciones actúan sobre valores booleanos, matrices booleanas o una combinación de ambos:
andEach - Operación lógica AND
orEach - Operación lógica OR
notEach - Operación lógica NOT (un solo argumento)
Cuando los argumentos son escalares, devuelve un resultado booleano escalar. Cuando un argumento es una matriz y el otro es un escalar, el escalar se aplica a todos los elementos. Cuando ambos argumentos son matrices, realiza una operación elemento por elemento.
Ejemplos:
andEach(Size > 1KB, Size < 1MB) - archivos de entre
1 KB y 1 MB
orEach(Extension = "txt", Extension = "log") - archivos
txt o de registro
notEach(Exists) - archivos que no existen
allof(andEach(Exists, Size > 0)) - todos los archivos
tienen un tamaño distinto de cero.
anyof(notEach(Size > 1MB)) - cualquier archivo de 1 MB
o menos
logError(value1,
value2, ...),
logWarn(value1,
value2, ...),
logInfo(value1,
value2, ...)Muestra en el registro la representación como cadena concatenada de todos los argumentos (a nivel de error, advertencia o información, respectivamente), separados por espacios y devuelve el valor del último argumento. Estas funciones resultan útiles para depurar expresiones de filtro.
Ejemplos (utilizando el valor devuelto):
logInfo("File size:", Size) > 1MB - registra el tamaño de
los archivos y comprueba si superan 1 MB
logWarn("Processing:", Name) like "*.tmp" - registra el
nombre o nombres de los archivos y comprueba si se trata de un archivo
temporal
Size > 1KB and logInfo("Large file:", Name) contains
"test" - registra solo cuando se cumple la condición de tamaño y,
a continuación, comprueba el nombre
Los tamaños de archivo admiten estos sufijos:
KB, MB, GB, TBLas unidades de tiempo admiten estos sufijos:
semanas, semana, s, días, día, d, horas, hora, hr, h, minutos, minuto, min, m, segundos, segundo, seg, s, milisegundos, milisegundo, mseg, msSize < 10KB - El tamaño de cualquier archivo es
inferior a 10 KB
LeftSize >= 10MB - El archivo izquierdo ocupa al menos
10 MB
allof(Size < 1MB) - Todos los lados tienen menos de 1
MB
abs(LeftSize - RightSize) < 1KB - La diferencia de
tamaño es mínima
DateStr = "2025-07-20" - El archivo se modificó por
última vez en esa fecha
Date >= today() - Modificado hoy o más adelante
Date > d"2026-05-21 07:16:33" - Modified after a
specific date and time
isWithin(Date, d"2026-01-01", d"2026-12-31 23:59:59") -
Modified during the year 2026
isWithin(Date, today() - 7days, today()) - Archivo
modificado en la última semana
inRange(Size, 1KB, 10MB) - El tamaño del archivo debe
estar comprendido entre 1 KB (incluido) y 10 MB (no incluido)
allof(isWithin(Size, 100KB, 1MB)) - Todos los archivos
tienen un tamaño comprendido entre 100 KB y 1 MB
AttrStr contains "R" - El archivo es de solo lectura
Name matches "file[0-9]\.txt" - Expresión regular en el
nombre del archivo
Content contains "Test" - El contenido del archivo
incluye la palabra clave
sublines(Content, 0, 1) contains "XML" - La primera línea
contiene "XML"
strCount(Content, "TODO") > 5 - File contains more
than 5 TODO comments
regexCount(Content, "\bFIXME\b") > 0 - File contains
at least one FIXME marker
strFind(Name, "_test") != none - Files containing "_test"
in their name
strFind(Name, ".", 1) > 0 - Files with multiple dots
in their name (second dot exists)
regexFind(Name, "\d{4}") < 5 - Files where a 4-digit
number appears within the first 5 characters
regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2" -
Files with major version 2 (e.g., "v2.16.48")
regexExtract(Name, "([^_]+)_([^_]+)\.txt", 2) like
"test*" - Files where second part of name starts with "test"
le:regexExtract(Line, "(\d+)", 0, 1) - Extracts the
second number in each line (offset=1)
(Extension = "log" and Size > 10MB) or (Date < today() -
7days) - Archivos de registro de gran tamaño o archivos con más de
una semana de antigüedad
AttrStr not contains "H" and Name like "*.tmp" - Archivos
temporales no ocultos
isWithin(Extension, "a", "m") and inRange(Size, 0, 1MB) -
Archivos con extensiones de la 'a' a la 'm' y un tamaño inferior a 1 MB
toLower(Name) = "readme.txt" - Coincidencia de nombres de
archivo sin distinción entre mayúsculas y minúsculas
toHalfWidth(Name) like "*.txt" - Coincidir tras convertir
los caracteres de ancho completo a caracteres de ancho medio
trim(Name) = "readme.txt" - Match filename after removing
leading/trailing whitespace
trimLeft(Column("Value")) = "123" - Match column value
after removing leading whitespace (table mode)
trimRight(Line) contains "end" - Check if line (without
trailing whitespace) contains "end"
EOL = 3 - Files with CRLF (Windows) line endings
EOLStr = "LF" - Files with LF (Unix) line endings
allof(EOL = 1) - Checks whether all compared files use LF
line endings
leftprop("System.Title") != none - Left file has a title
property set
prop("System.Author") = none - No author property is set
on any side
if(LeftExists, LeftSize, 0) == 0 - Checks whether the
left file is missing or empty
Different - Mostrar solo los archivos y carpetas que han
cambiado (solo filtro de visualización)
Identical - Mostrar solo los archivos y carpetas que sean
idénticos (solo filtro de visualización)
allof(Binary) - Mostrar solo los archivos que sean
binarios en todos los lados (solo filtro de visualización)
DifferentLeftMiddle and not DifferentMiddleRight - En una
comparación a tres bandas, mostrar los archivos en los que solo difiere el
par izquierdo-central (solo filtro de visualización)
Los filtros de archivos son archivos de texto con la
extensión flt. Permiten aplicar varias reglas de
filtrado a una comparación de carpetas. A diferencia de las máscaras de
archivos, los filtros de archivos pueden incluir o excluir coincidencias.
WinMerge incluye varios filtros de
archivos predefinidos. Si estos filtros no le ofrecen las opciones que
necesita, puede crear los suyos propios. Para facilitar esa tarea, WinMerge
también incluye un archivo de plantilla llamado
FileFilter.tmpl. En esta sección se describe cómo
aplicar filtros de archivos a las comparaciones y se detalla la sintaxis de
los filtros de archivos. En Uso del cuadro de diálogo "Filtros" se explica cómo
añadir, editar y gestionar filtros.
WinMerge detecta automáticamente los filtros de archivos en estas ubicaciones:
Aquí es donde se instalan los filtros de archivos predefinidos. Por ejemplo,
C:\Program Files\WinMerge\Filters. Puede crear o
copiar filtros de archivos en esta ubicación para que estén disponibles para
todos los usuarios del sistema.
Antes de crear un nuevo filtro de archivos, compruebe si los predefinidos ya contienen lo que necesita. Si no es así, es posible que encuentre ejemplos de reglas útiles en los archivos existentes.
La ubicación de esta carpeta se define en la página "Sistema" de las
opciones de WinMerge. De forma predeterminada, se especifica como una
subcarpeta dentro de la carpeta de su perfil de usuario (por ejemplo,
Documentos en Windows 10). Los filtros que se crean o
se copian aquí normalmente solo son visibles para usted. Si crea nuevos
filtros de archivos, puede copiarlos aquí para mantenerlos privados.
Antes de poder aplicar los filtros de archivos que se encuentran en cualquier otra carpeta, debe instalarlos primero.
Puede aplicar un filtro de archivos mediante cualesquiera de estos métodos:
Cuando inicie una comparación de carpetas desde el cuadro de diálogo "Seleccione archivos o carpetas":
Después de seleccionar la 1ª y la 2ª carpeta, haga clic en junto al campo Filtro.
En el cuadro de diálogo "Filtros", utilice la pestaña "Filtros de archivos" para seleccionar un filtro de archivos y cargarlo en el campo Filtros.
Si hay algún filtro de archivos activado, el filtro seleccionado ya aparece en el campo Filtro.
Continúe con la operación de comparación. El archivo indicado en el campo Filtro se aplica al iniciar la operación.
Para modificar el filtrado de archivos una vez iniciada una operación de comparación de carpetas (por ejemplo, para aplicar un filtro diferente o desactivar el filtrado):
Haga clic en → .
En el cuadro de diálogo "Filtros" configure los nuevos ajustes del filtro de archivos y haga clic en «Aceptar»..
El nuevo filtro no se aplica automáticamente al cerrar el cuadro de diálogo "Filtros": pulse F5 para ver los nuevos resultados en la ventana de comparación de carpetas.
Cuando inicie una comparación de
carpetas desde la línea de comandos de WinMerge, utilice el parámetro
-f para especificar un filtro de archivos.
En esta sección se describe la sintaxis de los filtros de archivos de WinMerge y se ofrecen pautas para su creación.
El delimitador de comentarios es ##. Después de un delimitador
de comentarios, se ignoran todos los caracteres de la línea. WinMerge ignora
la mayoría de los caracteres de espacio en blanco en las reglas. Sin
embargo, un comentario siempre debe ir precedido de uno o varios caracteres
de espacio en blanco (espacio o tabulación). Para utilizar ##
como caracteres en una regla, omita el prefijo de espacio en blanco.
Las dos primeras líneas obligatorias de un filtro de archivo son:
El nombre del filtro que aparece en el cuadro de diálogo "Archivo"
El tipo de filtrado que se va a aplicar. Especifique uno de estos valores:
Incluye todo excepto los elementos que cumplan la regla especificada.
Excluye todo excepto los elementos que cumplan la regla especificada.
Cuando elija el método de exclusión, también debe añadir una regla d (directorio) que especifique las subcarpetas. Por lo general, es recomendable especificar todas las subcarpetas de esta manera:
d: \\*$ ## Subfolders
No confunda estos términos. Recuerde que, en los filtros de archivos, una regla include no especifica qué se debe incluir, sino qué no se debe incluir. Del mismo modo, una regla exclude no especifica qué se debe excluir, sino qué no se debe excluir.
A continuación, el archivo debe contener una o varias reglas de filtrado. Puede añadir tantas reglas como desee. Debe haber una regla por línea y cada regla debe estar completa en una sola línea (no se permiten saltos de línea dentro de una regla). Una regla comienza con un designador de tipo, seguido de una expresión regular o de una expresión de filtrado. Los designadores de tipo admitidos son:
regexpComparar nombres de archivos mediante expresiones regulares
regexpExcluir archivos que coincidan con la expresión regular (disponible a partir de la versión 2.16.19)
regexpBuscar nombres de carpetas utilizando expresiones regulares
regexpExcluir carpetas que coincidan con la expresión regular (disponible desde la versión 2.16.19)
exprExpresión de filtro para archivos (ej. fe:Size < 1KB) (disponible desde la versión 2.16.49)
exprExpresión de filtro para excluir archivos (disponible desde la versión 2.16.49)
exprExpresión de filtro para carpetas (disponible desde la versión 2.16.49)
exprExpresión de filtro para excluir carpetas (disponible desde la versión 2.16.49)
exprExpresión de filtro aplicada tanto a archivos como a carpetas (ej. e:Name like "Common*.*") (disponible desde la versión 2.16.56)
exprExpresión de filtro para excluir tanto archivos como carpetas (disponible desde la versión 2.16.56)
Entre los numerosos caracteres especiales de las expresiones regulares, los siguientes son especialmente importantes en las reglas de filtrado de archivos:
A menudo es necesario para que las reglas funcionen correctamente.
A menudo es necesario para que las reglas funcionen correctamente. Por ejemplo:
\.c$ ## solo busca nombres de archivo con esa extensión,c. \.c ## coincide con cualquier extensión que empiece porc, comocppycom.
Obliga a que los caracteres especiales se traten como caracteres normales.
Por ejemplo, para que coincida el nombre de una carpeta, antepone una barra
invertida doble (\\) al delimitador de la carpeta. Para que
coincida el punto de un nombre de archivo, especifica una barra invertida
seguida de un punto (\.).
No se utilizan caracteres especiales ni comodines para buscar nombres de archivo. Para buscar todos los nombres de archivo de un tipo determinado, basta con omitir el nombre del archivo.
Las reglas no distinguen entre mayúsculas y minúsculas. Por ejemplo,
f: \.bat$ coincide con winmerge.bat y
compare.BAT.
Example 9. Ejemplos de reglas de filtrado de archivos
Algunas reglas sencillas de filtrado de archivos:
f: \.cpp$ ## Coincide con archivos*.cppf: \.h$ ## Coincide con archivos*.hf: ^My ## Coincide con archivosMy*.*f: Dlg\. ## Coincide con archivos*Dlg.*d: \\test$ ## Coincide con carpetastestd: ^\\Build$ ## Coincide con carpetasBuildd: Temp$ ## Coincide con carpetas*Temp(por ejemplo,FirstTemp) d: Src ## Coincide con carpetas*Src*
Algunas reglas con expresiones regulares más complejas:
f: ^\.#.*$ ## archivo.#nombre_archivo.versionf: Dlg\.c(pp)?$ ## archivos*Dlg.cy*Dlg.cppf: ^I.*\.h$ ## archivosI*.hf: Srv[1-9]\.def$ ## archivos*Srv1.defa*Srv9.deff: ^[h,k,m] ## archivosh*.*,k*.*ym*.*
En una comparación de archivos, puede utilizar filtros de línea para ignorar líneas concretas. Por ejemplo, puede utilizar filtros de línea para ignorar comentarios o determinados tipos de código generado, como las marcas de tiempo de los sistemas de control de versiones. Cada filtro de línea es una regla y puede aplicar tantos filtros de línea como desee a una comparación de archivos.
Para saber cómo añadir, editar y gestionar filtros, consulte Uso del cuadro de diálogo "Filtros".
Puede aplicar filtros de línea utilizando cualesquiera de estos métodos:
Al iniciar una comparación de archivos desde el cuadro de diálogo "Seleccione archivos o carpetas"
Después de seleccionar el 1º y el 2º archivo, haga clic en junto al campo Filtro.
En el cuadro de diálogo "Filtros", utilice la pestaña "Filtros de línea" para activar los filtros de línea que desee utilizar (si los hay) o para ver qué filtros de línea están activados actualmente.
El campo Filtro no indica qué filtros de línea están activados.
Continúe con la operación de comparación de archivos. Los filtros de línea activados se aplican al iniciar la operación.
Una vez que haya iniciado una operación de comparación de archivos (por ejemplo, para aplicar filtros diferentes o desactivar el filtrado)
Haga clic en → .
Vaya a la pestaña "Filtros de archivo".
Marque los filtros de línea que desee aplicar y desmarque los que no desee aplicar.
También puede añadir, editar y eliminar filtros de la lista mediante los botones , y .
Para activar el filtrado de líneas, marque la casilla Habilitar Filtros de líneas. Para desactivar el filtrado de líneas, desmarque la casilla.
Haga clic en para cerrar el cuadro de diálogo "Filtros de archivos".
Haga clic en F5 para aplicar los cambios y actualizar la ventana de comparación de archivos.
Un filtro de línea es una regla que se aplica a cada diferencia de una sola línea en los archivos comparados, siempre que las reglas de filtro de línea estén activadas. Cuando una regla coincide con una diferencia de una sola línea, dicha diferencia se ignora.
Las diferencias ignoradas se marcan en la ventana de comparación de archivos con el color de Diferencia ignorada (tal y como se define en la página "Colores" de las opciones de WinMerge). Esto le permite distinguir las diferencias ignoradas de otros tipos. Sin embargo, no puede seleccionar ni fusionar las diferencias ignoradas.
La adaptación de filtros de línea puede describirse a partir de dos conceptos:
Cuando una regla coincide con cualquier parte de la línea, se ignora toda la diferencia. Por lo tanto, no es posible filtrar solo una parte de una línea. Por ejemplo, supongamos que dos archivos presentan la siguiente diferencia de una sola línea:
Fichero1:
# Jean Sibelius
Fichero2:
# Janne Sibelius
Sin filtrado, la línea se detecta como una diferencia. Pero si aplicamos una
regla de filtrado de líneas con la expresión ^#, las líneas se
consideran idénticas, ya que la expresión solo especifica el primer
carácter, que coincide en ambos archivos.
Una regla solo se aplica a una diferencia de varias líneas si todas las líneas coinciden. Por ejemplo, consideremos esta diferencia de dos líneas:
Fichero1:
# Jean Sibelius # Pekka Himanen
Fichero2:
# Janne Sibelius Pekka Himanen
La misma regla ^# coincide con la primera línea, pero no con la
segunda. Por lo tanto, la diferencia no se ignora.
Por lo general, es recomendable utilizar los marcadores de inicio de línea
(^) y de fin de línea ($) para controlar los
patrones con precisión, ya que la regla se aplica si cualquier parte de una
línea coincide con la expresión.
Example 10. Ejemplos de filtros de línea
^MYTAG$
Filtra las líneas que coinciden exactamente MYTAG
^::
Filtra las líneas que comienzan por ::
^/\*.*\*/$
Filtra las líneas que empiezan por
y terminan por
/**/
^[1-5]00
Filtra las líneas que empiezan por números 100, 200, 300, 400 y 500
Example 11. Regla de filtrado de líneas que coincidan con las líneas de CVS Id
Las líneas de CVS Id tienen este aspecto:
// $Id: Filters.xml 7591 2013-01-20 15:47:42Z christianlist $
... y se pueden filtrar con esta regla:
^// \WId: .*\$
Example 12. Filtrar los comentarios de los números de línea en los archivos po
Los comentarios de los números de línea de po tienen este aspecto:
#: src/filename.c:766
... y se pueden filtrar con esta regla:
^#
The display line filter controls which lines are visible in the File Compare window. Lines that do not match the filter are hidden, but the comparison result itself is not affected.
Use any of the following methods to open the display filter bar:
Click → , or press Ctrl+Shift+L.
Right-click selected text in the File Compare window and choose → . WinMerge automatically builds a
Line contains "..." expression from the selected text and
opens the filter bar.
To remove the filter, clear the input field and press Enter. To hide the filter bar while keeping the filter active, click the close button.
The display filter bar accepts input in two forms, determined by whether the
input starts with the le: prefix:
Input without the le: prefix is treated as a literal
string. WinMerge shows only lines that contain that string. Internally, the
input is equivalent to le:Line contains
".input"
Example: entering TODO shows all lines that contain
the text TODO.
le: prefix (filter expression)If the input starts with le:, the remainder is
interpreted as a filter expression. The full expression syntax described in
Filter expression syntax is available.
Example: le:Different and Line contains "ERROR"
The le: prefix must appear at the very beginning of the
input. If it appears anywhere else, the entire input is treated as a plain
string.
For example, Hello or le:Line contains "Hello" does
not contain a filter expression. The whole input is
treated as a literal string search for the text Hello or le:Line
contains "Hello".
Display line filter expressions use the same engine as folder compare filter expressions (see Sintaxis de expresiones de filtro), with the following additional attributes and functions that operate on individual lines.
Attributes marked as supporting side-specific prefixes accept
Left, Middle, and
Right prefixes (e.g., LeftLine,
RightLineLength). Attributes without a prefix evaluate
across all panes.
LineText content of the current line. Supports side-specific prefixes.
Example: Line contains "TODO"
LineLengthLength of the current line in characters. Supports side-specific prefixes.
Example: LineLength > 120
LineNumberReal line number in the file (1-based), not counting ghost lines. Supports
side-specific prefixes. Example: LineNumber <= 50
ViewLineNumberDisplay line number including ghost lines (1-based). Global attribute (no
side prefix). Example: ViewLineNumber <= 100
DifferentTrue if the line is part of a difference block. Global attribute. Example:
Different
IdenticalTrue if the line is identical across all panes. Global attribute.
TrivialTrue if the line differs only in whitespace or other ignored content. Global
attribute. Example: Different or Trivial
ExistsTrue if the line exists in the pane (not a ghost line). Supports
side-specific prefixes. Example: LeftExists and not
RightExists
MissingTrue if the line is a ghost line in the pane. The opposite of
Exists. Supports side-specific prefixes.
MovedTrue if the line is detected as a moved line. Supports side-specific prefixes.
BookmarkedTrue if the line has a bookmark. Supports side-specific prefixes.
DifferentLeftMiddle,
DifferentMiddleRight,
DifferentLeftRightTrue if the indicated pair of panes differs on this line. 3-way comparisons
only (except DifferentLeftRight which also works in
2-way). Global attributes. Example: DifferentLeftMiddle and not
DifferentMiddleRight
EOLEnd-of-line style for the current line as an integer value. Supports
side-specific prefixes. Values: 0 = None, 1 = LF, 2 = CR, 3 = CRLF Example:
le:EOL = 3 shows only lines with CRLF endings
EOLStrEnd-of-line style for the current line as a string. Supports side-specific
prefixes. Values: "None", "LF", "CR", "CRLF" Example: le:EOLStr =
"LF" shows only lines with LF endings
Column, ColumnCount (table mode only)Cell content and column count in CSV/table mode. Support side-specific
prefixes. Example: Column("Status") = "FAIL"
LineAt(lineNumber),
LineOffsetAt(offset)Text of the line at an absolute line number or at a relative offset from the
current line. Supports side-specific prefix functions. Example:
le:Different and RightLineOffsetAt(-1) matches "^//"
Column(indexOrName),
ColumnAt(line,
indexOrName),
ColumnOffsetAt(offset,
indexOrName) (table mode only)Cell content by index or name, at the current, absolute, or relative line.
Example: le:RightColumn("Category") != ColumnOffsetAt(-1,
"Category")
Display line filter expressions can also use functions described in Funciones.
matchContext(expr,
linesBefore,
linesAfter)True if the current line is within linesBefore
lines before or linesAfter lines after any line
matching expr. Example:
le:matchContext(Different, 3, 3)
matchNumber(expr)1-based index of the current line within all matching lines. Returns
noneif the line does not match. Example:
le:matchNumber(Different) = 1 shows only the first line
that matches (the first difference line).
matchCount(expr)Total number of lines matching expr across the
whole file. Example: le:matchNumber(Different) =
matchCount(Different) shows only the last line that matches (the
last difference line).
matchBlockNumber(expr)Returns the 1-based block number of the matching block containing the
current line. Returns none if the current line is not in
any matching block. Example: le:matchBlockNumber(Different) =
1 shows only lines in the first difference block.
matchBlockOffset(expr)Returns the 1-based offset of the current line within the matching
block. Returns none if the current line is not in any
matching block. Example: le:matchBlockOffset(Different) =
1 shows only the first line of each difference block.
matchBlockSize(expr)Returns the size (number of lines) of the matching block containing the
current line. Returns none if the current line is not in
any matching block. Example: le:matchBlockSize(Different) >
5 shows only lines in difference blocks larger than 5 lines.
matchBlockCount(expr)Total number of matching blocks in the file. Example:
le:matchBlockNumber(Different) =
matchBlockCount(Different) shows only lines in the last difference
block.
matchDistance(expr),
matchDistanceBefore(expr),
matchDistanceAfter(expr)Distance in lines to the nearest matching range (both directions, before
only, or after only). Example: le:matchDistance(Different) <=
5
matchInside(beginExpr,
endExpr)True if the current line falls between a line matching
beginExpr and the next line matching
endExpr (inclusive). Example:
le:matchInside(Line matches "^#ifdef", Line matches
"^#endif")
average(expr),
average(expr,
condition)Calculates the average (arithmetic mean) of numeric values produced by
evaluating expr for all lines in the file. If
condition is provided, only lines where
condition evaluates to true are included in the
calculation. Non-numeric results are ignored. Returns
noneif no numeric values are found. Example:
le:toInt(Column("Price")) >
average(toInt(Column("Price"))) shows rows where the price exceeds
the average price. Example with condition:
le:average(toInt(Column("Score")), Column("Status") =
"PASS") calculates the average score for rows with status "PASS".
maximum(expr),
maximum(expr,
condition)Returns the maximum value among all results produced by evaluating
expr for all lines in the file. If
condition is provided, only lines where
condition evaluates to true are considered.
Works with numeric values, strings (alphabetical comparison), and
timestamps. Returns noneif no values are found.
Example: le:toInt(Column("Quantity")) =
maximum(toInt(Column("Quantity"))) shows rows with the highest
quantity.
minimum(expr),
minimum(expr,
condition)Returns the minimum value among all results produced by evaluating
expr for all lines in the file. If
condition is provided, only lines where
condition evaluates to true are considered.
Works with numeric values, strings (alphabetical comparison), and
timestamps. Returns noneif no values are found.
Example: le:Column("Status") = minimum(Column("Status"))
shows rows with the alphabetically first status value.
sum(expr),
sum(expr,
condition)Calculates the sum of all numeric values produced by evaluating
expr for all lines in the file. If
condition is provided, only lines where
condition evaluates to true are included in the
calculation. Non-numeric results are ignored. Returns
noneif no numeric values are found. Example:
le:toInt(Column("Quantity")) / sum(toInt(Column("Quantity"))) *
100 calculates each row's percentage of the total quantity.
Example with condition: le:sum(toInt(Column("Sales")),
Column("Region") = "East") calculates total sales for the "East"
region.
| Entrada | Effect |
|---|---|
TODO |
Shows lines containing the text "TODO" (plain string) |
le:Different |
Shows only lines in difference blocks |
le:Different or Trivial |
Shows differences, excluding whitespace-only changes |
le:matchContext(Different, 3, 3) |
Shows difference blocks with 3 lines of context on each side |
le:matchNumber(Different) = 1 |
Shows only the first difference line |
le:matchBlockNumber(Different) <= 3 |
Shows only lines in the first 3 difference blocks |
le:matchBlockOffset(Different) = 1 |
Shows only the first line of each difference block |
le:matchBlockSize(Different) > 10 |
Shows only lines in difference blocks larger than 10 lines |
le:Different and Line contains "ERROR" |
Shows lines that are both different and contain "ERROR" |
le:strFind(Line, "TODO") < 10 |
Shows lines where "TODO" appears within the first 10 characters |
le:regexFind(Line, "\d{4}") != none |
Shows lines containing a 4-digit number |
le:matchContext(Bookmarked, 2, 2) |
Shows bookmarked lines with 2 lines of context |
le:LineNumber <= 50 |
Shows only the first 50 lines |
le:EOL = 3 |
Shows only lines with CRLF (Windows) line endings |
le:EOLStr = "LF" |
Shows only lines with LF (Unix) line endings |
le:allof(EOL = 1) |
Shows lines where all panes use LF line endings |
le:toInt(Column("Count")) > 100 |
Shows rows where the "Count" column value exceeds 100 (table mode) |
The display file/folder filter in the Folder Compare window works the same way as the display line filter in the File Compare window, but operates on files and folders instead of lines. It controls which items are visible without affecting the comparison result.
To open the display filter bar, click → , or press Ctrl+Shift+L.
The filter bar accepts the same syntax as the Filter field in the Select Files or Folders dialog. See Sintaxis y ejemplos de máscaras de archivo and Sintaxis de expresiones de filtro for details.
To remove the filter, clear the input field and press Enter. To hide the filter bar while keeping the filter active, click the close button.
Ejemplos:
*.cpp;*.h - shows C++ source and header files
!.git\;!.vs\ - excludes .git and .vs folders
fe:Different - shows only different files
de:Items > 10 - shows folders with more than 10
items
e:Date > today() - 7days - shows items modified
within the last week
En esta sección se describe el cuadro de diálogo "Filtros", que ofrece funciones para crear y gestionar filtros de archivos y filtros de línea.
Para abrir el cuadro de diálogo «Filtros», use cualesquiera de estos métodos:
En el cuadro de diálogo "Seleccione archivos o carpetas", haga clic en a la derecha del campo Filtro. Este método se utiliza cuando se desea aplicar un filtro de archivos a una operación de comparación de carpetas.
Haga clic en → . Este método se puede utilizar en cualquier momento, excepto cuando está abierto el cuadro de diálogo "Seleccione archivos o carpetas".
El cuadro de diálogo "Filtros" tiene una pestaña para cada tipo de filtro de WinMerge:
Seleccione esta pestaña para utilizar filtros de archivos en las operaciones de comparación de carpetas.
Seleccione esta pestaña para utilizar filtros de línea en las operaciones de comparación de archivos.
Seleccione esta pestaña para trabajar con filtros de sustitución en las operaciones de comparación de archivos.
The display line filter is not configured through this dialog. Open it via → . See Using the display line filter.
La parte principal de esta pestaña es una lista de filtros de archivos disponibles para las operaciones de comparación de carpetas. La lista incluye filtros de archivos compartidos, privados e instalados que WinMerge reconoce, tal y como se describe en Ubicaciones de los filtros de archivos.
Debe habilitar un filtro de archivos para que esté disponible en una operación de comparación de carpetas o deshabilitar un filtro actual para que deje de utilizarse:
Abra el cuadro de diálogo "Filtros", si aún no está abierto.
Selecciona un filtro de archivos o de la lista.
Haga clic en para cerrar el cuadro de diálogo "Filtros".
Hay varias formas de aplicar filtros de archivos una vez habilitados. Para obtener más información, consulte Aplicación de filtros de archivos.
Utilice estos botones para gestionar su lista de filtros de archivos y crear nuevos filtros:
Seleccione un filtro de archivos de la lista y haga clic en para ver rápidamente cómo funciona el filtro. Consulte Comprobación de las reglas de filtrado de archivos para obtener más información.
Le permite buscar un filtro de archivos y añadirlo a la lista de filtros. Los filtros de archivos que no se encuentren ni en la carpeta compartida ni en la carpeta privada predeterminada no se detectarán a menos que los instale.
Crea una nueva copia de una plantilla de archivo en las carpetas de filtros compartidas o privadas y la abre en su editor predeterminado. Edite la plantilla y añada sus reglas, tal y como se describe en Creación de un filtro de archivos.
Seleccione un filtro de archivos de la lista y haga clic en para abrir el archivo en su editor predeterminado. editor.
Seleccione un filtro de archivos de la lista y haga clic en para borrar el archivo y eliminarlo de la lista. ¡Sí, el archivo es borrado de verdad!
Los cambios se guardan al hacer clic en para cerrar el cuadro de diálogo «Filtros». Los filtros de línea se guardan en el Registro de Windows.
Si los filtros de archivos que se instalan con WinMerge no le proporcionan el filtrado que necesita, puede crear los suyos propios:
Haga clic en → . O bien, en el cuadro de diálogo "Seleccione archivos o carpetas", haga clic en a la derecha del campo Filtro.
En la pestaña "Filtros de archivo" del cuadro de diálogo "Filtros", haga clic en .
En el cuadro de diálogo "Filtro compartido o privado" seleccione Filtro compartido o Filtro privado (consulte Ubicaciones de los filtros de archivos para conocer sus usos) y haga clic en Aceptar.
Se abre el cuadro de diálogo "Seleccione un nombre de archivo para el nuevo filtro" en la carpeta de archivos compartidos o privados de su sistema (si la carpeta privada no existe, WinMerge la creará).
En el cuadro de diálogo "Seleccione un nombre de archivo para el nuevo filtro", introduzca un nuevo nombre de archivo y haga clic en .
No elija un nombre de archivo que ya exista: para editar un archivo existente, vuelva al paso 2 y haga clic en "Editar..." en lugar de "Nuevo...".
WinMerge inicializa el nuevo archivo con el contenido de la plantilla
FileFilter.tmpl y lo abre en su editor de texto
predeterminado
Siga las instrucciones de la plantilla para editarla, actualizando el nombre y la descripción del marcador de posición y añadiendo reglas de filtrado, tal y como se describe en la sección Sintaxis del filtro de archivos. Guarde el archivo en su editor de texto.
Si quiere probar rápidamente una regla que está definiendo, haga clic en "Probar..." en el cuadro de diálogo "Filtros". Consulte Comprobación de las reglas de filtrado de archivos para obtener más información.
Si ha creado el filtro de archivos en una de las carpetas de filtros
predeterminadas y el cuadro de diálogo Filtros no
muestra el nuevo filtro, intente hacer clic en
para cerrarlo y, a continuación, vuelva a
hacer clic en → para volver a abrirlo. La
lista de Filtros de archivodebería incluir ahora el
nuevo filtro.
Si ha guardado el archivo en una ubicación diferente de su sistema de archivos, WinMerge no podrá detectarlo a menos que lo instale. Para que un filtro de archivos sea detectable en cualquier lugar del sistema:
Haga clic en en el cuadro de diálogo Filtros.
En el cuadro de diálogo "Buscar archivo de filtro para instalar", busque el
archivo flt en su sistema y haga clic en
. La lista "Filtros de archivo" debería incluir
ahora el filtro de archivo instalado.
Utilice el cuadro de diálogo "Probar filtro" para comprobar rápidamente un filtro de archivos con datos de ejemplo, lo que le ayudará a desarrollar nuevas reglas o a comprender cómo funcionan las reglas existentes. Puede resultar más sencillo que ejecutar una operación de comparación completa.
Empezando desde el cuadro de diálogo "Filtros":
En la pestaña "Filtros de archivo" seleccione el filtro de archivos que desee probar.
Si quiere ver las reglas que va a probar, haga clic en para abrir el archivo y poder consultarlo durante los siguientes pasos.
Haga clic en.
En el cuadro de diálogo "Probar filtro" seleccione el tipo de regla que desea probar:
Para probar una regla de archivos f: en su filtro de archivos, desmarque la opción Nombre de carpeta.
Para probar una regla de la carpeta d: marque la opción Nombre de carpeta.
Texto para probar.
El texto debe ser adecuado para el tipo de regla que esté probando. Por ejemplo, si ha marcado la opción Nombre de carpeta, probablemente querrá introducir un nombre de carpeta, como \temp.
En el cuadro Resultado aparece su entrada, seguida de
su estado: passed o
failed.
Utilice esta pestaña para configurar y activar filtros de línea en las operaciones de comparación de archivos. La pestaña incluye una lista de reglas. Cada regla contiene una única expresión regular. Puede aplicar cualquier combinación de reglas de la lista a una comparación de archivos.
Debajo de la lista Expresiones regulares hay un cuadro de edición y unos botones que puede utilizar para mantener la lista actualizada en cualquier momento añadiendo, editando y eliminando reglas.
Para añadir una nueva regla:
Haga clic en . El cursor de edición se activa automáticamente en el cuadro de edición.
Introduzca una expresión en el cuadro de edición situado debajo de la lista Expresiones regulares.
Haga clic en para cargar la expresión en una nueva línea de la lista.
Para editar una regla existente:
Seleccione la línea y haga clic en .
Edite la expresión en el cuadro de edición.
Haga clic en cuando haya terminado.
Para eliminar una regla existente, selecciónela (marque la casilla) y haga clic en .
En la lista de Expresiones regulares marque solo los filtros que desee aplicar y desmarque los que no desee aplicar.
Marque o desmarque la opción Habilitar Filtros de línea. Si activa el filtrado, se utilizarán todas las reglas que estén marcadas actualmente en la lista Expresión regular. Si el filtrado está desactivado, no se utilizará ninguna regla, aunque estén marcadas.
Haga clic en para cerrar el cuadro de diálogo "Filtros" y guardar la configuración.
Hay varias formas de aplicar filtros de archivos una vez activados. Para más información, consulte Aplicación de filtros de línea.
Las expresiones regulares pueden ser muy complejas. Afortunadamente, la mayoría de los filtros de archivos de WinMerge utilizan expresiones de extensión sencillas, tal y como se muestra en los ejemplos de este tema. Los archivos de filtro que se instalan con WinMerge incluyen muchos otros ejemplos útiles.
Por último, hay muchos recursos en Internet que pueden servir de ayuda con las expresiones regulares, entre ellos estos sitios web: