--- title: "Tekst i kolekcje" description: "Funkcje tekstu i kolekcji w skryptach TapHome: LENGTH, GETAT, SETAT, APPEND, INSERT, REMOVEAT, COPY, INDEXOF, REPLACE, SPLIT, COMPARE oraz BYTECOLLECTION, UINT16COLLECTION, BOOLCOLLECTION." url: "https://taphome.com/pl/docs/script/text-string-and-byte-array/" language: pl lastmod: 2026-11-06 generator: hugo ai: topics: ["string-functions","byte-array","collections","scripting-language"] questions: ["Jak uzyskać długość tekstu w skrypcie TapHome?","Jak podzielić tekst według separatora w TapHome?","Jak zastąpić fragment tekstu w TapHome?","Jak utworzyć kolekcję bajtów z wartości szesnastkowych?","Jak znaleźć indeks elementu w tekście lub kolekcji?","Czy APPEND tworzy nową kolekcję, czy zmienia oryginalną?","Jak porównać dwa teksty w skrypcie TapHome?"] --- # Tekst i kolekcje Funkcje skryptowe TapHome dla tekstów, kolekcji i tablic bajtów — LENGTH, GETAT, SETAT, APPEND, INSERT, REMOVEAT, COPY, INDEXOF, REPLACE, SPLIT, COMPARE, BYTECOLLECTION, UINT16COLLECTION, BOOLCOLLECTION. Ostatnia aktualizacja: 2026-11-06 Te funkcje przyjmują jako pierwszy argument tekst lub kolekcję i pracują ze znakami lub elementami według indeksu liczonego od zera. - **Kolekcja** jest zmieniana **na miejscu** przez `APPEND`, `INSERT`, `REMOVEAT`, `SETAT` i `REPLACE`, które zwracają tę samą kolekcję. Dla **tekstu** zwracają nowy tekst. - **Blob**, na przykład `RECEIVEDMSG.PAYLOAD`, przyjmują tylko `LENGTH`, `GETAT`, `COPY` i `INDEXOF`. - Pierwszy argument `Null` zatrzymuje skrypt komunikatem *Parameter 1 is null*, z wyjątkiem `LENGTH` (0), `INDEXOF` (-1) i `SPLIT` (pusta kolekcja); `COMPARE` zgłasza *COMPARE arguments 1 and 2 must be strings*. `ENCODE` i `DECODE` (XML, Base64) są na stronie [Konwersje typów danych](https://taphome.com/pl/docs/script/data-type-conversions/), `EQUALS` na stronie [Logika i diagnostyka](https://taphome.com/pl/docs/script/logic-and-diagnostics/#equals). Typy kolekcji opisuje strona [Typy danych](https://taphome.com/pl/docs/script/data-types/). ## LENGTH `LENGTH` zwraca liczbę znaków tekstu, elementów kolekcji lub bajtów bloba; dla liczby zwraca rozmiar jej typu w bajtach, a dla `Null` 0. ```taphome # znaki w tekście LENGTH("Hello World"); # Result: 11 # długość liczby LENGTH(40); # Result: 8 (a decimal literal is a double) # bajty w kolekcji bajtów LENGTH(BYTECOLLECTION("010203")); # Result: 3 ``` ## GETAT `GETAT` zwraca element o podanym indeksie: `char` tekstu, element kolekcji lub bajt bloba. ```text GETAT(value, index) ``` **Zwraca** — dla tekstu `char`, a nie jednoliterowy tekst; porównuj go z literałem znakowym, takim jak `'l'`. ```taphome GETAT("Hello", 2); # Result: 'l' (Char) GETAT({1, 2, 4}, 2); # Result: 4 ``` ## SETAT `SETAT` zastępuje element o podanym indeksie; kolekcja jest zmieniana na miejscu, w tekście znak o podanym indeksie jest zastępowany tekstem `newValue`. ```text SETAT(value, index, newValue) ``` ```taphome # zamiana jednego znaku SETAT("Hello", 1, "a"); # Result: "Hallo" # zamiana znaku na dłuższy tekst SETAT("Hello", 4, "o World"); # Result: "Hello World" # kolekcja do zmiany VAR c := {1, 2, 4}; # zamiana elementu na miejscu SETAT(c, 2, 3); # Result: {1, 2, 3}, and c is now {1, 2, 3} ``` ## APPEND `APPEND` dodaje wartość na końcu tekstu lub kolekcji; kolekcja jest zmieniana na miejscu i zwracana, a nie kopiowana. ```text APPEND(value, what) ``` **Uwagi** — Dopisanie kolekcji o tym samym typie elementu dodaje wszystkie jej elementy. Pojedyncza wartość jest dodawana jako jeden element. Kolekcja o innym typie elementu to błąd (*Cannot append 'UInt8' collection to 'Double' collection*). ```taphome # kolekcja do rozszerzenia VAR c := {1, 2}; # dodanie jednego elementu na miejscu APPEND(c, 3); # Result: {1, 2, 3}, and c is now {1, 2, 3} # dodanie kilku elementów na miejscu APPEND(c, {4, 5}); # Result: {1, 2, 3, 4, 5} # dopisanie tekstu do tekstu APPEND("abc", "def"); # Result: "abcdef" ``` ## INSERT `INSERT` wstawia wartość na podanym indeksie: podciąg do tekstu albo element do kolekcji na miejscu. ```text INSERT(value, index, what) ``` ```taphome # wstawienie podtekstu INSERT("Hello", 5, " World"); # Result: "Hello World" # wstawienie znaku INSERT("Hello", 1, "i"); # Result: "Hiello" # wstawienie elementu do kolekcji INSERT({1, 2, 4}, 2, 3); # Result: {1, 2, 3, 4} ``` ## REMOVEAT `REMOVEAT` usuwa `count` znaków lub elementów, domyślnie 1, począwszy od podanego indeksu. ```text REMOVEAT(value, index) REMOVEAT(value, index, count) ``` ```taphome # usunięcie jednego znaku REMOVEAT("Hello", 1); # Result: "Hllo" # usunięcie 2 znaków od indeksu 3 REMOVEAT("Hello", 3, 2); # Result: "Hel" # usunięcie 2 elementów z kolekcji REMOVEAT({1, 2, 3, 4}, 2, 2); # Result: {1, 2} ``` ## COPY `COPY` zwraca nowy tekst, kolekcję lub blob z `length` elementami od pozycji `from`; bez `length` kopiuje do końca, bez `from` całą wartość. ```text COPY(value) COPY(value, from) COPY(value, from, length) ``` ```taphome # kopiowanie od indeksu 2 do końca COPY("Hello World", 2); # Result: "llo World" # kopiowanie 4 znaków od indeksu 2 COPY("Hello World", 2, 4); # Result: "llo " # kopiowanie 1 bajtu z bloba COPY(BYTECOLLECTION("01020304"), 2, 1); # Result: {0x03} ``` **Błędy** — *Parameter 1 must be a non-empty string* przy kopiowaniu z pustego tekstu. ## INDEXOF `INDEXOF` zwraca pozycję pierwszego wystąpienia wartości w tekście, kolekcji lub blobie albo `-1`, gdy jej nie znaleziono. ```text INDEXOF(value, what) ``` ```taphome # pozycja podtekstu INDEXOF("Hello World", "Wor"); # Result: 6 # nie znaleziono daje -1 INDEXOF("Hello World", "or12"); # Result: -1 # pozycja elementu w blobie INDEXOF(BYTECOLLECTION("ab cd ee ff 01 02"), 2); # Result: 5 ``` **Błędy** — *Parameter 2 must be a non-empty string* przy szukaniu pustego tekstu w tekście. ## REPLACE `REPLACE` zastępuje każde wystąpienie wartości: tekst daje nowy tekst, w kolekcji pasujące elementy są zastępowane na miejscu. ```text REPLACE(value, what, replacement) ``` ```taphome # usunięcie każdego l REPLACE("Hello", "l", ""); # Result: "Heo" # zamiana podtekstu REPLACE("Hello", "lo", "22"); # Result: "Hel22" # zamiana elementu w blobie REPLACE(BYTECOLLECTION("050607"), 5, 9); # Result: {0x09, 0x06, 0x07} ``` **Błędy** — *Empty string to replace*, gdy `what` jest pustym tekstem. ## SPLIT `SPLIT` dzieli tekst przy każdym separatorze i zwraca `collection`; puste części są zachowywane. ```text SPLIT(string, separator) ``` **Parametry** — `separator` to `char`, tekst, `collection` lub `collection`. ```taphome # podział przy separatorze SPLIT("1;2;3;4", ";"); # Result: {"1", "2", "3", "4"} # separator dłuższy niż jeden znak SPLIT("1;2;3.4", "2;"); # Result: {"1;", "3.4"} # kilka separatorów naraz SPLIT("1;2;3.4", {"2", "3."}); # Result: {"1;", ";", "4"} ``` ## COMPARE `COMPARE` porównuje dwa teksty i zwraca liczbę ujemną, gdy pierwszy w sortowaniu jest przed drugim, 0, gdy są równe, i liczbę dodatnią, gdy jest po nim; polegaj tylko na znaku, a nie na wielkości. ```text COMPARE(string1, string2) COMPARE(string1, string2, CompareOptions) ``` **Uwagi** — Bez opcji jednostka sterująca zwraca różnicę kodów pierwszych różniących się znaków, więc wielkie litery są sortowane przed małymi. Z `CompareOptions` (`IgnoreCase`, `IgnoreNonSpace`, `IgnoreSymbols`, `IgnoreKanaType`, `IgnoreWidth`, `OrdinalIgnoreCase`, `StringSort`, `Ordinal`, `None`) teksty są porównywane według reguł językowych kultury niezmiennej (invariant culture), takich samych na każdej jednostce sterującej, zmodyfikowanych tymi opcjami. ```taphome # równe teksty dają 0 COMPARE("abc", "abc"); # Result: 0 # inna wielkość liter daje liczbę dodatnią COMPARE("abc", "ABC"); # Result: 32 # pierwszy tekst jest sortowany przed drugim COMPARE("a", "c"); # Result: -2 # pominięcie wielkości liter daje 0 COMPARE("abc", "ABC", CompareOptions.IgnoreCase); # Result: 0 ``` **Błędy** — *COMPARE arguments 1 and 2 must be strings*. ## BYTECOLLECTION `BYTECOLLECTION` tworzy `collection` z tekstu z cyframi szesnastkowymi albo wypełnioną podaną liczbą bajtów zerowych (1 – 2048). ```text BYTECOLLECTION(hexString) BYTECOLLECTION(count) ``` **Uwagi** — Znaki tekstu, które nie są cyframi szesnastkowymi, są ignorowane, więc bajty mogą oddzielać spacje, przecinki i myślniki; liczba pozostałych cyfr musi być parzysta. ```taphome # bajty z tekstu szesnastkowego BYTECOLLECTION("00 0A FF"); # Result: {0x00, 0x0A, 0xFF} # tekst szesnastkowy z różnymi separatorami BYTECOLLECTION("aa, be1-1,fe"); # Result: {0xAA, 0xBE, 0x11, 0xFE} # liczba daje tyle bajtów zerowych BYTECOLLECTION(6); # Result: 6 zero bytes ``` **Błędy** — *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` tworzy `collection` z 1 – 2048 zer, zwykle wypełnianą funkcją `PACKVALUE` i zapisywaną do rejestrów Modbus funkcją `MODBUSWBLOCK`. ```taphome collection regs := UINT16COLLECTION(4); PACKVALUE(regs, 0, BigEndianFloat, 21.5); PACKVALUE(regs, 2, Uint16, 100); MODBUSWBLOCK(H, 200, regs); ``` **Dostępność** — TapHome Next 2026.1.39016+. **Zobacz też** — [Dane binarne](https://taphome.com/pl/docs/script/binary-data/), [Funkcje Modbus](https://taphome.com/pl/docs/script/modbus/). ## BOOLCOLLECTION `BOOLCOLLECTION` tworzy `collection` z 1 – 2048 wartości `FALSE`, zwykle do zapisu cewek Modbus funkcją `MODBUSWBLOCK`. ```taphome collection coils := BOOLCOLLECTION(8); SETAT(coils, 0, TRUE); MODBUSWBLOCK(C, 0, coils); ``` **Dostępność** — TapHome Next 2026.1.39016+.