[comment]: # attributes: notoc [comment]: # ({b219ec06-0458cee0}) # 1 Funzioni macro #### Panoramica Le funzioni macro offrono la possibilità di personalizzare i valori delle [macro](/manual/config/macros) (ad esempio, accorciando o estraendo sottostringhe specifiche), rendendoli più facili da usare. La sintassi di una funzione macro è: ```default {macro.func(params)} ``` dove - **macro** - la macro da personalizzare; - **func** - la funzione da applicare (vedi [funzioni supportate](#supported-functions)); - **params** - un elenco di parametri della funzione separati da virgole, che devono essere racchiusi tra **doppi apici** se: - iniziano con uno spazio o con doppi apici; - contengono parentesi di chiusura o una virgola. Ad esempio: ```default {{TIME}.fmttime(format,time_shift)} {{ITEM.VALUE}.regsub(pattern, output)} {{$USERMACRO}.regsub(pattern, output)} {{#LLDMACRO}.regsub(pattern, output)} ``` Le funzioni macro sono supportate per: - [Macro integrate](/manual/appendix/macros/supported_by_location) - [User macro](/manual/appendix/macros/supported_by_location#other-macro-types) - [Low-level discovery macro](/manual/appendix/macros/supported_by_location#other-macro-types) - [Expression macro](/manual/appendix/macros/supported_by_location#other-macro-types) Le funzioni macro possono essere utilizzate in tutte le posizioni che supportano le macro elencate. Ciò si applica salvo che sia esplicitamente indicato che è attesa solo una macro (ad esempio, durante la configurazione delle [host macro](/manual/config/hosts/host#configuration) o dei [filtri](/manual/discovery/low_level_discovery#filter) delle regole di low-level discovery). Vedi anche: [problemi noti](/manual/installation/known_issues#macro-functions). È supportata una sola funzione per macro; non sono supportate catene di più funzioni macro. :::noteclassic Consultare gli [esempi di escaping](/manual/appendix/escaping) per i casi in cui le funzioni macro vengono usate all'interno di altri contesti (funzione, item key, un'altra macro, ecc). ::: [comment]: # ({/b219ec06-0458cee0}) [comment]: # ({49d5aaf8-f23fb953}) #### Funzioni supportate Le funzioni sono elencate senza informazioni aggiuntive. Fai clic sulla funzione per visualizzare i dettagli completi. |Function|Description| |--|--------| |[btoa](#btoa)|Codifica del valore della macro in formato Base64.| |[fmtnum](#fmtnum)|Formattazione numerica per controllare il numero di cifre visualizzate dopo la virgola decimale.| |[fmttime](#fmttime)|Formattazione dell'ora.| |[htmldecode](#htmldecode)|Decodifica del valore della macro dalla codifica HTML.| |[htmlencode](#htmlencode)|Codifica del valore della macro in codifica HTML.| |[iregsub](#iregsub)|Estrazione di una sottostringa tramite corrispondenza con un'espressione regolare (senza distinzione tra maiuscole e minuscole).| |[lowercase](#lowercase)|Trasformazione dei caratteri del valore della macro in minuscolo.| |[regrepl](#regrepl)|Sostituzione di un carattere/sottostringa nel valore della macro.| |[regsub](#regsub)|Estrazione di una sottostringa tramite corrispondenza con un'espressione regolare (con distinzione tra maiuscole e minuscole).| |[tr](#tr)|Traslitterazione dei caratteri del valore della macro.| |[uppercase](#uppercase)|Trasformazione dei caratteri del valore della macro in maiuscolo.| |[urldecode](#urldecode)|Decodifica del valore della macro dalla codifica URL.| |[urlencode](#urlencode)|Codifica del valore della macro in codifica URL.| [comment]: # ({/49d5aaf8-f23fb953}) [comment]: # ({91058888-c1632a9e}) #### Dettagli della funzione I parametri opzionali della funzione sono indicati da < >. [comment]: # ({/91058888-c1632a9e}) [comment]: # ({d82603b4-26fb165d}) ##### btoa {#btoa} Codifica un valore macro in Base64. La codifica Base64 è un metodo per rappresentare dati binari come testo, utile per l'archiviazione e la trasmissione sicura di contenuti binari su protocolli basati su testo. Esempio: ```default {{ITEM.VALUE}.btoa()} - codificherà in Base64 un valore come "zabbix" in "emFiYml4" ``` Questa funzione è supportata a partire da Zabbix 7.0.4. [comment]: # ({/d82603b4-26fb165d}) [comment]: # ({31245134-4df3fd19}) ##### fmtnum(digits) {#fmtnum} Formattazione dei numeri per controllare il numero di cifre stampate dopo il separatore decimale. Parametri: - **digits** - il numero di cifre dopo il separatore decimale. Intervallo valido: 0-20. Non verranno prodotti zeri finali. Esempi: ```default {{ITEM.VALUE}.fmtnum(2)} - restituirà "24.35" da un valore ricevuto di "24.3483523" {{ITEM.VALUE}.fmtnum(0)} - restituirà "24" da un valore ricevuto di "24.3483523" ``` [comment]: # ({/31245134-4df3fd19}) [comment]: # ({1bcbff41-3caa4dc7}) ##### fmttime(format,) {#fmttime} Formattazione dell'ora.
Si noti che questa funzione può essere usata con macro che risolvono in un valore in uno dei seguenti formati di ora: - `hh:mm:ss` - `yyyy-mm-ddThh:mm:ss[tz]` (standard ISO8601) - timestamp UNIX Parametri: - **format** - stringa di formato obbligatoria, compatibile con la formattazione della funzione `strftime`;
- **time\_shift** (opzionale) - lo spostamento temporale applicato all'ora prima della formattazione; deve iniziare con `-` o `+`, dove:
- `N` - il numero di unità di tempo da aggiungere o sottrarre; - `time_unit` - h (ora), d (giorno), w (settimana), M (mese) o y (anno). Commenti: - Il parametro `time_shift` supporta operazioni temporali multistep e può includere `/` per spostare all'inizio dell'unità di tempo (`/d` - mezzanotte, `/w` - primo giorno della settimana (lunedì), `/M` - primo giorno del mese, ecc.). Esempi: `-1w` - esattamente 7 giorni indietro; `-1w/w` - lunedì della settimana precedente; `-1w/w+1d` - martedì della settimana precedente. - Le operazioni temporali vengono calcolate da sinistra a destra senza priorità. Per esempio, `-1M/d+1h/w` verrà interpretato come `((-1M/d)+1h)/w`. Esempi: ```default {{TIMESTAMP}.fmttime(%B)} - restituirà "October" da un valore ricevuto di "1633098961" {{TIMESTAMP}.fmttime(%d %B,-1M/M)} - restituirà "1 September" da un valore ricevuto di "1633098961" ``` [comment]: # ({/1bcbff41-3caa4dc7}) [comment]: # ({26e2caaa-6f65f316}) ##### htmldecode {#htmldecode} Decodifica di un valore macro dalla codifica HTML. Questa funzione è supportata da Zabbix 7.0.4. Sono supportati i seguenti caratteri: |Value|Decoded value| |----|------| |`&`|`&`| |`<`|`<`| |`>`|`>`| |`"`|`"`| |`'`|`'`| |`'`|`'`| Esempio: ```default {{ITEM.VALUE}.htmldecode()} - decodificherà in HTML un valore come "<" in "<" ``` [comment]: # ({/26e2caaa-6f65f316}) [comment]: # ({f282eb66-c4adc457}) ##### htmlencode {#htmlencode} Codifica un valore di macro in codifica HTML. Questa funzione è supportata da Zabbix 7.0.4. Sono supportati i seguenti caratteri: |Value|Encoded value| |----|------| |`&`|`&`| |`<`|`<`| |`>`|`>`| |`"`|`"`| |`'`|`'`| Esempio: ```default {{ITEM.VALUE}.htmlencode()} - codificherà in HTML un carattere come "<" in "<" ``` [comment]: # ({/f282eb66-c4adc457}) [comment]: # ({edaa6df7-e78b5abd}) ##### iregsub(pattern,output) {#iregsub} Estrazione di una sottostringa tramite corrispondenza con un'espressione regolare (senza distinzione tra maiuscole e minuscole). Parametri: - **pattern** - l'espressione regolare da confrontare; - **output** - le opzioni di output. I segnaposto **\\1 - \\9** sono supportati per i gruppi di cattura. **\\0** restituisce il testo corrispondente. Commenti: - Se non vi è alcuna corrispondenza per l'espressione regolare, la funzione restituisce una stringa vuota. - Se il pattern della funzione è un'espressione regolare non valida, allora la macro viene valutata come 'UNKNOWN' (tranne per le macro di low-level discovery, nel qual caso la funzione verrà ignorata e la macro rimarrà irrisolta). - I riferimenti a gruppi di cattura inesistenti nella stringa di sostituzione vengono sostituiti con una stringa vuota. Esempio: ```default {{ITEM.VALUE}.iregsub("fail|error|fault|problem","ERROR")} - verrà risolta in "ERROR" se vengono ricevute le sottostringhe "fail", "error", "fault" o "problem" (senza distinzione tra maiuscole e minuscole); restituirà una stringa vuota se non vi è alcuna corrispondenza ``` [comment]: # ({/edaa6df7-e78b5abd}) [comment]: # ({67e9a7db-9922adb7}) ##### minuscolo {#lowercase} Trasformazione di tutti i caratteri del valore della macro in minuscolo. Funziona con set di caratteri a byte singolo (come ASCII) e non supporta UTF-8. Questa funzione è supportata da Zabbix 7.0.4. Esempio: ```default {{ITEM.VALUE}.lowercase()} - trasformerà un valore come "Zabbix SERVER" in "zabbix server" (minuscolo) ``` [comment]: # ({/67e9a7db-9922adb7}) [comment]: # ({40208dc1-031347c2}) ##### regrepl(pattern,replacement,,,...) {#regrepl} Sostituzione di caratteri/sottostringhe nel valore della macro.
Nota che questa funzione è supportata solo con la libreria **libpcre2**. Se Zabbix server/proxy è stato compilato con `libpcre`, questa funzione restituirà UNKNOWN. Questa funzione è supportata a partire da Zabbix 7.0.4. Parametri: - **pattern** - l'espressione regolare da confrontare; - **replacement** - la stringa di sostituzione. I segnaposto **\\1 - \\9** sono supportati nelle stringhe di sostituzione per i gruppi di cattura. Commenti: - I pattern e le sostituzioni vengono elaborati in sequenza, con ogni coppia successiva applicata in base al risultato della sostituzione precedente; - I riferimenti a gruppi di cattura inesistenti nella stringa di sostituzione vengono sostituiti con una stringa vuota. Esempi: ```default {{ITEM.VALUE}.regrepl("oldParam", "newParam")} - sostituirà "oldParam" con "newParam" {{ITEM.VALUE}.regrepl("([^a-z])","\\\1")} - tutti i caratteri non alfabetici verranno escapati con una barra rovesciata {$THRESHOLD:"{{#FSNAME}.regrepl(\"\\$\",\"\")}"} - rimuoverà una barra rovesciata finale (ad esempio, per sostituire "C:\" con "C:") {{ITEM.VALUE}.regrepl("_v1\.0", "_v2.0", "\(final\)", "")} - sostituirà più parti nel valore dell'item ``` [comment]: # ({/40208dc1-031347c2}) [comment]: # ({825c2e80-a8dcf3b5}) ##### regsub(pattern,output) {#regsub} Estrazione di sottostringhe tramite una corrispondenza con espressione regolare (con distinzione tra maiuscole e minuscole). Parametri: - **pattern** - l'espressione regolare da confrontare; - **output** - le opzioni di output. I segnaposto **\\1 - \\9** sono supportati per i gruppi di cattura. **\\0** restituisce il testo corrispondente. Commenti: - Se non vi è alcuna corrispondenza per l'espressione regolare, la funzione restituisce una stringa vuota. - Se il pattern della funzione è un'espressione regolare non corretta, allora la macro viene valutata come 'UNKNOWN' (tranne per le macro di low-level discovery, nel qual caso la funzione verrà ignorata e la macro rimarrà irrisolta). - I riferimenti a gruppi di cattura inesistenti nella stringa di sostituzione vengono sostituiti con una stringa vuota. Esempi: ```default {{ITEM.VALUE}.regsub("^([0-9]+)", Problem ID: \1)} - verrà risolto in "Problem ID: 123" se viene ricevuto un valore come "123 Log line" {{ITEM.VALUE}.regsub("fail|error|fault|problem","ERROR")} - verrà risolto in "ERROR" se vengono ricevute le sottostringhe "fail", "error", "fault" o "problem" (con distinzione tra maiuscole e minuscole); restituirà una stringa vuota se non vi è alcuna corrispondenza ``` Vedi [altri esempi](#additional-examples). [comment]: # ({/825c2e80-a8dcf3b5}) [comment]: # ({f0be3d81-e91a391f}) ##### tr(characters,replacement) {#tr} Traslitterazione dei caratteri del valore della macro. Questa funzione è supportata da Zabbix 7.0.4. - **characters** - l'insieme dei caratteri da sostituire; - **replacement** - l'insieme dei caratteri di sostituzione corrispondenti per posizione. Esempi: ```default {{ITEM.VALUE}.tr(abc, xyz)} - sostituirà tutte le occorrenze di "a" con "x", "b" con "y", "c" con "z" {{ITEM.VALUE}.tr(abc, xyzq)} - sostituirà tutte le occorrenze di "a" con "x", "b" con "y", "c" con "z" ("q" viene ignorato) {{ITEM.VALUE}.tr(abcde, xyz)} - sostituirà tutte le occorrenze di "a" con "x", "b" con "y", "c" con "z", "d" con "z", "e" con "z" (cioè xyzzz) {{ITEM.VALUE}.tr("\\\'", "\/\"")} - sostituirà tutte le occorrenze di backslash con slash, e gli apici singoli con doppi apici {{ITEM.VALUE}.tr(A-Z,a-z)} - convertirà tutte le lettere in minuscolo {{ITEM.VALUE}.tr(0-9a-z,*)} - sostituirà tutti i numeri e le lettere minuscole con "*" {{ITEM.VALUE}.tr(0-9,ab)} - sostituirà tutte le occorrenze di 0 con "a" e tutte le occorrenze di 1, 2, 3, 4, 5, 6, 7, 8 e 9 con "b" {{ITEM.VALUE}.tr(0-9abcA-L,*)} - sostituirà tutti i numeri, i caratteri "abc" e l'intervallo A-L con "*" {{ITEM.VALUE}.tr("\n","*")} - sostituirà le occorrenze di fine riga con * {{ITEM.VALUE}.tr("e", "\n")} - sostituirà tutte le "e" con fine riga ``` Per includere caratteri letterali: ```default backslash - deve essere escapato come \\ apice singolo - deve essere escapato come \' doppio apice - deve essere escapato come \" ``` Sequenze di escape supportate con backslash: ```default \\\\ => \\ - doppio backslash in singolo backslash \\a => \a - avviso \\b => \b - backspace \\f => \f - form feed \\n => \n - nuova riga \\r => \r - ritorno \\t => \t - tabulazione orizzontale \\v => \v - tabulazione verticale ``` [comment]: # ({/f0be3d81-e91a391f}) [comment]: # ({ec9dd6cc-d8a53517}) ##### maiuscolo {#uppercase} Trasformazione di tutti i caratteri del valore della macro in maiuscolo. Funziona con set di caratteri a byte singolo (come ASCII) e non supporta UTF-8. Questa funzione è supportata da Zabbix 7.0.4. Esempio: ```default {{ITEM.VALUE}.uppercase()} - trasformerà un valore come "Zabbix Server" in "ZABBIX SERVER" (maiuscolo) ``` [comment]: # ({/ec9dd6cc-d8a53517}) [comment]: # ({98faa99f-4fb82e83}) ##### urldecode {#urldecode} Decodifica un valore macro dalla codifica URL. Questa funzione è supportata da Zabbix 7.0.4. Esempio: ```default {{ITEM.VALUE}.urldecode()} - decodificherà un valore come "%2F" in "/" ``` [comment]: # ({/98faa99f-4fb82e83}) [comment]: # ({8b7a9c23-8dec62fd}) ##### urlencode {#urlencode} Codifica un valore macro in URL encoding. Questa funzione è supportata da Zabbix 7.0.4. Esempio: ```default {{ITEM.VALUE}.urlencode()} - codificherà in URL un carattere come "/" in "%2F" ``` [comment]: # ({/8b7a9c23-8dec62fd}) [comment]: # ({a95b22c2-b6fdaa9a}) #### Esempi aggiuntivi La tabella seguente mostra altri esempi di utilizzo delle funzioni macro. :::noteinfo `{#IFALIAS}` è una [macro LLD](/manual/config/macros/lld_macros) ed è definita solo nei contesti di discovery a basso livello (regole di discovery, prototipi e gli item/trigger creati da essi). Se viene usata al di fuori di LLD, il token non verrà espanso. ::: |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*` (invalid regular expression)| |`{{#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)}` (invalid regular expression)| |`{$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)}"}` (invalid regular expression)| |`"{$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)}\"}"` (invalid regular expression)| ##### Visualizzare i valori completi degli item I valori lunghi delle macro risolte {ITEM.VALUE} e {ITEM.LASTVALUE} per gli item di tipo text/log vengono troncati a 20 caratteri in alcune posizioni del frontend. Per visualizzare i valori completi di queste macro, puoi usare le funzioni macro, ad esempio: ```default {{ITEM.VALUE}.regsub("(.*)", \1)} {{ITEM.LASTVALUE}.regsub("(.*)", \1)} ``` Vedi anche: {ITEM.VALUE} e {ITEM.LASTVALUE} [dettagli delle macro](/manual/appendix/macros/supported_by_location). [comment]: # ({/a95b22c2-b6fdaa9a})