---
title: "Parsovacie funkcie"
description: "Parsovanie v skripte TapHome: výber hodnoty medzi dvoma vzormi cez PARSETEXT, čítanie JSON cez PARSEJSON a XML cez PARSEXML a ošetrenie chýbajúcich hodnôt."
url: "https://taphome.com/sk/docs/script/parsing-functions/"
language: sk
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["parsing","json","xml","text-extraction","scripting-language"]
  questions: ["Ako parsovať dáta JSON v skripte TapHome?","Ako získam hodnotu z XML v TapHome?","Ako pomocou PARSETEXT vyberiem text medzi dvoma vzormi?","Ako prečítam vnorenú položku JSON pomocou cesty JSON path?","Ako ošetrím chýbajúce prvky pri parsovaní JSON?","Ako parsujem XML, ktoré obsahuje menné priestory?","Prečo PARSETEXT zastaví skript chybou \"Specified argument was out of the range of valid values\"?","Ako v skripte TapHome prejdem cyklom cez JSON pole?"]
---

# Parsovacie funkcie

Parsovacie funkcie skriptu TapHome — PARSETEXT na text medzi vzormi, PARSEJSON s JSONPath a PARSEXML s XPath — na čítanie hodnôt z odpovedí zariadení.

Posledná aktualizácia: 2026-11-06

Parsovacie funkcie čítajú hodnoty z textu, ktorý vráti zariadenie — typicky z odpovede na HTTP požiadavku alebo z prijatej správy v skripte [Packet parsera](https://taphome.com/sk/docs/script/packet-parser/). Prijímajú reťazec, bajtovú kolekciu (`collection<uint8>`) alebo blob, fungujú v každom skripte a potrebujú Core 2022.2 alebo novší.

## PARSETEXT

`PARSETEXT` vráti časť textu, ktorá nasleduje za ľavým vzorom a končí pred pravým vzorom; keď je táto časť číslo, vráti číslo.

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

| Názov | Typ | Popis |
|---|---|---|
| `source` | reťazec, `collection<uint8>` alebo blob | Prehľadávaný text. Bajty sa čítajú ako `iso-8859-1`. |
| `leftPattern` | reťazec | Text pred hodnotou. Viac častí oddelených `...` sa hľadá jedna po druhej. |
| `rightPattern` | reťazec, voliteľný | Text za hodnotou. Bez neho hodnota končí na prvom znaku, ktorý nie je písmeno, číslica ani `.` (úvodné `+` alebo `-` sa ponechá). |

**Návratová hodnota** — číslo, keď sa nájdený text dá prečítať ako číslo (s desatinnou bodkou), inak text bez úvodných a koncových medzier. `Null`, keď sa ľavý vzor nenájde.

> [!WARNING]
> Keď sa ľavý vzor nájde, ale pravý nie, skript sa zastaví chybou *Specified argument was out of the range of valid values.* — nevráti `Null`. Keď pravý vzor môže chýbať, overte ho najprv funkciou `INDEXOF` (overené na Core 2026.1).

**Príklad**

```taphome
# text medzi dvoma vzormi
PARSETEXT("Lorem ipsum dolor sit amet", "ipsum", "amet");
# Result: "dolor sit"
PARSETEXT("<temp>12.2</temp>", "<temp>", "</temp>");
# Result: 12.2
# bez pravého vzoru hodnota končí prvým iným znakom
PARSETEXT("<temp>12.2</temp>", "<temp>");
# Result: 12.2
PARSETEXT("status:ok,error:none", "status:");
# Result: "ok"
# viac ľavých častí, hľadajú sa postupne
PARSETEXT("Lorem ipsum dolor sit amet", "ipsum...sit");
# Result: "amet"
PARSETEXT("Lorem ipsum dolor sit amet consectetur adipiscing", "ipsum...sit", "adipiscing");
# Result: "amet consectetur"
# ľavý vzor sa nenašiel
PARSETEXT("a=1", "b=");
# Result: Null
```

**Príklad — pravý vzor, ktorý môže chýbať**

```taphome
# poloha ľavého vzoru
VAR start := INDEXOF(text, "temp=");
# skončí, ak chýba pravý vzor
IF start < 0 OR INDEXOF(COPY(text, start), ";") < 0
    RETURN(NaN);
END
# načíta hodnotu medzi vzormi
PARSETEXT(text, "temp=", ";");
```

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

## PARSEJSON

`PARSEJSON` prečíta hodnotu z JSON pomocou výrazu JSONPath; s `TRUE` ako tretím argumentom vráti `Null` namiesto zastavenia skriptu, keď sa cesta nenájde.

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

| Názov | Typ | Popis |
|---|---|---|
| `json` | reťazec, `collection<uint8>` alebo blob | Text JSON. |
| `path` | reťazec | JSONPath. Úvodné `$.` je voliteľné. |
| `ignoreError` | bool, voliteľný | `TRUE` (alebo `1`): vráti `Null`, keď sa cesta nenájde, JSON je neplatný alebo `json` je `Null`. Predvolene `FALSE`. |

**Návratová hodnota** — hodnota na zadanej ceste: reťazec, číslo alebo bool. Viac zhôd sa vráti ako kolekcia. Objekt alebo pole sa vráti ako svoj text JSON, ktorý sa dá znova parsovať.

| Cesta | Vyberie |
|---|---|
| `temperature`, `cloud.connected` | Položku, vnorenú položku. |
| `$.devices[0].name` | Položku prvého prvku poľa. |
| `$.devices[-1:].deviceId` | Posledný prvok poľa. |
| `$[?(@.period == 1)].price` | Prvky, ktorých položka spĺňa podmienku. |

**Príklad** — keď `json` obsahuje:

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

```taphome
# položka na najvyššej úrovni
PARSEJSON(json, "firstName");
# Result: "John"
# vnorená položka
PARSEJSON(json, "address.city");
# Result: "Nara"
PARSEJSON(json, "age");
# Result: 26
# chýbajúca cesta vráti Null, nie chybu
PARSEJSON(json, "address.country", TRUE);
# Result: Null
```

`PARSEJSON(json, "address.country")` bez tretieho argumentu zastaví skript chybou *PARSEJSON - Element not found: 'address.country'*.

**Príklad — cyklus cez JSON pole**

S `TRUE` vráti `PARSEJSON` za posledným prvkom `Null`, čím sa cyklus skončí:

```taphome
# počítadlo cyklu a zbierané mená
VAR i := 0;
VAR names := "";
# meno prvého prvku poľa
VAR name := PARSEJSON(json, "$.devices[0].name", TRUE);
WHILE !ISNULL(name)
    names := names + name + "\n";
    i := i + 1;
    # meno ďalšieho prvku
    name := PARSEJSON(json, "$.devices[" + TOSTRING(i) + "].name", TRUE);
LOOP
# vráti zozbierané mená
names;
```

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

## PARSEXML

`PARSEXML` prečíta hodnotu z XML pomocou výrazu XPath a vráti hodnotu prvého zodpovedajúceho uzla.

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

**Návratová hodnota** — hodnota prvého uzla: číslo, keď sa text dá prečítať ako číslo, inak reťazec; `Null`, keď nič nevyhovuje. Funkcie XPath vracajú vlastný výsledok, napríklad číslo z `count()`.

**Poznámky**

- Čísla v texte uzlov sa čítajú podľa jazykových nastavení riadiacej jednotky. Ak chcete prečítať číslo s desatinnou bodkou nezávisle od nich, obaľte cestu funkciou XPath `number()`.
- Menné priestory deklarované v dokumente sa registrujú automaticky. Menný priestor s prefixom (`xmlns:dc="…"`) sa používa so svojím prefixom; predvolený menný priestor (`xmlns="…"`) dostane názov prvku, ktorý ho deklaruje — pre `<DIDL-Lite xmlns="…">` napíšte `DIDL-Lite:container`.
- Dokumenty menšie ako 80 kB a skompilované výrazy sa ukladajú do vyrovnávacej pamäte, takže opakované volania nad tou istou odpoveďou sú lacné.

**Príklad** — keď odpoveď obsahuje:

```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
# telo odpovede ako text XML
VAR xml := response.Content;
# názov druhej knihy
PARSEXML(xml, "//book[2]/title");
# Result: "Midnight Rain"
# hodnota atribútu
PARSEXML(xml, "//book[1]/@id");
# Result: "bk101"
# number() načíta cenu ako číslo s desatinnou bodkou
PARSEXML(xml, "number(//catalog/book[1]/price)");
# Result: 44.95
# count() vráti počet zhodných uzlov
PARSEXML(xml, "count(//book)");
# Result: 2
# bez zhody sa vráti Null
PARSEXML(xml, "//catalog/magazine[1]/price");
# Result: Null
```

**Príklad — XML s mennými priestormi**

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

**Chyby** — *PARSEXML - parse error: …* (neplatné XML alebo XPath).

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