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.

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, EQUALS pe pagina Logică și diagnostic. Tipurile de colecții sunt descrise în Tipuri de date.

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.

LENGTH("Hello World");
# Result: 11
LENGTH(40);
# Result: 8 (a decimal literal is a double)
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.

1

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'.

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.

1

SETAT(value, index, newValue)

SETAT("Hello", 1, "a");
# Result: "Hallo"
SETAT("Hello", 4, "o World");
# Result: "Hello World"
VAR c := {1, 2, 4};
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ă.

1

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).

VAR c := {1, 2};
APPEND(c, 3);
# Result: {1, 2, 3}, and c is now {1, 2, 3}
APPEND(c, {4, 5});
# Result: {1, 2, 3, 4, 5}
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.

1

INSERT(value, index, what)

INSERT("Hello", 5, " World");
# Result: "Hello World"
INSERT("Hello", 1, "i");
# Result: "Hiello"
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.

1
2

REMOVEAT(value, index)
REMOVEAT(value, index, count)

REMOVEAT("Hello", 1);
# Result: "Hllo"
REMOVEAT("Hello", 3, 2);
# Result: "Hel"
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.

1
2
3

COPY(value)
COPY(value, from)
COPY(value, from, length)

COPY("Hello World", 2);
# Result: "llo World"
COPY("Hello World", 2, 4);
# Result: "llo "
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ă.

1

INDEXOF(value, what)

INDEXOF("Hello World", "Wor");
# Result: 6
INDEXOF("Hello World", "or12");
# Result: -1
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.

1

REPLACE(value, what, replacement)

REPLACE("Hello", "l", "");
# Result: "Heo"
REPLACE("Hello", "lo", "22");
# Result: "Hel22"
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ă.

1

SPLIT(string, separator)

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

SPLIT("1;2;3;4", ";");
# Result: {"1", "2", "3", "4"}
SPLIT("1;2;3.4", "2;");
# Result: {"1;", "3.4"}
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.

1
2

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.

COMPARE("abc", "abc");
# Result: 0
COMPARE("abc", "ABC");
# Result: 32
COMPARE("a", "c");
# Result: -2
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).

1
2

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.

BYTECOLLECTION("00 0A FF");
# Result: {0x00, 0x0A, 0xFF}
BYTECOLLECTION("aa, be1-1,fe");
# Result: {0xAA, 0xBE, 0x11, 0xFE}
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.

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, Funcții Modbus.

BOOLCOLLECTION

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

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

Disponibilitate — TapHome Next 2026.1.39016+.