---
title: "Funzioni di parsing"
description: "Parsing negli script TapHome: estrarre un valore tra due modelli con PARSETEXT, leggere JSON con PARSEJSON e XML con PARSEXML, e gestire i valori mancanti."
url: "https://taphome.com/it/docs/script/parsing-functions/"
language: it
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["parsing","json","xml","text-extraction","scripting-language"]
  questions: ["Come si analizzano i dati JSON in uno script TapHome?","Come estraggo un valore da XML in TapHome?","Come si estrae il testo tra due modelli con PARSETEXT?","Come leggo un campo JSON annidato con un percorso JSON?","Come gestisco gli elementi mancanti durante il parsing di JSON?","Come analizzo un XML che contiene namespace?","Perché PARSETEXT interrompe lo script con \"Specified argument was out of the range of valid values\"?","Come eseguo un ciclo su un array JSON in uno script TapHome?"]
---

# Funzioni di parsing

Funzioni di parsing degli script TapHome — PARSETEXT per il testo tra due modelli, PARSEJSON con JSONPath e PARSEXML con XPath — per leggere valori dalle risposte dei dispositivi.

Ultimo aggiornamento: 2026-11-06

Le funzioni di parsing leggono valori dal testo restituito da un dispositivo — tipicamente la risposta di una richiesta HTTP o un messaggio ricevuto in uno script [Packet parser](https://taphome.com/it/docs/script/packet-parser/). Accettano una stringa, una collezione di byte (`collection<uint8>`) o un blob, funzionano in ogni script e richiedono Core 2022.2 o più recente.

## PARSETEXT

`PARSETEXT` restituisce la parte di un testo che segue un modello sinistro e termina prima di un modello destro; quando quella parte è un numero, viene restituito un numero.

```text
PARSETEXT(source, leftPattern)
PARSETEXT(source, leftPattern, rightPattern)
```

| Nome | Tipo | Descrizione |
|---|---|---|
| `source` | string, `collection<uint8>` o blob | Testo in cui cercare. I byte vengono letti come `iso-8859-1`. |
| `leftPattern` | string | Testo prima del valore. Più parti separate da `...` vengono cercate una dopo l'altra. |
| `rightPattern` | string, facoltativo | Testo dopo il valore. Senza di esso il valore termina al primo carattere che non è una lettera, una cifra o `.` (un `+` o `-` iniziale viene mantenuto). |

**Valore restituito** — un numero quando il testo trovato si legge come numero (con il punto decimale), altrimenti il testo senza spazi iniziali e finali. `Null` quando il modello sinistro non viene trovato.

> [!WARNING]
> Quando il modello sinistro viene trovato ma quello destro no, lo script si interrompe con l'errore *Specified argument was out of the range of valid values.* — non restituisce `Null`. Quando il modello destro può mancare, verificalo prima con `INDEXOF` (verificato su Core 2026.1).

**Esempio**

```taphome
# testo tra due modelli
PARSETEXT("Lorem ipsum dolor sit amet", "ipsum", "amet");
# Result: "dolor sit"
PARSETEXT("<temp>12.2</temp>", "<temp>", "</temp>");
# Result: 12.2
# senza modello destro il valore termina al primo altro carattere
PARSETEXT("<temp>12.2</temp>", "<temp>");
# Result: 12.2
PARSETEXT("status:ok,error:none", "status:");
# Result: "ok"
# più parti sinistre, cercate una dopo l'altra
PARSETEXT("Lorem ipsum dolor sit amet", "ipsum...sit");
# Result: "amet"
PARSETEXT("Lorem ipsum dolor sit amet consectetur adipiscing", "ipsum...sit", "adipiscing");
# Result: "amet consectetur"
# modello sinistro non trovato
PARSETEXT("a=1", "b=");
# Result: Null
```

**Esempio — modello destro che può mancare**

```taphome
# posizione del modello sinistro
VAR start := INDEXOF(text, "temp=");
# esce se manca il modello destro
IF start < 0 OR INDEXOF(COPY(text, start), ";") < 0
    RETURN(NaN);
END
# legge il valore tra i modelli
PARSETEXT(text, "temp=", ";");
```

**Vedi anche** — [INDEXOF](https://taphome.com/it/docs/script/text-string-and-byte-array/#indexof), [COPY](https://taphome.com/it/docs/script/text-string-and-byte-array/#copy).

## PARSEJSON

`PARSEJSON` legge un valore da JSON con un'espressione JSONPath; con `TRUE` come terzo argomento restituisce `Null` invece di interrompere lo script quando il percorso non viene trovato.

```text
PARSEJSON(json, path)
PARSEJSON(json, path, ignoreError)
```

| Nome | Tipo | Descrizione |
|---|---|---|
| `json` | string, `collection<uint8>` o blob | Testo JSON. |
| `path` | string | JSONPath. Il prefisso `$.` è facoltativo. |
| `ignoreError` | bool, facoltativo | `TRUE` (o `1`): restituisce `Null` quando il percorso non viene trovato, il JSON non è valido o `json` è `Null`. Predefinito `FALSE`. |

**Valore restituito** — il valore nel percorso: una stringa, un numero o un bool. Più corrispondenze vengono restituite come collezione. Un oggetto o un array viene restituito come testo JSON, che può essere analizzato di nuovo.

| Percorso | Seleziona |
|---|---|
| `temperature`, `cloud.connected` | Un campo, un campo annidato. |
| `$.devices[0].name` | Un campo del primo elemento dell'array. |
| `$.devices[-1:].deviceId` | L'ultimo elemento di un array. |
| `$[?(@.period == 1)].price` | Elementi il cui campo soddisfa una condizione. |

**Esempio** — con `json` che contiene:

```json
{
  "firstName": "John",
  "lastName": "Doe",
  "age": 26,
  "address": {
    "streetAddress": "Naist street",
    "city": "Nara",
    "postalCode": "630-0192"
  }
}
```

```taphome
# campo di primo livello
PARSEJSON(json, "firstName");
# Result: "John"
# campo annidato
PARSEJSON(json, "address.city");
# Result: "Nara"
PARSEJSON(json, "age");
# Result: 26
# percorso mancante: restituisce Null, nessun errore
PARSEJSON(json, "address.country", TRUE);
# Result: Null
```

`PARSEJSON(json, "address.country")` senza il terzo argomento interrompe lo script con *PARSEJSON - Element not found: 'address.country'*.

**Esempio — ciclo su un array JSON**

Con `TRUE`, `PARSEJSON` restituisce `Null` dopo l'ultimo elemento, il che termina il ciclo:

```taphome
# contatore del ciclo e nomi raccolti
VAR i := 0;
VAR names := "";
# nome del primo elemento dell'array
VAR name := PARSEJSON(json, "$.devices[0].name", TRUE);
WHILE !ISNULL(name)
    names := names + name + "\n";
    i := i + 1;
    # nome dell'elemento successivo
    name := PARSEJSON(json, "$.devices[" + TOSTRING(i) + "].name", TRUE);
LOOP
# restituisce i nomi raccolti
names;
```

**Errori** — *PARSEJSON - Element not found: 'path'*; *PARSEJSON - parse error: …* (JSON non valido); *PARSEJSON - argument 1 is null*.

## PARSEXML

`PARSEXML` legge un valore da XML con un'espressione XPath e restituisce il valore del primo nodo corrispondente.

```text
PARSEXML(xml, xpath)
```

**Valore restituito** — il valore del primo nodo: un numero quando il testo si legge come numero, altrimenti una stringa; `Null` quando non c'è nessuna corrispondenza. Le funzioni XPath restituiscono il proprio risultato, ad esempio un numero da `count()`.

**Note**

- I numeri nel testo dei nodi vengono letti secondo le impostazioni di lingua dell'unità di controllo. Per leggere un numero con il punto decimale indipendentemente da esse, racchiudi il percorso nella funzione XPath `number()`.
- I namespace dichiarati nel documento vengono registrati automaticamente. Un namespace con prefisso (`xmlns:dc="…"`) si usa con il suo prefisso; un namespace predefinito (`xmlns="…"`) prende il nome dell'elemento che lo dichiara — per `<DIDL-Lite xmlns="…">` scrivi `DIDL-Lite:container`.
- I documenti più piccoli di 80 kB e le espressioni compilate vengono messi in cache, quindi le chiamate ripetute sulla stessa risposta sono poco costose.

**Esempio** — con la risposta che contiene:

```xml
<?xml version="1.0"?>
<catalog>
  <book id="bk101">
    <title>XML Developer's Guide</title>
    <price>44.95</price>
  </book>
  <book id="bk102">
    <title>Midnight Rain</title>
    <price>5.95</price>
  </book>
</catalog>
```

```taphome
# corpo della risposta come testo XML
VAR xml := response.Content;
# titolo del secondo libro
PARSEXML(xml, "//book[2]/title");
# Result: "Midnight Rain"
# valore dell'attributo
PARSEXML(xml, "//book[1]/@id");
# Result: "bk101"
# number() legge il prezzo come numero con punto decimale
PARSEXML(xml, "number(//catalog/book[1]/price)");
# Result: 44.95
# count() restituisce il numero di nodi corrispondenti
PARSEXML(xml, "count(//book)");
# Result: 2
# nessuna corrispondenza: restituisce Null
PARSEXML(xml, "//catalog/magazine[1]/price");
# Result: Null
```

**Esempio — XML con namespace**

```taphome
VAR xml := response.Content;
PARSEXML(xml, "//DIDL-Lite:container[dc:title='My Playlist']/DIDL-Lite:res");
```

**Errori** — *PARSEXML - parse error: …* (XML o XPath non valido).

**Vedi anche** — [SENDHTTPREQUEST](https://taphome.com/it/docs/script/packet-parser/#sendhttprequest), [DECODE](https://taphome.com/it/docs/script/data-type-conversions/#decode).