--- title: "Text a kolekcie" description: "Funkcie skriptovacieho jazyka TapHome pre text a kolekcie: LENGTH, GETAT, SETAT, APPEND, INSERT, REMOVEAT, COPY, INDEXOF, REPLACE, SPLIT, COMPARE a BYTECOLLECTION, UINT16COLLECTION, BOOLCOLLECTION." url: "https://taphome.com/sk/docs/script/text-string-and-byte-array/" language: sk lastmod: 2026-11-06 generator: hugo ai: topics: ["string-functions","byte-array","collections","scripting-language"] questions: ["Ako získam dĺžku reťazca v TapHome skripte?","Ako rozdelím reťazec podľa oddeľovača v TapHome?","Ako nahradím text v reťazci v TapHome?","Ako vytvorím bajtovú kolekciu z hexadecimálnych hodnôt?","Ako nájdem index prvku v reťazci alebo kolekcii?","Vytvorí APPEND novú kolekciu, alebo zmení pôvodnú?","Ako porovnám dva reťazce v TapHome skripte?"] --- # Text a kolekcie Funkcie skriptu TapHome pre reťazce, kolekcie a bajtové polia — LENGTH, GETAT, SETAT, APPEND, INSERT, REMOVEAT, COPY, INDEXOF, REPLACE, SPLIT, COMPARE, BYTECOLLECTION, UINT16COLLECTION, BOOLCOLLECTION. Posledná aktualizácia: 2026-11-06 Tieto funkcie berú ako prvý argument reťazec alebo kolekciu a pracujú so znakmi alebo prvkami podľa indexu, ktorý sa počíta od nuly. - **Kolekciu** menia funkcie `APPEND`, `INSERT`, `REMOVEAT`, `SETAT` a `REPLACE` **na mieste** a vracajú tú istú kolekciu. Pre **reťazec** vracajú nový reťazec. - **Blob**, napríklad `RECEIVEDMSG.PAYLOAD`, prijímajú iba `LENGTH`, `GETAT`, `COPY` a `INDEXOF`. - Prvý argument `Null` zastaví skript chybou *Parameter 1 is null*, okrem `LENGTH` (0), `INDEXOF` (-1) a `SPLIT` (prázdna kolekcia); `COMPARE` hlási *COMPARE arguments 1 and 2 must be strings*. `ENCODE` a `DECODE` (XML, Base64) sú na stránke [Konverzie dátových typov](https://taphome.com/sk/docs/script/data-type-conversions/), `EQUALS` na stránke [Logika a diagnostika](https://taphome.com/sk/docs/script/logic-and-diagnostics/#equals). Typy kolekcií opisuje stránka [Dátové typy](https://taphome.com/sk/docs/script/data-types/). ## LENGTH `LENGTH` vráti počet znakov reťazca, prvkov kolekcie alebo bajtov blobu; pre číslo vráti veľkosť jeho typu v bajtoch a pre `Null` 0. ```taphome # znaky v reťazci LENGTH("Hello World"); # Result: 11 # dĺžka čísla LENGTH(40); # Result: 8 (a decimal literal is a double) # bajty v bajtovej kolekcii LENGTH(BYTECOLLECTION("010203")); # Result: 3 ``` ## GETAT `GETAT` vráti prvok na zadanom indexe: `char` reťazca, prvok kolekcie alebo bajt blobu. ```text GETAT(value, index) ``` **Návratová hodnota** — pre reťazec `char`, nie jednopísmenový reťazec; porovnávajte ho so znakovým literálom, napríklad `'l'`. ```taphome GETAT("Hello", 2); # Result: 'l' (Char) GETAT({1, 2, 4}, 2); # Result: 4 ``` ## SETAT `SETAT` nahradí prvok na zadanom indexe; kolekcia sa zmení na mieste, v reťazci sa znak na indexe nahradí textom `newValue`. ```text SETAT(value, index, newValue) ``` ```taphome # nahradenie jedného znaku SETAT("Hello", 1, "a"); # Result: "Hallo" # nahradenie znaku dlhším textom SETAT("Hello", 4, "o World"); # Result: "Hello World" # kolekcia na zmenu VAR c := {1, 2, 4}; # nahradenie prvku priamo v kolekcii SETAT(c, 2, 3); # Result: {1, 2, 3}, and c is now {1, 2, 3} ``` ## APPEND `APPEND` pridá hodnotu na koniec reťazca alebo kolekcie; kolekcia sa zmení na mieste a vráti sa, nekopíruje sa. ```text APPEND(value, what) ``` **Poznámky** — Pridanie kolekcie s rovnakým typom prvkov pridá všetky jej prvky. Jedna hodnota sa pridá ako jeden prvok. Kolekcia s iným typom prvkov je chyba (*Cannot append 'UInt8' collection to 'Double' collection*). ```taphome # kolekcia na rozšírenie VAR c := {1, 2}; # pridanie jedného prvku priamo APPEND(c, 3); # Result: {1, 2, 3}, and c is now {1, 2, 3} # pridanie viacerých prvkov priamo APPEND(c, {4, 5}); # Result: {1, 2, 3, 4, 5} # pripojenie textu k reťazcu APPEND("abc", "def"); # Result: "abcdef" ``` ## INSERT `INSERT` vloží hodnotu na zadaný index: podreťazec do reťazca alebo prvok do kolekcie, a to na mieste. ```text INSERT(value, index, what) ``` ```taphome # vloženie podreťazca INSERT("Hello", 5, " World"); # Result: "Hello World" # vloženie znaku INSERT("Hello", 1, "i"); # Result: "Hiello" # vloženie prvku do kolekcie INSERT({1, 2, 4}, 2, 3); # Result: {1, 2, 3, 4} ``` ## REMOVEAT `REMOVEAT` odstráni `count` znakov alebo prvkov, predvolene 1, počnúc zadaným indexom. ```text REMOVEAT(value, index) REMOVEAT(value, index, count) ``` ```taphome # odstránenie jedného znaku REMOVEAT("Hello", 1); # Result: "Hllo" # odstránenie 2 znakov od indexu 3 REMOVEAT("Hello", 3, 2); # Result: "Hel" # odstránenie 2 prvkov z kolekcie REMOVEAT({1, 2, 3, 4}, 2, 2); # Result: {1, 2} ``` ## COPY `COPY` vráti nový reťazec, kolekciu alebo blob s `length` položkami od pozície `from`; bez `length` kopíruje až do konca, bez `from` celú hodnotu. ```text COPY(value) COPY(value, from) COPY(value, from, length) ``` ```taphome # kopírovanie od indexu 2 do konca COPY("Hello World", 2); # Result: "llo World" # kopírovanie 4 znakov od indexu 2 COPY("Hello World", 2, 4); # Result: "llo " # kopírovanie 1 bajtu z blobu COPY(BYTECOLLECTION("01020304"), 2, 1); # Result: {0x03} ``` **Chyby** — *Parameter 1 must be a non-empty string* pri kopírovaní z prázdneho reťazca. ## INDEXOF `INDEXOF` vráti pozíciu prvého výskytu hodnoty v reťazci, kolekcii alebo blobe, alebo `-1`, keď sa hodnota nenájde. ```text INDEXOF(value, what) ``` ```taphome # pozícia podreťazca INDEXOF("Hello World", "Wor"); # Result: 6 # nenájdené vráti -1 INDEXOF("Hello World", "or12"); # Result: -1 # pozícia prvku v blobe INDEXOF(BYTECOLLECTION("ab cd ee ff 01 02"), 2); # Result: 5 ``` **Chyby** — *Parameter 2 must be a non-empty string* pri hľadaní prázdneho reťazca v reťazci. ## REPLACE `REPLACE` nahradí každý výskyt hodnoty: z reťazca vznikne nový reťazec, v kolekcii sa zhodné prvky nahradia na mieste. ```text REPLACE(value, what, replacement) ``` ```taphome # odstránenie každého l REPLACE("Hello", "l", ""); # Result: "Heo" # nahradenie podreťazca REPLACE("Hello", "lo", "22"); # Result: "Hel22" # nahradenie prvku v blobe REPLACE(BYTECOLLECTION("050607"), 5, 9); # Result: {0x09, 0x06, 0x07} ``` **Chyby** — *Empty string to replace*, keď je `what` prázdny reťazec. ## SPLIT `SPLIT` rozdelí reťazec pri každom oddeľovači a vráti `collection`; prázdne časti sa zachovajú. ```text SPLIT(string, separator) ``` **Parametre** — `separator` je `char`, reťazec, `collection` alebo `collection`. ```taphome # rozdelenie podľa oddeľovača SPLIT("1;2;3;4", ";"); # Result: {"1", "2", "3", "4"} # oddeľovač dlhší ako jeden znak SPLIT("1;2;3.4", "2;"); # Result: {"1;", "3.4"} # viac oddeľovačov naraz SPLIT("1;2;3.4", {"2", "3."}); # Result: {"1;", ";", "4"} ``` ## COMPARE `COMPARE` porovná dva reťazce a vráti záporné číslo, keď sa prvý radí pred druhý, 0, keď sú rovnaké, a kladné číslo, keď sa radí za neho; spoliehajte sa iba na znamienko výsledku, nie na jeho veľkosť. ```text COMPARE(string1, string2) COMPARE(string1, string2, CompareOptions) ``` **Poznámky** — Bez možností vráti riadiaca jednotka rozdiel kódov prvých odlišných znakov, preto sa veľké písmená radia pred malé. S `CompareOptions` (`IgnoreCase`, `IgnoreNonSpace`, `IgnoreSymbols`, `IgnoreKanaType`, `IgnoreWidth`, `OrdinalIgnoreCase`, `StringSort`, `Ordinal`, `None`) sa reťazce porovnávajú podľa jazykových pravidiel invariantnej kultúry, rovnakých na každej riadiacej jednotke, upravených týmito možnosťami. ```taphome # rovnaké reťazce dajú 0 COMPARE("abc", "abc"); # Result: 0 # iná veľkosť písmen dá kladné číslo COMPARE("abc", "ABC"); # Result: 32 # prvý reťazec sa radí pred druhý COMPARE("a", "c"); # Result: -2 # ignorovanie veľkosti písmen dá 0 COMPARE("abc", "ABC", CompareOptions.IgnoreCase); # Result: 0 ``` **Chyby** — *COMPARE arguments 1 and 2 must be strings*. ## BYTECOLLECTION `BYTECOLLECTION` vytvorí `collection` buď z reťazca hexadecimálnych číslic, alebo vyplnenú zadaným počtom nulových bajtov (1 – 2048). ```text BYTECOLLECTION(hexString) BYTECOLLECTION(count) ``` **Poznámky** — Znaky reťazca, ktoré nie sú hexadecimálne číslice, sa ignorujú, takže bajty môžu oddeľovať medzery, čiarky aj pomlčky; počet zostávajúcich číslic musí byť párny. ```taphome # bajty z hexadecimálneho textu BYTECOLLECTION("00 0A FF"); # Result: {0x00, 0x0A, 0xFF} # hexadecimálny text s rôznymi oddeľovačmi BYTECOLLECTION("aa, be1-1,fe"); # Result: {0xAA, 0xBE, 0x11, 0xFE} # číslo dá toľko nulových bajtov 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` vytvorí `collection` s 1 – 2048 nulami, typicky na naplnenie pomocou `PACKVALUE` a zápis do registrov Modbus pomocou `MODBUSWBLOCK`. ```taphome collection regs := UINT16COLLECTION(4); PACKVALUE(regs, 0, BigEndianFloat, 21.5); PACKVALUE(regs, 2, Uint16, 100); MODBUSWBLOCK(H, 200, regs); ``` **Dostupnosť** — TapHome Next 2026.1.39016+. **Pozrite aj** — [Binárne dáta](https://taphome.com/sk/docs/script/binary-data/), [Modbus funkcie](https://taphome.com/sk/docs/script/modbus/). ## BOOLCOLLECTION `BOOLCOLLECTION` vytvorí `collection` s 1 – 2048 hodnotami `FALSE`, typicky na zápis coilov Modbus pomocou `MODBUSWBLOCK`. ```taphome collection coils := BOOLCOLLECTION(8); SETAT(coils, 0, TRUE); MODBUSWBLOCK(C, 0, coils); ``` **Dostupnosť** — TapHome Next 2026.1.39016+.