--- title: "Text a kolekce" description: "Funkce skriptu TapHome pro text a kolekce: LENGTH, GETAT, SETAT, APPEND, INSERT, REMOVEAT, COPY, INDEXOF, REPLACE, SPLIT, COMPARE a BYTECOLLECTION, UINT16COLLECTION, BOOLCOLLECTION." url: "https://taphome.com/cs/docs/script/text-string-and-byte-array/" language: cs lastmod: 2026-11-06 generator: hugo ai: topics: ["string-functions","byte-array","collections","scripting-language"] questions: ["Jak ve skriptu TapHome zjistit délku řetězce?","Jak v TapHome rozdělit řetězec podle oddělovače?","Jak v TapHome nahradit text v řetězci?","Jak vytvořit kolekci bajtů ze šestnáctkových hodnot?","Jak najít index prvku v řetězci nebo kolekci?","Vytvoří APPEND novou kolekci, nebo změní původní?","Jak ve skriptu TapHome porovnat dva řetězce?"] --- # 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: 2026-11-06 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ů](https://taphome.com/cs/docs/script/data-type-conversions/), `EQUALS` na stránce [Logika a diagnostika](https://taphome.com/cs/docs/script/logic-and-diagnostics/#equals). Typy kolekcí popisuje stránka [Datové typy](https://taphome.com/cs/docs/script/data-types/). ## 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. ```taphome # 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. ```text GETAT(value, index) ``` **Vrací** — pro řetězec `char`, ne jednopísmenný řetězec; porovnávejte ho se znakovým literálem, například `'l'`. ```taphome 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`. ```text SETAT(value, index, newValue) ``` ```taphome # 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. ```text 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*). ```taphome # 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ě. ```text INSERT(value, index, what) ``` ```taphome # 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. ```text REMOVEAT(value, index) REMOVEAT(value, index, count) ``` ```taphome # 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. ```text COPY(value) COPY(value, from) COPY(value, from, length) ``` ```taphome # 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. ```text INDEXOF(value, what) ``` ```taphome # 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ě. ```text REPLACE(value, what, replacement) ``` ```taphome # 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`; prázdné části se zachovají. ```text SPLIT(string, separator) ``` **Parametry** — `separator` je `char`, řetězec, `collection` nebo `collection`. ```taphome # 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. ```text 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. ```taphome # 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`, buď z řetězce šestnáctkových číslic, nebo naplněnou zadaným počtem nulových bajtů (1 – 2048). ```text 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ý. ```taphome # 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` z 1 – 2048 nul, kterou typicky naplníte pomocí `PACKVALUE` a zapíšete do registrů Modbus pomocí `MODBUSWBLOCK`. ```taphome collection 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](https://taphome.com/cs/docs/script/binary-data/), [Funkce Modbus](https://taphome.com/cs/docs/script/modbus/). ## BOOLCOLLECTION `BOOLCOLLECTION` vytvoří `collection` z 1 – 2048 hodnot `FALSE`, typicky pro zápis cívek (coils) Modbus pomocí `MODBUSWBLOCK`. ```taphome collection coils := BOOLCOLLECTION(8); SETAT(coils, 0, TRUE); MODBUSWBLOCK(C, 0, coils); ``` **Dostupnost** — TapHome Next 2026.1.39016+.