---
title: "Sintaxă și controlul fluxului"
description: "Sintaxa scripturilor TapHome: punct și virgulă, comentarii, literali numerici și text, blocuri IF și ELSEIF, SWITCH, buclele WHILE și DO, BREAK, CONTINUE, RETURN și împărțirea sigură cu IF."
url: "https://taphome.com/ro/docs/script/basics/"
language: ro
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["scripting-language","syntax","control-flow","variables","expressions"]
  questions: ["Cum se scriu scripturi pe mai multe linii în TapHome?","Cum se folosesc instrucțiunile IF/ELSE în expresiile TapHome?","Cum funcționează instrucțiunea SWITCH în TapHome?","Cum se scrie o buclă WHILE sau DO în TapHome?","Cum se scriu numere hexazecimale sau binare în TapHome?","Cum se remediază eroarea „Line in script: 1 Message: Division by zero\" într-un script TapHome?","Cum se împart în siguranță două variabile (va1/va2), aplicând formula doar când numitorul este mai mare decât 0?","Cum se scrie valoarea 0 când un dispozitiv este în eroare sau returnează NaN în loc de număr?","Unde se poate pune un comentariu într-un script TapHome?"]
---

# Sintaxă și controlul fluxului

Sintaxa limbajului de scripting TapHome: instrucțiuni și punct și virgulă, comentarii, literali, IF în formă de funcție și de bloc, SWITCH, buclele WHILE și DO, BREAK, CONTINUE și RETURN.

Ultima actualizare: 2026-11-06

Un script TapHome este o secvență de instrucțiuni, fiecare încheiată cu punct și virgulă, care se poate ramifica cu `IF` și `SWITCH` și se poate repeta cu buclele `WHILE` și `DO`. Pagina descrie comentariile, literalii (numere, valori hexazecimale și binare, text, colecții), forma de funcție și de bloc a lui `IF`, `SWITCH`, buclele cu `BREAK` și `CONTINUE` și `RETURN`. Cuvintele cheie și numele nu țin cont de majuscule, iar un script returnează valoarea ultimei instrucțiuni, dacă `RETURN` nu îl încheie mai devreme. De exemplu, `IF(va2 > 0, va1/va2, 0)` împarte în siguranță și evită eroarea `Division by zero`.

## Instrucțiuni și punct și virgulă

Un script este o secvență de instrucțiuni, iar fiecare instrucțiune se termină cu punct și virgulă `;`. Instrucțiunile de tip bloc (`IF … END`, `WHILE … LOOP`, `DO … LOOP WHILE …`) și comentariile nu se termină cu punct și virgulă. Cuvintele cheie și numele nu țin cont de majuscule: `IF`, `if` și `If` sunt același lucru.

```taphome
# x pornește de la 5
VAR x := 5;
IF x > 3
    x := x - 1;   # se execută doar când x este mai mare decât 3
END
# ultima expresie este rezultatul
x;
# Result: 4
```

Punctul și virgula se poate omite doar după ultima instrucțiune a scriptului; în interiorul unui bloc fiecare instrucțiune îl necesită, inclusiv ultima dinaintea lui `END` sau `LOOP`. În interiorul unui bloc, lipsa punctului și virgulei înaintea lui `END` sau `LOOP` oprește scriptul cu `Unexpected character 'E' at the end of statement. Expected ';'` (`'L'` înaintea lui `LOOP`).

## Comentarii

Un comentariu începe cu `#` și continuă până la sfârșitul liniei. Poate sta pe o linie proprie sau poate urma după o instrucțiune completă: după punctul și virgula ei ori după `END`, `ELSE` sau `LOOP`.

```taphome
# valoare inițială
VAR x := 5;          # un comentariu după punct și virgulă
IF x > 3
    x := 1;
END                  # sfârșitul verificării
```

Un `#` în interiorul unei instrucțiuni (înaintea punctului și virgulei sau după condiția lui `IF` ori `WHILE`) eșuează cu `Comment must start on a new line and inline comments are not supported`.

## Literali

Un literal este o valoare scrisă direct în script.

| Literal | Exemplu | Observații |
|---|---|---|
| Număr | `5`, `21.5`, `-3` | Separator zecimal `.`. Un literal numeric este de tip `double`, deci `5 / 2` este `2.5`. Fără exponent (`1e3`), fără punct la început (`.5`). |
| Hexazecimal | `0xA0A0`, `0xff` | De tip `int`, cifrele nu țin cont de majuscule: `0xA0A0` este 41120. |
| Binar | `0b10101010` | De tip `int`: 170. |
| Boolean | `TRUE`, `FALSE` | |
| Număr necunoscut | `NaN` | Nu este egal cu nimic; se testează cu [`ISNAN`](https://taphome.com/ro/docs/script/logic-and-diagnostics/#isnan). |
| Fără valoare | `Null` | Se testează cu [`ISNULL`](https://taphome.com/ro/docs/script/logic-and-diagnostics/#isnull). |
| Șir de caractere | `"°C"`, `"a\nb"`, `"C:\\data"` | Secvențe escape `\n`, `\r`, `\t`, `\"`, `\\`, `\xHH`, `\uXXXX`. O secvență escape invalidă eșuează cu `Couldn't unescape …`. |
| Caracter | `'A'`, `'\n'` | Exact un caracter. |
| Colecție | `{1, 2, 3}`, `{"a", "b"}` | Cel puțin un element, consultați [Colecții](https://taphome.com/ro/docs/script/data-types/#collections). |
| Valoare de enumerare | `H`, `BigEndianFloat`, `DateTimeKind.Utc` | Simplă sau cu numele tipului, consultați [Tipuri de enumerare](https://taphome.com/ro/docs/script/data-types/#enum-types). |

## IF

`IF` returnează una dintre două valori în funcție de o condiție (forma de funcție) sau execută unul dintre mai multe blocuri de instrucțiuni (forma de bloc).

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

**Parametri**

| Nume | Tip | Descriere |
|---|---|---|
| `condition` | bool | Un număr diferit de zero este `TRUE`, `Null` este `FALSE`. |
| `valueIfTrue` | any | Se returnează când condiția este `TRUE`. |
| `valueIfFalse` | any | Opțional, se returnează în celelalte cazuri. |

**Returnează** valoarea selectată sau `Null` când condiția nu este `TRUE` și nu există al treilea argument. Se evaluează doar ramura selectată, așa că cealaltă nu poate eșua.

**Exemplu** — împărțire sigură și înlocuirea lui `NaN`. Împărțirea la zero oprește scriptul cu `Line in script: 1 Message: Division by zero`; condiția previne acest lucru:

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

**Forma de bloc**

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

Condiția poate fi între paranteze și trebuie să încapă pe o singură linie; sfârșitul liniei o încheie. `ELSEIF` se poate repeta, `ELSE` este opțional, `END` este obligatoriu. Blocul în sine returnează `Null`; pentru a produce o valoare din interiorul lui se folosește `RETURN`.

```taphome
# alege o valoare după temperatura Te
IF Te < 5
    RETURN(1);   # sub 5
ELSEIF Te > 10
    RETURN(3);   # peste 10
ELSE
    RETURN(0);   # altfel
END
```

**Erori** — `Function IF requires at least 2 parameters.`; `Unexpected keyword 'X' at the end of IF statement.` când un `;` urmează după un `END` interior.

**Consultați și** — [SWITCH](https://taphome.com/ro/docs/script/basics/#switch), [Operatori](https://taphome.com/ro/docs/script/operators/).

## SWITCH

`SWITCH` compară o valoare cu o listă de cazuri și returnează rezultatul primului caz care se potrivește sau un rezultat implicit când niciun caz nu se potrivește.

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

**Observații** — `SWITCH` primește cel puțin 4 și cel mult 100 de argumente, întotdeauna un număr par: valoarea, perechi formate dintr-un caz și rezultatul lui și rezultatul implicit. Cazurile se compară ca la `=`: numerele după valoare, textul exact; compararea unui text cu un număr eșuează cu `Operator '==' not defined …`. Se evaluează doar rezultatul cazului care se potrivește.

**Exemplu** — manualul dispozitivului indică modul activ prin valori de biți; scriptul le transformă în pozițiile unui comutator cu mai multe valori:

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

```taphome
# citește biții modului din registrul Modbus 168
# valoarea bitului devine o poziție a comutatorului, altfel NaN
SWITCH(MODBUSR(H, 168, UInt16),
    0, 0,
    0x0002, 1,
    0x0004, 2,
    0x0008, 3,
    0x0010, 4,
    0x0040, 5,
    0x0800, 6,
    NaN);
```

**Erori** — `Function SWITCH requires at least 4 parameters.`; `Invalid arguments for SWITCH function.` pentru un număr impar de argumente.

## Buclele WHILE și DO

`WHILE` repetă instrucțiunile cât timp condiția este `TRUE`; `DO … LOOP WHILE` le execută cel puțin o dată. `CONTINUE;` sare peste restul trecerii curente, `BREAK;` părăsește bucla; ambele se scriu fără paranteze.

```text
WHILE condition
    statements;
LOOP

DO
    statements;
LOOP WHILE condition
```

Ca la `IF`, condiția se încheie la sfârșitul liniei. Când începe cu `(`, se încheie la `)` corespunzătoare: `WHILE (a > 0) AND (b > 0)` ia drept condiție doar `(a > 0)`, de aceea se scrie `WHILE (a > 0 AND b > 0)`.

```taphome
int i := 10;   # contorul pornește de la 10
WHILE i > 0
    i := i - 1;   # numărătoare inversă
    IF i > 5
        CONTINUE;   # sare peste restul trecerii cât timp i este peste 5
    END
    BREAK;   # iese din buclă când i este cel mult 5
LOOP
i;
# Result: 5
```

```taphome
int n := 1;   # valoare inițială
# corpul rulează cel puțin o dată, apoi cât timp n < 100
DO
    n := n * 2;   # n se dublează la fiecare trecere
LOOP WHILE n < 100
n;
# Result: 128
```

**Erori** — o buclă se oprește cu `More than 1 000 000 loops, stopping loop`. `BREAK` sau `CONTINUE` în afara unei bucle eșuează cu `Cannot use BREAK() outside of WHILE or DO-WHILE`. Un `;` după un `LOOP` sau `END` interior eșuează cu `Unexpected character ';' in WHILE statement`.

> [!WARNING]
> Numele se rezolvă înaintea cuvintelor cheie ale buclelor. O variabilă sau o abreviere de dispozitiv numită `Do` sau `While` ascunde cuvântul cheie, iar bucla eșuează cu `Missing operator between 'DO' and …`.

## RETURN

`RETURN` încheie imediat scriptul și face din valoarea dată rezultatul lui.

```text
RETURN(value)
```

**Observații** — fără `RETURN`, rezultatul este valoarea ultimei instrucțiuni. `RETURN` se folosește pentru a da o valoare din interiorul unui bloc sau pentru a opri mai devreme un script listener la mesajele pe care nu le tratează.

```taphome
# termină scriptul cu 0 când Te este necunoscută
IF ISNAN(Te)
    RETURN(0);
END
# convertește temperatura în °F
Te * 1.8 + 32;
# Result: the temperature in °F, or 0 when it is unknown
```

**Consultați și** — [Rezultatul scriptului](https://taphome.com/ro/docs/script/#script-result).
