---
title: "Text și colecții"
description: "Funcțiile pentru text și colecții din scripturile TapHome: LENGTH, GETAT, SETAT, APPEND, INSERT, REMOVEAT, COPY, INDEXOF, REPLACE, SPLIT, COMPARE și BYTECOLLECTION, UINT16COLLECTION, BOOLCOLLECTION."
url: "https://taphome.com/ro/docs/script/text-string-and-byte-array/"
language: ro
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["string-functions","byte-array","collections","scripting-language"]
  questions: ["Cum se obține lungimea unui șir de caractere într-un script TapHome?","Cum se împarte un șir de caractere după un separator în TapHome?","Cum se înlocuiește un text în interiorul unui șir de caractere în TapHome?","Cum se creează o colecție de octeți din valori hexazecimale?","Cum se găsește indexul unui element într-un șir de caractere sau într-o colecție?","APPEND creează o colecție nouă sau o modifică pe cea originală?","Cum se compară două șiruri de caractere într-un script TapHome?"]
---

# Text și colecții

Funcțiile de script TapHome pentru șiruri de caractere, colecții și tablouri de octeți — LENGTH, GETAT, SETAT, APPEND, INSERT, REMOVEAT, COPY, INDEXOF, REPLACE, SPLIT, COMPARE, BYTECOLLECTION, UINT16COLLECTION, BOOLCOLLECTION.

Ultima actualizare: 2026-11-06

Aceste funcții primesc ca prim argument un șir de caractere sau o colecție și lucrează cu caractere sau elemente după un index care începe de la zero.

- O **colecție** este modificată **pe loc** de `APPEND`, `INSERT`, `REMOVEAT`, `SETAT` și `REPLACE`, care returnează aceeași colecție. Pentru un **șir de caractere** ele returnează un șir nou.
- Un **blob**, precum `RECEIVEDMSG.PAYLOAD`, este acceptat doar de `LENGTH`, `GETAT`, `COPY` și `INDEXOF`.
- Un prim argument `Null` oprește scriptul cu *Parameter 1 is null*, cu excepția lui `LENGTH` (0), `INDEXOF` (-1) și `SPLIT` (o colecție goală); `COMPARE` raportează *COMPARE arguments 1 and 2 must be strings*.

`ENCODE` și `DECODE` (XML, Base64) se găsesc pe pagina [Conversii de tipuri de date](https://taphome.com/ro/docs/script/data-type-conversions/), `EQUALS` pe pagina [Logică și diagnostic](https://taphome.com/ro/docs/script/logic-and-diagnostics/#equals). Tipurile de colecții sunt descrise în [Tipuri de date](https://taphome.com/ro/docs/script/data-types/).

## LENGTH

`LENGTH` returnează numărul de caractere ale unui șir, de elemente ale unei colecții sau de octeți ai unui blob; pentru un număr returnează dimensiunea tipului lui în octeți, iar pentru `Null` 0.

```taphome
# caractere într-un șir
LENGTH("Hello World");
# Result: 11
# lungimea unui număr
LENGTH(40);
# Result: 8 (a decimal literal is a double)
# octeți într-o colecție de octeți
LENGTH(BYTECOLLECTION("010203"));
# Result: 3
```

## GETAT

`GETAT` returnează elementul de la un index: un `char` al unui șir, un element al unei colecții sau un octet al unui blob.

```text
GETAT(value, index)
```

**Returnează** — pentru un șir de caractere un `char`, nu un șir de o singură literă; se compară cu un literal de caracter precum `'l'`.

```taphome
GETAT("Hello", 2);
# Result: 'l' (Char)
GETAT({1, 2, 4}, 2);
# Result: 4
```

## SETAT

`SETAT` înlocuiește elementul de la un index; o colecție este modificată pe loc, iar la un șir de caractere caracterul de la index este înlocuit cu textul lui `newValue`.

```text
SETAT(value, index, newValue)
```

```taphome
# înlocuirea unui caracter
SETAT("Hello", 1, "a");
# Result: "Hallo"
# înlocuirea unui caracter cu un text mai lung
SETAT("Hello", 4, "o World");
# Result: "Hello World"
# o colecție de modificat
VAR c := {1, 2, 4};
# înlocuirea unui element pe loc
SETAT(c, 2, 3);
# Result: {1, 2, 3}, and c is now {1, 2, 3}
```

## APPEND

`APPEND` adaugă o valoare la sfârșitul unui șir de caractere sau al unei colecții; o colecție este modificată pe loc și returnată, nu copiată.

```text
APPEND(value, what)
```

**Observații** — Adăugarea unei colecții cu același tip de element adaugă toate elementele ei. O singură valoare se adaugă ca un element. O colecție cu alt tip de element produce o eroare (*Cannot append 'UInt8' collection to 'Double' collection*).

```taphome
# o colecție de extins
VAR c := {1, 2};
# adăugarea unui element pe loc
APPEND(c, 3);
# Result: {1, 2, 3}, and c is now {1, 2, 3}
# adăugarea mai multor elemente pe loc
APPEND(c, {4, 5});
# Result: {1, 2, 3, 4, 5}
# adăugarea textului la un șir
APPEND("abc", "def");
# Result: "abcdef"
```

## INSERT

`INSERT` inserează o valoare la un index: un subșir într-un șir de caractere sau, pe loc, un element într-o colecție.

```text
INSERT(value, index, what)
```

```taphome
# inserarea unui subșir
INSERT("Hello", 5, " World");
# Result: "Hello World"
# inserarea unui caracter
INSERT("Hello", 1, "i");
# Result: "Hiello"
# inserarea unui element într-o colecție
INSERT({1, 2, 4}, 2, 3);
# Result: {1, 2, 3, 4}
```

## REMOVEAT

`REMOVEAT` elimină `count` caractere sau elemente, implicit 1, începând de la un index.

```text
REMOVEAT(value, index)
REMOVEAT(value, index, count)
```

```taphome
# eliminarea unui caracter
REMOVEAT("Hello", 1);
# Result: "Hllo"
# eliminarea a 2 caractere de la indexul 3
REMOVEAT("Hello", 3, 2);
# Result: "Hel"
# eliminarea a 2 elemente dintr-o colecție
REMOVEAT({1, 2, 3, 4}, 2, 2);
# Result: {1, 2}
```

## COPY

`COPY` returnează un șir de caractere, o colecție sau un blob nou cu `length` elemente începând de la `from`; fără `length` copiază până la sfârșit, fără `from` întreaga valoare.

```text
COPY(value)
COPY(value, from)
COPY(value, from, length)
```

```taphome
# copiere de la indexul 2 până la sfârșit
COPY("Hello World", 2);
# Result: "llo World"
# copierea a 4 caractere de la indexul 2
COPY("Hello World", 2, 4);
# Result: "llo "
# copierea unui octet dintr-un blob
COPY(BYTECOLLECTION("01020304"), 2, 1);
# Result: {0x03}
```

**Erori** — *Parameter 1 must be a non-empty string* la copierea dintr-un șir gol.

## INDEXOF

`INDEXOF` returnează poziția primei apariții a unei valori într-un șir de caractere, o colecție sau un blob, sau `-1` când valoarea nu este găsită.

```text
INDEXOF(value, what)
```

```taphome
# poziția unui subșir
INDEXOF("Hello World", "Wor");
# Result: 6
# negăsit dă -1
INDEXOF("Hello World", "or12");
# Result: -1
# poziția unui element într-un blob
INDEXOF(BYTECOLLECTION("ab cd ee ff 01 02"), 2);
# Result: 5
```

**Erori** — *Parameter 2 must be a non-empty string* la căutarea unui șir gol într-un șir de caractere.

## REPLACE

`REPLACE` înlocuiește fiecare apariție a unei valori: un șir de caractere dă un șir nou, iar într-o colecție elementele care se potrivesc sunt înlocuite pe loc.

```text
REPLACE(value, what, replacement)
```

```taphome
# eliminarea fiecărui l
REPLACE("Hello", "l", "");
# Result: "Heo"
# înlocuirea unui subșir
REPLACE("Hello", "lo", "22");
# Result: "Hel22"
# înlocuirea unui element într-un blob
REPLACE(BYTECOLLECTION("050607"), 5, 9);
# Result: {0x09, 0x06, 0x07}
```

**Erori** — *Empty string to replace* când `what` este un șir gol.

## SPLIT

`SPLIT` împarte un șir de caractere la fiecare separator și returnează o `collection<string>`; părțile goale se păstrează.

```text
SPLIT(string, separator)
```

**Parametri** — `separator` este un `char`, un șir de caractere, o `collection<char>` sau o `collection<string>`.

```taphome
# împărțire la un separator
SPLIT("1;2;3;4", ";");
# Result: {"1", "2", "3", "4"}
# separator mai lung de un caracter
SPLIT("1;2;3.4", "2;");
# Result: {"1;", "3.4"}
# mai multe separatoare deodată
SPLIT("1;2;3.4", {"2", "3."});
# Result: {"1;", ";", "4"}
```

## COMPARE

`COMPARE` compară două șiruri de caractere și returnează un număr negativ când primul se sortează înaintea celui de-al doilea, 0 când sunt egale și un număr pozitiv când se sortează după el; contează doar semnul, nu mărimea.

```text
COMPARE(string1, string2)
COMPARE(string1, string2, CompareOptions)
```

**Observații** — Fără opțiuni, unitatea de control returnează diferența dintre codurile primelor caractere care diferă, așa că literele mari se sortează înaintea celor mici. Cu `CompareOptions` (`IgnoreCase`, `IgnoreNonSpace`, `IgnoreSymbols`, `IgnoreKanaType`, `IgnoreWidth`, `OrdinalIgnoreCase`, `StringSort`, `Ordinal`, `None`), șirurile se compară după regulile lingvistice ale culturii invariante, aceleași pe fiecare unitate de control, ajustate prin aceste opțiuni.

```taphome
# șirurile egale dau 0
COMPARE("abc", "abc");
# Result: 0
# literele mari în loc de mici dau un număr pozitiv
COMPARE("abc", "ABC");
# Result: 32
# primul șir se sortează înaintea celui de-al doilea
COMPARE("a", "c");
# Result: -2
# ignorarea literelor mari și mici dă 0
COMPARE("abc", "ABC", CompareOptions.IgnoreCase);
# Result: 0
```

**Erori** — *COMPARE arguments 1 and 2 must be strings*.

## BYTECOLLECTION

`BYTECOLLECTION` creează o `collection<uint8>`, fie dintr-un șir de cifre hexazecimale, fie umplută cu un număr dat de octeți zero (1 – 2048).

```text
BYTECOLLECTION(hexString)
BYTECOLLECTION(count)
```

**Observații** — Caracterele șirului care nu sunt cifre hexazecimale se ignoră, așa că spațiile, virgulele și cratimele pot separa octeții; numărul cifrelor rămase trebuie să fie par.

```taphome
# octeți dintr-un text hexazecimal
BYTECOLLECTION("00 0A FF");
# Result: {0x00, 0x0A, 0xFF}
# text hexazecimal cu separatori diferiți
BYTECOLLECTION("aa, be1-1,fe");
# Result: {0xAA, 0xBE, 0x11, 0xFE}
# un număr dă atâția octeți zero
BYTECOLLECTION(6);
# Result: 6 zero bytes
```

**Erori** — *Parameter must be a non-empty string*; *Length must be a multiple of 2*; *Maximum array length is 2048*; *Invalid array length. Must be greater than 0 and less than or equal 2048*.

## UINT16COLLECTION

`UINT16COLLECTION` creează o `collection<uint16>` cu 1 – 2048 de zerouri, de regulă completată cu `PACKVALUE` și scrisă în registrele Modbus cu `MODBUSWBLOCK`.

```taphome
collection<uint16> regs := UINT16COLLECTION(4);
PACKVALUE(regs, 0, BigEndianFloat, 21.5);
PACKVALUE(regs, 2, Uint16, 100);
MODBUSWBLOCK(H, 200, regs);
```

**Disponibilitate** — TapHome Next 2026.1.39016+.

**Consultați și** — [Date binare](https://taphome.com/ro/docs/script/binary-data/), [Funcții Modbus](https://taphome.com/ro/docs/script/modbus/).

## BOOLCOLLECTION

`BOOLCOLLECTION` creează o `collection<bool>` cu 1 – 2048 de valori `FALSE`, de regulă pentru scrierea coil-urilor Modbus cu `MODBUSWBLOCK`.

```taphome
collection<bool> coils := BOOLCOLLECTION(8);
SETAT(coils, 0, TRUE);
MODBUSWBLOCK(C, 0, coils);
```

**Disponibilitate** — TapHome Next 2026.1.39016+.
