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.
El filtro de archivos y carpetas de muestra también está disponible para las operaciones de comparación de carpetas. A diferencia de los filtros de archivos, no afecta al resultado de la comparación; solo controla qué elementos se muestran en la ventana de comparación de carpetas. Consulte Uso del filtro de archivos y carpetas a mostrar.
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.
El filtro de líneas de muestra también se aplica únicamente a las operaciones de comparación de archivos. A diferencia de los filtros de líneas, no afecta al resultado de la comparación, solo controla qué líneas se muestran en la ventana de comparación de archivos. Consulte Uso de la pestaña "Filtros de línea".
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)
exprFilter expression for files (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: ninguno (representa un valor
nulo o ausente)
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: precedida por d y entre
comillas dobles (p. ej., d"2026-05-21 07:16:33",
d"2026-05-21")
Internamente, los valores pueden ser de los siguientes tipos: Boolean,
Integer, Real, Timestamp, String, File Content, Array o
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 muestra (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
Devuelve true si se detecta que el archivo es binario,
false si es de texto o none si el
archivo no existe. Este atributo admite prefijos específicos para cada lado
(ej., LeftBinary, RightBinary).
Ejemplo: allof(Binary) con el fin de mostrar los archivos
que son binarios en todos los lados.
DifferentLeftMiddle
Devuelve true si los archivos izquierdo y central son
diferentes en una comparación a tres bandas, false en
caso contrario. Devuelve none en comparaciones a dos
bandas. Este es un atributo global (no admite prefijos específicos de
ningún lado). Ejemplo: DifferentLeftMiddle and not
DifferentMiddleRight para encontrar archivos en los que solo el
izquierdo difiere del central.
DifferentMiddleRight
Devuelve true si los archivos central y derecho son
diferentes en una comparación a tres bandas, false en
caso contrario. Devuelve none en comparaciones a dos
bandas. Este es un atributo global (no admite prefijos específicos de
ningún lado). Ejemplo: DifferentMiddleRight para mostrar
los archivos en los que hay diferencias entre el central y el derecho.
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.
EOLDevuelve el tipo de fin de línea (EOL) como un valor entero. En los archivos, devuelve el tipo de fin de línea predominante. En las líneas, devuelve el tipo de fin de línea de esa línea concreta.
Valores: 0 = Ninguno, 1 = LF (Unix), 2 = CR (Mac), 3 = CRLF (Windows), 4 = Mixto (varios estilos de fin de línea en el archivo)
EOLStrDevuelve el tipo de fin de línea (EOL) como una cadena. En los archivos, devuelve el tipo de fin de línea predominante. En las líneas, devuelve el tipo de fin de línea de esa línea concreta.
Valores: "Ninguno", "LF", "CR", "CRLF", "Mixto"
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.
Las expresiones de filtro admiten diversas funciones para manipular y analizar datos. Las funciones están organizadas por categorías para facilitar su consulta.
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)
Cuenta cuántas veces aparece la subcadena substr
en str. La búsqueda no distingue entre
mayúsculas y minúsculas de forma predeterminada (respeta las directivas
@cs/@ci). Si
str es una matriz, el resultado es una matriz de
enteros con el recuento de cada elemento. Las coincidencias superpuestas se
cuentan por separado (por ejemplo, strCount(«aaaa», «aa»)
devuelve 2).
Ejemplos:
strCount("hello hello world", "hello") devuelve 2
strCount("Test TEST test", "test") devuelve 3 (sin
distinguir entre mayúsculas y minúsculas)
@cs strCount("Test TEST test", "test") devuelve 1 (sin
distinguir entre mayúsculas y minúsculas)
le:strCount(Line, "ERROR") > 2 muestra las líneas que
contienen «ERROR» más de dos veces
regexCount(str,
patrón)
Cuenta cuántas veces aparece la expresión regular
patrón en str. La
búsqueda no distingue entre mayúsculas y minúsculas por defecto (respeta las
directivas @cs/@ci). Si
str es una matriz, el resultado es una matriz de
enteros con el recuento de cada elemento. Las coincidencias de longitud cero
se gestionan adecuadamente para evitar bucles infinitos.
Ejemplos:
regexCount("test123abc456", "\d+") devuelve 2
regexCount("AAA BBB CCC", "[A-Z]+") devuelve 3
@cs regexCount("Test TEST", "TEST") devuelve 1
le:regexCount(Line, "\b(error|warning)\b") > 0 muestra
las líneas que contienen palabras clave de error o advertencia
strFind(str,
substr[,
coincidencia])
Busca la posición (contando a partir de 0) de la enésima aparición de la
subcadena substr en
str. El parámetro opcional
coincidencia especifica qué coincidencia se debe
buscar (contando a partir de 0, el valor por defecto es 0 para la primera
aparición). La búsqueda no distingue entre mayúsculas y minúsculas por
defecto (respeta las directivas
@cs/@ci). Devuelve
none si no se encuentra la subcadena o si el índice de
aparición está fuera de rango. Si str es una
matriz, el resultado es una matriz de posiciones (o valores nulos).
Ejemplos:
strFind("hello world", "o") devuelve 4 (la primera 'o')
strFind("hello world", "o", 1) devuelve 7 (la segunda
'o')
@cs strFind("Test TEST test", "test") devuelve 10
(distingue entre mayúsculas y minúsculas)
strFind(array("abc", "def"), "b") returns
array(1, none)
regexFind(str,
patrón[, grupo[,
coincidencia]])
Busca la posición (contando a partir de 0) de la enésima coincidencia de una
expresión regular en str. El parámetro opcional
grupo especifica qué grupo de captura se debe
localizar (contando a partir de 0, el valor por defecto es 0 para toda la
coincidencia). El parámetro opcional
coincidencia especifica qué coincidencia del
patrón se debe buscar (a partir de 0, el valor por defecto es 0 para la
primera ocurrencia). La búsqueda no distingue entre mayúsculas y minúsculas
de forma predeterminada (respetando las directivas
@cs/@ci). Devuelve
none si el patrón no coincide, si el índice del grupo
está fuera de rango o si el índice de la coincidencia está fuera de rango.
Si str es una matriz, el resultado es una matriz
de posiciones (o valores nulos) .
Ejemplos:
regexFind("test123abc456", "\d+") devuelve 4 (posición de
"123")
regexFind("test123abc456", "\d+", 0, 1) devuelve 10
(posición de "456", segunda coincidencia)
regexFind("abc-def-ghi", "([a-z]+)-([a-z]+)", 1) devuelve
0 (posición del primer grupo de captura "abc")
regexFind("v1.0 and v2.5", "v(\d+)\.(\d+)", 1, 1)
devuelve 10 (versión principal "2" en la segunda coincidencia)
regexFind(array("test123", "abc"), "\d+") devuelve
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,
patrón[, grupo[,
desplazamiento]])
Captura el texto de la cadena que coincida con un patrón de expresión
regular. El parámetro opcional grupo especifica
qué grupo de captura se debe extraer (contando a partir de 0). El grupo 0
(por defecto) devuelve toda la coincidencia. Los grupos 1, 2, etc.,
devuelven los grupos de captura correspondientes definidos por los
paréntesis del patrón. El parámetro opcional
desplazamiento especifica qué coincidencia del
patrón se debe capturar (contando a partir de 0). El desplazamiento 0 (por
defecto) devuelve la primera coincidencia. El desplazamiento 1 devuelve la
segunda y así sucesivamente. Esto resulta útil para extraer la enésima
aparición en una línea, como por ejemplo el segundo número de una cadena.
Devuelve none si el patrón no coincide, si el índice del
grupo está fuera de rango o si el desplazamiento supera el número de
coincidencias. Si str es una matriz, el
resultado es una matriz con capturas para cada elemento. La búsqueda no
distingue entre mayúsculas y minúsculas por defecto (respetando las
directivas @cs/@ci).
Ejemplos:
regexExtract("abc123", "[a-z]+\d+") devuelve
"abc123"(coincidencia completa)
regexExtract("abc123", "([a-z]+)(\d+)", 1) returns
"abc" (primer grupo de captura)
regexExtract("abc123", "([a-z]+)(\d+)", 2) returns
"123" (segundo grupo de capturas)
regexExtract("2025-05-16", "(\d{4})-(\d{2})-(\d{2})", 1)
devuelve "2025"
regexExtract("user@example.com", "([^@]+)@([^@]+)", 1)
devuelve "user"
regexExtract("user@example.com", "([^@]+)@([^@]+)", 2)
devuelve "example.com"
regexExtract("value 123 and value 456", "(\d+)", 0, 0)
returns "123" (primer número)
regexExtract("value 123 and value 456", "(\d+)", 0, 1)
returns "456" (segundo número)
regexExtract("v1.0.0 and v2.0.0", "v(\d+)\.(\d+)\.(\d+)", 1,
1) returns "2" (versión principal de la segunda
coincidencia)
regexExtract("test", "\d+") devuelve
none (no hay coincidencias)
regexExtract("abc", "([a-z])", 5) devuelve
none (grupo fuera de rango)
regexExtract(array("abc123", "def456"), "([a-z]+)(\d+)",
1) devuelve array("abc", "def")
@cs regexExtract("ABC123", "([a-z]+)", 1) devuelve
none (distingue entre mayúsculas y minúsculas, no hay
coincidencias)
le:regexExtract(Line, "error:\s+(\w+)", 1) extrae el tipo
de error de las líneas del registro
fe:regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2"
filtra los archivos cuya versión principal sea 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)
Elimina los caracteres de espacio en blanco al principio y al final
(espacio, tabulación, salto de línea, retorno de carro) de la cadena. Si
str es una matriz, el resultado es una matriz de
cadenas recortadas.
Ejemplos:
trim(" hello ") devuelve "hello"
trim(array(" test ", " data ")) devuelve
array("test", "data")
trimLeft(str)
Elimina los caracteres de espacio en blanco iniciales (espacio, tabulación,
salto de línea, retorno de carro) del principio de la cadena. Se conservan
los espacios en blanco finales. Si str es una
matriz, el resultado es una matriz de cadenas recortadas por la izquierda.
Ejemplos:
trimLeft(" hello ") devuelve "hello "
trimRight(str)
Elimina los caracteres de espacio en blanco al final (espacio, tabulación,
salto de línea, retorno de carro) de la cadena. Se conservan los espacios en
blanco al principio. Si str es una matriz, el
resultado es una matriz de cadenas recortadas por la derecha.
Ejemplos:
trimRight(" hello ") devuelve " 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)Convierte una cadena en un número. La función toNumber
devuelve un número entero o un número de coma flotante, dependiendo del
formato de entrada. La función toInt devuelve
únicamente números enteros. La función toDouble
devuelve únicamente números de coma flotante. Se ignoran las comas de la
entrada. Devuelve none si se produce un error de
análisis. Ejemplo: le:toInt(Column("Count")) > 100
toDateTime(str)
Convierte una cadena en un valor de marca de tiempo. Admite múltiples
formatos de fecha y hora. Devuelve none si no se puede
analizar la cadena. Ejemplo: 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, ...)Crea una matriz a partir de los valores indicados. Ejemplo:
array(1, 2, 3)
at(array,
index)Devuelve el elemento situado en el índice especificado (contando a partir de
0). Los índices negativos se cuentan desde el final. Ejemplo:
at(array(1, 2, 3), -1) devuelve 3
anyof(booleans)Devuelve true si algún elemento de boolean
array cumple la condición.
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)Devuelve la longitud del valor como un entero.
Comportamiento:
Matriz: devuelve el número de elementos de la matriz
Cadena: devuelve el número de caracteres UTF-8
Ninguno (monoestado): devuelve 0
Otros valores escalares (Integer, Real, Boolean, Timestamp, etc.): devuelve 1
Ejemplos:
len(array(1, 2, 3)) - Devuelve 3
len("hello") - Devuelve 5
len(123) - Devuelve 1
len(Size) - Devuelve el número de lados (2 o 3) en una
comparación de carpetas
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" - Modificado después de
una fecha y hora concretas
isWithin(Date, d"2026-01-01", d"2026-12-31 23:59:59") -
Modificado durante el año 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 - El archivo contiene
más de 5 comentarios TODO
regexCount(Content, "\bFIXME\b") > 0 - El archivo
contiene al menos un marcador FIXME
strFind(Name, "_test") != none - Archivos cuyo nombre
contenga "_test"
strFind(Name, ".", 1) > 0 - Archivos cuyo nombre
contiene varios puntos (hay un segundo punto)
regexFind(Name, "\d{4}") < 5 - Archivos en los que
aparece un número de 4 dígitos entre los primeros 5 caracteres
regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2" -
Archivos con versión principal 2 (por ejemplo, "v2.16.48")
regexExtract(Name, "([^_]+)_([^_]+)\.txt", 2) like
"test*" - Archivos cuya segunda parte del nombre empiece por
"test"
le:regexExtract(Line, "(\d+)", 0, 1) - Extrae el segundo
número de cada línea (desplazamiento= 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" - Buscar el nombre del archivo
tras eliminar los espacios en blanco iniciales y finales
trimLeft(Column("Value")) = "123" - Comparar el valor de
la columna tras eliminar los espacios en blanco iniciales (modo tabla)
trimRight(Line) contains "end" - Comprueba si la línea
(sin espacios al final) contiene "end"
EOL = 3 - Archivos con finales de línea CRLF (Windows)
EOLStr = "LF" - Archivos con finales de línea LF (Unix)
allof(EOL = 1) - Comprueba si todos los archivos
comparados utilizan finales de línea LF
leftprop("System.Title") != none - El archivo de la
izquierda tiene la propiedad del título definida
prop("System.Author") = none - No se ha establecido
ninguna propiedad de autor en ninguno de los lados
if(LeftExists, LeftSize, 0) == 0 - Comprueba si el
archivo de la izquierda no existe o está vacío
Different - Mostrar solo los archivos y carpetas que han
cambiado (solo filtros de muestra)
Identical - Mostrar solo los archivos y carpetas que sean
idénticos (solo filtros de muestra)
allof(Binary) - Mostrar solo los archivos que sean
binarios en todos los lados (solo filtros de muestra)
DifferentLeftMiddle and not DifferentMiddleRight - En una
comparación a tres bandas, mostrar los archivos en los que solo difiere el
par izquierdo-central (solo filtros de muestra)
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)
exprFilter expression for files (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 archivos".
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:
^#
El filtro de líneas de muestra controla qué líneas se muestran en la ventana de comparación de archivos. Las líneas que no se ajustan al filtro quedan ocultas, pero esto no afecta al resultado de la comparación en sí.
Use cualesquiera de los siguientes métodos para abrir la barra de filtros de muestra:
Haga clic en → o pulse Ctrl+Mayús+L.
Haga clic con el botón derecho del ratón sobre el texto seleccionado en la
ventana de comparación de archivos y seleccione → . WinMerge crea automáticamente una expresión La línea
contiene "..." a partir del texto seleccionado y abre la barra de
filtros.
Para eliminar el filtro, borre el contenido del campo de entrada y pulse Intro. Para ocultar la barra de filtro sin desactivarlo, haga clic en el botón de cerrar.
La barra de filtros de muestra admite entradas en dos formatos que dependen
de si la entrada comienza con el prefijo le::
Las entradas que no incluyan el prefijo le: se tratan
como una cadena literal. WinMerge muestra únicamente las líneas que
contengan dicha cadena. Internamente, la entrada es equivalente a
le:La línea contiene
".entrada"
Ejemplo: al introducir TODO, se muestran todas las
líneas que contienen el texto TODO.
le: prefijo (expresión de filtro)Si la entrada comienza por le:, el resto se interpreta
como una expresión de filtro. Se puede utilizar toda la sintaxis de
expresiones descrita en Sintaxis de expresiones de filtro.
Ejemplo: le:Different and Line contains "ERROR"
El prefijo le: debe aparecer justo al principio de la
entrada. Si aparece en cualquier otro lugar, toda la entrada se trata como
una cadena de texto sin formato.
Por ejemplo, Hello or le:La línea contiene "Hello"
no contiene una expresión de filtro. Toda la entrada se
trata como una búsqueda literal de la cadena de texto Hello or
le:La línea contiene "Hello".
Las expresiones de filtro de líneas de muestra utilizan el mismo motor que las expresiones de filtro de comparación de carpetas con los siguientes atributos y funciones adicionales que operan en líneas individuales (consulte Sintaxis de expresiones de filtro).
Los atributos marcados como compatibles con prefijos específicos de lado
admiten los prefijos Left, Middle y
Right (por ejemplo, LeftLine,
RightLineLength). Los atributos sin prefijo se evalúan
en todos los paneles.
LineContenido de texto de la línea actual. Admite prefijos específicos de cada
lado. Ejemplo: La línea contiene "TODO"
LineLengthLongitud de la línea actual en caracteres. Admite prefijos específicos para
cada lado. Ejemplo: LineLength > 120
LineNumberNúmero real de línea en el archivo (contando a partir de 1), sin contar las
líneas ocultas. Admite prefijos específicos para cada lado. Ejemplo:
LineNumber <= 50
ViewLineNumberMostrar el número de línea, incluidas las líneas ocultas (contando a partir
de 1). Atributo global (sin prefijo lateral). Ejemplo:
ViewLineNumber <= 100
DifferentEs verdadero si la línea forma parte de un bloque de diferencias. Atributo
global. Ejemplo: Different
IdenticalEs verdadero si la línea es idéntica en todos los paneles. Atributo global.
TrivialEs verdadero si la línea solo difiere en espacios en blanco u otro contenido
ignorado. Atributo global. Ejemplo: Different or Trivial
ExistsEs verdadero si la línea existe en el panel (no es una línea oculta). Admite
prefijos específicos para cada lado. Ejemplo: LeftExists and not
RightExists
MissingEs verdadero si la línea es una línea oculta en el panel. Es lo contrario
de Exists. Admite prefijos específicos de cada lado.
MovedEs verdadero si la línea se detecta como una línea desplazada. Admite prefijos específicos para cada lado.
BookmarkedEs verdadero si la línea tiene un marcador. Admite prefijos específicos para cada lado.
DifferentLeftMiddle,
DifferentMiddleRight,
DifferentLeftRightEs verdadero si el par de paneles indicado difiere en esta línea. Solo
comparaciones a tres bandas (excepto DifferentLeftRight,
que también funciona en comparaciones a dos bandas). Atributos globales.
Ejemplo: DifferentLeftMiddle and not DifferentMiddleRight
EOLEstilo de fin de línea para la línea actual expresado como un valor entero.
Admite prefijos específicos para cada lado. Valores: 0= Ninguno, 1= LF, 2=
CR, 3= CRLF. Ejemplo: le:EOL = 3 muestra solo las líneas
que terminan en CRLF
EOLStrEstilo de fin de línea para la línea actual, expresado como cadena. Admite
prefijos específicos para cada lado. Valores: "Ninguno", "LF", "CR",
"CRLF". Ejemplo: le:EOLStr = "LF" muestra únicamente las
líneas que terminan en LF
Column, ColumnCount (solo en modo
tabla)Contenido de las celdas y número de columnas en modo CSV/tabla. Admite
prefijos específicos para cada columna. Ejemplo: Column("Status")
= "FAIL"
LineAt(Número_línea),
LineOffsetAt(desplazamiento)Texto de la línea indicado mediante un número de línea absoluto o una
distancia relativa respecto a la línea actual. Admite funciones de prefijo
específicas para cada lado. Ejemplo: le:Different y
RightLineOffsetAt(-1) coinciden con "^//"
Column(indexOrName),
ColumnAt(línea,
indexOrName),
ColumnOffsetAt(desplazamiento,
indexOrName) (solo en modo tabla)Contenido de una celda por índice o nombre, en la línea actual, absoluta o
relativa. Ejemplo: le:RightColumn("Category") !=
ColumnOffsetAt(-1, "Category")
Las expresiones de los filtros de línea de muestra también pueden utilizar las funciones descritas en Funciones.
matchContext(expr,
linesBefore,
linesAfter)Es verdadero si la línea actual se encuentra dentro de
linesBefore líneas anteriores o
linesAfter líneas posteriores a cualquier línea
que coincida con expr. Ejemplo:
le:matchContext(Different, 3, 3)
matchNumber(expr)Índice, contando a partir de 1, de la línea actual entre todas las líneas
coincidentes. Devuelve ninguno si la línea no coincide.
Ejemplo: le:matchNumber(Different) = 1 muestra solo la
primera línea que coincide (la primera línea con diferencias).
matchCount(expr)Número total de líneas que coinciden con expr en
todo el archivo. Ejemplo: le:matchNumber(Different) =
matchCount(Different) muestra solo la última línea que coincide
(la última línea con diferencias).
matchBlockNumber(expr)Devuelve el número de bloque (contando a partir de 1) del bloque coincidente
que contiene la línea actual. Devuelve ninguno si la
línea actual no se encuentra en ningún bloque coincidente. Ejemplo:
le:matchBlockNumber(Different) = 1 muestra únicamente las
líneas del primer bloque de diferencias.
matchBlockOffset(expr)Devuelve el desplazamiento (contando a partir de 1) de la línea actual
dentro del bloque coincidente. Devuelve ninguno si la
línea actual no se encuentra en ningún bloque coincidente. Ejemplo:
le:matchBlockOffset(Different) = 1 muestra únicamente la
primera línea de cada bloque de diferencias.
matchBlockSize(expr)Devuelve el tamaño (número de líneas) del bloque coincidente que contiene la
línea actual. Devuelve ninguno si la línea actual no se
encuentra en ningún bloque coincidente. Ejemplo:
le:matchBlockSize(Different) > 5 muestra únicamente
las líneas de los bloques de diferencias que tengan más de 5 líneas.
matchBlockCount(expr)Número total de bloques coincidentes en el archivo. Ejemplo:
le:matchBlockNumber(Different) =
matchBlockCount(Different) muestra únicamente las líneas del
último bloque de diferencias.
matchDistance(expr),
matchDistanceBefore(expr),
matchDistanceAfter(expr)Distancia en líneas hasta el rango coincidente más cercano (en ambas
direcciones, solo antes o solo después). Ejemplo:
le:matchDistance(Different) <= 5
matchInside(beginExpr,
endExpr)Es verdadero si la línea actual se encuentra entre una línea que coincida
con beginExpr y la siguiente línea que coincida
con endExpr (ambas incluidas). Ejemplo:
le:matchInside(la línea coincide con «^#ifdef», la línea coincide
con «^#endif»)
average(expr),
average(expr,
condición)Calcula la media (media aritmética) de los valores numéricos obtenidos al
evaluar expr en todas las líneas del archivo. Si
se especifica condición, solo se incluyen en el
cálculo las líneas en las que condición se evalúa
como verdadero. Se ignoran los resultados no numéricos. Devuelve
ninguno si no se encuentran valores numéricos. Ejemplo:
le:toInt(Column("Price")) >
average(toInt(Column("Price"))) muestra las filas en las que el
precio supera el precio medio. Ejemplo con condición:
le:average(toInt(Column("Score")), Column("Status") =
"PASS") calcula la puntuación media de las filas con el estado
"PASS".
maximum(expr),
maximum(expr,
condición)Devuelve el valor máximo de entre todos los resultados obtenidos al evaluar
expr en todas las líneas del archivo. Si se
proporciona condición, solo se tienen en cuenta
las líneas en las que condición se evalúa como
verdadero. Funciona con valores numéricos, cadenas (comparación alfabética)
y marcas de tiempo. Devuelve ninguno si no se encuentran
valores. Ejemplo: le:toInt(Column("Quantity")) =
maximum(toInt(Column("Quantity"))) muestra las filas con la
cantidad más alta.
minimum(expr),
minimum(expr,
condición)Devuelve el valor mínimo de entre todos los resultados obtenidos al evaluar
expr para todas las líneas del archivo. Si se
proporciona condición, solo se tienen en cuenta
las líneas en las que condición se evalúa como
verdadero. Funciona con valores numéricos, cadenas (comparación alfabética)
y marcas de tiempo. Devuelve ninguno si no se encuentran
valores. Ejemplo: le:Column("Status") =
minimum(Column("Status")) muestra las filas con el valor de estado
que aparece primero en orden alfabético.
sum(expr),
sum(expr,
condición)Calcula la suma de todos los valores numéricos obtenidos al evaluar
expr en todas las líneas del archivo. Si se
especifica condition, solo se incluyen en el
cálculo las líneas en las que condition da como
resultado 'verdadero'. Se ignoran los resultados no numéricos. Devuelve
none si no se encuentran valores numéricos. Ejemplo:
le:toInt(Column(«Quantity»)) / sum(toInt(Column("Quantity"))) *
100 calcula el porcentaje de cada fila respecto a la cantidad
total. Ejemplo con condición: le:sum(toInt(Column("Sales")),
Column("Region") = "East") calcula las ventas totales de la región
"East".
| Entrada | Efecto |
|---|---|
TODO |
Muestra las líneas que contienen el texto "TODO" (cadena simple) |
le:Different |
Muestra solo las líneas de los bloques que presentan diferencias |
le:Different or Trivial |
Muestra todas las diferencias, incluidas las que se han ignorado |
le:matchContext(Different, 3, 3) |
Muestra bloques de diferencias con tres líneas de contexto a cada lado |
le:matchNumber(Different) = 1 |
Muestra solo la primera línea de diferencias |
le:matchBlockNumber(Different) <= 3 |
Muestra solo las líneas de los tres primeros bloques de diferencias |
le:matchBlockOffset(Different) = 1 |
Muestra solo la primera línea de cada bloque de diferencias |
le:matchBlockSize(Different) > 10 |
Muestra únicamente las líneas de los bloques de diferencias que superen las 10 líneas |
le:Different and Line contiene "ERROR" |
Muestra las líneas que son diferentes y que contienen "ERROR" |
le:strFind(Line, "TODO") < 10 |
Muestra las líneas en las que aparece "TODO" entre los primeros 10 caracteres |
le:regexFind(Line, "\d{4}") != none |
Muestra las líneas que contienen un número de 4 dígitos |
le:matchContext(Bookmarked, 2, 2) |
Muestra las líneas marcadas con dos líneas de contexto |
le:LineNumber <= 50 |
Muestra solo las primeras 50 líneas |
le:EOL = 3 |
Muestra solo las líneas con finales de línea CRLF (Windows) |
le:EOLStr = "LF" |
Muestra solo las líneas con finales de línea LF (Unix) |
le:allof(EOL = 1) |
Muestra las líneas en las que todos los paneles utilizan finales de línea LF |
le:toInt(Column("Count")) > 100 |
Muestra las filas en las que el valor de la columna "Count" es superior a 100 (modo tabla) |
El filtro de archivos y carpetas de muestra de la ventana de comparación de carpetas funciona igual que el filtro de líneas de muestra de la ventana de comparación de archivos, pero actúa sobre archivos y carpetas en lugar de sobre líneas. Controla qué elementos se muestran sin afectar al resultado de la comparación.
Para abrir la barra de filtros a mostrar, haga clic en → o pulse Ctrl+Mayús+L.
La barra de filtro admite la misma sintaxis que el campo Filtro del cuadro de diálogo "Seleccionar archivos o carpetas". Para obtener más información, consulte Sintaxis y ejemplos de máscaras de archivo y Sintaxis de expresiones de filtro.
Para eliminar el filtro, borre el contenido del campo de entrada y pulse Intro. Para ocultar la barra de filtro sin desactivarlo, haga clic en el botón de cerrar.
Ejemplos:
*.cpp;*.h: muestra los archivos fuente y de cabecera
de C++
!.git\;!.vs\ - excluye las carpetas .git y .vs
fe:Different - muestra solo los archivos diferentes
de:Items > 10 - Muestra las carpetas con más de 10
elementos
e:Date > today() - 7days - Muestra los elementos
modificados durante la última semana
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íneas.
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íneas 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.
El filtro de línea de muestra no se configura a través de este cuadro de diálogo. Ábralo mediante → . Consulte Uso de la pestaña "Filtros de línea".
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 archivos" 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 archivos deberí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 archivos" 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 archivos" 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íneas 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íneas. 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: