---
title: "Syntax und Ablaufsteuerung"
description: "TapHome-Skriptsyntax: Semikolons, Kommentare, Zahlen- und Textliterale, Blöcke IF und ELSEIF, SWITCH, Schleifen WHILE und DO, BREAK, CONTINUE, RETURN und sichere Division mit IF."
url: "https://taphome.com/de/docs/script/basics/"
language: de
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["scripting-language","syntax","control-flow","variables","expressions"]
  questions: ["Wie schreibe ich mehrzeilige Skripte in TapHome?","Wie verwende ich IF/ELSE-Anweisungen in TapHome-Ausdrücken?","Wie funktioniert die SWITCH-Anweisung in TapHome?","Wie schreibe ich eine WHILE- oder DO-Schleife in TapHome?","Wie schreibe ich Hexadezimal- oder Binärzahlen in TapHome?","Wie behebe ich den Fehler \"Line in script: 1 Message: Division by zero\" in einem TapHome-Skript?","Wie teile ich zwei Variablen (va1/va2) sicher, sodass die Formel nur gilt, wenn der Nenner größer als 0 ist?","Wie schreibe ich den Wert 0, wenn ein Gerät einen Fehler hat oder statt einer Zahl NaN zurückgibt?","Wo kann ich in einem TapHome-Skript einen Kommentar einfügen?"]
---

# Syntax und Ablaufsteuerung

Syntax der TapHome-Skriptsprache: Anweisungen und Semikolons, Kommentare, Literale, IF in Funktions- und Blockform, SWITCH, Schleifen WHILE und DO, BREAK, CONTINUE und RETURN.

Zuletzt aktualisiert: 2026-11-06

Ein TapHome-Skript ist eine Folge von Anweisungen, jeweils mit einem Semikolon abgeschlossen, die sich mit `IF` und `SWITCH` verzweigen und mit den Schleifen `WHILE` und `DO` wiederholen lässt. Diese Seite behandelt Kommentare, Literale (Zahlen, hexadezimale und binäre Werte, Text, Sammlungen), die Funktions- und Blockform von `IF`, `SWITCH`, die Schleifen mit `BREAK` und `CONTINUE` sowie `RETURN`. Bei Schlüsselwörtern und Namen spielt die Groß- und Kleinschreibung keine Rolle, und ein Skript liefert den Wert seiner letzten Anweisung, sofern `RETURN` es nicht früher beendet. Zum Beispiel dividiert `IF(va2 > 0, va1/va2, 0)` sicher und vermeidet den Fehler `Division by zero`.

## Anweisungen und Semikolons

Ein Skript ist eine Folge von Anweisungen, und jede Anweisung endet mit einem Semikolon `;`. Blockanweisungen (`IF … END`, `WHILE … LOOP`, `DO … LOOP WHILE …`) und Kommentare enden nicht mit einem Semikolon. Bei Schlüsselwörtern und Namen spielt die Groß- und Kleinschreibung keine Rolle: `IF`, `if` und `If` sind dasselbe.

```taphome
# x startet bei 5
VAR x := 5;
IF x > 3
    x := x - 1;   # läuft nur, wenn x größer als 3 ist
END
# der letzte Ausdruck ist das Ergebnis
x;
# Result: 4
```

Das Semikolon darf nur nach der letzten Anweisung des Skripts fehlen; innerhalb eines Blocks braucht es jede Anweisung, auch die letzte vor `END` oder `LOOP`. Fehlt innerhalb eines Blocks das Semikolon vor `END` oder `LOOP`, bricht das Skript mit `Unexpected character 'E' at the end of statement. Expected ';'` ab (`'L'` vor `LOOP`).

## Kommentare

Ein Kommentar beginnt mit `#` und reicht bis zum Zeilenende. Er kann in einer eigenen Zeile stehen oder auf eine vollständige Anweisung folgen: nach ihrem Semikolon oder nach `END`, `ELSE` oder `LOOP`.

```taphome
# Startwert
VAR x := 5;          # ein Kommentar nach dem Semikolon
IF x > 3
    x := 1;
END                  # Ende der Prüfung
```

Ein `#` innerhalb einer Anweisung (vor ihrem Semikolon oder nach der Bedingung von `IF` oder `WHILE`) schlägt mit `Comment must start on a new line and inline comments are not supported` fehl.

## Literale

Ein Literal ist ein Wert, der direkt im Skript steht.

| Literal | Beispiel | Hinweise |
|---|---|---|
| Zahl | `5`, `21.5`, `-3` | Dezimaltrennzeichen `.`. Ein Zahlenliteral ist ein `double`, daher ergibt `5 / 2` den Wert `2.5`. Kein Exponent (`1e3`), kein führender Punkt (`.5`). |
| Hexadezimal | `0xA0A0`, `0xff` | Ein `int`, bei den Ziffern spielt die Groß- und Kleinschreibung keine Rolle: `0xA0A0` ist 41120. |
| Binär | `0b10101010` | Ein `int`: 170. |
| Boolesch | `TRUE`, `FALSE` | |
| Unbekannte Zahl | `NaN` | Nie gleich irgendetwas; prüfen Sie es mit [`ISNAN`](https://taphome.com/de/docs/script/logic-and-diagnostics/#isnan). |
| Kein Wert | `Null` | Prüfen Sie es mit [`ISNULL`](https://taphome.com/de/docs/script/logic-and-diagnostics/#isnull). |
| Text | `"°C"`, `"a\nb"`, `"C:\\data"` | Escape-Sequenzen `\n`, `\r`, `\t`, `\"`, `\\`, `\xHH`, `\uXXXX`. Eine ungültige Escape-Sequenz schlägt mit `Couldn't unescape …` fehl. |
| Zeichen | `'A'`, `'\n'` | Genau ein Zeichen. |
| Sammlung | `{1, 2, 3}`, `{"a", "b"}` | Mindestens ein Element, siehe [Sammlungen](https://taphome.com/de/docs/script/data-types/#collections). |
| Aufzählungswert | `H`, `BigEndianFloat`, `DateTimeKind.Utc` | Allein oder mit dem Typnamen, siehe [Aufzählungstypen](https://taphome.com/de/docs/script/data-types/#enum-types). |

## IF

`IF` gibt abhängig von einer Bedingung einen von zwei Werten zurück (Funktionsform) oder führt einen von mehreren Anweisungsblöcken aus (Blockform).

```text
IF(condition, valueIfTrue)
IF(condition, valueIfTrue, valueIfFalse)
```

**Parameter**

| Name | Typ | Beschreibung |
|---|---|---|
| `condition` | bool | Eine Zahl ungleich null ist `TRUE`, `Null` ist `FALSE`. |
| `valueIfTrue` | any | Wird zurückgegeben, wenn die Bedingung `TRUE` ist. |
| `valueIfFalse` | any | Optional, wird sonst zurückgegeben. |

**Rückgabewert** ist der gewählte Wert, oder `Null`, wenn die Bedingung nicht `TRUE` ist und es kein drittes Argument gibt. Nur der gewählte Zweig wird ausgewertet, der andere kann also nicht fehlschlagen.

**Beispiel** — sichere Division und ein Ersatz für `NaN`. Eine Division durch null bricht das Skript mit `Line in script: 1 Message: Division by zero` ab; die Bedingung verhindert das:

```taphome
IF(va2 > 0, va1/va2, 0);
# Result: va1/va2, or 0 when va2 is 0
IF(ISNAN(Te), 0, Te);
# Result: 0 when the device is in error or returns NaN
```

**Blockform**

```text
IF condition
    statements;
ELSEIF condition
    statements;
ELSE
    statements;
END
```

Die Bedingung darf in Klammern stehen und muss in eine Zeile passen; der Zeilenumbruch beendet sie. `ELSEIF` kann sich wiederholen, `ELSE` ist optional, `END` ist Pflicht. Der Block selbst gibt `Null` zurück; verwenden Sie `RETURN`, um aus seinem Inneren einen Wert zu liefern.

```taphome
# Wert nach der Temperatur Te wählen
IF Te < 5
    RETURN(1);   # unter 5
ELSEIF Te > 10
    RETURN(3);   # über 10
ELSE
    RETURN(0);   # sonst
END
```

**Fehler** — `Function IF requires at least 2 parameters.`; `Unexpected keyword 'X' at the end of IF statement.`, wenn auf ein inneres `END` ein `;` folgt.

**Siehe auch** — [SWITCH](https://taphome.com/de/docs/script/basics/#switch), [Operatoren](https://taphome.com/de/docs/script/operators/).

## SWITCH

`SWITCH` vergleicht einen Wert mit einer Liste von Fällen und gibt das Ergebnis des ersten passenden Falls zurück, oder ein Standardergebnis, wenn kein Fall passt.

```text
SWITCH(value, case1, result1, case2, result2, ..., defaultResult)
```

**Hinweise** — `SWITCH` nimmt mindestens 4 und höchstens 100 Argumente, immer eine gerade Anzahl: den Wert, Paare aus Fall und Ergebnis und das Standardergebnis. Fälle werden wie mit `=` verglichen: Zahlen nach Wert, Text exakt; der Vergleich von Text mit einer Zahl schlägt mit `Operator '==' not defined …` fehl. Nur das Ergebnis des passenden Falls wird ausgewertet.

**Beispiel** — das Handbuch des Geräts führt den aktiven Modus als Bitwerte auf; das Skript macht daraus Stellungen eines Mehrfachschalters:

![SWITCH-Beispiel](https://taphome.com/documentation/script/switch-example.png)

```taphome
# Modusbits aus dem Modbus-Register 168 lesen
# ein Bitwert wird zur Schalterstellung, sonst NaN
SWITCH(MODBUSR(H, 168, UInt16),
    0, 0,
    0x0002, 1,
    0x0004, 2,
    0x0008, 3,
    0x0010, 4,
    0x0040, 5,
    0x0800, 6,
    NaN);
```

**Fehler** — `Function SWITCH requires at least 4 parameters.`; `Invalid arguments for SWITCH function.` bei einer ungeraden Anzahl von Argumenten.

## Schleifen WHILE und DO

`WHILE` wiederholt seine Anweisungen, solange die Bedingung `TRUE` ist; `DO … LOOP WHILE` führt sie mindestens einmal aus. `CONTINUE;` überspringt den Rest des Durchlaufs, `BREAK;` verlässt die Schleife; beide werden ohne Klammern geschrieben.

```text
WHILE condition
    statements;
LOOP

DO
    statements;
LOOP WHILE condition
```

Wie bei `IF` endet die Bedingung am Zeilenumbruch. Beginnt sie mit `(`, endet sie an der passenden `)`: `WHILE (a > 0) AND (b > 0)` nimmt nur `(a > 0)` als Bedingung, schreiben Sie also `WHILE (a > 0 AND b > 0)`.

```taphome
int i := 10;   # Zähler startet bei 10
WHILE i > 0
    i := i - 1;   # herunterzählen
    IF i > 5
        CONTINUE;   # Rest des Durchlaufs überspringen, solange i über 5 liegt
    END
    BREAK;   # Schleife verlassen, sobald i höchstens 5 ist
LOOP
i;
# Result: 5
```

```taphome
int n := 1;   # Startwert
# der Rumpf läuft mindestens einmal, dann solange n < 100
DO
    n := n * 2;   # n bei jedem Durchlauf verdoppeln
LOOP WHILE n < 100
n;
# Result: 128
```

**Fehler** — eine Schleife bricht mit `More than 1 000 000 loops, stopping loop` ab. `BREAK` oder `CONTINUE` außerhalb einer Schleife schlägt mit `Cannot use BREAK() outside of WHILE or DO-WHILE` fehl. Ein `;` nach einem inneren `LOOP` oder `END` schlägt mit `Unexpected character ';' in WHILE statement` fehl.

> [!WARNING]
> Namen werden vor den Schlüsselwörtern der Schleife aufgelöst. Eine Variable oder eine Geräteabkürzung namens `Do` oder `While` verdeckt das Schlüsselwort, und die Schleife schlägt mit `Missing operator between 'DO' and …` fehl.

## RETURN

`RETURN` beendet das Skript sofort und macht den angegebenen Wert zu seinem Ergebnis.

```text
RETURN(value)
```

**Hinweise** — ohne `RETURN` ist das Ergebnis der Wert der letzten Anweisung. Verwenden Sie `RETURN`, um aus dem Inneren eines Blocks einen Wert zu liefern oder um ein Listener-Skript bei Nachrichten, die es nicht verarbeitet, vorzeitig zu beenden.

```taphome
# Skript mit 0 beenden, wenn Te unbekannt ist
IF ISNAN(Te)
    RETURN(0);
END
# Temperatur in °F umrechnen
Te * 1.8 + 32;
# Result: the temperature in °F, or 0 when it is unknown
```

**Siehe auch** — [Skriptergebnis](https://taphome.com/de/docs/script/#script-result).