TapHome

Text a kolekce

Funkce skriptu TapHome pro řetězce, kolekce a pole bajtů — LENGTH, GETAT, SETAT, APPEND, INSERT, REMOVEAT, COPY, INDEXOF, REPLACE, SPLIT, COMPARE, BYTECOLLECTION, UINT16COLLECTION, BOOLCOLLECTION.

Poslední aktualizace:

Tyto funkce přijímají jako první argument řetězec nebo kolekci a pracují se znaky nebo prvky podle indexu počítaného od nuly.

  • Kolekci mění APPEND, INSERT, REMOVEAT, SETAT a REPLACE na místě a vracejí tutéž kolekci. U řetězce vracejí nový řetězec.
  • Blob, například RECEIVEDMSG.PAYLOAD, přijímají jen LENGTH, GETAT, COPY a INDEXOF.
  • První argument Null zastaví skript s hlášením Parameter 1 is null, kromě LENGTH (0), INDEXOF (-1) a SPLIT (prázdná kolekce); COMPARE hlásí COMPARE arguments 1 and 2 must be strings.

ENCODE a DECODE (XML, Base64) jsou na stránce Převody datových typů, EQUALS na stránce Logika a diagnostika. Typy kolekcí popisuje stránka Datové typy.

LENGTH

LENGTH vrátí počet znaků řetězce, prvků kolekce nebo bajtů blobu; pro číslo vrátí velikost jeho typu v bajtech a pro Null 0.

# znaky v řetězci
LENGTH("Hello World");
# Result: 11
# délka čísla
LENGTH(40);
# Result: 8 (a decimal literal is a double)
# bajty v bajtové kolekci
LENGTH(BYTECOLLECTION("010203"));
# Result: 3

GETAT

GETAT vrátí prvek na zadaném indexu: char řetězce, prvek kolekce nebo bajt blobu.

1

GETAT(value, index)

Vrací — pro řetězec char, ne jednopísmenný řetězec; porovnávejte ho se znakovým literálem, například 'l'.

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

SETAT

SETAT nahradí prvek na zadaném indexu; kolekce se změní na místě, u řetězce se znak na indexu nahradí textem newValue.

1

SETAT(value, index, newValue)

# nahrazení jednoho znaku
SETAT("Hello", 1, "a");
# Result: "Hallo"
# nahrazení znaku delším textem
SETAT("Hello", 4, "o World");
# Result: "Hello World"
# kolekce ke změně
VAR c := {1, 2, 4};
# nahrazení prvku přímo v kolekci
SETAT(c, 2, 3);
# Result: {1, 2, 3}, and c is now {1, 2, 3}

APPEND

APPEND přidá hodnotu na konec řetězce nebo kolekce; kolekce se změní na místě a vrátí se, nekopíruje se.

1

APPEND(value, what)

Poznámky — Připojení kolekce se stejným typem prvku přidá všechny její prvky. Jednotlivá hodnota se přidá jako jeden prvek. Kolekce s jiným typem prvku je chyba (Cannot append ‘UInt8’ collection to ‘Double’ collection).

# kolekce k rozšíření
VAR c := {1, 2};
# přidání jednoho prvku přímo
APPEND(c, 3);
# Result: {1, 2, 3}, and c is now {1, 2, 3}
# přidání více prvků přímo
APPEND(c, {4, 5});
# Result: {1, 2, 3, 4, 5}
# připojení textu k řetězci
APPEND("abc", "def");
# Result: "abcdef"

INSERT

INSERT vloží hodnotu na zadaný index: podřetězec do řetězce, nebo prvek do kolekce na místě.

1

INSERT(value, index, what)

# vložení podřetězce
INSERT("Hello", 5, " World");
# Result: "Hello World"
# vložení znaku
INSERT("Hello", 1, "i");
# Result: "Hiello"
# vložení prvku do kolekce
INSERT({1, 2, 4}, 2, 3);
# Result: {1, 2, 3, 4}

REMOVEAT

REMOVEAT odebere count znaků nebo prvků, výchozí 1, počínaje zadaným indexem.

1
2

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

# odstranění jednoho znaku
REMOVEAT("Hello", 1);
# Result: "Hllo"
# odstranění 2 znaků od indexu 3
REMOVEAT("Hello", 3, 2);
# Result: "Hel"
# odstranění 2 prvků z kolekce
REMOVEAT({1, 2, 3, 4}, 2, 2);
# Result: {1, 2}

COPY

COPY vrátí nový řetězec, kolekci nebo blob s length položkami od pozice from; bez length kopíruje až do konce, bez from celou hodnotu.

1
2
3

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

# kopírování od indexu 2 do konce
COPY("Hello World", 2);
# Result: "llo World"
# kopírování 4 znaků od indexu 2
COPY("Hello World", 2, 4);
# Result: "llo "
# kopírování 1 bajtu z blobu
COPY(BYTECOLLECTION("01020304"), 2, 1);
# Result: {0x03}

Chyby — Parameter 1 must be a non-empty string při kopírování z prázdného řetězce.

INDEXOF

INDEXOF vrátí pozici prvního výskytu hodnoty v řetězci, kolekci nebo blobu, nebo -1, když nebyla nalezena.

1

INDEXOF(value, what)

# pozice podřetězce
INDEXOF("Hello World", "Wor");
# Result: 6
# nenalezeno vrátí -1
INDEXOF("Hello World", "or12");
# Result: -1
# pozice prvku v blobu
INDEXOF(BYTECOLLECTION("ab cd ee ff 01 02"), 2);
# Result: 5

Chyby — Parameter 2 must be a non-empty string při hledání prázdného řetězce v řetězci.

REPLACE

REPLACE nahradí každý výskyt hodnoty: z řetězce vznikne nový řetězec, v kolekci se shodné prvky nahradí na místě.

1

REPLACE(value, what, replacement)

# odstranění každého l
REPLACE("Hello", "l", "");
# Result: "Heo"
# nahrazení podřetězce
REPLACE("Hello", "lo", "22");
# Result: "Hel22"
# nahrazení prvku v blobu
REPLACE(BYTECOLLECTION("050607"), 5, 9);
# Result: {0x09, 0x06, 0x07}

Chyby — Empty string to replace, když je what prázdný řetězec.

SPLIT

SPLIT rozdělí řetězec u každého oddělovače a vrátí collection<string>; prázdné části se zachovají.

1

SPLIT(string, separator)

Parametry — separator je char, řetězec, collection<char> nebo collection<string>.

# rozdělení podle oddělovače
SPLIT("1;2;3;4", ";");
# Result: {"1", "2", "3", "4"}
# oddělovač delší než jeden znak
SPLIT("1;2;3.4", "2;");
# Result: {"1;", "3.4"}
# více oddělovačů najednou
SPLIT("1;2;3.4", {"2", "3."});
# Result: {"1;", ";", "4"}

COMPARE

COMPARE porovná dva řetězce a vrátí záporné číslo, když se první řadí před druhý, 0, když jsou shodné, a kladné číslo, když se řadí za něj; spoléhejte jen na znaménko, ne na velikost.

1
2

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

Poznámky — Bez voleb vrátí řídicí jednotka rozdíl kódů prvních odlišných znaků, takže velká písmena se řadí před malá. S CompareOptions (IgnoreCase, IgnoreNonSpace, IgnoreSymbols, IgnoreKanaType, IgnoreWidth, OrdinalIgnoreCase, StringSort, Ordinal, None) se řetězce porovnávají podle jazykových pravidel invariantní kultury, na každé řídicí jednotce stejně, upravených těmito volbami.

# shodné řetězce dají 0
COMPARE("abc", "abc");
# Result: 0
# jiná velikost písmen dá kladné číslo
COMPARE("abc", "ABC");
# Result: 32
# první řetězec se řadí před druhý
COMPARE("a", "c");
# Result: -2
# ignorování velikosti písmen dá 0
COMPARE("abc", "ABC", CompareOptions.IgnoreCase);
# Result: 0

Chyby — COMPARE arguments 1 and 2 must be strings.

BYTECOLLECTION

BYTECOLLECTION vytvoří collection<uint8>, buď z řetězce šestnáctkových číslic, nebo naplněnou zadaným počtem nulových bajtů (1 – 2048).

1
2

BYTECOLLECTION(hexString)
BYTECOLLECTION(count)

Poznámky — Znaky řetězce, které nejsou šestnáctkovými číslicemi, se ignorují, takže bajty mohou oddělovat mezery, čárky a pomlčky; počet zbývajících číslic musí být sudý.

# bajty z hexadecimálního textu
BYTECOLLECTION("00 0A FF");
# Result: {0x00, 0x0A, 0xFF}
# hexadecimální text s různými oddělovači
BYTECOLLECTION("aa, be1-1,fe");
# Result: {0xAA, 0xBE, 0x11, 0xFE}
# číslo dá tolik nulových bajtů
BYTECOLLECTION(6);
# Result: 6 zero bytes

Chyby — 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 vytvoří collection<uint16> z 1 – 2048 nul, kterou typicky naplníte pomocí PACKVALUE a zapíšete do registrů Modbus pomocí MODBUSWBLOCK.

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

Dostupnost — TapHome Next 2026.1.39016+.

Viz také — Binární data, Funkce Modbus.

BOOLCOLLECTION

BOOLCOLLECTION vytvoří collection<bool> z 1 – 2048 hodnot FALSE, typicky pro zápis cívek (coils) Modbus pomocí MODBUSWBLOCK.

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

Dostupnost — TapHome Next 2026.1.39016+.