TapHome

Testo e collezioni

Funzioni degli script TapHome per stringhe, collezioni e array di byte — LENGTH, GETAT, SETAT, APPEND, INSERT, REMOVEAT, COPY, INDEXOF, REPLACE, SPLIT, COMPARE, BYTECOLLECTION, UINT16COLLECTION, BOOLCOLLECTION.

Queste funzioni accettano come primo argomento una stringa o una collezione e lavorano con i caratteri o gli elementi tramite un indice che parte da zero.

  • Una collezione viene modificata sul posto da APPEND, INSERT, REMOVEAT, SETAT e REPLACE, che restituiscono la stessa collezione. Per una stringa restituiscono una nuova stringa.
  • Un blob, come RECEIVEDMSG.PAYLOAD, è accettato solo da LENGTH, GETAT, COPY e INDEXOF.
  • Un primo argomento Null interrompe lo script con Parameter 1 is null, tranne in LENGTH (0), INDEXOF (-1) e SPLIT (una collezione vuota); COMPARE segnala COMPARE arguments 1 and 2 must be strings.

ENCODE e DECODE (XML, Base64) sono nella pagina Conversioni tra tipi di dati, EQUALS nella pagina Logica e diagnostica. I tipi di collezione sono descritti in Tipi di dati.

LENGTH

LENGTH restituisce il numero di caratteri di una stringa, di elementi di una collezione o di byte di un blob; per un numero restituisce la dimensione del suo tipo in byte e per Null 0.

LENGTH("Hello World");
# Result: 11
LENGTH(40);
# Result: 8 (a decimal literal is a double)
LENGTH(BYTECOLLECTION("010203"));
# Result: 3

GETAT

GETAT restituisce l’elemento in una posizione: un char di una stringa, un elemento di una collezione o un byte di un blob.

1

GETAT(value, index)

Valore restituito — per una stringa un char, non una stringa di una lettera; confrontalo con un letterale di carattere come 'l'.

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

SETAT

SETAT sostituisce l’elemento in una posizione; una collezione viene modificata sul posto, per una stringa il carattere nella posizione viene sostituito dal testo di 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 aggiunge un valore alla fine di una stringa o di una collezione; una collezione viene modificata sul posto e restituita, non copiata.

1

APPEND(value, what)

Note — L’aggiunta di una collezione con lo stesso tipo di elemento aggiunge tutti i suoi elementi. Un singolo valore viene aggiunto come un elemento. Una collezione con un altro tipo di elemento è un errore (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 inserisce un valore in una posizione: una sottostringa in una stringa, oppure un elemento in una collezione, sul posto.

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 rimuove count caratteri o elementi, 1 per impostazione predefinita, a partire da una posizione.

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 restituisce una nuova stringa, collezione o blob con length elementi a partire da from; senza length copia fino alla fine, senza from l’intero valore.

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}

Errori — Parameter 1 must be a non-empty string quando si copia da una stringa vuota.

INDEXOF

INDEXOF restituisce la posizione della prima occorrenza di un valore in una stringa, in una collezione o in un blob, oppure -1 se non viene trovato.

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

Errori — Parameter 2 must be a non-empty string quando in una stringa si cerca una stringa vuota.

REPLACE

REPLACE sostituisce ogni occorrenza di un valore: da una stringa si ottiene una nuova stringa, in una collezione gli elementi corrispondenti vengono sostituiti sul posto.

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}

Errori — Empty string to replace quando what è una stringa vuota.

SPLIT

SPLIT divide una stringa a ogni separatore e restituisce una collection<string>; le parti vuote vengono mantenute.

1

SPLIT(string, separator)

Parametri — separator è un char, una stringa, una collection<char> o una 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 confronta due stringhe e restituisce un numero negativo quando la prima viene prima della seconda nell’ordinamento, 0 quando sono uguali e un numero positivo quando viene dopo; considera solo il segno, non la grandezza.

1
2

COMPARE(string1, string2)
COMPARE(string1, string2, CompareOptions)

Note — Senza opzioni un’unità di controllo restituisce la differenza dei codici di carattere dei primi caratteri diversi, quindi le lettere maiuscole vengono prima delle minuscole. Con CompareOptions (IgnoreCase, IgnoreNonSpace, IgnoreSymbols, IgnoreKanaType, IgnoreWidth, OrdinalIgnoreCase, StringSort, Ordinal, None) le stringhe vengono confrontate secondo le regole linguistiche della cultura invariante, uguali su ogni unità di controllo, adattate da quelle opzioni.

COMPARE("abc", "abc");
# Result: 0
COMPARE("abc", "ABC");
# Result: 32
COMPARE("a", "c");
# Result: -2
COMPARE("abc", "ABC", CompareOptions.IgnoreCase);
# Result: 0

Errori — COMPARE arguments 1 and 2 must be strings.

BYTECOLLECTION

BYTECOLLECTION crea una collection<uint8>, da una stringa di cifre esadecimali oppure riempita con un dato numero di byte a zero (1 – 2048).

1
2

BYTECOLLECTION(hexString)
BYTECOLLECTION(count)

Note — I caratteri della stringa che non sono cifre esadecimali vengono ignorati, quindi spazi, virgole e trattini possono separare i byte; il numero di cifre rimanenti deve essere pari.

BYTECOLLECTION("00 0A FF");
# Result: {0x00, 0x0A, 0xFF}
BYTECOLLECTION("aa, be1-1,fe");
# Result: {0xAA, 0xBE, 0x11, 0xFE}
BYTECOLLECTION(6);
# Result: 6 zero bytes

Errori — 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 crea una collection<uint16> di 1 – 2048 zeri, di solito riempita con PACKVALUE e scritta nei registri Modbus con MODBUSWBLOCK.

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

Disponibile — Core 2026.1, build 39001 e successivi.

Vedi anche — Dati binari, Funzioni Modbus.

BOOLCOLLECTION

BOOLCOLLECTION crea una collection<bool> di 1 – 2048 valori FALSE, di solito per scrivere coil Modbus con MODBUSWBLOCK.

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

Disponibile — Core 2026.1, build 39001 e successivi.