[comment]: # attributes: notoc [comment]: # ({b219ec06-0458cee0}) # 1 Fonctions de macro #### Vue d'ensemble Les fonctions de macro offrent la possibilité de personnaliser les valeurs des [macros](/manual/config/macros) (par exemple, en les raccourcissant ou en extrayant des sous-chaînes spécifiques), ce qui les rend plus faciles à utiliser. La syntaxe d'une fonction de macro est la suivante : ```default {macro.func(params)} ``` où - **macro** - la macro à personnaliser ; - **func** - la fonction à appliquer (voir [fonctions prises en charge](#supported-functions)) ; - **params** - une liste de paramètres de fonction séparés par des virgules, qui doivent être **entre guillemets doubles** si : - ils commencent par un espace ou par des guillemets doubles ; - ils contiennent des parenthèses fermantes ou une virgule. Par exemple : ```default {{TIME}.fmttime(format,time_shift)} {{ITEM.VALUE}.regsub(pattern, output)} {{$USERMACRO}.regsub(pattern, output)} {{#LLDMACRO}.regsub(pattern, output)} ``` Les fonctions de macro sont prises en charge pour : - [Macros intégrées](/manual/appendix/macros/supported_by_location) - [Macros utilisateur](/manual/appendix/macros/supported_by_location#other-macro-types) - [Macros de découverte bas niveau](/manual/appendix/macros/supported_by_location#other-macro-types) - [Macros d'expression](/manual/appendix/macros/supported_by_location#other-macro-types) Les fonctions de macro peuvent être utilisées dans tous les emplacements prenant en charge les macros répertoriées. Cela s'applique sauf indication explicite selon laquelle seule une macro est attendue (par exemple, lors de la configuration des [macros d'hôte](/manual/config/hosts/host#configuration) ou des [filtres](/manual/discovery/low_level_discovery#filter) d'une règle de découverte bas niveau). Voir aussi : [problèmes connus](/manual/installation/known_issues#macro-functions). Une seule fonction par macro est prise en charge ; les chaînes de plusieurs fonctions de macro ne sont pas prises en charge. :::noteclassic Veuillez consulter les [exemples d'échappement](/manual/appendix/escaping) pour les cas où les fonctions de macro sont utilisées dans d'autres contextes (fonction, clé d'élément, autre macro, etc.). ::: [comment]: # ({/b219ec06-0458cee0}) [comment]: # ({49d5aaf8-f23fb953}) #### Fonctions prises en charge Les fonctions sont répertoriées sans information supplémentaire. Cliquez sur la fonction pour voir les détails complets. |Function|Description| |--|--------| |[btoa](#btoa)|Encodage de la valeur de macro au format Base64.| |[fmtnum](#fmtnum)|Formatage des nombres pour contrôler le nombre de chiffres affichés après la virgule décimale.| |[fmttime](#fmttime)|Formatage de l'heure.| |[htmldecode](#htmldecode)|Décodage de la valeur de macro à partir de l'encodage HTML.| |[htmlencode](#htmlencode)|Encodage de la valeur de macro en encodage HTML.| |[iregsub](#iregsub)|Extraction d'une sous-chaîne par correspondance avec une expression régulière (insensible à la casse).| |[lowercase](#lowercase)|Transformation des caractères de la valeur de macro en minuscules.| |[regrepl](#regrepl)|Remplacement d'un caractère ou d'une sous-chaîne dans la valeur de macro.| |[regsub](#regsub)|Extraction d'une sous-chaîne par correspondance avec une expression régulière (sensible à la casse).| |[tr](#tr)|Translittération des caractères de la valeur de macro.| |[uppercase](#uppercase)|Transformation des caractères de la valeur de macro en majuscules.| |[urldecode](#urldecode)|Décodage de la valeur de macro à partir de l'encodage URL.| |[urlencode](#urlencode)|Encodage de la valeur de macro en encodage URL.| [comment]: # ({/49d5aaf8-f23fb953}) [comment]: # ({91058888-c1632a9e}) #### Détails de la fonction Les paramètres de fonction facultatifs sont indiqués par < >. [comment]: # ({/91058888-c1632a9e}) [comment]: # ({d82603b4-26fb165d}) ##### btoa {#btoa} Encodage d'une valeur de macro en Base64. L'encodage Base64 est une méthode permettant de représenter des données binaires sous forme de texte, utile pour le stockage et la transmission sécurisée de contenu binaire via des protocoles textuels. Exemple : ```default {{ITEM.VALUE}.btoa()} - encodera en Base64 une valeur comme "zabbix" en "emFiYml4" ``` Cette fonction est prise en charge depuis Zabbix 7.0.4. [comment]: # ({/d82603b4-26fb165d}) [comment]: # ({31245134-4df3fd19}) ##### fmtnum(digits) {#fmtnum} Formatage des nombres pour contrôler le nombre de chiffres affichés après la virgule. Paramètres : - **digits** - le nombre de chiffres après la virgule. Plage valide : 0-20. Aucun zéro final ne sera produit. Exemples : ```default {{ITEM.VALUE}.fmtnum(2)} - retournera "24.35" à partir d'une valeur reçue de "24.3483523" {{ITEM.VALUE}.fmtnum(0)} - retournera "24" à partir d'une valeur reçue de "24.3483523" ``` [comment]: # ({/31245134-4df3fd19}) [comment]: # ({1bcbff41-3caa4dc7}) ##### fmttime(format,) {#fmttime} Formatage de l'heure.
Notez que cette fonction peut être utilisée avec des macros qui se résolvent en une valeur dans l'un des formats horaires suivants : - `hh:mm:ss` - `yyyy-mm-ddThh:mm:ss[tz]` (norme ISO8601) - horodatage UNIX Paramètres : - **format** - chaîne de format obligatoire, compatible avec le formatage de la fonction `strftime` ;
- **time\_shift** (facultatif) - décalage temporel appliqué à l'heure avant le formatage ; doit commencer par `-` ou `+`, où :
- `N` - le nombre d'unités de temps à ajouter ou à soustraire ; - `time_unit` - h (heure), d (jour), w (semaine), M (mois) ou y (année). Commentaires : - Le paramètre `time_shift` prend en charge les opérations temporelles en plusieurs étapes et peut inclure `/` pour un décalage vers le début de l'unité de temps (`/d` - minuit, `/w` - 1er jour de la semaine (lundi), `/M` - 1er jour du mois, etc.). Exemples : `-1w` - exactement 7 jours en arrière ; `-1w/w` - lundi de la semaine précédente ; `-1w/w+1d` - mardi de la semaine précédente. - Les opérations temporelles sont calculées de gauche à droite sans priorités. Par exemple, `-1M/d+1h/w` sera interprété comme `((-1M/d)+1h)/w`. Exemples : ```default {{TIMESTAMP}.fmttime(%B)} - renverra "October" à partir d'une valeur reçue de "1633098961" {{TIMESTAMP}.fmttime(%d %B,-1M/M)} - renverra "1 September" à partir d'une valeur reçue de "1633098961" ``` [comment]: # ({/1bcbff41-3caa4dc7}) [comment]: # ({26e2caaa-6f65f316}) ##### htmldecode {#htmldecode} Décodage d'une valeur de macro à partir de l'encodage HTML. Cette fonction est prise en charge depuis Zabbix 7.0.4. Les caractères suivants sont pris en charge : |Value|Decoded value| |----|------| |`&`|`&`| |`<`|`<`| |`>`|`>`| |`"`|`"`| |`'`|`'`| |`'`|`'`| Exemple : ```default {{ITEM.VALUE}.htmldecode()} - décodera en HTML une valeur comme "<" en "<" ``` [comment]: # ({/26e2caaa-6f65f316}) [comment]: # ({f282eb66-c4adc457}) ##### htmlencode {#htmlencode} Encodage d'une valeur de macro en encodage HTML. Cette fonction est prise en charge depuis Zabbix 7.0.4. Les caractères suivants sont pris en charge : |Value|Encoded value| |----|------| |`&`|`&`| |`<`|`<`| |`>`|`>`| |`"`|`"`| |`'`|`'`| Exemple : ```default {{ITEM.VALUE}.htmlencode()} - encodera en HTML un caractère comme "<" en "<" ``` [comment]: # ({/f282eb66-c4adc457}) [comment]: # ({edaa6df7-e78b5abd}) ##### iregsub(pattern,output) {#iregsub} Extraction d’une sous-chaîne par correspondance avec une expression régulière (insensible à la casse). Paramètres : - **pattern** - l’expression régulière à faire correspondre ; - **output** - les options de sortie. Les espaces réservés **\\1 - \\9** sont pris en charge pour les groupes de capture. **\\0** renvoie le texte correspondant. Commentaires : - S’il n’y a aucune correspondance pour l’expression régulière, la fonction renvoie une chaîne vide. - Si le modèle de la fonction est une expression régulière incorrecte, alors la macro est évaluée à 'UNKNOWN' (sauf pour les macros de découverte de bas niveau, auquel cas la fonction sera ignorée et la macro restera non résolue). - Les références à des groupes de capture inexistants dans la chaîne de remplacement sont remplacées par une chaîne vide. Exemple : ```default {{ITEM.VALUE}.iregsub("fail|error|fault|problem","ERROR")} - sera résolu en "ERROR" si les sous-chaînes "fail", "error", "fault" ou "problem" sont reçues (sans tenir compte de la casse) ; renverra une chaîne vide s’il n’y a aucune correspondance ``` [comment]: # ({/edaa6df7-e78b5abd}) [comment]: # ({67e9a7db-9922adb7}) ##### minuscules {#lowercase} Transformation de tous les caractères de la valeur de la macro en minuscules. Fonctionne avec les jeux de caractères à un octet (comme ASCII) et ne prend pas en charge UTF-8. Cette fonction est prise en charge depuis Zabbix 7.0.4. Exemple : ```default {{ITEM.VALUE}.lowercase()} - transformera une valeur comme "Zabbix SERVER" en "zabbix server" (minuscules) ``` [comment]: # ({/67e9a7db-9922adb7}) [comment]: # ({40208dc1-031347c2}) ##### regrepl(pattern,replacement,,,...) {#regrepl} Remplacement d'un caractère ou d'une sous-chaîne dans la valeur d'une macro.
Notez que cette fonction n'est prise en charge qu'avec la bibliothèque **libpcre2**. Si le serveur/proxy Zabbix a été compilé avec `libpcre`, cette fonction renverra UNKNOWN. Cette fonction est prise en charge depuis Zabbix 7.0.4. Paramètres : - **pattern** - l'expression régulière à faire correspondre ; - **replacement** - la chaîne de remplacement. Les espaces réservés **\\1 - \\9** sont pris en charge dans les chaînes de remplacement pour capturer des groupes. Commentaires : - Les motifs et les remplacements sont traités séquentiellement, chaque paire suivante étant appliquée conformément au résultat du remplacement précédent ; - Les références à des groupes de capture inexistants dans la chaîne de remplacement sont remplacées par une chaîne vide. Exemples : ```default {{ITEM.VALUE}.regrepl("oldParam", "newParam")} - remplacera "oldParam" par "newParam" {{ITEM.VALUE}.regrepl("([^a-z])","\\\1")} - tous les caractères non alphabétiques seront échappés avec une barre oblique inverse {$THRESHOLD:"{{#FSNAME}.regrepl(\"\\$\",\"\")}"} - supprimera une barre oblique inverse finale (par exemple, pour remplacer "C:\" par "C:") {{ITEM.VALUE}.regrepl("_v1\.0", "_v2.0", "\(final\)", "")} - remplacera plusieurs parties dans la valeur de l'élément ``` [comment]: # ({/40208dc1-031347c2}) [comment]: # ({825c2e80-a8dcf3b5}) ##### regsub(pattern,output) {#regsub} Extraction de sous-chaîne par correspondance avec une expression régulière (sensible à la casse). Paramètres : - **pattern** - l’expression régulière à faire correspondre ; - **output** - les options de sortie. Les espaces réservés **\\1 - \\9** sont pris en charge pour les groupes de capture. **\\0** renvoie le texte correspondant. Commentaires : - S’il n’y a aucune correspondance pour l’expression régulière, la fonction renvoie une chaîne vide. - Si le modèle de la fonction est une expression régulière incorrecte, alors la macro est évaluée à 'UNKNOWN' (sauf pour les macros de découverte de bas niveau, auquel cas la fonction sera ignorée et la macro restera non résolue). - Les références à des groupes de capture inexistants dans la chaîne de remplacement sont remplacées par une chaîne vide. Exemples : ```default {{ITEM.VALUE}.regsub("^([0-9]+)", Problem ID: \1)} - sera résolu en "Problem ID: 123" si une valeur telle que "123 Log line" est reçue {{ITEM.VALUE}.regsub("fail|error|fault|problem","ERROR")} - sera résolu en "ERROR" si les sous-chaînes "fail", "error", "fault" ou "problem" sont reçues (sensible à la casse) ; renverra une chaîne vide s’il n’y a aucune correspondance ``` Voir [plus d’exemples](#additional-examples). [comment]: # ({/825c2e80-a8dcf3b5}) [comment]: # ({f0be3d81-e91a391f}) ##### tr(characters,replacement) {#tr} Translittération des caractères de la valeur de macro. Cette fonction est prise en charge depuis Zabbix 7.0.4. - **characters** - l'ensemble des caractères à remplacer ; - **replacement** - l'ensemble des caractères de remplacement correspondants par position. Exemples : ```default {{ITEM.VALUE}.tr(abc, xyz)} - remplacera toutes les occurrences de "a" par "x", "b" par "y", "c" par "z" {{ITEM.VALUE}.tr(abc, xyzq)} - remplacera toutes les occurrences de "a" par "x", "b" par "y", "c" par "z" ("q" est ignoré) {{ITEM.VALUE}.tr(abcde, xyz)} - remplacera toutes les occurrences de "a" par "x", "b" par "y", "c" par "z", "d" par "z", "e" par "z" (c.-à-d. xyzzz) {{ITEM.VALUE}.tr("\\\'", "\/\"")} - remplacera toutes les occurrences de la barre oblique inverse par une barre oblique, et les apostrophes par des guillemets doubles {{ITEM.VALUE}.tr(A-Z,a-z)} - convertira toutes les lettres en minuscules {{ITEM.VALUE}.tr(0-9a-z,*)} - remplacera tous les chiffres et les lettres minuscules par "*" {{ITEM.VALUE}.tr(0-9,ab)} - remplacera toutes les occurrences de 0 par "a", et toutes les occurrences de 1, 2, 3, 4, 5, 6, 7, 8 et 9 par "b" {{ITEM.VALUE}.tr(0-9abcA-L,*)} - remplacera tous les chiffres, les caractères "abc" et la plage A-L par "*" {{ITEM.VALUE}.tr("\n","*")} - remplacera les occurrences de fin de ligne par * {{ITEM.VALUE}.tr("e", "\n")} - remplacera tous les "e" par une fin de ligne ``` Pour inclure des caractères littéraux : ```default backslash - doit être échappé comme \\ single quote - doit être échappé comme \' double quote - doit être échappé comme \" ``` Séquences d'échappement prises en charge avec la barre oblique inverse : ```default \\\\ => \\ - double barre oblique inverse vers une seule barre oblique inverse \\a => \a - alerte \\b => \b - retour arrière \\f => \f - saut de page \\n => \n - nouvelle ligne \\r => \r - retour chariot \\t => \t - tabulation horizontale \\v => \v - tabulation verticale ``` [comment]: # ({/f0be3d81-e91a391f}) [comment]: # ({ec9dd6cc-d8a53517}) ##### majuscules {#uppercase} Transformation de tous les caractères de la valeur de la macro en majuscules. Fonctionne avec les jeux de caractères à un octet (comme ASCII) et ne prend pas en charge UTF-8. Cette fonction est prise en charge depuis Zabbix 7.0.4. Exemple : ```default {{ITEM.VALUE}.uppercase()} - transformera une valeur comme "Zabbix Server" en "ZABBIX SERVER" (majuscules) ``` [comment]: # ({/ec9dd6cc-d8a53517}) [comment]: # ({98faa99f-4fb82e83}) ##### urldecode {#urldecode} Décodage d'une valeur de macro à partir de l'encodage URL. Cette fonction est prise en charge depuis Zabbix 7.0.4. Exemple : ```default {{ITEM.VALUE}.urldecode()} - décodera une valeur comme "%2F" en "/" ``` [comment]: # ({/98faa99f-4fb82e83}) [comment]: # ({8b7a9c23-8dec62fd}) ##### urlencode {#urlencode} Encodage d'une valeur de macro au format URL. Cette fonction est prise en charge depuis Zabbix 7.0.4. Exemple : ```default {{ITEM.VALUE}.urlencode()} - encodera un caractère comme "/" en "%2F" au format URL ``` [comment]: # ({/8b7a9c23-8dec62fd}) [comment]: # ({a95b22c2-b6fdaa9a}) #### Exemples supplémentaires Le tableau ci-dessous montre d'autres exemples d'utilisation des fonctions de macro. :::noteinfo `{#IFALIAS}` est une [macro LLD](/manual/config/macros/lld_macros) et n'est définie que dans les contextes de découverte de bas niveau (règles de découverte, prototypes et éléments/déclencheurs créés à partir d'eux). Son utilisation en dehors de la LLD laissera le jeton non développé. ::: |Macro function|Received value|Output| |-------------|----|-------------| |`{{ITEM.VALUE}.regsub(^[0-9]+, Problem)}`|`123Log line`|`Problem`| |`{{ITEM.VALUE}.regsub("^([0-9]+)", "Problem")}`|`123 Log line`|`Problem`| |`{{ITEM.VALUE}.regsub(".*", "Problem ID: \1")}`|`Log line`|`Problem ID: `| |`{{ITEM.VALUE}.regsub("^(\w+).*?([0-9]+)", " Problem ID: \1_\2 ")}`|`MySQL crashed errno 123`|` Problem ID: MySQL_123 `| |`{{ITEM.VALUE}.regsub("([1-9]+", "Problem ID: \1")}`|`123 Log line`|`*UNKNOWN*` (expression régulière invalide)| |`{{#IFALIAS}.regsub("(.*)_([0-9]+)", \1)}`|`customername_1`|`customername`| |`{{#IFALIAS}.regsub("(.*)_([0-9]+)", \2)}`|`customername_1`|`1`| |`{{#IFALIAS}.regsub("(.*)_([0-9]+", \1)}`|`customername_1`|`{{#IFALIAS}.regsub("(.*)_([0-9]+", \1)}` (expression régulière invalide)| |`{$MACRO:"{{#IFALIAS}.regsub(\"(.*)_([0-9]+)\", \1)}"}`|`customername_1`|`{$MACRO:"customername"}`| |`{$MACRO:"{{#IFALIAS}.regsub(\"(.*)_([0-9]+)\", \2)}"}`|`customername_1`|`{$MACRO:"1"}`| |`{$MACRO:"{{#IFALIAS}.regsub(\"(.*)_([0-9]+\", \1)}"}`|`customername_1`|`{$MACRO:"{{#IFALIAS}.regsub(\"(.*)_([0-9]+\", \1)}"}` (expression régulière invalide)| |`"{$MACRO:"\{{#IFALIAS}.regsub("(.*)_([0-9]+)", \1)}\"}"`|`customername_1`|`"{$MACRO:"\customername\"}"`| |`"{$MACRO:"\{{#IFALIAS}.regsub("(.*)_([0-9]+)", \2)}\"}"`|`customername_1`|`"{$MACRO:"\1\"}"`| |`"{$MACRO:\"{{#IFALIAS}.regsub(\\"(.*)_([0-9]+\\", \1)}\"}"`|`customername_1`|`"{$MACRO:\"{{#IFALIAS}.regsub(\\"(.*)_([0-9]+\\", \1)}\"}"` (expression régulière invalide)| ##### Voir les valeurs complètes des éléments Les longues valeurs des macros résolues {ITEM.VALUE} et {ITEM.LASTVALUE} pour les éléments de type texte/journal sont tronquées à 20 caractères dans certains emplacements de l'interface. Pour voir les valeurs complètes de ces macros, vous pouvez utiliser des fonctions de macro, par exemple : ```default {{ITEM.VALUE}.regsub("(.*)", \1)} {{ITEM.LASTVALUE}.regsub("(.*)", \1)} ``` Voir aussi : {ITEM.VALUE} et {ITEM.LASTVALUE} [détails des macros](/manual/appendix/macros/supported_by_location). [comment]: # ({/a95b22c2-b6fdaa9a})