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:

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.

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

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)
# î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ă.

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

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

1
INSERT(value, index, what)
# 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.

1
2
REMOVEAT(value, index)
REMOVEAT(value, index, count)
# 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.

1
2
3
COPY(value)
COPY(value, from)
COPY(value, from, length)
# 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ă.

1
INDEXOF(value, what)
# 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.

1
REPLACE(value, what, replacement)
# 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ă.

1
SPLIT(string, separator)

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

# î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.

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.

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

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.

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

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