Utilisation des filtres


Lorsque vous comparez des fichiers ou des dossiers, vous pouvez utiliser des filtres pour restreindre la portée de la comparaison. Cela peut être utile lorsque vous souhaitez simplifier le résultat de la comparaison en éliminant les différences qui ne vous intéressent pas. Les filtres sont des règles basées sur des expressions régulières. WinMerge utilise le moteur d'expressions régulières populaire PCRE (Perl Compatible Regular Expressions).

Le fonctionnement de base du filtrage est simple : chaque élément qui serait normalement comparé (dossier, fichier ou ligne d'un fichier) est évalué, et si l'expression du filtre correspond à l'élément cible, le filtre est appliqué. Selon le type de filtre, l'élément est soit inclus, soit exclu de la comparaison.

Il existe différents filtres WinMerge pour les opérations de comparaison de dossiers et de fichiers :

Comparaison de dossiers : masques de fichiers et filtres de fichiers

Vous pouvez spécifier les fichiers à inclure dans une comparaison de dossiers en utilisant des masques de fichiers simples ou, pour un filtrage plus complexe, en appliquant plusieurs règles spécifiées dans un filtre de fichier.

Les fichiers et dossiers filtrés sont masqués par défaut dans le résultat, ce qui est généralement l'effet recherché. Vous pouvez cliquer sur AffichageAfficher les éléments ignorés pour les faire réapparaître, mais la fenêtre de comparaison n'affiche que des informations minimales à leur sujet. Par exemple, vous ne pouvez pas savoir si un fichier ignoré est un fichier texte ou un fichier binaire.

Le filtre d'affichage des fichiers/dossiers est également disponible pour les opérations de comparaison de dossiers. Contrairement aux filtres de fichiers, il n'affecte pas le résultat de la comparaison; il contrôle uniquement les éléments visibles dans la fenêtre de comparaison de dossiers. Voir Utilisation du filtre de fichier/dossier d'affichage.

Comparaisons de fichiers : filtres de lignes et filtres de substitution

Les filtres de lignes s'appliquent uniquement aux opérations de comparaison de fichiers. Ils vous permettent d'ignorer les différences portant sur une seule ligne.

Les filtres de substitution s'appliquent uniquement aux opérations de comparaison de fichiers. Ils remplacent les chaînes de caractères dans le bloc de diff par des chaînes spécifiées, les comparent, et ignorent le bloc de diff si les résultats du remplacement correspondent. Ils sont utiles pour ignorer un grand nombre de changements sans intérêt.

Le filtre d'affichage des lignes s'applique uniquement aux opérations de comparaison de fichiers. Contrairement aux filtres de lignes, il n'affecte pas le résultat de la comparaison; il contrôle uniquement les lignes visibles dans la fenêtre de comparaison de fichiers. Voir Utilisation du filtre de ligne d'affichage.

1. Utilisation des masques de fichiers

Vous pouvez utiliser un ou plusieurs masques de fichiers spécifiant les extensions de fichiers à inclure dans une comparaison de dossiers. Tous les autres fichiers seront omis de votre sélection.

1.1. Définition et application des masques de fichiers

Définissez et appliquez un masque de fichier au moment où vous lancez votre opération de comparaison de dossiers :

  • Si vous utilisez la boîte de dialogue « Sélectionner des fichiers ou des dossiers », après avoir choisi les dossiers 1er et 2e, saisissez un ou plusieurs masques de fichiers dans le champ Filtre. Les masques sont appliqués lorsque vous démarrez l'opération de comparaison.

  • Si vous utilisez la ligne de commande WinMerge, utilisez le commutateur -f pour spécifier les masques de fichiers (voir l'exemple dans la section suivante).

1.2. Syntaxe et exemple de masques de fichiers

Vous pouvez spécifier des masques de fichiers et des filtres étendus en utilisant ce format :

        Filtre1 du Groupe1;Filtre2 ...|Filtre1 du Groupe2;Filtre2 ...|...
      
  • Le caractère | sépare les groupes de filtres et agit comme un ET logique.

  • Les filtres au sein d'un même groupe sont séparés par ; et sont interprétés avec un OU logique.

  • Un fichier est inclus uniquement s'il correspond à au moins un filtre dans chaque groupe.

  • Pour inclure un caractère | (barre verticale) littéral dans une expression régulière qui n'est pas entourée de guillemets doubles (comme dans les filtres f: ou f!:), utilisez || à la place.

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

  • Chaque filtre (par ex., Filtre1, Filtre2) peut être de l'un des types suivants :

    *.ext

    Masque de fichier par extension (ex: *.txt)

    *.

    Fichiers sans extension (ex: README)

    !*.ext

    Exclure les fichiers correspondant à l'extension (disponible depuis 2.16.19)

    dossier\

    Dossiers cibles (doit se terminer par \) (disponible depuis 2.16.19)

    !dossier\

    Exclure les dossiers correspondants (disponible depuis 2.16.19)

    f: regexp

    Fait correspondre les noms de fichiers par expressions régulières (disponible depuis 2.16.49)

    f!: regexp

    Exclure les fichiers correspondant à la regex (disponible depuis 2.16.49)

    d: regexp

    Fait correspondre les noms de dossiers par regex (disponible depuis 2.16.49)

    d!: regexp

    Exclure les dossiers correspondant à la regex (disponible depuis 2.16.49)

    fe: expr

    Expression de filtre pour les fichiers (ex: fe:Size < 1KB) (disponible depuis 2.16.49)

    fe!: expr

    Expression de filtre pour exclure des fichiers (disponible depuis 2.16.49)

    de: expr

    Expression de filtre pour les dossiers (disponible depuis 2.16.49)

    de!: expr

    Expression de filtre pour exclure des dossiers (disponible depuis 2.16.49)

    pf: nom du filtre de fichier

    Appliquer un filtre de fichier par son nom (disponible depuis 2.16.49)

Example 1. Masque de fichier

Dans cet exemple en ligne de commande, l'opération de comparaison de dossiers inclut uniquement les fichiers avec les extensions xml ou txt. Tous les autres fichiers sont omis :

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


Example 2. Exclure des dossiers (depuis la version 2.16.19)

Dans cet exemple en ligne de commande, l'opération de comparaison de dossiers exclut les dossiers .git et .vs :

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


Example 3. Expression de filtre (depuis la version 2.16.49)

Dans cet exemple en ligne de commande, l'opération de comparaison de dossiers inclut uniquement les fichiers ayant les extensions cpp ou h et dont la taille est inférieure à 1 Ko :

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


1.3. Syntaxe des expressions de filtre

WinMerge permet un filtrage puissant à l'aide d'expressions opérant sur les métadonnées des fichiers, leur contenu et le contexte de comparaison. Cette section décrit les attributs, opérateurs, fonctions, types de données et règles d'évaluation pris en charge.

1.3.1. Littéraux et types

Les types de littéraux pris en charge incluent :

  • Booléen : true, false

  • Nul : none (représente une valeur nulle ou manquante)

  • Entier : entiers signés 64 bits (ex : 1024, ou avec des unités comme 100KB, 7days)

  • Réel (Double) : nombres à virgule flottante avec décimale ou exposant facultatifs (ex : 3.14, .5, 1e6)

  • Chaîne de caractères : entourée de guillemets doubles (p. ex. "exemple")

  • Date/Heure : Préfixée par d et entourée de guillemets doubles (p. ex. d"2026-05-21 07:16:33", d"2026-05-21")

En interne, les valeurs peuvent être des types suivants : Booléen, Entier, Réel, Horodatage, Chaîne de caractères, Contenu de fichier, Tableau ou Aucun.

1.3.2. Directives

Les expressions de filtre prennent en charge des directives qui contrôlent la manière dont l'expression est évaluée. Les directives sont spécifiées au début de l'expression, préfixées par @, et séparées de l'expression par un espace.

1.3.2.1. Directives de sensibilité à la casse

Par défaut, tous les opérateurs de comparaison de chaînes (=, !=, <, <=, >, >=, contains, recontains, like, matches) sont insensibles à la casse. Vous pouvez contrôler ce comportement en utilisant les directives suivantes :

@cs, @casesensitive

Active la comparaison sensible à la casse. Avec ces directives, "ABC" et "abc" sont considérés comme différents.

@ci, @caseinsensitive

Active la comparaison insensible à la casse (comportement par défaut). Avec ces directives, "ABC" et "abc" sont considérés comme identiques.

Example 4. Exemples de sensibilité à la casse

@cs Name = "README.txt"           ## Sensible à la casse : correspond uniquement à "README.txt"
@ci Name = "readme.txt"           ## Insensible à la casse : correspond à "README.txt", "readme.txt", "ReadMe.TXT", etc.
@casesensitive Extension = "TXT"  ## Sensible à la casse : correspond uniquement aux fichiers avec l'extension ".TXT"
@caseinsensitive Content contains "error"  ## Insensible à la casse : correspond à "Error", "ERROR", "error", etc.

1.3.2.2. Directives d'optimisation

Par défaut, les expressions de filtre sont optimisées pour améliorer les performances. Vous pouvez contrôler ce comportement en utilisant les directives suivantes :

@optimize, @opt

Active l'optimisation des expressions de filtre (comportement par défaut). Cela peut améliorer les performances pour les expressions complexes.

@nooptimize, @noopt

Désactive l'optimisation des expressions de filtre. C'est utile pour le débogage ou lorsque l'optimisation provoque des résultats inattendus.

Example 5. Exemples d'optimisation

@optimize Size > 10MB and Extension = "log"     ## Active l'optimisation (par défaut)
@noopt Name matches "complex[0-9]+pattern"    ## Désactive l'optimisation pour le débogage
@nooptimize Content contains "special-case"   ## Désactive l'optimisation

1.3.2.3. Directive Name

La directive @name vous permet d'attribuer un nom descriptif à une expression de filtre. Ce nom est destiné à être utilisé dans les messages d'erreur et les journaux pour aider à identifier l'expression de filtre qui a causé un problème.

@name="Filter Name", @name=FilterName

Attribue un nom à l'expression de filtre. Si le nom contient des espaces ou des caractères spéciaux, il doit être entouré de guillemets doubles. Les noms sans espaces peuvent être spécifiés sans guillemets.

Le nom spécifié sera utilisé dans les messages d'erreur et les sorties de diagnostic pour identifier le filtre. C'est particulièrement utile lors de l'utilisation de multiples expressions de filtre complexes.

Example 6. Exemples de la directive Name

@name="Gros fichiers images" Size > 10MB and Extension = "png"
@name=PetitsFichiersTexte Size < 1KB and Extension = "txt"
@name="Modifié aujourd'hui" Date >= today()
@name="Filtre de test" @cs Name like "test_*.cpp"

Note

La directive @name peut être combinée avec d'autres directives. Lorsque plusieurs directives sont utilisées, elles doivent toutes apparaître au début de l'expression, séparées par un espace.

1.3.3. Attributs

Les expressions de filtre prennent en charge divers attributs se rapportant aux métadonnées et au contenu des fichiers. Les noms d'attributs sont insensibles à la casse. Vous pouvez éventuellement spécifier à quel côté de la comparaison (gauche, droite ou milieu) un attribut s'applique en utilisant un préfixe.

1.3.3.1. Attributs principaux
Exists

Retourne true si le fichier existe, false sinon

Name

Nom du fichier

BaseName

Retourne le nom du fichier sans l'extension. Par exemple, « document.txt » retourne « document ».

Extension

Extension du fichier

IsFolder

Retourne true si l'élément est un dossier/répertoire, false si c'est un fichier.

Folder

Retourne le chemin relatif en excluant le nom de fichier et le dossier de base

RelPath

Renvoie le chemin relatif à partir du répertoire racine de comparaison, incluant le chemin du dossier et le nom du fichier. Par exemple, si la comparaison porte sur « C:\Project » et que le fichier se trouve dans « C:\Project\src\main.cpp », RelPath renvoie « src\main.cpp ».

FullPath

Retourne le chemin complet du fichier

Size

Taille du fichier

Date

Horodatage de dernière modification

DateStr

Chaîne de date de dernière modification au format yyyy-MM-dd

CreationTime

Horodatage de la date de création

Attributes

Retourne les attributs de fichier sous forme d'entier

AttrStr

Retourne la chaîne des attributs de fichier. Exemples : "R" pour Lecture seule, "H" pour Caché, "A" pour Archive, "S" pour fichier Système.

1.3.3.2. Attributs spécifiques aux fichiers

Les attributs suivants sont disponibles uniquement pour les éléments de comparaison de fichiers. Lorsqu'ils sont utilisés avec des dossiers, le comportement est indéfini.

Content

Contenu du fichier. Retourne une valeur de type FileContent. Seuls contains et recontains peuvent être utilisés avec ce type.

1.3.3.3. Attributs spécifiques aux dossiers

Les attributs suivants sont disponibles uniquement pour les éléments de comparaison de dossiers. Lorsqu'ils sont utilisés avec des fichiers, le comportement est indéfini.

Files

Nombre de fichiers directement contenus dans le dossier.

RecursiveFiles

Nombre de fichiers contenus dans le dossier, incluant tous les sous-dossiers.

Items

Nombre d'éléments (fichiers et sous-dossiers) directement contenus dans le dossier.

RecursiveItems

Nombre d'éléments (fichiers et sous-dossiers) contenus dans le dossier, incluant tous les sous-dossiers.

TotalSize

Taille totale de tous les fichiers directement contenus dans le dossier, en octets.

RecursiveTotalSize

Taille totale de tous les fichiers contenus dans le dossier, incluant tous les sous-dossiers, en octets.

1.3.3.4. Préfixes spécifiques au côté

Des préfixes peuvent être ajoutés pour spécifier le côté de la comparaison :

  • Left : S'applique au fichier du côté gauche (par ex., LeftSize)

  • Right : S'applique au fichier du côté droit (par ex., RightDate)

  • Middle : S'applique au fichier du milieu dans une comparaison à 3 voies (par ex., MiddleName)

Les attributs sans préfixe (par ex. Size) renvoient un tableau de valeurs de tous les côtés disponibles (Gauche, Milieu, Droite).

1.3.3.5. Attributs de propriétés Windows

Ces attributs permettent d'accéder aux valeurs du système de propriétés Windows, telles que les métadonnées définies par le schéma du système de propriétés Windows (par ex. System.Title, System.FileOwner, System.Image.HorizontalResolution).

Prop

Renvoie un tableau de valeurs de propriété (Gauche, Milieu, Droite) pour le nom de propriété canonique spécifié. Exemple : prop("System.Title")

LeftProp

Valeur de propriété du fichier du côté gauche. Exemple : leftprop("System.FileOwner")

MiddleProp

Valeur de propriété du fichier du milieu (dans une comparaison à 3 voies).

RightProp

Valeur de propriété du fichier du côté droit.

1.3.3.6. Attributs pour les filtres d'affichage uniquement

Les attributs suivants sont conçus pour être utilisés dans les filtres d'affichage uniquement (spécifiés via les préfixes e:, e!:, fe:, fe!:, de:, ou de!: dans le champ Filtre). Ils ne doivent pas être utilisés dans les règles d'inclusion/exclusion des filtres de fichiers (.flt), car ils nécessitent que la comparaison soit d'abord terminée et peuvent conduire à un comportement inattendu.

Identical

Renvoie true si le résultat de la comparaison indique que les éléments sont identiques, false sinon. Il s'agit d'un attribut global (ne prend pas en charge les préfixes de côté). Exemple : Identical pour n'afficher que les fichiers identiques.

Different

Renvoie true si le résultat de la comparaison indique que les éléments sont différents, false sinon. Il s'agit d'un attribut global (ne prend pas en charge les préfixes de côté). Exemple : Different pour n'afficher que les fichiers différents.

Skipped

Renvoie true si la comparaison a été ignorée en raison d'une erreur ou d'une règle de filtrage, false sinon. Il s'agit d'un attribut global (ne prend pas en charge les préfixes de côté). Exemple : Skipped pour n'afficher que les éléments ignorés.

Binary

Renvoie true si le fichier est détecté comme binaire, false s'il s'agit d'un fichier texte, ou none si le fichier n'existe pas. Cet attribut prend en charge les préfixes spécifiques au type de codage (p. ex. LeftBinary, RightBinary). Exemple : allof(Binary) pour afficher les fichiers binaires des deux côtés.

DifferentLeftMiddle

Renvoie true si les fichiers de gauche et du milieu diffèrent lors d'une comparaison à trois voies, false sinon. Renvoie none lors d'une comparaison à deux voies. Il s'agit d'un attribut global (ne prend pas en charge les préfixes spécifiques à un côté). Exemple : DifferentLeftMiddle and not DifferentMiddleRight pour trouver les fichiers où seul le fichier de gauche diffère de celui du milieu.

DifferentMiddleRight

Renvoie true si les fichiers du milieu et de droite diffèrent lors d'une comparaison à trois voies, false sinon. Renvoie none lors d'une comparaison à deux voies. Il s'agit d'un attribut global (ne prend pas en charge les préfixes spécifiques à un côté). Exemple : DifferentMiddleRight pour afficher les fichiers où les fichiers du milieu et de droite diffèrent.

DifferentLeftRight

Dans les comparaisons à 3 voies, renvoie true si les fichiers de gauche et de droite sont différents, false sinon. Dans les comparaisons à 2 voies, renvoie true si les deux fichiers existent et sont différents. Il s'agit d'un attribut global. Exemple : DifferentLeftRight pour afficher les fichiers où la gauche et la droite diffèrent.

Differences

Renvoie le nombre de différences de texte dans la comparaison de fichiers. Cet attribut n'est significatif que pour les fichiers texte qui ont été comparés. Il s'agit d'un attribut global. Exemple : Differences > 0 pour afficher les fichiers présentant des différences, ou Differences > 10 pour les fichiers avec plus de 10 différences.

IgnoredDiffs

Renvoie le nombre de différences ignorées lors de la comparaison de fichiers (différences filtrées par les filtres de ligne ou les paramètres d'espaces). Cet attribut n'est significatif que pour les fichiers texte qui ont été comparés. Il s'agit d'un attribut global (ne prend pas en charge les préfixes de côté). Exemple : IgnoredDiffs > 0 pour afficher les fichiers avec des différences ignorées, ou Differences = 0 and IgnoredDiffs > 0 pour afficher les fichiers identiques à l'exception des différences ignorées.

Unpacker

Renvoie le nom du plug-in de décompression utilisé pour la comparaison de fichiers, ou une chaîne vide si aucun n'a été utilisé. Il s'agit d'un attribut global. Exemple : Unpacker = "CompareMSExcelFiles" pour afficher les fichiers comparés via le décompresseur Excel, ou Unpacker != "" pour afficher tous les fichiers où un décompresseur a été utilisé.

Prediffer

Renvoie le nom du plug-in prediffer utilisé pour la comparaison de fichiers, ou une chaîne vide si aucun n'a été utilisé. Il s'agit d'un attribut global. Exemple : Prediffer = "IgnoreColumns" pour afficher les fichiers comparés avec le prediffer IgnoreColumns, ou Prediffer != "" pour afficher tous les fichiers où un prediffer a été utilisé.

EOL

Renvoie le style de fin de ligne (EOL) sous forme d'entier. Pour les fichiers, renvoie le style EOL prédominant ; pour les lignes, renvoie le style EOL de la ligne concernée.

Valeurs : 0 = Aucun, 1 = LF (Unix), 2 = CR (Mac), 3 = CRLF (Windows), 4 = Mixte (plusieurs styles de fin de ligne dans le fichier)

EOLStr

Renvoie le style de fin de ligne (EOL) sous forme de chaîne de caractères. Pour les fichiers, renvoie le style EOL prédominant; pour les lignes, renvoie le style EOL de la ligne concernée.

Valeurs : « Aucun », « LF », « CR », « CRLF », « Mixte »

Codepage

Renvoie la page de code du fichier (encodage des caractères) sous forme d'entier. Cet attribut prend en charge les préfixes spécifiques au côté (ex. LeftCodepage, RightCodepage). Exemple : Codepage = 65001 pour afficher les fichiers UTF-8, ou allof(Codepage = 65001) pour afficher les fichiers qui sont en UTF-8 de tous les côtés.

HasBOM

Renvoie true si le fichier possède une marque d'ordre des octets (BOM), false sinon. Cet attribut prend en charge les préfixes spécifiques au côté. Exemple : HasBOM pour afficher les fichiers avec BOM, ou not HasBOM pour afficher les fichiers sans BOM.

1.3.3.7. Évaluation de tableau

Les attributs sans préfixe de côté (par ex. Size) renvoient un tableau de valeurs de tous les côtés disponibles (Gauche, Milieu, Droite). Lors de l'application d'un opérateur à de tels tableaux, le comportement diffère selon que la comparaison se fait avec un scalaire ou un autre tableau.

1.3.3.7.1. Tableau vs Scalaire

Lors de la comparaison d'un tableau à un scalaire, l'opération est appliquée à chaque élément du tableau individuellement. Cela donne un tableau de booléens. Si un élément de ce tableau est true, l'expression globale est évaluée à true. Sinon, elle est évaluée à false.

Example 7. Exemple

[3, 5, 8] > 6 -> [false, false, true] -> true

1.3.3.7.2. Tableau vs Tableau

Lors de la comparaison de deux tableaux, le comportement dépend de l'opérateur :

  • Pour = et != : Les tableaux doivent avoir la même longueur. Le résultat est une valeur booléenne unique, pas un tableau. = renvoie true uniquement si tous les éléments sont égaux. != renvoie true si au moins un élément diffère.

  • Pour tous les autres opérateurs (par ex. >, <) : l'opération est appliquée élément par élément, produisant un tableau de booléens. Le résultat final de l'expression est true si n'importe quel élément du tableau booléen est true, et false si tous les éléments sont false.

Example 8. Exemples

[2, 4] = [2, 4] -> true
[2, 4] != [2, 5] -> true (car 4 != 5)
[3, 5, 8] > [6, 4, 2]
 -> [false, true, true]
 -> true (car au moins une comparaison est vraie)
              

1.3.3.7.3. Résumé
  • Les comparaisons Tableau vs Scalaire produisent un tableau de booléens. Le résultat global de l'expression est true si au moins un élément est true.

  • La comparaison Tableau vs Tableau avec = ou != renvoie une valeur booléenne unique.

  • La comparaison Tableau vs Tableau avec d'autres opérateurs produit un tableau de booléens. Le résultat final est true si n'importe quel élément est true.

1.3.4. Opérateurs

Par défaut, tous les opérateurs de comparaison de chaînes (tels que =, !=, <, <=, >, >=, like, matches, contains et recontains) sont insensibles à la casse. Vous pouvez contrôler ce comportement à l'aide de directives (voir Directives de sensibilité à la casse).

<, <=, >, >=

Comparaison numérique, d'horodatage ou de chaîne

=

Comparaison d'égalité

!=

Comparaison d'inégalité

+, -, *, /, %

Opérateurs arithmétiques. + et - effectuent l'addition et la soustraction. * et / effectuent la multiplication et la division. % est l'opérateur modulo (reste).

and, or, not

Opérateurs logiques

like

Correspondance de chaîne avec caractères génériques

Vous pouvez également utiliser not like pour effectuer la correspondance inverse.

matches

Correspondance par expressions régulières

Vous pouvez également utiliser not matches pour effectuer la correspondance inverse.

contains

Vérifie si une chaîne contient une sous-chaîne

Vous pouvez également utiliser not contains pour vérifier l'absence de la sous-chaîne.

recontains

Vérifie si une sous-chaîne correspond à une expression régulière

Vous pouvez également utiliser not recontains pour garantir qu'aucune correspondance n'existe.

1.3.5. Fonctions

Les expressions de filtrage prennent en charge diverses fonctions de manipulation et d'analyse des données. Ces fonctions sont organisées par catégorie pour faciliter leur consultation.

1.3.5.1. Fonctions de chaînes de caractères
strlen(source)

Renvoie la longueur de la chaîne sous forme d'un Integer. Si source est un tableau de chaînes, le résultat est un tableau d'entiers. Exemple : strlen(Name)

strCount(str, substr)

Compte le nombre d'occurrences de la sous-chaîne substr dans str. La recherche est insensible à la casse par défaut (respecte les directives @cs et @ci). Si str est un tableau, le résultat est un tableau d'entiers contenant le nombre d'occurrences de chaque élément. Les correspondances qui se chevauchent sont comptées séparément (p. ex. strCount("aaaa", "aa") renvoie 2).

Exemples :

  • strCount("hello hello world", "hello") renvoie 2

  • strCount("Test TEST test", "test") renvoie 3 (sans tenir compte de la casse)

  • @cs strCount("Test TEST test", "test") renvoie 1 (sensible à la casse)

  • le:strCount(Line, "ERROR") > 2 affiche les lignes contenant « ERROR » plus de deux fois

regexCount(str, pattern)

Compte le nombre de fois où l'expression régulière pattern est trouvée dans str. La recherche est insensible à la casse par défaut (respecte les directives @cs et @ci). Si str est un tableau, le résultat est un tableau d'entiers contenant le nombre d'occurrences de chaque élément. Les correspondances vides sont gérées de manière élégante afin d'éviter les boucles infinies.

Exemples :

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

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

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

  • le:regexCount(Line, "\b(error|warning)\b") > 0 affiche les lignes contenant les mots-clés d'erreur ou d'avertissement

strFind(str, substr[, occurrence])

Trouve la position (à partir de 0) de la Nième occurrence de la sous-chaîne substr dans str. Le paramètre optionnel occurrence spécifie l'occurrence à rechercher (à partir de 0, par défaut 0 pour la première occurrence). La recherche est insensible à la casse par défaut (respecte les directives `@cs` et `@ci`). Renvoie `none` si la sous-chaîne est introuvable ou si l'indice d'occurrence est hors limites. Si str est un tableau, le résultat est un tableau de positions (ou la valeur `none`).

Exemples :

  • strFind("hello world", "o") renvoie 4 (premier 'o')

  • strFind("hello world", "o", 1) renvoie 7 (deuxième 'o')

  • @cs strFind("Test TEST test", "test") renvoie 10 (sensible à la casse)

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

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

Trouve la position (à partir de 0) de la Nième occurrence d'une correspondance d'expression régulière dans str. Le paramètre optionnel group spécifie le groupe de capture à rechercher (indexé à partir de 0, par défaut 0 pour la correspondance entière). Le paramètre optionnel occurrence spécifie l'occurrence du motif à rechercher (indexé à partir de 0, par défaut 0 pour la première occurrence). La recherche est insensible à la casse par défaut (respecte les directives @cs et @ci). Renvoie none si le motif ne correspond pas, si l'index du groupe ou l'index de l'occurrence est hors limites. Si str est un tableau, le résultat est un tableau de positions (ou la valeur « none »).

Exemples :

  • regexFind("test123abc456", "\d+") renvoie 4 (position de « 123 »)

  • regexFind("test123abc456", "\d+", 0, 1) renvoie 10 (position de « 456 », deuxième correspondance)

  • regexFind("abc-def-ghi", "([a-z]+)-([a-z]+)", 1) renvoie 0 (position du premier groupe de capture « abc »)

  • regexFind("v1.0 and v2.5", "v(\d+)\.(\d+)", 1, 1) renvoie 10 (version majeure « 2 » dans la deuxième occurrence)

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

substr(source, start, count)

Renvoie une plage de texte spécifique de la chaîne ou du tableau de chaînes sous forme d'une String. Si source est un tableau de chaînes, le résultat est un tableau de chaînes. Exemple : substr(Name, 0, 3)

replace(str, from, to)

Remplace toutes les occurrences de la chaîne from par to. Si str est un tableau, le résultat est un tableau de chaînes avec les remplacements appliqués. Exemple : replace(name, ".bak", ".txt")

regexReplace(str, pattern, replacement)

Remplace toutes les correspondances du motif d'expression régulière par la chaîne de remplacement. Prend en charge les références arrière ($1, $2, etc.) dans la chaîne de remplacement. Si str est un tableau, le résultat est un tableau de chaînes avec les remplacements appliqués. Exemple : regexReplace(name, "^(\w+)_(\w+)$", "$2_$1") permute des mots séparés par un souligné.

replaceWithList(str, filepath)

Remplace plusieurs chaînes de caractères dans str en utilisant des règles de remplacement chargées depuis un fichier séparé par des tabulations. Le format du fichier est le suivant : une règle de remplacement par ligne : search_string<TAB>replacement_string. Les lignes commençant par # sont considérées comme des commentaires et ignorées. Les lignes vides sont également ignorées. Si str est un tableau, le résultat est un tableau de chaînes avec les remplacements appliqués.

Exemple de format de fichier :

# Ligne de commentaire
pomme	orange
chat	chien
ancien	nouveau

Exemples :

  • replaceWithList(Name, "C:\Filters\replacements.txt") - applique les remplacements du fichier au nom du fichier

regexReplaceWithList(str, filepath)

Remplace les chaînes de caractères dans str à l'aide d'expressions régulières chargées depuis un fichier séparé par des tabulations. Le format du fichier est le suivant : une expression régulière par ligne : regex_pattern<TAB>replacement_string. La chaîne de remplacement peut inclure des références arrière ($1, $2, etc.) vers des groupes capturés. Les lignes commençant par # sont considérées comme des commentaires et ignorées. Les lignes vides sont également ignorées. Si str est un tableau, le résultat est un tableau de chaînes avec les remplacements appliqués.

Exemple de format de fichier :

# Ligne de commentaire
\d+	NOMBRE
(\d{4})-(\d{2})-(\d{2})	$1_$2_$3

Exemples :

  • regexReplaceWithList(Name, "C:\Filters\regex_replacements.txt") - applique des remplacements d'expressions régulières au nom du fichier

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

Capture le texte correspondant à un motif d'expression régulière dans la chaîne. Le paramètre optionnel group spécifie le groupe de capture à extraire (indexé à partir de 0). Le groupe 0 (par défaut) renvoie la correspondance complète ; les groupes 1, 2, etc. renvoient les groupes de capture correspondants définis entre parenthèses dans le motif. Le paramètre optionnel offset spécifie l'occurrence du motif à capturer (indexé à partir de 0). L'offset 0 (par défaut) renvoie la première occurrence ; l'offset 1 renvoie la deuxième, etc. Ceci est utile pour capturer la Nième occurrence dans une ligne, comme le deuxième chiffre d'une chaîne. Renvoie none si le motif ne correspond à aucune occurrence, si l'index du groupe est hors limites ou si l'offset dépasse le nombre d'occurrences. Si str est un tableau, le résultat est un tableau contenant les captures pour chaque élément. La recherche est insensible à la casse par défaut (respecte les directives @cs/@ci).

Exemples :

  • regexExtract("abc123", "[a-z]+\d+") renvoie "abc123" (correspondance complète)

  • regexExtract("abc123", "([a-z]+)(\d+)", 1) renvoie "abc" (premier groupe de capture)

  • regexExtract("abc123", "([a-z]+)(\d+)", 2) renvoie "123" (deuxième groupe de capture)

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

  • regexExtract("user@example.com", "([^@]+)@([^@]+)", 1) renvoie "user"

  • regexExtract("user@example.com", "([^@]+)@([^@]+)", 2) renvoie "example.com"

  • regexExtract("value 123 and value 456", "(\d+)", 0, 0) renvoie "123" (premier nombre)

  • regexExtract("value 123 and value 456", "(\d+)", 0, 1) renvoie "456" (deuxième nombre)

  • regexExtract("v1.0.0 et v2.0.0", "v(\d+)\.(\d+)\.(\d+)", 1, 1) renvoie "2" (version majeure de la deuxième occurrence)

  • regexExtract("test", "\d+") renvoie none (aucune correspondance)

  • regexExtract("abc", "([a-z])", 5) renvoie aucun (groupe hors limites)

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

  • L'expression régulière `@cs regexExtract("ABC123", "([a-z]+)", 1)` renvoie `none` (sensible à la casse, aucune correspondance).

  • le:regexExtract(Line, "error:\s+(\w+)", 1) extrait le type d'erreur des lignes de journal

  • fe:regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2" filtre les fichiers dont la version majeure est 2

normalizeUnicode(str[, form])

Normalise la chaîne Unicode. Le paramètre optionnel 'form' spécifie la forme de normalisation : "NFC" ou "C" (par défaut), "NFD" ou "D", "NFKC" ou "KC", "NFKD" ou "KD". On peut aussi utiliser les formes numériques : 1=NFC, 2=NFD, 5=NFKC, 6=NFKD. Si str est un tableau, le résultat est un tableau de chaînes normalisées. Exemple : normalizeUnicode(name, "NFC")

toLower(str)

Convertit tous les caractères de la chaîne en minuscules. Si str est un tableau, le résultat est un tableau de chaînes en minuscules. Exemple : toLower("Hello World") renvoie "hello world"

toUpper(str)

Convertit tous les caractères de la chaîne en majuscules. Si str est un tableau, le résultat est un tableau de chaînes en majuscules. Exemple : toUpper("Hello World") renvoie "HELLO WORLD"

toHalfWidth(str)

Convertit les caractères de pleine chasse (full-width) en caractères de demi-chasse (half-width). Principalement utilisé pour convertir les caractères alphanumériques et katakana de pleine chasse en demi-chasse. Si str est un tableau, le résultat est un tableau de chaînes converties.

toFullWidth(str)

Convertit les caractères de demi-chasse en caractères de pleine chasse. Principalement utilisé pour convertir les caractères alphanumériques et katakana de demi-chasse en pleine chasse. Si str est un tableau, le résultat est un tableau de chaînes converties.

toKatakana(str)

Convertit les caractères hiragana en katakana. Les caractères non-hiragana restent inchangés. Si str est un tableau, le résultat est un tableau de chaînes converties.

toHiragana(str)

Convertit les caractères katakana en hiragana. Les caractères non-katakana restent inchangés. Si str est un tableau, le résultat est un tableau de chaînes converties.

toSimplifiedChinese(str)

Convertit les caractères chinois traditionnels en caractères chinois simplifiés. Les caractères qui n'ont pas de forme simplifiée restent inchangés. Si str est un tableau, le résultat est un tableau de chaînes converties.

toTraditionalChinese(str)

Convertit les caractères chinois simplifiés en caractères chinois traditionnels. Les caractères qui n'ont pas de forme traditionnelle restent inchangés. Si str est un tableau, le résultat est un tableau de chaînes converties.

trim(str)

Supprime les espaces en début et en fin de chaîne (espace, tabulation, saut de ligne, retour chariot). Si str est un tableau, le résultat est un tableau de chaînes tronquées.

Exemples :

  • trim("hello ") renvoie "hello"

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

trimLeft(str)

Supprime les espaces de début (espace, tabulation, saut de ligne, retour chariot) de la chaîne. Les espaces de fin sont conservés. Si str est un tableau, le résultat est un tableau de chaînes tronquées à gauche.

Exemples :

  • trimLeft(" bonjour ") renvoie "bonjour "

trimRight(str)

Supprime les espaces de fin de chaîne (espace, tabulation, saut de ligne, retour chariot). Les espaces de début sont conservés. Si str est un tableau, le résultat est un tableau de chaînes tronquées à droite.

Exemples :

  • trimRight(" hello ") renvoie " hello"

1.3.5.2. Fonctions de contenu de fichier
lineCount(content)

Renvoie le nombre de lignes dans le contenu du fichier ou le tableau de contenu de fichier sous forme d'un Integer. Si content est un tableau, le résultat est un tableau d'entiers. Exemple : lineCount(Content)

sublines(content, start, count)

Extrait le nombre spécifié de lignes en commençant par l'index de ligne donné dans le contenu du fichier ou le tableau de contenu de fichier, et les renvoie sous la forme d'une seule chaîne concaténée. Si content est un tableau, le résultat est un tableau de chaînes.

1.3.5.3. Fonctions de conversion de type
toNumber(str), toInt(str), toDouble(str)

Convertit une chaîne de caractères en nombre. La fonction toNumber renvoie un entier ou un nombre à virgule flottante selon le format d'entrée; la fonction toInt renvoie uniquement des entiers; la fonction toDouble renvoie uniquement des nombres à virgule flottante. Les virgules dans l'entrée sont ignorées. En cas d'échec de l'analyse syntaxique, la fonction renvoie none. Exemple : le:toInt(Column("Count")) > 100

toDateTime(str)

Convertit une chaîne de caractères en une valeur d'horodatage. Prend en charge plusieurs formats de date et d'heure. Renvoie none si la chaîne ne peut pas être analysée. Exemple : toDateTime("2025-01-15") > today()

1.3.5.4. Fonctions de date/heure
now()

Renvoie la date et l'heure actuelles sous forme d'une valeur Timestamp.

today()

Renvoie la date du jour sous forme d'une valeur Timestamp représentant 00:00:00.000 au début de la journée.

startOfWeek(timestamp)

Renvoie le premier jour de la semaine, qui est toujours le dimanche quel que soit le paramètre régional.

startOfMonth(timestamp)

Renvoie le premier jour du mois.

startOfYear(timestamp)

Renvoie le premier jour de l'année.

toDateStr(timestamp)

Convertit l'horodatage donné en une chaîne de date au format yyyy-MM-dd. Si timestamp est un tableau d'horodatages, le résultat est un tableau de chaînes.

1.3.5.5. Fonctions mathématiques et de comparaison
abs(value)

Renvoie la valeur absolue de l'entier ou du tableau d'entiers. Si value est un tableau d'entiers, le résultat est un tableau d'entiers.

isWithin(value, min, max)

Renvoie true si value se situe dans la plage [min, max] (inclusif aux deux extrémités). Prend en charge les entiers, les nombres à virgule flottante, les horodatages et les chaînes (comparaison insensible à la casse). Si value est un tableau, le résultat est un tableau de booléens où chaque élément est vérifié individuellement.

Exemples :

  • isWithin(5, 1, 10) renvoie true

  • isWithin(Size, 1KB, 10MB) vérifie si la taille de l'un des fichiers est comprise entre 1 Ko et 10 Mo

  • isWithin(Date, today() - 7days, today()) vérifie si le fichier a été modifié au cours de la dernière semaine

  • allof(isWithin(Size, 1KB, 10MB)) vérifie si toutes les tailles de fichiers sont comprises entre 1 Ko et 10 Mo

inRange(value, min, max)

Renvoie true si value se situe dans la plage [min, max) (borne inférieure incluse, borne supérieure exclue). Prend en charge les entiers, les nombres à virgule flottante, les horodatages et les chaînes (comparaison insensible à la casse). Si value est un tableau, le résultat est un tableau de booléens où chaque élément est vérifié individuellement.

Exemples :

  • inRange(5, 1, 10) renvoie true

  • inRange(10, 1, 10) renvoie false

  • inRange(Size, 0, 1MB) vérifie si la taille de l'un des fichiers est inférieure à 1 Mo

  • anyof(inRange(Date, startOfMonth(today()), today())) vérifie si un fichier a été modifié ce mois-ci (aujourd'hui exclu)

1.3.5.6. Fonctions de chaînes de caractères
array(value1, value2, ...)

Crée un tableau à partir des valeurs données. Exemple : array(1, 2, 3)

at(array, index)

Renvoie l'élément à l'index spécifié (à partir de 0). Les indices négatifs sont numérotés à partir de la fin. Exemple : at(array(1, 2, 3), -1) renvoie 3

anyof(booleans)

Renvoie true si un élément quelconque du tableau booléen satisfait la condition.

allof(booleans)

Renvoie true si tous les éléments du tableau de booléens satisfont à la condition.

allequal(array)

Renvoie true si toutes les valeurs du tableau sont égales.

len(value)

Renvoie la longueur de la valeur sous forme d'un Integer.

Comportement :

  • Tableau : Renvoie le nombre d'éléments du tableau

  • Chaîne de caractères : Renvoie le nombre de caractères UTF-8

  • Aucun (monostate) : Renvoie 0

  • Autres valeurs scalaires (Entier, Réel, Booléen, Horodatage, etc.) : Renvoie 1

Exemples :

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

  • len("hello") - renvoie 5

  • len(123) - renvoie 1

  • len(Size) - renvoie le nombre de côtés (2 ou 3) dans une comparaison de dossiers

1.3.5.7. Fonctions conditionnelles
if(condition, trueValue, falseValue)

Renvoie trueValue si la condition est évaluée à vrai, sinon renvoie falseValue. Cette fonction effectue une évaluation en court-circuit (elle n'évalue que la branche qui sera renvoyée).

Exemples :

  • if(Size > 1MB, "large", "small") - renvoie "large" ou "small" selon la taille du fichier

  • if(Extension = "txt", "text file", "other file") - classifie les fichiers par extension

  • if(Exists, Size, 0) - renvoie la taille du fichier ou 0 si le fichier n'existe pas

ifEach(conditionArray, trueValue, falseValue)

Sélection conditionnelle par élément. Pour chaque élément de conditionArray, renvoie l'élément correspondant de trueValue si la condition est vraie, sinon renvoie l'élément correspondant de falseValue. Si trueValue ou falseValue est un scalaire, il est diffusé à tous les éléments.

Exemples :

  • ifEach(Size > 1MB, "large", "small") - renvoie un tableau d'étiquettes "large"/"small" pour chaque fichier

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

  • anyof(ifEach(Size > 100KB, Size < 10MB, false)) - vérifie si l'un des fichiers est compris entre 100 Ko et 10 Mo

choose(index, value0, value1, ...)

Sélectionne une valeur parmi les arguments en fonction de l'index. Si l'index est 0, renvoie value0 ; s'il est 1, renvoie value1, etc. Les indices négatifs sont ramenés à 0. Les indices au-delà de la dernière valeur renvoient la dernière valeur.

Exemples :

  • choose(0, "first", "second", "third") - renvoie "first"

  • choose(DiffCode % 3, "equal", "different", "unique") - associe des codes de diff à des étiquettes

  • choose(5, "a", "b", "c") - renvoie "c" (hors limites, renvoie la dernière valeur)

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

Sélection de valeurs par élément. Pour chaque index de indexArray, sélectionne la valeur correspondante dans les arguments restants. Si indexArray est un scalaire, se comporte comme choose.

Exemples :

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

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

  • chooseEach(array(2, 0, 1), "first", "second", "third") - renvoie array("third", "first", "second")

1.3.5.8. Fonctions logiques élément par élément
andEach(value1, value2), orEach(value1, value2), notEach(value)

Opérations logiques par élément. Ces fonctions opèrent sur des booléens, des tableaux de booléens ou une combinaison des deux :

  • andEach - Opération ET logique

  • orEach - Opération OU logique

  • notEach - Opération NON logique (argument unique)

Lorsque les arguments sont des scalaires, renvoie un résultat booléen scalaire. Lorsqu'un argument est un tableau et l'autre un scalaire, le scalaire est diffusé à tous les éléments. Lorsque les deux arguments sont des tableaux, effectue l'opération élément par élément.

Exemples :

  • andEach(Size > 1KB, Size < 1MB) - fichiers entre 1 Ko et 1 Mo

  • orEach(Extension = "txt", Extension = "log") - fichiers txt ou log

  • notEach(Exists) - fichiers qui n'existent pas

  • allof(andEach(Exists, Size > 0)) - tous les fichiers existent avec une taille non nulle

  • anyof(notEach(Size > 1MB)) - n'importe quel fichier de 1 Mo ou moins

1.3.5.9. Fonctions de diagnostic et d'enregistrement
logError(value1, value2, ...), logWarn(value1, value2, ...), logInfo(value1, value2, ...)

Envoie la représentation sous forme de chaîne concaténée de tous les arguments dans le journal (respectivement au niveau erreur, avertissement ou information), séparés par des espaces, et renvoie la valeur du dernier argument. Ces fonctions sont utiles pour déboguer les expressions de filtre.

Exemples (utilisant la valeur de retour) :

  • logInfo("File size:", Size) > 1MB - consigne la/les taille(s) de fichier et vérifie si elle est supérieure à 1 Mo

  • logWarn("Processing:", Name) like "*.tmp" - consigne le/les nom(s) de fichier et vérifie s'il s'agit d'un fichier temporaire

  • Size > 1KB and logInfo("Large file:", Name) contains "test" - ne consigne que si la condition de taille est vraie, puis vérifie le nom

1.3.6. Unités

Les tailles de fichiers prennent en charge ces suffixes :

Ko, Mo, Go, To

Les durées prennent en charge ces suffixes :

semaines, semaine, s, jours, jour, j, heures, heure, hr, h, minutes, minute, min, m, secondes, seconde, sec, s, millisecondes, milliseconde, msec, ms

1.3.7. Exemples

  • Size < 10KB - La taille de n'importe quel côté est inférieure à 10 Ko

  • LeftSize >= 10MB - Le fichier du côté gauche fait au moins 10 Mo

  • allof(Size < 1MB) - Tous les côtés font moins de 1 Mo

  • abs(LeftSize - RightSize) < 1KB - La différence de taille est faible

  • DateStr = "2025-07-20" - Le fichier a été modifié pour la dernière fois à cette date

  • Date >= today() - Modifié aujourd'hui ou plus tard

  • Date > d"2026-05-21 07:16:33" - Modifié après une date et une heure spécifiques

  • isWithin(Date, d"2026-01-01", d"2026-12-31 23:59:59") - Modifié au cours de l'année 2026

  • isWithin(Date, today() - 7days, today()) - Fichier modifié au cours de la dernière semaine

  • inRange(Size, 1KB, 10MB) - La taille du fichier est comprise entre 1 Ko (inclus) et 10 Mo (exclu)

  • allof(isWithin(Size, 100KB, 1MB)) - Toutes les tailles de fichiers sont comprises entre 100 Ko et 1 Mo

  • AttrStr contains "R" - Le fichier est en lecture seule

  • Name matches "file[0-9]\.txt" - Regex sur le nom du fichier

  • Content contains "Test" - Le contenu du fichier contient le mot-clé

  • sublines(Content, 0, 1) contains "XML" - La première ligne contient "XML"

  • strCount(Content, "TODO") > 5 - Le fichier contient plus de 5 commentaires TODO

  • regexCount(Content, "\bFIXME\b") > 0 - Le fichier contient au moins un marqueur FIXME

  • strFind(Name, "_test") != none - Fichiers contenant "_test" dans leur nom

  • strFind(Name, ".", 1) > 0 - Fichiers dont le nom contient plusieurs points (le deuxième point existe)

  • regexFind(Name, "\d{4}") < 5 - Fichiers où un nombre à 4 chiffres apparaît parmi les 5 premiers caractères

  • regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2" - Fichiers avec version majeure 2 (par exemple, "v2.16.48")

  • regexExtract(Name, "([^_]+)_([^_]+)\.txt", 2) like "test*" - Fichiers dont la deuxième partie du nom commence par "test"

  • le:regexExtract(Line, "(\d+)", 0, 1) - Extrait le deuxième nombre de chaque ligne (décalage=1)

  • (Extension = "log" and Size > 10MB) or (Date < today() - 7days) - Gros fichiers journaux ou fichiers de plus d'une semaine

  • AttrStr not contains "H" and Name like "*.tmp" - Fichiers temporaires non cachés

  • isWithin(Extension, "a", "m") and inRange(Size, 0, 1MB) - Fichiers avec extensions de 'a' à 'm' et taille inférieure à 1 Mo

  • toLower(Name) = "readme.txt" - Correspondance de nom de fichier insensible à la casse

  • toHalfWidth(Name) like "*.txt" - Correspondance après conversion pleine chasse en demi-chasse

  • trim(Name) = "readme.txt" - Correspond au nom de fichier après suppression des espaces en début et en fin de fichier

  • trimLeft(Column("Value")) = "123" - Correspond à la valeur de la colonne après suppression des espaces en début de colonne (mode tableau)

  • trimRight(Line) contient "end" - Vérifie si la ligne (sans espace final) contient "end"

  • EOL = 3 - Fichiers avec des fins de ligne CRLF (Windows)

  • EOLStr = "LF" - Fichiers avec des fins de ligne LF (Unix)

  • allof(EOL = 1) - Vérifie si tous les fichiers comparés utilisent des fins de ligne LF

  • leftprop("System.Title") != none - Le fichier de gauche possède une propriété title définie

  • prop("System.Author") = none - Aucune propriété d'auteur n'est définie

  • if(LeftExists, LeftSize, 0) == 0 - Vérifie si le fichier de gauche est manquant ou vide

  • Different - Afficher uniquement les fichiers/dossiers qui sont différents (filtre d'affichage uniquement)

  • Identical - Afficher uniquement les fichiers/dossiers qui sont identiques (filtre d'affichage uniquement)

  • allof(Binary) - Afficher uniquement les fichiers qui sont binaires de tous les côtés (filtre d'affichage uniquement)

  • DifferentLeftMiddle and not DifferentMiddleRight - Dans une comparaison à 3 voies, afficher les fichiers où seule la paire gauche-milieu diffère (filtre d'affichage uniquement)

2. Utilisation des filtres de fichiers

Les filtres de fichiers sont des fichiers texte portant l'extension flt. Ils vous permettent d'appliquer plusieurs règles de filtrage à une comparaison de dossiers. Contrairement aux masques de fichiers, les filtres de fichiers peuvent inclure ou exclure des correspondances.

WinMerge installe un certain nombre de filtres de fichiers prédéfinis. Si ces filtres ne fournissent pas le filtrage dont vous avez besoin, vous pouvez créer les vôtres. Pour faciliter cette tâche, WinMerge fournit également un fichier modèle nommé FileFilter.tmpl. Cette section décrit comment appliquer des filtres de fichiers aux comparaisons et documente la syntaxe des filtres de fichiers. Utilisation de la boîte de dialogue Filtres décrit comment ajouter, modifier et gérer les filtres.

2.1. Emplacements des filtres de fichiers

WinMerge détecte automatiquement les filtres de fichiers dans ces emplacements :

Sous-dossier Filters dans le dossier d'installation de WinMerge

C'est ici que sont installés les filtres de fichiers prédéfinis. Par exemple, C:\Program Files\WinMerge\Filters. Vous pouvez créer ou copier des fichiers de filtres à cet endroit pour les mettre à la disposition de tous les utilisateurs de votre système.

Avant de créer un nouveau filtre de fichiers, vérifiez si les filtres prédéfinis ne contiennent pas déjà ce dont vous avez besoin. Sinon, vous pourriez trouver des exemples de règles utiles dans les fichiers existants.

Dossier de filtres privé par défaut

L'emplacement de ce dossier est défini dans la page Système des options de WinMerge. Par défaut, il est spécifié comme un sous-dossier dans votre dossier de profil utilisateur (par exemple, Documents sous Windows 10). Les filtres créés ou copiés ici ne sont normalement visibles que par vous. Si vous créez de nouveaux filtres de fichiers, vous pouvez les copier ici pour les garder privés.

Avant de pouvoir appliquer des filtres de fichiers existant dans un autre dossier, vous devez d'abord les installer.

2.2. Appliquer des filtres de fichiers

Vous pouvez appliquer un filtre de fichier en utilisant l'une de ces méthodes :

  • Lorsque vous lancez une comparaison de dossiers à partir de la boîte de dialogue Sélectionner des fichiers ou des dossiers :

    1. Après avoir choisi les dossiers 1er et 2e, cliquez sur Sélectionner à côté du champ Filtre.

    2. Dans la boîte de dialogue Filtres, utilisez l'onglet Filtres de fichiers pour choisir un filtre et le charger dans le champ Filtre.

      Note

      Si un filtre de fichier est actuellement activé, le filtre sélectionné est déjà chargé dans le champ Filtre.

    3. Procédez à l'opération de comparaison. Le filtre présent dans le champ Filtre est appliqué au démarrage de l'opération.

  • Pour modifier le filtrage des fichiers après avoir déjà lancé une opération de comparaison de dossiers (par exemple, pour appliquer un filtre différent ou désactiver le filtrage) :

    1. Cliquez sur OutilsFiltres.

    2. Dans la boîte de dialogue Filtres, configurez votre nouveau réglage de filtre de fichier, puis cliquez sur OK.

    3. Le nouveau filtrage n'est pas appliqué automatiquement à la fermeture de la boîte de dialogue Filtres : appuyez sur F5 pour voir les nouveaux résultats dans la fenêtre de comparaison de dossiers.

  • Lorsque vous lancez une comparaison de dossiers depuis la ligne de commande WinMerge, utilisez le drapeau -f pour spécifier un filtre de fichier.

2.3. Syntaxe des filtres de fichiers

Cette section décrit la syntaxe des filtres de fichiers de WinMerge et fournit des directives pour les rédiger.

Le délimiteur de commentaire est ##. Après un délimiteur de commentaire, tous les caractères d'une ligne sont ignorés. WinMerge ignore la plupart des caractères d'espacement dans les règles. Cependant, un commentaire doit toujours être précédé d'un ou plusieurs caractères d'espacement (espace ou tabulation). Pour utiliser ## comme caractères dans une règle, omettez le préfixe d'espace.

Les deux premières lignes requises d'un filtre de fichier sont :

name

Le nom du filtre tel qu'il apparaît dans la boîte de dialogue Fichiers

def

Le type de filtrage à appliquer. Spécifiez l'une de ces valeurs :

include

Inclut tout, sauf les éléments correspondant à la règle spécifiée.

exclude

Exclut tout, sauf les éléments correspondant à la règle spécifiée.

Lorsque vous choisissez la méthode d'exclusion (exclude), vous devez également ajouter une règle d (répertoire) qui spécifie les sous-dossiers. C'est généralement une bonne idée de spécifier tous les sous-dossiers, comme ceci :

d: \\*$ ## Sous-dossiers

Tip

Ne confondez pas ces termes. Rappelez-vous que, dans les filtres de fichiers, une règle include ne spécifie pas ce qu'il faut inclure, elle spécifie ce qu'il ne faut pas inclure. De même, exclude ne spécifie pas ce qu'il faut exclure, elle spécifie ce qu'il ne faut pas exclure.

Ensuite, votre fichier doit contenir une ou plusieurs règles de filtrage. Vous pouvez ajouter autant de règles que vous le souhaitez. Il doit y avoir une règle par ligne, et chaque règle doit tenir sur une seule ligne (aucun saut de ligne n'est autorisé dans une règle). Une règle commence par un indicateur de type, suivi soit d'une expression régulière, soit d'une expression de filtre. Les indicateurs de type pris en charge sont :

f: regexp

Faire correspondre les noms de fichiers à l'aide d'expressions régulières

f!: regexp

Exclure les fichiers correspondant à la regex (Disponible depuis la 2.16.19)

d: regexp

Faire correspondre les noms de dossiers à l'aide d'une regex

d!: regexp

Exclure les dossiers correspondant à la regex (Disponible depuis la 2.16.19)

fe: expr

Expression de filtre pour les fichiers (ex: fe:Size < 1KB) (disponible depuis 2.16.49)

fe!: expr

Expression de filtre pour exclure des fichiers (disponible depuis 2.16.49)

de: expr

Expression de filtre pour les dossiers (disponible depuis 2.16.49)

de!: expr

Expression de filtre pour exclure des dossiers (disponible depuis 2.16.49)

e: expr

Expression de filtre appliquée aux fichiers et aux dossiers (par exemple : e:Name like "Common*.*") (Disponible depuis la version 2.16.56)

e!: expr

Expression de filtre permettant d'exclure à la fois les fichiers et les dossiers (Disponible depuis la version 2.16.56)

Parmi les nombreux caractères spéciaux de regex, les suivants sont particulièrement importants dans les règles de filtrage de fichiers :

^ (début de ligne)

Fréquemment requis pour que les règles fonctionnent correctement.

$ (fin de ligne)

Fréquemment requis pour que les règles fonctionnent correctement. Par exemple :

\.c$ ## ne correspond qu'aux noms de fichiers ayant l'extension c.
\.c  ## correspond à toute extension commençant par c, comme cpp et com.
\ (échappement)

Force les caractères spéciaux à correspondre à des caractères normaux. Par exemple, pour faire correspondre un nom de dossier, faites précéder le délimiteur barre oblique inversée du dossier d'une barre oblique inversée (\\). Pour faire correspondre le point dans un nom de fichier, spécifiez une barre oblique inversée suivie d'un point (\.).

Aucun caractère spécial ni caractère générique n'est utilisé pour faire correspondre les noms de fichiers. Pour faire correspondre tous les noms de fichiers d'un certain type, omettez simplement le nom du fichier.

Les règles sont insensibles à la casse. Par exemple, f: \.bat$ correspond à winmerge.bat et à compare.BAT.

Example 9. Exemples de règles de filtrage de fichiers

Quelques règles de filtrage de fichiers simples :

f: \.cpp$ ## Correspond aux fichiers *.cpp
f: \.h$ ## Correspond aux fichiers *.h
f: ^My ## Correspond aux fichiers My*.*
f: Dlg\. ## Correspond aux fichiers *Dlg.*
d: \\test$ ## Correspond aux dossiers test
d: ^\\Build$ ## Correspond aux dossiers Build
d: Temp$ ## Correspond aux dossiers *Temp (par exemple, FirstTemp)
d: Src ## Correspond aux dossiers *Src*

Quelques règles avec des expressions régulières plus complexes :

f: ^\.#.*$ ## fichiers .#nom_fichier.version
f: Dlg\.c(pp)?$ ## fichiers *Dlg.c et *Dlg.cpp
f: ^I.*\.h$ ## fichiers I*.h
f: Srv[1-9]\.def$ ## fichiers *Srv1.def à *Srv9.def
f: ^[h,k,m] ## fichiers h*.*, k*.*, et m*.*

3. Utilisation des filtres de lignes

Dans une comparaison de fichiers, vous pouvez utiliser des filtres de lignes pour ignorer des lignes individuelles. Par exemple, vous pourriez utiliser des filtres de lignes pour ignorer les commentaires ou certains types de code généré, comme les horodatages des systèmes de contrôle de version. Chaque filtre de ligne est une règle, et vous pouvez appliquer n'importe quel nombre de filtres de lignes à une comparaison de fichiers.

Pour apprendre à ajouter, modifier et gérer les filtres, voir Utilisation de la boîte de dialogue Filtres.

3.1. Application des filtres de lignes

Vous pouvez appliquer des filtres de lignes en utilisant l'une de ces méthodes :

  • Lorsque vous lancez une comparaison de fichiers à partir de la boîte de dialogue Sélectionner des fichiers ou des dossiers

    1. Après avoir choisi le 1er et le 2e fichiers, cliquez sur Sélectionner à côté du champ Filtre.

    2. Dans la boîte de dialogue Filtres, utilisez l'onglet Filtres de lignes pour activer les filtres que vous souhaitez utiliser (le cas échéant), ou pour voir quels filtres sont actuellement activés.

      Note

      Le champ Filtre n'indique pas quels filtres de lignes sont activés.

    3. Poursuivez l'opération de comparaison de fichiers. Les filtres de lignes activés sont appliqués au démarrage de l'opération.

  • Après avoir déjà lancé une opération de comparaison de fichiers (par exemple, pour appliquer des filtres différents ou désactiver le filtrage) :

    1. Cliquez sur OutilsFiltres.

    2. Ouvrez l'onglet Filtres de fichiers.

    3. Cochez les filtres de lignes individuels que vous souhaitez appliquer, et décochez ceux que vous ne souhaitez pas appliquer.

      Vous pouvez également ajouter, modifier et supprimer des filtres de la liste en utilisant les boutons Nouveau, Modifier et Supprimer.

    4. Pour activer le filtrage de lignes, cochez Activer les filtres de lignes. Pour le désactiver, décochez l'option.

    5. Cliquez sur OK pour fermer la boîte de dialogue Filtres de fichiers.

    6. Appuyez sur F5 pour appliquer vos modifications et actualiser la fenêtre de comparaison de fichiers.

3.2. Syntaxe des filtres de lignes

Un filtre de ligne est une règle qui est évaluée par rapport à chaque différence sur une seule ligne dans vos fichiers comparés, si les règles de filtrage de lignes sont activées. Lorsqu'une règle correspond à une différence sur une seule ligne, la différence est ignorée.

Les différences ignorées sont marquées dans la fenêtre de comparaison de fichiers avec la couleur Différence ignorée (telle que définie dans la page Couleurs des options de WinMerge). Cela vous permet de distinguer les différences ignorées des autres types. Cependant, vous ne pouvez pas sélectionner ni fusionner une différence ignorée.

La correspondance des filtres de lignes peut être décrite en deux points :

  • Lorsqu'une règle correspond à n'importe quelle partie de la ligne, la différence entière est ignorée. Par conséquent, vous ne pouvez pas filtrer uniquement une partie d'une ligne. Par exemple, supposons que deux fichiers présentent la différence suivante sur une seule ligne :

    Fichier1 : 

    # Jean Sibelius

    Fichier2 : 

    # Janne Sibelius

    Sans filtrage, la ligne est détectée comme une différence. Mais si nous appliquons une règle de filtrage de ligne avec l'expression ^#, les lignes sont signalées comme identiques, car l'expression ne spécifie que le premier caractère, qui correspond dans les deux fichiers.

  • Une règle ne s'applique à une différence de plusieurs lignes que si toutes les lignes correspondent. Par exemple, considérons cette différence de deux lignes :

    Fichier1 : 

    # Jean Sibelius
    # Pekka Himanen

    Fichier2 : 

    # Janne Sibelius
    Pekka Himanen

    La même règle ^# correspond à la première ligne, mais pas à la seconde. Par conséquent, la différence n'est pas ignorée.

Tip

C'est généralement une bonne pratique d'utiliser les marqueurs de début de ligne ( ^ ) et de fin de ligne ( $ ) pour contrôler vos motifs avec précision, car la règle est appliquée si n'importe quelle partie d'une ligne correspond à l'expression.

Example 10. Exemples de filtres de lignes

^MYTAG$

Filtre les lignes qui correspondent exactement à MYTAG

^::

Filtre les lignes commençant par ::

^/\*.*\*/$

Filtre les lignes commençant par /* et se terminant par */

^[1-5]00

Filtre les lignes commençant par les nombres 100, 200, 300, 400 et 500


Example 11. Règle de filtrage de ligne correspondant aux lignes d'ID CVS

Les lignes d'ID CVS ressemblent à ceci :

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

... et peuvent être filtrées avec cette règle :

^// \WId: .*\$

Example 12. Filtrer les commentaires de numéro de ligne dans les fichiers po

les commentaires de numéro de ligne po ressemblent à ceci :

#: src/filename.c:766

... et peuvent être filtrées avec cette règle :

^#

4. Utilisation du filtre de ligne d'affichage

Le filtre d'affichage des lignes détermine les lignes visibles dans la fenêtre de comparaison de fichiers. Les lignes ne correspondant pas au filtre sont masquées, mais le résultat de la comparaison reste inchangé.

4.1. Ouverture de la barre de filtre d'affichage

Utilisez l'une des méthodes suivantes pour ouvrir la barre de filtre d'affichage :

  • Cliquez sur AfficherAfficher la barre de filtre, ou appuyez sur Ctrl+Maj+L.

  • Dans la fenêtre Comparaison de fichiers, cliquez avec le bouton droit sur le texte sélectionné et choisissez Ajouter aux filtresAjouter aux filtres d'affichage. WinMerge construit automatiquement une expression La ligne contient "..." à partir du texte sélectionné et ouvre la barre de filtre.

Pour supprimer le filtre, effacez le champ de saisie et appuyez sur la touche Entrée. Pour masquer la barre de filtre tout en conservant le filtre actif, cliquez sur le bouton Fermer.

4.2. Saisie d'un filtre

La barre de filtre d'affichage accepte les entrées sous deux formes, selon que l'entrée commence ou non par le préfixe le: :

Chaîne de caractères simple (sans préfixe)

Les données saisies sans le préfixe le: sont traitées comme une chaîne littérale. WinMerge n'affiche que les lignes contenant cette chaîne. En interne, la saisie est équivalente à le:La ligne contient "entrée".

Exemple : la saisie de TODO affiche toutes les lignes contenant le texte TODO.

le: prefix (filtre d'expression)

Si l'entrée commence par le:, le reste est interprété comme une expression de filtre. La syntaxe complète de l'expression, décrite dans Syntaxe des expressions de filtre, est disponible.

Exemple : le:Différent et la ligne contient « ERROR »

Important

Le préfixe le: doit figurer au tout début de la chaîne de caractères. S'il apparaît ailleurs, la chaîne entière est traitée comme une simple chaîne de caractères.

Par exemple, Hello or le:Line contains "Hello" ne contient pas d'expression de filtre. L'ensemble de l'entrée est traité comme une recherche littérale du texte Hello or le:Line contains "Hello".

4.3. Syntaxe des expressions de filtre

Les expressions de filtre de ligne d'affichage utilisent le même moteur que les expressions de filtre de comparaison de dossiers (voir Syntaxe des expressions de filtre), avec les attributs et fonctions supplémentaires suivants qui opèrent sur les lignes individuelles.

4.3.1. Attributs de ligne

Les attributs marqués comme prenant en charge les préfixes spécifiques à un côté acceptent les préfixes Left, Middle et Right (p. ex. LeftLine, RightLineLength). Les attributs sans préfixe sont évalués sur tous les panneaux.

Line

Contenu textuel de la ligne courante. Prend en charge les préfixes spécifiques au côté. Exemple : La ligne contient « TODO »

LineLength

Longueur de la ligne courante en caractères. Prend en charge les préfixes spécifiques au côté. Exemple : LineLength > 120

LineNumber

Numéro de ligne réel dans le fichier (à partir de 1), sans compter les lignes fantômes. Prend en charge les préfixes spécifiques au côté. Exemple : LineNumber <= 50

ViewLineNumber

Afficher le numéro de ligne, y compris les lignes fantômes (numérotation à partir de 1). Attribut global (sans préfixe latéral). Exemple : ViewLineNumber <= 100

Different

Vrai si la ligne fait partie d'un bloc de différence. Attribut global. Exemple : Different

Identical

Vrai si la ligne est identique sur tous les panneaux. Attribut global.

Trivial

Vrai si la ligne ne diffère que par des espaces ou d'autres éléments ignorés. Attribut global. Exemple : Different or Trivial

Exists

Vrai si la ligne existe dans le volet (et non une ligne fantôme). Prend en charge les préfixes spécifiques au côté. Exemple : LeftExists and not RightExists

Missing

Vrai si la ligne est une ligne fantôme dans le volet. L'inverse de Exists. Prend en charge les préfixes spécifiques au côté.

Moved

Vrai si la ligne est détectée comme une ligne déplacée. Prend en charge les préfixes spécifiques au côté.

Bookmarked

Vrai si la ligne comporte un signet. Prend en charge les préfixes spécifiques au côté.

DifferentLeftMiddle, DifferentMiddleRight, DifferentLeftRight

Vrai si la paire de panneaux indiquée diffère sur cette ligne. Comparaisons à trois voies uniquement (sauf DifferentLeftRight qui fonctionne également en comparaison à deux voies). Attributs globaux. Exemple : DifferentLeftMiddle and not DifferentMiddleRight

EOL

Style de fin de ligne pour la ligne courante (valeur entière). Prend en charge les préfixes spécifiques à chaque côté. Valeur  : 0 = Aucun, 1 = LF, 2 = CR, 3 = CRLF. Exemple : le:EOL = 3 affiche uniquement les lignes se terminant par CRLF

EOLStr

Style de fin de ligne pour la ligne courante (sous forme de chaîne de caractères). Prend en charge les préfixes spécifiques à chaque côté. Valeurs : "None", "LF", "CR", "CRLF". Exemple : le:EOLStr = "LF" affiche uniquement les lignes se terminant par un saut de ligne (LF)

Column, ColumnCount (mode tableau uniquement)

Contenu des cellules et nombre de colonnes en mode CSV/tableau. Prise en charge des préfixes spécifiques au côté. Exemple : Column("Status") = "FAIL"

LineAt(lineNumber), LineOffsetAt(offset)

Texte de la ligne à un numéro de ligne absolu ou à un décalage relatif par rapport à la ligne courante. Prend en charge les fonctions de préfixe spécifiques au côté. Exemple : le:Different and RightLineOffsetAt(-1)` matches « ^// » `

Column(indexOrName), ColumnAt(line, indexOrName), ColumnOffsetAt(offset, indexOrName) (mode tableau uniquement)

Contenu de la cellule par index ou nom, à la ligne courante, absolue ou relative. Exemple : le:RightColumn("Category") != ColumnOffsetAt(-1, "Category")

4.3.2. Fonctions de ligne

Les expressions de filtre de ligne d'affichage peuvent également utiliser les fonctions décrites dans Fonctions.

matchContext(expr, linesBefore, linesAfter)

Vrai si la ligne actuelle se situe entre linesBefore lignes avant et linesAfter lignes après toute ligne correspondant à expr. Exemple : le:matchContext(Different, 3, 3)

matchNumber(expr)

Indice de la ligne courante (à partir de 1) parmi toutes les lignes correspondantes. Renvoie none si la ligne ne correspond à aucune correspondance. Exemple : le:matchNumber(Different) = 1 affiche uniquement la première ligne correspondante (la première ligne différente).

matchCount(expr)

Nombre total de lignes correspondant à expr dans l'ensemble du fichier. Exemple : le:matchNumber(Different) = matchCount(Different) affiche uniquement la dernière ligne correspondante (la dernière ligne de différence).

matchBlockNumber(expr)

Renvoie le numéro du bloc correspondant (à partir de 1) contenant la ligne courante. Renvoie none si la ligne courante ne se trouve dans aucun bloc correspondant. Exemple : le:matchBlockNumber(Different) = 1 affiche uniquement les lignes du premier bloc de différence.

matchBlockOffset(expr)

Renvoie le décalage (à partir de 1) de la ligne courante dans le bloc correspondant. Renvoie none si la ligne courante ne se trouve dans aucun bloc correspondant. Exemple : le:matchBlockOffset(Different) = 1 affiche uniquement la première ligne de chaque bloc de différence.

matchBlockSize(expr)

Renvoie la taille (nombre de lignes) du bloc correspondant contenant la ligne courante. Renvoie none si la ligne courante ne se trouve dans aucun bloc correspondant. Exemple : le:matchBlockSize(Different) > 5 affiche uniquement les lignes des blocs de différence de plus de 5 lignes.

matchBlockCount(expr)

Nombre total de blocs correspondants dans le fichier. Exemple : le:matchBlockNumber(Different) = matchBlockCount(Different) affiche uniquement les lignes du dernier bloc de différence.

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

Distance en lignes à la plage correspondante la plus proche (dans les deux sens, avant uniquement ou après uniquement). Exemple : le:matchDistance(Different) <= 5

matchInside(beginExpr, endExpr)

Vrai si la ligne actuelle se situe entre une ligne correspondant à beginExpr et la ligne suivante correspondant à endExpr (incluse). Exemple : le:matchInside(Line matches "^#ifdef", Line matches "^#endif")

moyenne(expr), moyenne(expr, condition)

Calcule la moyenne arithmétique des valeurs numériques obtenues en évaluant expr sur toutes les lignes du fichier. Si une condition est fournie, seules les lignes où condition est vrai sont prises en compte. Les résultats non numériques sont ignorés. Renvoie none si aucune valeur numérique n'est trouvée. Exemple : le:toInt(Column("Price")) > average(toInt(Column("Price"))) affiche les lignes où le prix est supérieur au prix moyen. Exemple avec condition : le:average(toInt(Column("Score")), Column("Status") = "PASS") calcule le score moyen des lignes dont le statut est « PASS ».

maximum(expr), maximum(expr, condition)

Renvoie la valeur maximale parmi tous les résultats obtenus en évaluant expr sur toutes les lignes du fichier. Si condition est fourni, seules les lignes où condition est vrai sont prises en compte. Fonctionne avec les valeurs numériques, les chaînes de caractères (comparaison alphabétique) et les horodatages. Renvoie none si aucune valeur n'est trouvée. Exemple : le:toInt(Column("Quantity")) = maximum(toInt(Column("Quantity"))) affiche les lignes avec la quantité la plus élevée.

minimum(expr), minimum(expr, condition)

Renvoie la valeur minimale parmi tous les résultats obtenus en évaluant expr sur toutes les lignes du fichier. Si condition est fourni, seules les lignes où condition est vrai sont prises en compte. Fonctionne avec les valeurs numériques, les chaînes de caractères (comparaison alphabétique) et les horodatages. Renvoie none si aucune valeur n'est trouvée. Exemple : le:Column("Status") = minimum(Column("Status")) affiche les lignes dont la valeur de statut est la première par ordre alphabétique.

sum(expr), sum(expr, condition)

Calcule la somme de toutes les valeurs numériques obtenues en évaluant expr pour chaque ligne du fichier. Si condition est fourni, seules les lignes où condition est vrai sont prises en compte dans le calcul. Les résultats non numériques sont ignorés. Renvoie none si aucune valeur numérique n'est trouvée. Exemple : le:toInt(Column("Quantity")) / sum(toInt(Column("Quantity"))) * 100 calcule le pourcentage de chaque ligne par rapport à la quantité totale. Exemple avec condition : le:sum(toInt(Column("Sales")), Column("Region") = "East") calcule le total des ventes pour la région « East ».

4.3.3. Exemples

Saisie Effet
TODO Affiche les lignes contenant le texte « TODO » (chaîne de caractères brute)
le:Different Affiche uniquement les lignes des blocs de différence
le:Different or Trivial Affiche toutes les différences, y compris les différences ignorées
le:matchContext(Different, 3, 3) Affiche des blocs de différences avec 3 lignes de contexte de chaque côté
le:matchNumber(Different) = 1 Affiche uniquement la première ligne de différence
le:matchBlockNumber(Different) <= 3 N'affiche que les lignes des 3 premiers blocs de différence
le:matchBlockOffset(Different) = 1 Affiche uniquement la première ligne de chaque bloc de différence
le:matchBlockSize(Different) > 10 Affiche uniquement les lignes des blocs de différence supérieurs à 10 lignes
le:Different and Line contains "ERROR" Affiche les lignes qui sont à la fois différentes et qui contiennent « ERREUR ».
le:strFind(Line, "TODO") < 10 Affiche les lignes où « TODO » apparaît dans les 10 premiers caractères
le:regexFind(Line, "\d{4}") != none Affiche les lignes contenant un nombre à 4 chiffres
le:matchContext(Bookmarked, 2, 2) Affiche les lignes mises en signet avec 2 lignes de contexte
le:LineNumber <= 50 Affiche uniquement les 50 premières lignes
le:EOL = 3 Affiche uniquement les lignes se terminant par CRLF (Windows)
le:EOLStr = "LF" Affiche uniquement les lignes se terminant par LF (Unix)
le:allof(EOL = 1) Affiche les lignes où tous les panneaux utilisent des fins de ligne LF
le:toInt(Column("Count")) > 100 Affiche les lignes où la valeur de la colonne « Nombre » dépasse 100 (mode tableau)

5. Utilisation du filtre de fichier/dossier d'affichage

Le filtre d'affichage des fichiers et dossiers dans la fenêtre de comparaison de dossiers fonctionne de la même manière que le filtre d'affichage des lignes dans la fenêtre de comparaison de fichiers, mais il s'applique aux fichiers et aux dossiers au lieu des lignes. Il détermine les éléments visibles sans affecter le résultat de la comparaison.

Pour ouvrir la barre de filtre d'affichage, cliquez sur AffichageBarre de filtre d'affichage, ou appuyez sur Ctrl+Maj+L.

La barre de filtre accepte la même syntaxe que le champ Filtre de la boîte de dialogue Sélectionner des fichiers ou des dossiers. Consultez Syntaxe et exemple de masques de fichiers et Syntaxe des expressions de filtre pour plus de détails.

Pour supprimer le filtre, effacez le champ de saisie et appuyez sur la touche Entrée. Pour masquer la barre de filtre tout en conservant le filtre actif, cliquez sur le bouton Fermer.

Exemples :

  • *.cpp;*.h - affiche les fichiers sources et d'en-tête C++

  • !.git\;!.vs\ - exclut les dossiers .git et .vs

  • for:Different - affiche uniquement les fichiers différents

  • de:Items > 10 - affiche les dossiers contenant plus de 10 éléments

  • a:Date > aujourd'hui() - 7 jours - affiche les éléments modifiés au cours de la dernière semaine

6. Utilisation des filtres de substitution

À déterminer

7. Utilisation de la boîte de dialogue Filtres

Cette section décrit la boîte de dialogue Filtres, qui fournit des fonctions pour créer et gérer les filtres de fichiers et les filtres de lignes.

Pour ouvrir la boîte de dialogue Filtres, utilisez l'une ou l'autre de ces méthodes :

  • Dans la boîte de dialogue Sélectionner des fichiers ou des dossiers, cliquez sur Sélectionner à droite du champ Filtre. Vous utilisez cette méthode lorsque vous souhaitez appliquer un filtre de fichier à une opération de comparaison de dossiers.

  • Cliquez sur OutilsFiltres. Cette méthode peut être utilisée à tout moment, sauf lorsque la boîte de dialogue Sélectionner des fichiers ou des dossiers est ouverte.

La boîte de dialogue Filtres possède un onglet pour chaque type de filtre WinMerge :

Filtres de fichiers

Choisissez cet onglet pour travailler avec les filtres de fichiers pour les opérations de comparaison de dossiers.

Filtres de lignes

Choisissez cet onglet pour travailler avec les filtres de lignes pour les opérations de comparaison de fichiers.

Filtres de substitution

Choisissez cet onglet pour travailler avec les filtres de substitution pour les opérations de comparaison de fichiers.

Afficher le filtre de ligne

Le filtre de ligne d'affichage n'est pas configurable via cette boîte de dialogue. Ouvrez-la via AffichageBarre de filtre d'affichage. Voir Utilisation du filtre de ligne d'affichage.

7.1. Utilisation de l'onglet Filtres de fichiers

La partie principale de cet onglet est une liste de filtres de fichiers disponibles pour les opérations de comparaison de dossiers. La liste comprend les filtres de fichiers partagés, privés et installés que WinMerge connaît, comme décrit dans Emplacements des filtres de fichiers.

7.1.1. Activation et désactivation des filtres de fichiers

Vous devez activer un filtre de fichier pour le rendre disponible dans une opération de comparaison de dossiers, ou désactiver un filtre actuel pour qu'il ne soit plus utilisé :

  1. Ouvrez la boîte de dialogue Filtres, si elle n'est pas déjà ouverte.

  2. Sélectionnez un filtre de fichier ou <Aucun> dans la liste.

  3. Cliquez sur OK pour fermer la boîte de dialogue Filtres.

Il existe plusieurs façons d'appliquer des filtres de fichiers après les avoir activés. Pour plus de détails, voir Appliquer des filtres de fichiers.

7.1.2. Configuration des filtres de fichiers

Utilisez ces boutons pour gérer votre liste de Filtres de fichiers et en créer de nouveaux :

Tester

Sélectionnez un filtre de fichier dans la liste et cliquez sur Tester pour voir rapidement comment le filtre fonctionne. Voir Test des règles de filtrage de fichiers pour plus de détails.

Installer

Permet de localiser un filtre de fichier et de l'ajouter à la liste des filtres. Les filtres qui ne se trouvent ni dans le dossier partagé ni dans le dossier privé par défaut ne sont pas détectés à moins que vous ne les installiez.

Nouveau

Crée une nouvelle copie d'un modèle de fichier dans le dossier de filtres partagés ou privés, et l'ouvre dans votre éditeur par défaut. Modifiez le modèle et ajoutez vos règles, comme décrit dans Créer un filtre de fichier.

Modifier

Sélectionnez un filtre de fichier dans la liste et cliquez sur Modifier pour ouvrir le fichier dans votre éditeur par défaut.

Supprimer

Sélectionnez un filtre de fichier dans la liste et cliquez sur Supprimer pour supprimer le fichier et le retirer de la liste. Oui, le fichier est réellement supprimé !

Vos modifications sont enregistrées lorsque vous cliquez sur OK pour fermer la boîte de dialogue Filtres. Les filtres de lignes sont stockés dans le registre Windows.

7.1.3. Créer un filtre de fichier

Si les filtres installés avec WinMerge ne fournissent pas le filtrage dont vous avez besoin, vous pouvez créer les vôtres :

  1. Cliquez sur OutilsFiltres. Ou, depuis la boîte de dialogue Sélectionner des fichiers ou des dossiers, cliquez sur Sélectionner à droite du champ Filtre.

  2. Dans l'onglet Filtres de fichiers de la boîte de dialogue Filtres, cliquez sur Nouveau.

  3. Dans la boîte de dialogue Filtre partagé ou privé, choisissez Filtre partagé ou Filtre privé (voir Emplacements des filtres de fichiers pour leurs usages) et cliquez sur OK.

    La boîte de dialogue Sélectionner un nom de fichier pour le nouveau filtre s'ouvre dans le dossier des fichiers partagés ou privés de votre système (si le dossier privé n'existe pas, WinMerge le crée).

  4. Dans la boîte de dialogue Sélectionner un nom de fichier pour le nouveau filtre, saisissez un nouveau nom de fichier et cliquez sur Enregistrer.

    Note

    Ne choisissez pas un nom de fichier existant : pour modifier un fichier existant, revenez à l'étape 2 et cliquez sur Modifier au lieu de Nouveau.

    WinMerge initialise le nouveau fichier avec le contenu du modèle FileFilter.tmpl et l'ouvre dans votre éditeur de texte par défaut.

  5. Suivez les instructions du modèle pour l'éditer, en mettant à jour le nom et la description et en ajoutant des règles de filtrage comme décrit dans Syntaxe des filtres de fichiers. Enregistrez le fichier dans votre éditeur de texte.

    Tip

    Si vous souhaitez tester rapidement une règle que vous définissez, essayez de cliquer sur Tester dans la boîte de dialogue Filtres. Voir Test des règles de filtrage de fichiers pour plus de détails.

  6. Si vous avez créé votre filtre dans l'un des dossiers Filters standards et que la boîte de dialogue Filtres n'affiche pas votre nouveau filtre, essayez de cliquer sur OK pour la fermer, puis sur OutilsFiltres pour la rouvrir. La liste Filtres de fichiers devrait maintenant inclure le nouveau filtre.

    Si vous avez enregistré le fichier dans un autre emplacement sur votre système, WinMerge ne pourra pas le détecter à moins que vous ne l'installiez. Pour rendre un filtre de fichier détectable n'importe où sur votre système :

    1. Cliquez sur Installer dans la boîte de dialogue Filtres.

    2. Dans la boîte de dialogue Localiser le fichier de filtre à installer, naviguez jusqu'au fichier flt sur votre système et cliquez sur Ouvrir. La liste des filtres de fichiers devrait maintenant inclure le filtre installé.

7.1.4. Test des règles de filtrage de fichiers

Utilisez la boîte de dialogue Tester le filtre pour tester rapidement un filtre par rapport à des données d'exemple, afin de vous aider à développer de nouvelles règles ou à comprendre le fonctionnement des règles existantes. Cela peut être plus facile que de lancer une opération de comparaison complète.

À partir de la boîte de dialogue Filtres :

  1. Dans l'onglet Filtres de fichiers, choisissez le filtre que vous souhaitez tester.

  2. Si vous souhaitez voir les règles que vous allez tester, cliquez sur Modifier maintenant pour ouvrir le fichier afin de pouvoir le consulter pendant les étapes suivantes.

  3. Cliquez sur Tester.

  4. Dans la boîte de dialogue Tester le filtre, choisissez le type de règle à tester :

    • Pour tester une règle de fichier f: dans votre filtre, décochez l'option Nom du dossier.

    • Pour tester une règle de dossier d:, cochez l'option Nom du dossier.

  5. Saisissez le texte à tester.

    Le texte doit être approprié au type de règle que vous testez. Par exemple, si vous avez coché l'option Nom du dossier, vous voudrez probablement saisir un nom de dossier, tel que \temp.

    La zone Résultat affiche votre saisie, suivie de son état : soit réussi (passed), soit échoué (failed).

7.2. Utilisation de l'onglet Filtres de lignes

Utilisez cet onglet pour configurer et activer des filtres de lignes pour les opérations de comparaison de fichiers. L'onglet présente une liste de règles. Chaque règle contient une seule expression régulière. Vous pouvez appliquer n'importe quelle combinaison de règles de la liste à une comparaison de fichiers.

7.2.1. Configuration des filtres de lignes

Sous la liste Expressions régulières se trouvent une zone d'édition et des boutons que vous pouvez utiliser pour mettre à jour la liste à tout moment en ajoutant, modifiant et supprimant des règles.

Pour ajouter une nouvelle règle :

  1. Cliquez sur Nouveau. Votre curseur d'édition est automatiquement activé dans la zone d'édition.

  2. Saisissez une expression dans la zone d'édition sous la liste Expressions régulières.

  3. Cliquez sur Enregistrer pour charger l'expression dans une nouvelle ligne de la liste.

Pour modifier une règle existante :

  1. Sélectionnez la ligne et cliquez sur Modifier.

  2. Modifiez l'expression dans la zone d'édition.

  3. Cliquez sur Enregistrer quand vous avez terminé.

Pour supprimer une règle existante, sélectionnez (cochez) la règle et cliquez sur Supprimer.

7.2.2. Activation et désactivation des filtres de lignes

  1. Dans la liste Expressions régulières, cochez uniquement les filtres que vous souhaitez appliquer, et décochez tous les filtres que vous ne souhaitez pas appliquer.

  2. Cochez ou décochez l'option Activer les filtres de lignes. Si vous activez le filtrage, toutes les règles actuellement cochées dans la liste Expressions régulières seront utilisées. Si le filtrage est désactivé, aucune règle n'est utilisée, même si elle est cochée.

  3. Cliquez sur OK pour fermer la boîte de dialogue Filtres et enregistrer vos réglages.

Il existe plusieurs façons d'appliquer des filtres de fichiers après les avoir activés. Pour plus de détails, voir Application des filtres de lignes.

7.3. Utilisation de l'onglet Filtres de substitution

À déterminer

7.3.1. Configuration des filtres de substitution

À déterminer

7.3.2. Activation et désactivation des filtres de substitution

À déterminer

8. Obtenir de l'aide sur les expressions régulières

Les expressions régulières peuvent être très complexes. Heureusement, la plupart des filtres de fichiers dans WinMerge utilisent des expressions d'extension simples, comme le montrent les exemples de cette rubrique. Les fichiers de filtres installés avec WinMerge comprennent de nombreux autres exemples utiles.

Enfin, il existe de nombreuses ressources sur le Web pour vous aider avec les regex, notamment ces sites :