---
title: "Parsing-Funktionen"
description: "Parsing in TapHome-Skripten: einen Wert zwischen zwei Mustern mit PARSETEXT ausschneiden, JSON mit PARSEJSON und XML mit PARSEXML lesen und fehlende Werte behandeln."
url: "https://taphome.com/de/docs/script/parsing-functions/"
language: de
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["parsing","json","xml","text-extraction","scripting-language"]
  questions: ["Wie parse ich in einem TapHome-Skript JSON-Daten?","Wie lese ich in TapHome einen Wert aus XML aus?","Wie parse ich mit PARSETEXT Text zwischen zwei Mustern?","Wie lese ich ein verschachteltes JSON-Feld mit einem JSON-Pfad?","Wie behandle ich fehlende Elemente beim Parsen von JSON?","Wie parse ich XML, das Namensräume enthält?","Warum hält PARSETEXT das Skript mit \"Specified argument was out of the range of valid values\" an?","Wie durchlaufe ich in einem TapHome-Skript ein JSON-Array?"]
---

# Parsing-Funktionen

Parsing-Funktionen der TapHome-Skripte — PARSETEXT für Text zwischen Mustern, PARSEJSON mit JSONPath und PARSEXML mit XPath — zum Auslesen von Werten aus Geräteantworten.

Zuletzt aktualisiert: 2026-11-06

Parsing-Funktionen lesen Werte aus Text, den ein Gerät zurückgibt — typischerweise die Antwort auf eine HTTP-Anfrage oder eine empfangene Nachricht in einem [Packet-Parser-Skript](https://taphome.com/de/docs/script/packet-parser/). Sie akzeptieren einen String, eine Bytesammlung (`collection<uint8>`) oder einen Blob, funktionieren in jedem Skript und erfordern Core 2022.2 oder neuer.

## PARSETEXT

`PARSETEXT` gibt den Teil eines Textes zurück, der auf ein linkes Muster folgt und vor einem rechten Muster endet; ist dieser Teil eine Zahl, wird eine Zahl zurückgegeben.

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

| Name | Typ | Beschreibung |
|---|---|---|
| `source` | String, `collection<uint8>` oder Blob | Zu durchsuchender Text. Bytes werden als `iso-8859-1` gelesen. |
| `leftPattern` | String | Text vor dem Wert. Mehrere durch `...` getrennte Teile werden nacheinander gesucht. |
| `rightPattern` | String, optional | Text nach dem Wert. Ohne ihn endet der Wert am ersten Zeichen, das kein Buchstabe, keine Ziffer und kein `.` ist (ein führendes `+` oder `-` bleibt erhalten). |

**Rückgabewert** — eine Zahl, wenn sich der gefundene Text als Zahl lesen lässt (mit Dezimalpunkt), sonst der Text ohne umgebende Leerzeichen. `Null`, wenn das linke Muster nicht gefunden wird.

> [!WARNING]
> Wird das linke Muster gefunden, das rechte aber nicht, hält das Skript mit dem Fehler *Specified argument was out of the range of valid values.* an — es gibt nicht `Null` zurück. Wenn das rechte Muster fehlen kann, prüfen Sie es zuerst mit `INDEXOF` (überprüft auf Core 2026.1).

**Beispiel**

```taphome
# Text zwischen zwei Mustern
PARSETEXT("Lorem ipsum dolor sit amet", "ipsum", "amet");
# Result: "dolor sit"
PARSETEXT("<temp>12.2</temp>", "<temp>", "</temp>");
# Result: 12.2
# ohne rechtes Muster endet der Wert am ersten anderen Zeichen
PARSETEXT("<temp>12.2</temp>", "<temp>");
# Result: 12.2
PARSETEXT("status:ok,error:none", "status:");
# Result: "ok"
# mehrere linke Teile werden nacheinander gesucht
PARSETEXT("Lorem ipsum dolor sit amet", "ipsum...sit");
# Result: "amet"
PARSETEXT("Lorem ipsum dolor sit amet consectetur adipiscing", "ipsum...sit", "adipiscing");
# Result: "amet consectetur"
# linkes Muster nicht gefunden
PARSETEXT("a=1", "b=");
# Result: Null
```

**Beispiel — rechtes Muster, das fehlen kann**

```taphome
# Position des linken Musters
VAR start := INDEXOF(text, "temp=");
# Abbruch, wenn das rechte Muster fehlt
IF start < 0 OR INDEXOF(COPY(text, start), ";") < 0
    RETURN(NaN);
END
# Wert zwischen den Mustern lesen
PARSETEXT(text, "temp=", ";");
```

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

## PARSEJSON

`PARSEJSON` liest einen Wert aus JSON mit einem JSONPath-Ausdruck; mit `TRUE` als drittem Argument gibt es `Null` zurück, statt das Skript anzuhalten, wenn der Pfad nicht gefunden wird.

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

| Name | Typ | Beschreibung |
|---|---|---|
| `json` | String, `collection<uint8>` oder Blob | JSON-Text. |
| `path` | String | JSONPath. Das führende `$.` ist optional. |
| `ignoreError` | bool, optional | `TRUE` (oder `1`): `Null` zurückgeben, wenn der Pfad nicht gefunden wird, das JSON ungültig ist oder `json` gleich `Null` ist. Standard `FALSE`. |

**Rückgabewert** — der Wert am Pfad: ein String, eine Zahl oder ein bool. Mehrere Treffer werden als Sammlung zurückgegeben. Ein Objekt oder ein Array wird als sein JSON-Text zurückgegeben, der erneut geparst werden kann.

| Pfad | Wählt aus |
|---|---|
| `temperature`, `cloud.connected` | Ein Feld, ein verschachteltes Feld. |
| `$.devices[0].name` | Ein Feld des ersten Array-Elements. |
| `$.devices[-1:].deviceId` | Das letzte Element eines Arrays. |
| `$[?(@.period == 1)].price` | Elemente, deren Feld eine Bedingung erfüllt. |

**Beispiel** — wenn `json` Folgendes enthält:

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

```taphome
# Feld auf oberster Ebene
PARSEJSON(json, "firstName");
# Result: "John"
# verschachteltes Feld
PARSEJSON(json, "address.city");
# Result: "Nara"
PARSEJSON(json, "age");
# Result: 26
# fehlender Pfad liefert Null statt Fehler
PARSEJSON(json, "address.country", TRUE);
# Result: Null
```

`PARSEJSON(json, "address.country")` ohne drittes Argument hält das Skript mit *PARSEJSON - Element not found: 'address.country'* an.

**Beispiel — Schleife über ein JSON-Array**

Mit `TRUE` gibt `PARSEJSON` nach dem letzten Element `Null` zurück, was die Schleife beendet:

```taphome
# Schleifenzähler und gesammelte Namen
VAR i := 0;
VAR names := "";
# Name des ersten Array-Elements
VAR name := PARSEJSON(json, "$.devices[0].name", TRUE);
WHILE !ISNULL(name)
    names := names + name + "\n";
    i := i + 1;
    # Name des nächsten Elements
    name := PARSEJSON(json, "$.devices[" + TOSTRING(i) + "].name", TRUE);
LOOP
# gesammelte Namen zurückgeben
names;
```

**Fehler** — *PARSEJSON - Element not found: 'path'*; *PARSEJSON - parse error: …* (ungültiges JSON); *PARSEJSON - argument 1 is null*.

## PARSEXML

`PARSEXML` liest einen Wert aus XML mit einem XPath-Ausdruck und gibt den Wert des ersten passenden Knotens zurück.

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

**Rückgabewert** — der Wert des ersten Knotens: eine Zahl, wenn sich der Text als Zahl lesen lässt, sonst ein String; `Null`, wenn nichts passt. XPath-Funktionen geben ihr eigenes Ergebnis zurück, zum Beispiel eine Zahl aus `count()`.

**Hinweise**

- Zahlen im Knotentext werden gemäß den Spracheinstellungen der Steuereinheit gelesen. Um eine Zahl unabhängig davon mit Dezimalpunkt zu lesen, schließen Sie den Pfad in die XPath-Funktion `number()` ein.
- Im Dokument deklarierte Namensräume werden automatisch registriert. Ein Namensraum mit Präfix (`xmlns:dc="…"`) wird mit seinem Präfix verwendet; ein Standardnamensraum (`xmlns="…"`) erhält den Namen des Elements, das ihn deklariert — für `<DIDL-Lite xmlns="…">` schreiben Sie `DIDL-Lite:container`.
- Dokumente kleiner als 80 kB und kompilierte Ausdrücke werden zwischengespeichert, sodass wiederholte Aufrufe auf dieselbe Antwort wenig kosten.

**Beispiel** — wenn die Antwort Folgendes enthält:

```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
# Antwortinhalt als XML-Text
VAR xml := response.Content;
# Titel des zweiten Buches
PARSEXML(xml, "//book[2]/title");
# Result: "Midnight Rain"
# Attributwert
PARSEXML(xml, "//book[1]/@id");
# Result: "bk101"
# number() liest den Preis als Zahl mit Dezimalpunkt
PARSEXML(xml, "number(//catalog/book[1]/price)");
# Result: 44.95
# count() liefert die Anzahl passender Knoten
PARSEXML(xml, "count(//book)");
# Result: 2
# ohne Treffer wird Null geliefert
PARSEXML(xml, "//catalog/magazine[1]/price");
# Result: Null
```

**Beispiel — XML mit Namensräumen**

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

**Fehler** — *PARSEXML - parse error: …* (ungültiges XML oder XPath).

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