[comment]: # attributes: notoc [comment]: # translation:outdated [comment]: # ({09129833-0458cee0}) # 1 Funzioni macro #### Panoramica Le funzioni macro offrono la possibilità di personalizzare i valori delle [macro](/manual/config/macros) (ad esempio, abbreviare o estrarre sottostringhe specifiche), rendendoli più facili da utilizzare. La sintassi di una funzione macro è: ```default {macro.func(params)} ``` dove - **macro** - la macro da personalizzare; - **func** - la funzione da applicare (vedere [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 chiuse o una virgola. Per 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) - [Macro utente](/manual/appendix/macros/supported_by_location#other-macro-types) - [Macro di low-level discovery](/manual/appendix/macros/supported_by_location#other-macro-types) - [Macro di espressione](/manual/appendix/macros/supported_by_location#other-macro-types) Le funzioni macro possono essere utilizzate in tutte le posizioni che supportano le macro elencate. Questo vale salvo nei casi in cui sia esplicitamente indicato che è prevista solo una macro (ad esempio, durante la configurazione delle [macro host](/manual/config/hosts/host#configuration) o dei [filtri](/manual/discovery/low_level_discovery#filter) delle regole di low-level discovery). È supportata una sola funzione per macro; non sono supportate più funzioni macro concatenate. :::noteclassic Consultare gli [esempi di escaping](/manual/appendix/escaping) per i casi in cui le funzioni macro vengono utilizzate all'interno di altri contesti (funzione, chiave item, un'altra macro, ecc.). ::: [comment]: # ({/09129833-0458cee0}) [comment]: # ({f9dac088-b8563887}) #### Funzioni supportate Le funzioni sono elencate senza informazioni aggiuntive. Fare clic sulla funzione per visualizzare tutti i dettagli. |Function|Description| |--|--------| |[btoa](#btoa)|Codifica del valore della macro in codifica Base64.| |[fmtnum](#fmtnum)|Formattazione dei numeri per controllare il numero di cifre visualizzate dopo il separatore decimale.| |[fmttime](#fmttime)|Formattazione dell'ora.| |[htmldecode](#htmldecode)|Decodifica del valore della macro dalla codifica HTML.| |[htmlencode](#htmlencode)|Codifica del valore della macro nella 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 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 nella codifica URL.| [comment]: # ({/f9dac088-b8563887}) [comment]: # ({91058888-c1632a9e}) #### Dettagli della funzione I parametri opzionali della funzione sono indicati da < >. [comment]: # ({/91058888-c1632a9e}) [comment]: # ({d8d5fafe-6e2e93df}) ##### btoa {#btoa} Codifica di un valore macro in codifica Base64. La codifica Base64 è un metodo per rappresentare dati binari come testo, utile per l'archiviazione e la trasmissione sicura di contenuti binari tramite protocolli basati su testo. Esempio: ```default {{ITEM.VALUE}.btoa()} - codificherà in Base64 un valore come "zabbix" in "emFiYml4" ``` [comment]: # ({/d8d5fafe-6e2e93df}) [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]: # ({a8d94ee5-3caa4dc7}) ##### fmttime(format,) {#fmttime} Formattazione dell'ora.
Si noti che questa funzione può essere utilizzata con macro che vengono risolte in un valore in uno dei seguenti formati temporali: - `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 `-` oppure `+`, dove: - `N` - il numero di unità di tempo da aggiungere o sottrarre; - `time_unit` - h (ora), d (giorno), w (settimana), M (mese) oppure y (anno). Commenti: - Il parametro `time_shift` supporta operazioni temporali in più passaggi e può includere `/` per spostarsi all'inizio dell'unità di tempo (`/d` - mezzanotte, `/w` - 1° giorno della settimana (lunedì), `/M` - 1° 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à. Ad 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]: # ({/a8d94ee5-3caa4dc7}) [comment]: # ({d224cb43-e5cb24ab}) ##### htmldecode {#htmldecode} Decodifica di un valore macro dalla codifica HTML. Sono supportati i seguenti caratteri: |Valore|Valore decodificato| |----|------| |`&`|`&`| |`<`|`<`| |`>`|`>`| |`"`|`"`| |`'`|`'`| |`'`|`'`| Esempio: ```default {{ITEM.VALUE}.htmldecode()} - decodificherà in HTML un valore come "<" in "<" ``` [comment]: # ({/d224cb43-e5cb24ab}) [comment]: # ({f78164e5-b0e6d63f}) ##### htmlencode {#htmlencode} Codifica di un valore macro nella codifica HTML. Sono supportati i seguenti caratteri: |Valore|Valore codificato| |----|------| |`&`|`&`| |`<`|`<`| |`>`|`>`| |`"`|`"`| |`'`|`'`| Esempio: ```default {{ITEM.VALUE}.htmlencode()} - codificherà in HTML un carattere come "<" in "<" ``` [comment]: # ({/f78164e5-b0e6d63f}) [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]: # ({9186768b-b7de9b23}) ##### 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. Esempio: ```default {{ITEM.VALUE}.lowercase()} - trasformerà un valore come "Zabbix SERVER" in "zabbix server" (minuscolo) ``` [comment]: # ({/9186768b-b7de9b23}) [comment]: # ({2064b2f8-2d4d3410}) ##### regrepl(pattern,replacement,,,...) {#regrepl} Sostituzione di caratteri/sottostringhe nel valore della macro. Parametri: - **pattern** - l'espressione regolare da corrispondere; - **replacement** - la stringa di sostituzione. I segnaposto **\\1 - \\9** sono supportati nelle stringhe di sostituzione per i gruppi catturati. 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 preceduti da una barra rovesciata di escape {$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]: # ({/2064b2f8-2d4d3410}) [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]: # ({40e84cc5-d7660986}) ##### tr(characters,replacement) {#tr} Traslitterazione dei caratteri del valore della macro. - **characters** - l'insieme dei caratteri da sostituire; - **replacement** - l'insieme dei caratteri sostitutivi 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 della barra rovesciata con la barra, e gli apici singoli con i 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 un fine riga ``` Per includere caratteri letterali: ```default barra rovesciata - deve essere preceduta da escape come \\ apice singolo - deve essere preceduto da escape come \' doppio apice - deve essere preceduto da escape come \" ``` Sequenze di escape supportate con barra rovesciata: ```default \\\\ => \\ - doppia barra rovesciata in barra rovesciata singola \\a => \a - avviso \\b => \b - backspace \\f => \f - avanzamento pagina \\n => \n - nuova riga \\r => \r - ritorno carrello \\t => \t - tabulazione orizzontale \\v => \v - tabulazione verticale ``` [comment]: # ({/40e84cc5-d7660986}) [comment]: # ({57ab4e3a-8315e479}) ##### 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. Esempio: ```default {{ITEM.VALUE}.uppercase()} - trasformerà un valore come "Zabbix Server" in "ZABBIX SERVER" (maiuscolo) ``` [comment]: # ({/57ab4e3a-8315e479}) [comment]: # ({9f54b4cb-15465392}) ##### urldecode {#urldecode} Decodifica di un valore macro dalla codifica URL. Esempio: ```default {{ITEM.VALUE}.urldecode()} - decodificherà tramite URL un valore come "%2F" in "/" ``` [comment]: # ({/9f54b4cb-15465392}) [comment]: # ({725aedc6-362f6ccf}) ##### urlencode {#urlencode} Codifica di un valore macro nel formato URL encoding. Esempio: ```default {{ITEM.VALUE}.urlencode()} - codificherà in URL un carattere come "/" in "%2F" ``` [comment]: # ({/725aedc6-362f6ccf}) [comment]: # ({a95b22c2-148bfc16}) #### 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 low-level discovery (regole di discovery, prototipi e item/trigger creati da essi). Se utilizzata al di fuori di LLD, il token rimarrà non espanso. ::: |Funzione macro|Valore ricevuto|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*` (espressione regolare non valida)| |`{{#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)}` (espressione regolare non valida)| |`{$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)}"}` (espressione regolare non valida)| |`"{$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)}\"}"` (espressione regolare non valida)| ##### Visualizzazione dei valori completi degli item I valori lunghi delle macro risolte {ITEM.VALUE} e {ITEM.LASTVALUE} per gli item di tipo testo/log vengono troncati a 20 caratteri in alcune posizioni del frontend. Per visualizzare i valori completi di queste macro è possibile utilizzare le funzioni macro, ad esempio: ```default {{ITEM.VALUE}.regsub("(.*)", \1)} {{ITEM.LASTVALUE}.regsub("(.*)", \1)} ``` Vedi anche: dettagli delle macro {ITEM.VALUE} e {ITEM.LASTVALUE} [macro details](/manual/appendix/macros/supported_by_location). [comment]: # ({/a95b22c2-148bfc16})