---
title: "Szintaxis és vezérlési szerkezetek"
description: "TapHome szkript szintaxis: pontosvesszők, megjegyzések, szám- és szövegliterálok, IF és ELSEIF blokkok, SWITCH, WHILE és DO ciklusok, BREAK, CONTINUE, RETURN és biztonságos osztás IF-fel."
url: "https://taphome.com/hu/docs/script/basics/"
language: hu
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["scripting-language","syntax","control-flow","variables","expressions"]
  questions: ["Hogyan írhatok többsoros szkripteket a TapHome-ban?","Hogyan használom az IF/ELSE utasításokat a TapHome kifejezésekben?","Hogyan működik a SWITCH utasítás a TapHome-ban?","Hogyan írhatok WHILE vagy DO ciklust a TapHome-ban?","Hogyan írhatok hexadecimális vagy bináris számokat a TapHome-ban?","Hogyan javíthatom a „Line in script: 1 Message: Division by zero” hibát egy TapHome szkriptben?","Hogyan oszthatok el biztonságosan két változót (va1/va2) úgy, hogy a képlet csak akkor fusson, ha a nevező nagyobb 0-nál?","Hogyan írhatok be 0 értéket, ha egy eszköz hibában van, vagy szám helyett NaN értéket ad vissza?","Hová tehetek megjegyzést egy TapHome szkriptben?"]
---

# Szintaxis és vezérlési szerkezetek

A TapHome szkriptnyelv szintaxisa: utasítások és pontosvesszők, megjegyzések, literálok, az IF függvény- és blokkformája, SWITCH, WHILE és DO ciklusok, BREAK, CONTINUE és RETURN.

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

A TapHome szkript utasítások sorozata, amelyeknek mindegyike pontosvesszővel végződik, és amely az `IF` és a `SWITCH` segítségével elágazhat, a `WHILE` és a `DO` ciklusokkal pedig ismételhet. Az oldal a megjegyzéseket, a literálokat (számok, hexadecimális és bináris értékek, szöveg, gyűjtemények), az `IF` függvény- és blokkformáját, a `SWITCH` utasítást, a `BREAK` és `CONTINUE` utasítást használó ciklusokat, valamint a `RETURN` utasítást mutatja be. A kulcsszavak és a nevek nem különböztetik meg a kis- és nagybetűket, a szkript pedig az utolsó utasítás értékét adja vissza, ha a `RETURN` korábban nem fejezi be. Például az `IF(va2 > 0, va1/va2, 0)` biztonságosan osztja az értékeket, és elkerüli a `Division by zero` hibát.

## Utasítások és pontosvesszők

A szkript utasítások sorozata, és minden utasítás pontosvesszővel `;` végződik. A blokkutasítások (`IF … END`, `WHILE … LOOP`, `DO … LOOP WHILE …`) és a megjegyzések után nincs pontosvessző. A kulcsszavak és a nevek nem különböztetik meg a kis- és nagybetűket: az `IF`, az `if` és az `If` ugyanaz.

```taphome
# x értéke 5-tel indul
VAR x := 5;
IF x > 3
    x := x - 1;   # csak akkor fut le, ha x nagyobb 3-nál
END
# az utolsó kifejezés az eredmény
x;
# Result: 4
```

A pontosvessző csak a szkript utolsó utasítása után hagyható el; blokkon belül minden utasításnak kell, az `END` vagy `LOOP` előtti utolsónak is. Ha blokkon belül hiányzik a pontosvessző az `END` vagy a `LOOP` előtt, a szkript az `Unexpected character 'E' at the end of statement. Expected ';'` hibával leáll (a `LOOP` előtt `'L'`).

## Megjegyzések

A megjegyzés `#` jellel kezdődik, és a sor végéig tart. Állhat külön sorban, vagy követhet egy teljes utasítást: a pontosvessző után, illetve az `END`, `ELSE` vagy `LOOP` után.

```taphome
# kezdőérték
VAR x := 5;          # megjegyzés a pontosvessző után
IF x > 3
    x := 1;
END                  # az ellenőrzés vége
```

Az utasításon belüli `#` (a pontosvessző előtt, vagy egy `IF` vagy `WHILE` feltétele után) a `Comment must start on a new line and inline comments are not supported` hibát okozza.

## Literálok

A literál a szkriptbe közvetlenül beírt érték.

| Literál | Példa | Megjegyzés |
|---|---|---|
| Szám | `5`, `21.5`, `-3` | Tizedesjel: pont `.`. A számliterál `double`, ezért az `5 / 2` eredménye `2.5`. Kitevő (`1e3`) és kezdő pont (`.5`) nem használható. |
| Hexadecimális | `0xA0A0`, `0xff` | `int`, a számjegyeknél a kis- és nagybetű nem számít: a `0xA0A0` értéke 41120. |
| Bináris | `0b10101010` | `int`: 170. |
| Logikai | `TRUE`, `FALSE` | |
| Ismeretlen szám | `NaN` | Soha nem egyenlő semmivel; az [`ISNAN`](https://taphome.com/hu/docs/script/logic-and-diagnostics/#isnan) függvénnyel vizsgáld. |
| Nincs érték | `Null` | Az [`ISNULL`](https://taphome.com/hu/docs/script/logic-and-diagnostics/#isnull) függvénnyel vizsgáld. |
| Szöveg | `"°C"`, `"a\nb"`, `"C:\\data"` | Escape-szekvenciák: `\n`, `\r`, `\t`, `\"`, `\\`, `\xHH`, `\uXXXX`. Érvénytelen escape-szekvencia esetén `Couldn't unescape …` hiba. |
| Karakter | `'A'`, `'\n'` | Pontosan egy karakter. |
| Gyűjtemény | `{1, 2, 3}`, `{"a", "b"}` | Legalább egy elem, lásd [Gyűjtemények](https://taphome.com/hu/docs/script/data-types/#collections). |
| Felsorolt érték | `H`, `BigEndianFloat`, `DateTimeKind.Utc` | Önmagában vagy a típus nevével, lásd [Felsorolt típusok](https://taphome.com/hu/docs/script/data-types/#enum-types). |

## IF

Az `IF` egy feltételtől függően két érték egyikét adja vissza (függvényforma), vagy több utasításblokk egyikét futtatja le (blokkforma).

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

**Paraméterek**

| Név | Típus | Leírás |
|---|---|---|
| `condition` | bool | A nem nulla szám `TRUE`, a `Null` `FALSE`. |
| `valueIfTrue` | any | Ezt adja vissza, ha a feltétel `TRUE`. |
| `valueIfFalse` | any | Nem kötelező; minden más esetben ezt adja vissza. |

**Visszatérési érték:** a kiválasztott érték, vagy `Null`, ha a feltétel nem `TRUE` és nincs harmadik argumentum. Csak a kiválasztott ág értékelődik ki, így a másik nem okozhat hibát.

**Példa** — biztonságos osztás és a `NaN` helyettesítése. A nullával való osztás a `Line in script: 1 Message: Division by zero` hibával leállítja a szkriptet; a feltétel ezt megakadályozza:

```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
```

**Blokkforma**

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

A feltétel lehet zárójelben, és egy sorba kell férnie; a sortörés lezárja. Az `ELSEIF` ismétlődhet, az `ELSE` nem kötelező, az `END` kötelező. Maga a blokk `Null` értéket ad vissza; ha a blokk belsejéből akarsz értéket adni, használd a `RETURN` utasítást.

```taphome
# érték választása a Te hőmérséklet alapján
IF Te < 5
    RETURN(1);   # 5 alatt
ELSEIF Te > 10
    RETURN(3);   # 10 fölött
ELSE
    RETURN(0);   # egyébként
END
```

**Hibák** — `Function IF requires at least 2 parameters.`; `Unexpected keyword 'X' at the end of IF statement.`, ha egy belső `END` után `;` áll.

**Lásd még** — [SWITCH](https://taphome.com/hu/docs/script/basics/#switch), [Operátorok](https://taphome.com/hu/docs/script/operators/).

## SWITCH

A `SWITCH` egy értéket esetek listájával hasonlít össze, és az első egyező eset eredményét adja vissza, vagy egy alapértelmezett eredményt, ha egyik eset sem egyezik.

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

**Megjegyzések** — a `SWITCH` legalább 4 és legfeljebb 100 argumentumot fogad, mindig páros számút: az értéket, eset–eredmény párokat és az alapértelmezett eredményt. Az esetek összehasonlítása úgy működik, mint az `=`: a számok érték szerint, a szöveg pontos egyezéssel; szöveg és szám összehasonlítása az `Operator '==' not defined …` hibát okozza. Csak az egyező eset eredménye értékelődik ki.

**Példa** — az eszköz kézikönyve az aktív üzemmódot bitértékekként adja meg; a szkript ezeket a többállású kapcsoló pozícióivá alakítja:

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

```taphome
# a mód bitjeinek olvasása a 168-as Modbus-regiszterből
# a bitérték kapcsolóállás lesz, különben NaN
SWITCH(MODBUSR(H, 168, UInt16),
    0, 0,
    0x0002, 1,
    0x0004, 2,
    0x0008, 3,
    0x0010, 4,
    0x0040, 5,
    0x0800, 6,
    NaN);
```

**Hibák** — `Function SWITCH requires at least 4 parameters.`; páratlan számú argumentum esetén `Invalid arguments for SWITCH function.`.

## WHILE és DO ciklusok

A `WHILE` addig ismétli az utasításait, amíg a feltétel `TRUE`; a `DO … LOOP WHILE` legalább egyszer lefuttatja őket. A `CONTINUE;` átugorja a menet hátralévő részét, a `BREAK;` kilép a ciklusból; mindkettőt zárójel nélkül kell írni.

```text
WHILE condition
    statements;
LOOP

DO
    statements;
LOOP WHILE condition
```

Ahogy az `IF` esetén, a feltétel a sortörésnél ér véget. Ha `(` jellel kezdődik, a hozzá tartozó `)` jelnél ér véget: a `WHILE (a > 0) AND (b > 0)` feltételként csak az `(a > 0)` részt veszi, ezért írd így: `WHILE (a > 0 AND b > 0)`.

```taphome
int i := 10;   # a számláló 10-ről indul
WHILE i > 0
    i := i - 1;   # visszaszámlálás
    IF i > 5
        CONTINUE;   # a menet hátralévő részének kihagyása, amíg i 5 fölött van
    END
    BREAK;   # kilépés a ciklusból, ha i legfeljebb 5
LOOP
i;
# Result: 5
```

```taphome
int n := 1;   # kezdőérték
# a törzs legalább egyszer lefut, utána amíg n < 100
DO
    n := n * 2;   # n megduplázása minden menetben
LOOP WHILE n < 100
n;
# Result: 128
```

**Hibák** — a ciklus a `More than 1 000 000 loops, stopping loop` hibával leáll. A cikluson kívüli `BREAK` vagy `CONTINUE` a `Cannot use BREAK() outside of WHILE or DO-WHILE` hibát okozza. Egy belső `LOOP` vagy `END` utáni `;` az `Unexpected character ';' in WHILE statement` hibát okozza.

> [!WARNING]
> A nevek feloldása a ciklus kulcsszavai előtt történik. Egy `Do` vagy `While` nevű változó vagy eszközrövidítés elfedi a kulcsszót, és a ciklus a `Missing operator between 'DO' and …` hibával leáll.

## RETURN

A `RETURN` azonnal befejezi a szkriptet, és a megadott értéket teszi meg az eredményének.

```text
RETURN(value)
```

**Megjegyzések** — `RETURN` nélkül az eredmény az utolsó utasítás értéke. A `RETURN` segítségével adhatsz értéket egy blokk belsejéből, vagy idő előtt leállíthatod a listener szkriptet azoknál az üzeneteknél, amelyeket nem dolgoz fel.

```taphome
# a szkript 0-val véget ér, ha Te ismeretlen
IF ISNAN(Te)
    RETURN(0);
END
# a hőmérséklet átszámítása °F-ra
Te * 1.8 + 32;
# Result: the temperature in °F, or 0 when it is unknown
```

**Lásd még** — [A szkript eredménye](https://taphome.com/hu/docs/script/#script-result).