---
title: "Funkce pro parsování"
description: "Parsování ve skriptu TapHome: vyříznutí hodnoty mezi dvěma vzory přes PARSETEXT, čtení JSON přes PARSEJSON a XML přes PARSEXML a ošetření chybějících hodnot."
url: "https://taphome.com/cs/docs/script/parsing-functions/"
language: cs
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["parsing","json","xml","text-extraction","scripting-language"]
  questions: ["Jak ve skriptu TapHome parsovat data JSON?","Jak v TapHome získat hodnotu z XML?","Jak přes PARSETEXT parsovat text mezi dvěma vzory?","Jak přečíst vnořené pole JSON pomocí cesty JSON?","Jak ošetřit chybějící prvky při parsování JSON?","Jak parsovat XML, které obsahuje jmenné prostory?","Proč PARSETEXT zastaví skript chybou \"Specified argument was out of the range of valid values\"?","Jak ve skriptu TapHome projít pole JSON v cyklu?"]
---

# Funkce pro parsování

Funkce skriptu TapHome pro parsování — PARSETEXT pro text mezi vzory, PARSEJSON s JSONPath a PARSEXML s XPath — pro čtení hodnot z odpovědí zařízení.

Poslední aktualizace: 2026-11-06

Funkce pro parsování čtou hodnoty z textu, který vrací zařízení — typicky z odpovědi na požadavek HTTP nebo z přijaté zprávy ve skriptu [Packet parser](https://taphome.com/cs/docs/script/packet-parser/). Přijímají řetězec, kolekci bajtů (`collection<uint8>`) nebo blob, fungují v každém skriptu a vyžadují Core 2022.2 nebo novější.

## PARSETEXT

`PARSETEXT` vrátí část textu, která následuje za levým vzorem a končí před pravým vzorem; když je ta část číslo, vrátí číslo.

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

| Název | Typ | Popis |
|---|---|---|
| `source` | řetězec, `collection<uint8>` nebo blob | Prohledávaný text. Bajty se čtou jako `iso-8859-1`. |
| `leftPattern` | řetězec | Text před hodnotou. Více částí oddělených `...` se hledá jedna po druhé. |
| `rightPattern` | řetězec, nepovinný | Text za hodnotou. Bez něj hodnota končí u prvního znaku, který není písmeno, číslice ani `.` (úvodní `+` nebo `-` zůstává). |

**Vrací** — číslo, když nalezený text lze přečíst jako číslo (s desetinnou tečkou), jinak text s oříznutými mezerami. `Null`, když levý vzor není nalezen.

> [!WARNING]
> Když je levý vzor nalezen, ale pravý ne, skript se zastaví chybou *Specified argument was out of the range of valid values.* — nevrátí `Null`. Když pravý vzor může chybět, ověřte ho nejprve přes `INDEXOF` (ověřeno na Core 2026.1).

**Příklad**

```taphome
# text mezi dvěma vzory
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čí prvním jiným znakem
PARSETEXT("<temp>12.2</temp>", "<temp>");
# Result: 12.2
PARSETEXT("status:ok,error:none", "status:");
# Result: "ok"
# více levých částí, hledají se postupně
PARSETEXT("Lorem ipsum dolor sit amet", "ipsum...sit");
# Result: "amet"
PARSETEXT("Lorem ipsum dolor sit amet consectetur adipiscing", "ipsum...sit", "adipiscing");
# Result: "amet consectetur"
# levý vzor se nenašel
PARSETEXT("a=1", "b=");
# Result: Null
```

**Příklad — pravý vzor, který může chybět**

```taphome
# poloha levého vzoru
VAR start := INDEXOF(text, "temp=");
# skončí, pokud chybí pravý vzor
IF start < 0 OR INDEXOF(COPY(text, start), ";") < 0
    RETURN(NaN);
END
# načte hodnotu mezi vzory
PARSETEXT(text, "temp=", ";");
```

**Viz také** — [INDEXOF](https://taphome.com/cs/docs/script/text-string-and-byte-array/#indexof), [COPY](https://taphome.com/cs/docs/script/text-string-and-byte-array/#copy).

## PARSEJSON

`PARSEJSON` přečte hodnotu z JSON výrazem JSONPath; s `TRUE` jako třetím argumentem vrátí `Null` místo zastavení skriptu, když cesta není nalezena.

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

| Název | Typ | Popis |
|---|---|---|
| `json` | řetězec, `collection<uint8>` nebo blob | Text JSON. |
| `path` | řetězec | JSONPath. Úvodní `$.` je volitelné. |
| `ignoreError` | bool, volitelný | `TRUE` (nebo `1`): vrátit `Null`, když cesta není nalezena, JSON je neplatný nebo `json` je `Null`. Výchozí `FALSE`. |

**Vrací** — hodnotu na dané cestě: řetězec, číslo nebo bool. Více shod se vrátí jako kolekce. Objekt nebo pole se vrátí jako svůj text JSON, který lze znovu parsovat.

| Cesta | Vybere |
|---|---|
| `temperature`, `cloud.connected` | Položka, vnořená položka. |
| `$.devices[0].name` | Položka prvního prvku pole. |
| `$.devices[-1:].deviceId` | Poslední prvek pole. |
| `$[?(@.period == 1)].price` | Prvky, jejichž položka splňuje podmínku. |

**Příklad** — když `json` obsahuje:

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

```taphome
# pole na nejvyšší úrovni
PARSEJSON(json, "firstName");
# Result: "John"
# vnořené pole
PARSEJSON(json, "address.city");
# Result: "Nara"
PARSEJSON(json, "age");
# Result: 26
# chybějící cesta vrátí Null, ne chybu
PARSEJSON(json, "address.country", TRUE);
# Result: Null
```

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

**Příklad — procházení pole JSON v cyklu**

S `TRUE` vrátí `PARSEJSON` za posledním prvkem `Null`, což cyklus ukončí:

```taphome
# počítadlo cyklu a sbíraná jména
VAR i := 0;
VAR names := "";
# jméno prvního prvku pole
VAR name := PARSEJSON(json, "$.devices[0].name", TRUE);
WHILE !ISNULL(name)
    names := names + name + "\n";
    i := i + 1;
    # jméno dalšího prvku
    name := PARSEJSON(json, "$.devices[" + TOSTRING(i) + "].name", TRUE);
LOOP
# vrátí nasbíraná jména
names;
```

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

## PARSEXML

`PARSEXML` přečte hodnotu z XML výrazem XPath a vrátí hodnotu prvního vyhovujícího uzlu.

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

**Vrací** — hodnotu prvního uzlu: číslo, když text lze přečíst jako číslo, jinak řetězec; `Null`, když nic nevyhovuje. Funkce XPath vracejí vlastní výsledek, například číslo z `count()`.

**Poznámky**

- Čísla v textu uzlu se čtou podle jazykového nastavení řídicí jednotky. Chcete-li číslo s desetinnou tečkou přečíst nezávisle na něm, obalte cestu funkcí XPath `number()`.
- Jmenné prostory deklarované v dokumentu se registrují automaticky. Jmenný prostor s prefixem (`xmlns:dc="…"`) se používá se svým prefixem; výchozí jmenný prostor (`xmlns="…"`) dostane název prvku, který ho deklaruje — pro `<DIDL-Lite xmlns="…">` pište `DIDL-Lite:container`.
- Dokumenty menší než 80 kB a zkompilované výrazy se ukládají do mezipaměti, takže opakovaná volání nad stejnou odpovědí jsou levná.

**Příklad** — když odpověď 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
# tělo odpovědi jako text XML
VAR xml := response.Content;
# název druhé knihy
PARSEXML(xml, "//book[2]/title");
# Result: "Midnight Rain"
# hodnota atributu
PARSEXML(xml, "//book[1]/@id");
# Result: "bk101"
# number() načte cenu jako číslo s desetinnou tečkou
PARSEXML(xml, "number(//catalog/book[1]/price)");
# Result: 44.95
# count() vrátí počet shodných uzlů
PARSEXML(xml, "count(//book)");
# Result: 2
# bez shody se vrátí Null
PARSEXML(xml, "//catalog/magazine[1]/price");
# Result: Null
```

**Příklad — XML se jmennými prostory**

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

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

**Viz také** — [SENDHTTPREQUEST](https://taphome.com/cs/docs/script/packet-parser/#sendhttprequest), [DECODE](https://taphome.com/cs/docs/script/data-type-conversions/#decode).