---
title: "Funcții de parsare"
description: "Parsare în scripturile TapHome: extragerea unei valori dintre două șabloane cu PARSETEXT, citirea JSON cu PARSEJSON și XML cu PARSEXML și tratarea valorilor lipsă."
url: "https://taphome.com/ro/docs/script/parsing-functions/"
language: ro
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["parsing","json","xml","text-extraction","scripting-language"]
  questions: ["Cum se parsează date JSON într-un script TapHome?","Cum se extrage o valoare din XML în TapHome?","Cum se parsează textul dintre două șabloane cu PARSETEXT?","Cum se citește un câmp JSON imbricat cu o cale JSON?","Cum se tratează elementele lipsă la parsarea JSON?","Cum se parsează un XML care conține spații de nume?","De ce oprește PARSETEXT scriptul cu „Specified argument was out of the range of valid values\"?","Cum se parcurge într-o buclă un tablou JSON într-un script TapHome?"]
---

# Funcții de parsare

Funcțiile de parsare din scripturile TapHome — PARSETEXT pentru textul dintre șabloane, PARSEJSON cu JSONPath și PARSEXML cu XPath — pentru citirea valorilor din răspunsurile dispozitivelor.

Ultima actualizare: 2026-11-06

Funcțiile de parsare citesc valori din textul pe care îl returnează un dispozitiv — de regulă răspunsul unei cereri HTTP sau un mesaj primit într-un script [Packet parser](https://taphome.com/ro/docs/script/packet-parser/). Acceptă un șir de caractere, o colecție de octeți (`collection<uint8>`) sau un blob, funcționează în orice script și necesită Core 2022.2 sau mai nou.

## PARSETEXT

`PARSETEXT` returnează partea unui text care urmează după un șablon din stânga și se termină înaintea unui șablon din dreapta; când această parte este un număr, se returnează un număr.

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

| Nume | Tip | Descriere |
|---|---|---|
| `source` | șir de caractere, `collection<uint8>` sau blob | Textul în care se caută. Octeții se citesc ca `iso-8859-1`. |
| `leftPattern` | șir de caractere | Textul dinaintea valorii. Mai multe părți separate prin `...` se caută una după alta. |
| `rightPattern` | șir de caractere, opțional | Textul de după valoare. Fără el, valoarea se termină la primul caracter care nu este literă, cifră sau `.` (un `+` sau `-` de la început se păstrează). |

**Returnează** — un număr când textul găsit se citește ca număr (cu punct zecimal), altfel textul fără spațiile de la margini. `Null` când șablonul din stânga nu este găsit.

> [!WARNING]
> Când șablonul din stânga este găsit, dar cel din dreapta nu, scriptul se oprește cu eroarea *Specified argument was out of the range of valid values.* — nu returnează `Null`. Când șablonul din dreapta poate lipsi, verificați-l mai întâi cu `INDEXOF` (verificat pe Core 2026.1).

**Exemplu**

```taphome
# text între două tipare
PARSETEXT("Lorem ipsum dolor sit amet", "ipsum", "amet");
# Result: "dolor sit"
PARSETEXT("<temp>12.2</temp>", "<temp>", "</temp>");
# Result: 12.2
# fără tipar drept, valoarea se termină la primul alt caracter
PARSETEXT("<temp>12.2</temp>", "<temp>");
# Result: 12.2
PARSETEXT("status:ok,error:none", "status:");
# Result: "ok"
# mai multe părți stângi, căutate pe rând
PARSETEXT("Lorem ipsum dolor sit amet", "ipsum...sit");
# Result: "amet"
PARSETEXT("Lorem ipsum dolor sit amet consectetur adipiscing", "ipsum...sit", "adipiscing");
# Result: "amet consectetur"
# tiparul stâng nu a fost găsit
PARSETEXT("a=1", "b=");
# Result: Null
```

**Exemplu — șablon din dreapta care poate lipsi**

```taphome
# poziția tiparului stâng
VAR start := INDEXOF(text, "temp=");
# iese dacă lipsește tiparul drept
IF start < 0 OR INDEXOF(COPY(text, start), ";") < 0
    RETURN(NaN);
END
# citește valoarea dintre tipare
PARSETEXT(text, "temp=", ";");
```

**Consultați și** — [INDEXOF](https://taphome.com/ro/docs/script/text-string-and-byte-array/#indexof), [COPY](https://taphome.com/ro/docs/script/text-string-and-byte-array/#copy).

## PARSEJSON

`PARSEJSON` citește o valoare din JSON cu o expresie JSONPath; cu `TRUE` ca al treilea argument returnează `Null` în loc să oprească scriptul când calea nu este găsită.

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

| Nume | Tip | Descriere |
|---|---|---|
| `json` | șir de caractere, `collection<uint8>` sau blob | Text JSON. |
| `path` | șir de caractere | JSONPath. Prefixul `$.` de la început este opțional. |
| `ignoreError` | bool, opțional | `TRUE` (sau `1`): returnează `Null` când calea nu este găsită, JSON-ul nu este valid sau `json` este `Null`. Implicit `FALSE`. |

**Returnează** — valoarea de la calea dată: un șir de caractere, un număr sau un bool. Mai multe potriviri se returnează ca o colecție. Un obiect sau un tablou se returnează ca text JSON, care se poate parsa din nou.

| Cale | Selectează |
|---|---|
| `temperature`, `cloud.connected` | Un câmp, un câmp imbricat. |
| `$.devices[0].name` | Un câmp al primului element al tabloului. |
| `$.devices[-1:].deviceId` | Ultimul element al unui tablou. |
| `$[?(@.period == 1)].price` | Elementele al căror câmp îndeplinește o condiție. |

**Exemplu** — când `json` conține:

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

```taphome
# câmp de la nivelul superior
PARSEJSON(json, "firstName");
# Result: "John"
# câmp imbricat
PARSEJSON(json, "address.city");
# Result: "Nara"
PARSEJSON(json, "age");
# Result: 26
# calea lipsă returnează Null, fără eroare
PARSEJSON(json, "address.country", TRUE);
# Result: Null
```

`PARSEJSON(json, "address.country")` fără al treilea argument oprește scriptul cu *PARSEJSON - Element not found: 'address.country'*.

**Exemplu — buclă peste un tablou JSON**

Cu `TRUE`, `PARSEJSON` returnează `Null` după ultimul element, ceea ce încheie bucla:

```taphome
# contor de buclă și nume colectate
VAR i := 0;
VAR names := "";
# numele primului element din tablou
VAR name := PARSEJSON(json, "$.devices[0].name", TRUE);
WHILE !ISNULL(name)
    names := names + name + "\n";
    i := i + 1;
    # numele elementului următor
    name := PARSEJSON(json, "$.devices[" + TOSTRING(i) + "].name", TRUE);
LOOP
# returnează numele colectate
names;
```

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

## PARSEXML

`PARSEXML` citește o valoare din XML cu o expresie XPath și returnează valoarea primului nod care se potrivește.

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

**Returnează** — valoarea primului nod: un număr când textul se citește ca număr, altfel un șir de caractere; `Null` când nu se potrivește nimic. Funcțiile XPath returnează propriul rezultat, de exemplu un număr din `count()`.

**Observații**

- Numerele din textul nodurilor se citesc după setările de limbă ale unității de control. Pentru a citi un număr cu punct zecimal indiferent de acestea, încadrați calea în funcția XPath `number()`.
- Spațiile de nume declarate în document se înregistrează automat. Un spațiu de nume cu prefix (`xmlns:dc="…"`) se folosește cu prefixul său; un spațiu de nume implicit (`xmlns="…"`) primește numele elementului care îl declară — pentru `<DIDL-Lite xmlns="…">` scrieți `DIDL-Lite:container`.
- Documentele mai mici de 80 kB și expresiile compilate se păstrează în cache, așa că apelurile repetate asupra aceluiași răspuns sunt ieftine.

**Exemplu** — când răspunsul conține:

```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
# corpul răspunsului ca text XML
VAR xml := response.Content;
# titlul celei de-a doua cărți
PARSEXML(xml, "//book[2]/title");
# Result: "Midnight Rain"
# valoarea atributului
PARSEXML(xml, "//book[1]/@id");
# Result: "bk101"
# number() citește prețul ca număr cu punct zecimal
PARSEXML(xml, "number(//catalog/book[1]/price)");
# Result: 44.95
# count() returnează numărul de noduri potrivite
PARSEXML(xml, "count(//book)");
# Result: 2
# fără potrivire se returnează Null
PARSEXML(xml, "//catalog/magazine[1]/price");
# Result: Null
```

**Exemplu — XML cu spații de nume**

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

**Erori** — *PARSEXML - parse error: …* (XML sau XPath nevalid).

**Consultați și** — [SENDHTTPREQUEST](https://taphome.com/ro/docs/script/packet-parser/#sendhttprequest), [DECODE](https://taphome.com/ro/docs/script/data-type-conversions/#decode).
