---
title: "Elemző függvények"
description: "TapHome szkript elemzés: vágj ki egy értéket két minta között a PARSETEXT-tel, olvass JSON-t a PARSEJSON-nal és XML-t a PARSEXML-lel, és kezeld a hiányzó értékeket."
url: "https://taphome.com/hu/docs/script/parsing-functions/"
language: hu
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["parsing","json","xml","text-extraction","scripting-language"]
  questions: ["Hogyan elemezhetek JSON adatokat TapHome szkriptben?","Hogyan nyerhetek ki értéket XML-ből a TapHome-ban?","Hogyan elemezhetem a két minta közötti szöveget a PARSETEXT-tel?","Hogyan olvashatok ki beágyazott JSON mezőt JSON útvonallal?","Hogyan kezeljem a hiányzó elemeket JSON elemzésekor?","Hogyan elemezhetek névtereket tartalmazó XML-t?","Miért állítja le a PARSETEXT a szkriptet a \"Specified argument was out of the range of valid values\" hibával?","Hogyan járhatok be egy JSON tömböt ciklussal egy TapHome szkriptben?"]
---

# Elemző függvények

TapHome szkript elemző függvények — PARSETEXT a minták közötti szöveghez, PARSEJSON JSONPath-szal és PARSEXML XPath-szal — értékek kiolvasásához az eszközök válaszaiból.

Utoljára frissítve: 2026-11-06

Az elemző függvények az eszköz által visszaadott szövegből olvasnak ki értékeket — jellemzően egy HTTP-kérés válaszából vagy egy [Packet parser](https://taphome.com/hu/docs/script/packet-parser/) szkriptben fogadott üzenetből. Szöveget, bájtgyűjteményt (`collection<uint8>`) vagy blobot fogadnak, minden szkriptben működnek; szükséges verzió: Core 2022.2 vagy újabb.

## PARSETEXT

A `PARSETEXT` a szövegnek azt a részét adja vissza, amely egy bal oldali minta után következik és egy jobb oldali minta előtt ér véget; ha ez a rész szám, számot ad vissza.

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

| Név | Típus | Leírás |
|---|---|---|
| `source` | szöveg, `collection<uint8>` vagy blob | A keresett szöveg. A bájtok `iso-8859-1` kódolásként olvasódnak be. |
| `leftPattern` | szöveg | Az érték előtti szöveg. A `...` jellel elválasztott részeket egymás után keresi meg. |
| `rightPattern` | szöveg, opcionális | Az érték utáni szöveg. Nélküle az érték az első olyan karakternél ér véget, amely nem betű, számjegy vagy `.` (a kezdő `+` vagy `-` megmarad). |

**Visszatérési érték** — szám, ha a talált szöveg számként olvasható (tizedesponttal), egyébként a szöveg a szóközök levágásával. `Null`, ha a bal oldali minta nem található.

> [!WARNING]
> Ha a bal oldali minta megvan, de a jobb oldali nincs, a szkript a *Specified argument was out of the range of valid values.* hibával leáll — nem `Null` értéket ad vissza. Ha a jobb oldali minta hiányozhat, előbb ellenőrizd az `INDEXOF` függvénnyel (ellenőrizve Core 2026.1 verzión).

**Példa**

```taphome
# két minta közötti szöveg
PARSETEXT("Lorem ipsum dolor sit amet", "ipsum", "amet");
# Result: "dolor sit"
PARSETEXT("<temp>12.2</temp>", "<temp>", "</temp>");
# Result: 12.2
# jobb oldali minta nélkül az érték az első más karakternél ér véget
PARSETEXT("<temp>12.2</temp>", "<temp>");
# Result: 12.2
PARSETEXT("status:ok,error:none", "status:");
# Result: "ok"
# több bal oldali rész, egymás után keresve
PARSETEXT("Lorem ipsum dolor sit amet", "ipsum...sit");
# Result: "amet"
PARSETEXT("Lorem ipsum dolor sit amet consectetur adipiscing", "ipsum...sit", "adipiscing");
# Result: "amet consectetur"
# a bal oldali minta nem található
PARSETEXT("a=1", "b=");
# Result: Null
```

**Példa — esetleg hiányzó jobb oldali minta**

```taphome
# a bal oldali minta helye
VAR start := INDEXOF(text, "temp=");
# kilép, ha hiányzik a jobb oldali minta
IF start < 0 OR INDEXOF(COPY(text, start), ";") < 0
    RETURN(NaN);
END
# a minták közötti érték beolvasása
PARSETEXT(text, "temp=", ";");
```

**Lásd még** — [INDEXOF](https://taphome.com/hu/docs/script/text-string-and-byte-array/#indexof), [COPY](https://taphome.com/hu/docs/script/text-string-and-byte-array/#copy).

## PARSEJSON

A `PARSEJSON` JSONPath kifejezéssel olvas ki értéket JSON-ból; harmadik argumentumként `TRUE` értékkel a szkript leállítása helyett `Null` értéket ad vissza, ha az útvonal nem található.

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

| Név | Típus | Leírás |
|---|---|---|
| `json` | szöveg, `collection<uint8>` vagy blob | JSON szöveg. |
| `path` | szöveg | JSONPath. A kezdő `$.` elhagyható. |
| `ignoreError` | bool, opcionális | `TRUE` (vagy `1`): `Null` értéket ad vissza, ha az útvonal nem található, a JSON érvénytelen, vagy a `json` értéke `Null`. Alapértelmezés: `FALSE`. |

**Visszatérési érték** — az útvonalon lévő érték: szöveg, szám vagy bool. Több találat esetén gyűjteményt ad vissza. Objektumot vagy tömböt a JSON szövegeként ad vissza, amely újra elemezhető.

| Útvonal | Mit választ ki |
|---|---|
| `temperature`, `cloud.connected` | Egy mezőt, egy beágyazott mezőt. |
| `$.devices[0].name` | A tömb első elemének egy mezőjét. |
| `$.devices[-1:].deviceId` | A tömb utolsó elemét. |
| `$[?(@.period == 1)].price` | Azokat az elemeket, amelyek mezője megfelel egy feltételnek. |

**Példa** — ha a `json` tartalma:

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

```taphome
# legfelső szintű mező
PARSEJSON(json, "firstName");
# Result: "John"
# beágyazott mező
PARSEJSON(json, "address.city");
# Result: "Nara"
PARSEJSON(json, "age");
# Result: 26
# hiányzó útvonal Null-t ad, hiba nélkül
PARSEJSON(json, "address.country", TRUE);
# Result: Null
```

A harmadik argumentum nélküli `PARSEJSON(json, "address.country")` a *PARSEJSON - Element not found: 'address.country'* hibával leállítja a szkriptet.

**Példa — ciklus JSON tömbön**

`TRUE` értékkel a `PARSEJSON` az utolsó elem után `Null` értéket ad vissza, ami befejezi a ciklust:

```taphome
# ciklusszámláló és gyűjtött nevek
VAR i := 0;
VAR names := "";
# a tömb első elemének neve
VAR name := PARSEJSON(json, "$.devices[0].name", TRUE);
WHILE !ISNULL(name)
    names := names + name + "\n";
    i := i + 1;
    # a következő elem neve
    name := PARSEJSON(json, "$.devices[" + TOSTRING(i) + "].name", TRUE);
LOOP
# visszaadja a gyűjtött neveket
names;
```

**Hibák** — *PARSEJSON - Element not found: 'path'*; *PARSEJSON - parse error: …* (érvénytelen JSON); *PARSEJSON - argument 1 is null*.

## PARSEXML

A `PARSEXML` XPath kifejezéssel olvas ki értéket XML-ből, és az első illeszkedő csomópont értékét adja vissza.

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

**Visszatérési érték** — az első csomópont értéke: szám, ha a szöveg számként olvasható, egyébként szöveg; `Null`, ha semmi sem illeszkedik. Az XPath függvények a saját eredményüket adják vissza, például a `count()` egy számot.

**Megjegyzések**

- A csomópontok szövegében lévő számok a vezérlőegység nyelvi beállításai szerint olvasódnak be. Ha ettől függetlenül tizedesponttal szeretnél számot beolvasni, foglald az útvonalat a `number()` XPath függvénybe.
- A dokumentumban deklarált névterek automatikusan regisztrálódnak. Az előtaggal rendelkező névteret (`xmlns:dc="…"`) az előtagjával használod; az alapértelmezett névtér (`xmlns="…"`) annak az elemnek a nevét kapja, amely deklarálja — a `<DIDL-Lite xmlns="…">` esetén írd: `DIDL-Lite:container`.
- A 80 kB-nál kisebb dokumentumok és a lefordított kifejezések gyorsítótárba kerülnek, így az ugyanarra a válaszra irányuló ismételt hívások olcsók.

**Példa** — ha a válasz tartalma:

```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
# a válasz törzse XML-szövegként
VAR xml := response.Content;
# a második könyv címe
PARSEXML(xml, "//book[2]/title");
# Result: "Midnight Rain"
# attribútum értéke
PARSEXML(xml, "//book[1]/@id");
# Result: "bk101"
# a number() az árat tizedesponttal olvassa számként
PARSEXML(xml, "number(//catalog/book[1]/price)");
# Result: 44.95
# a count() az egyező csomópontok számát adja
PARSEXML(xml, "count(//book)");
# Result: 2
# egyezés nélkül Null az eredmény
PARSEXML(xml, "//catalog/magazine[1]/price");
# Result: Null
```

**Példa — XML névterekkel**

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

**Hibák** — *PARSEXML - parse error: …* (érvénytelen XML vagy XPath).

**Lásd még** — [SENDHTTPREQUEST](https://taphome.com/hu/docs/script/packet-parser/#sendhttprequest), [DECODE](https://taphome.com/hu/docs/script/data-type-conversions/#decode).