---
title: "Tekst i zbirke"
description: "Funkcije skripte TapHome za tekst i zbirke: LENGTH, GETAT, SETAT, APPEND, INSERT, REMOVEAT, COPY, INDEXOF, REPLACE, SPLIT, COMPARE te BYTECOLLECTION, UINT16COLLECTION, BOOLCOLLECTION."
url: "https://taphome.com/hr/docs/script/text-string-and-byte-array/"
language: hr
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["string-functions","byte-array","collections","scripting-language"]
  questions: ["Kako u skripti TapHome dobiti duljinu niza znakova?","Kako u sustavu TapHome podijeliti niz znakova prema razdjelniku?","Kako u sustavu TapHome zamijeniti tekst unutar niza znakova?","Kako stvoriti zbirku bajtova iz heksadecimalnih vrijednosti?","Kako pronaći indeks elementa u nizu znakova ili zbirci?","Stvara li APPEND novu zbirku ili mijenja izvornu?","Kako u skripti TapHome usporediti dva niza znakova?"]
---

# Tekst i zbirke

Funkcije skripte TapHome za nizove znakova, zbirke i polja bajtova — LENGTH, GETAT, SETAT, APPEND, INSERT, REMOVEAT, COPY, INDEXOF, REPLACE, SPLIT, COMPARE, BYTECOLLECTION, UINT16COLLECTION, BOOLCOLLECTION.

Posljednje ažuriranje: 2026-11-06

Ove funkcije kao prvi argument primaju niz znakova ili zbirku i rade sa znakovima ili elementima prema indeksu koji počinje od nule.

- **Zbirku** funkcije `APPEND`, `INSERT`, `REMOVEAT`, `SETAT` i `REPLACE` mijenjaju **na mjestu** i vraćaju istu zbirku. Za **niz znakova** vraćaju novi niz znakova.
- **Blob**, kao `RECEIVEDMSG.PAYLOAD`, prihvaćaju samo `LENGTH`, `GETAT`, `COPY` i `INDEXOF`.
- Prvi argument `Null` zaustavlja skriptu porukom *Parameter 1 is null*, osim u `LENGTH` (0), `INDEXOF` (-1) i `SPLIT` (prazna zbirka); `COMPARE` prijavljuje *COMPARE arguments 1 and 2 must be strings*.

`ENCODE` i `DECODE` (XML, Base64) nalaze se na stranici [Pretvorbe tipova podataka](https://taphome.com/hr/docs/script/data-type-conversions/), `EQUALS` na stranici [Logika i dijagnostika](https://taphome.com/hr/docs/script/logic-and-diagnostics/#equals). Tipovi zbirki opisani su na stranici [Tipovi podataka](https://taphome.com/hr/docs/script/data-types/).

## LENGTH

`LENGTH` vraća broj znakova niza znakova, elemenata zbirke ili bajtova bloba; za broj vraća veličinu njegova tipa u bajtovima, a za `Null` 0.

```taphome
# znakovi u nizu znakova
LENGTH("Hello World");
# Result: 11
# duljina broja
LENGTH(40);
# Result: 8 (a decimal literal is a double)
# bajtovi u zbirci bajtova
LENGTH(BYTECOLLECTION("010203"));
# Result: 3
```

## GETAT

`GETAT` vraća element na indeksu: `char` niza znakova, element zbirke ili bajt bloba.

```text
GETAT(value, index)
```

**Vraća** — za niz znakova `char`, a ne niz od jednog slova; usporedite ga sa znakovnim literalom kao `'l'`.

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

## SETAT

`SETAT` zamjenjuje element na indeksu; zbirka se mijenja na mjestu, a u nizu znakova znak na indeksu zamjenjuje se tekstom iz `newValue`.

```text
SETAT(value, index, newValue)
```

```taphome
# zamjena jednog znaka
SETAT("Hello", 1, "a");
# Result: "Hallo"
# zamjena znaka duljim tekstom
SETAT("Hello", 4, "o World");
# Result: "Hello World"
# zbirka za promjenu
VAR c := {1, 2, 4};
# zamjena elementa na mjestu
SETAT(c, 2, 3);
# Result: {1, 2, 3}, and c is now {1, 2, 3}
```

## APPEND

`APPEND` dodaje vrijednost na kraj niza znakova ili zbirke; zbirka se mijenja na mjestu i vraća, a ne kopira.

```text
APPEND(value, what)
```

**Napomene** — Dodavanje zbirke s istim tipom elementa dodaje sve njezine elemente. Pojedinačna vrijednost dodaje se kao jedan element. Zbirka drugog tipa elementa je pogreška (*Cannot append 'UInt8' collection to 'Double' collection*).

```taphome
# zbirka za proširenje
VAR c := {1, 2};
# dodavanje jednog elementa na mjestu
APPEND(c, 3);
# Result: {1, 2, 3}, and c is now {1, 2, 3}
# dodavanje više elemenata na mjestu
APPEND(c, {4, 5});
# Result: {1, 2, 3, 4, 5}
# dodavanje teksta na niz znakova
APPEND("abc", "def");
# Result: "abcdef"
```

## INSERT

`INSERT` umeće vrijednost na indeks: podniz u niz znakova ili element u zbirku na mjestu.

```text
INSERT(value, index, what)
```

```taphome
# umetanje podniza
INSERT("Hello", 5, " World");
# Result: "Hello World"
# umetanje znaka
INSERT("Hello", 1, "i");
# Result: "Hiello"
# umetanje elementa u zbirku
INSERT({1, 2, 4}, 2, 3);
# Result: {1, 2, 3, 4}
```

## REMOVEAT

`REMOVEAT` uklanja `count` znakova ili elemenata, zadano 1, počevši od indeksa.

```text
REMOVEAT(value, index)
REMOVEAT(value, index, count)
```

```taphome
# uklanjanje jednog znaka
REMOVEAT("Hello", 1);
# Result: "Hllo"
# uklanjanje 2 znaka od indeksa 3
REMOVEAT("Hello", 3, 2);
# Result: "Hel"
# uklanjanje 2 elementa iz zbirke
REMOVEAT({1, 2, 3, 4}, 2, 2);
# Result: {1, 2}
```

## COPY

`COPY` vraća novi niz znakova, zbirku ili blob s `length` stavki počevši od `from`; bez `length` kopira do kraja, bez `from` cijelu vrijednost.

```text
COPY(value)
COPY(value, from)
COPY(value, from, length)
```

```taphome
# kopiranje od indeksa 2 do kraja
COPY("Hello World", 2);
# Result: "llo World"
# kopiranje 4 znaka od indeksa 2
COPY("Hello World", 2, 4);
# Result: "llo "
# kopiranje 1 bajta iz bloba
COPY(BYTECOLLECTION("01020304"), 2, 1);
# Result: {0x03}
```

**Pogreške** — *Parameter 1 must be a non-empty string* pri kopiranju iz praznog niza znakova.

## INDEXOF

`INDEXOF` vraća položaj prvog pojavljivanja vrijednosti u nizu znakova, zbirci ili blobu ili `-1` kada vrijednost nije pronađena.

```text
INDEXOF(value, what)
```

```taphome
# položaj podniza
INDEXOF("Hello World", "Wor");
# Result: 6
# ako nije pronađeno, rezultat je -1
INDEXOF("Hello World", "or12");
# Result: -1
# položaj elementa u blobu
INDEXOF(BYTECOLLECTION("ab cd ee ff 01 02"), 2);
# Result: 5
```

**Pogreške** — *Parameter 2 must be a non-empty string* pri traženju praznog niza znakova u nizu znakova.

## REPLACE

`REPLACE` zamjenjuje svako pojavljivanje vrijednosti: niz znakova daje novi niz znakova, a u zbirci se odgovarajući elementi zamjenjuju na mjestu.

```text
REPLACE(value, what, replacement)
```

```taphome
# uklanjanje svakog l
REPLACE("Hello", "l", "");
# Result: "Heo"
# zamjena podniza
REPLACE("Hello", "lo", "22");
# Result: "Hel22"
# zamjena elementa u blobu
REPLACE(BYTECOLLECTION("050607"), 5, 9);
# Result: {0x09, 0x06, 0x07}
```

**Pogreške** — *Empty string to replace* kada je `what` prazan niz znakova.

## SPLIT

`SPLIT` dijeli niz znakova na svakom razdjelniku i vraća `collection<string>`; prazni dijelovi se zadržavaju.

```text
SPLIT(string, separator)
```

**Parametri** — `separator` je `char`, niz znakova, `collection<char>` ili `collection<string>`.

```taphome
# dijeljenje na razdjelniku
SPLIT("1;2;3;4", ";");
# Result: {"1", "2", "3", "4"}
# razdjelnik dulji od jednog znaka
SPLIT("1;2;3.4", "2;");
# Result: {"1;", "3.4"}
# više razdjelnika odjednom
SPLIT("1;2;3.4", {"2", "3."});
# Result: {"1;", ";", "4"}
```

## COMPARE

`COMPARE` uspoređuje dva niza znakova i vraća negativan broj kada se prvi u redoslijedu nalazi prije drugoga, 0 kada su jednaki i pozitivan broj kada se nalazi iza njega; oslonite se samo na predznak, a ne na veličinu.

```text
COMPARE(string1, string2)
COMPARE(string1, string2, CompareOptions)
```

**Napomene** — Bez opcija centralna jedinica vraća razliku kodova prvih različitih znakova, pa se velika slova u redoslijedu nalaze prije malih. S `CompareOptions` (`IgnoreCase`, `IgnoreNonSpace`, `IgnoreSymbols`, `IgnoreKanaType`, `IgnoreWidth`, `OrdinalIgnoreCase`, `StringSort`, `Ordinal`, `None`) nizovi znakova uspoređuju se prema jezičnim pravilima invarijantne kulture, jednako na svakoj centralnoj jedinici, prilagođeno tim opcijama.

```taphome
# jednaki nizovi daju 0
COMPARE("abc", "abc");
# Result: 0
# drugačija veličina slova daje pozitivan broj
COMPARE("abc", "ABC");
# Result: 32
# prvi niz je prije drugoga
COMPARE("a", "c");
# Result: -2
# zanemarivanje veličine slova daje 0
COMPARE("abc", "ABC", CompareOptions.IgnoreCase);
# Result: 0
```

**Pogreške** — *COMPARE arguments 1 and 2 must be strings*.

## BYTECOLLECTION

`BYTECOLLECTION` stvara `collection<uint8>`, bilo iz niza heksadecimalnih znamenki, bilo popunjenu zadanim brojem nultih bajtova (1 – 2048).

```text
BYTECOLLECTION(hexString)
BYTECOLLECTION(count)
```

**Napomene** — Znakovi niza koji nisu heksadecimalne znamenke zanemaruju se, pa razmaci, zarezi i crtice mogu odvajati bajtove; broj preostalih znamenki mora biti paran.

```taphome
# bajtovi iz heksadecimalnog teksta
BYTECOLLECTION("00 0A FF");
# Result: {0x00, 0x0A, 0xFF}
# heksadecimalni tekst s različitim razdjelnicima
BYTECOLLECTION("aa, be1-1,fe");
# Result: {0xAA, 0xBE, 0x11, 0xFE}
# broj daje toliko nultih bajtova
BYTECOLLECTION(6);
# Result: 6 zero bytes
```

**Pogreške** — *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` stvara `collection<uint16>` od 1 – 2048 nula, koja se obično popunjava funkcijom `PACKVALUE` i upisuje u registre Modbus funkcijom `MODBUSWBLOCK`.

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

**Dostupno** — TapHome Next 2026.1.39016+.

**Vidi također** — [Binarni podaci](https://taphome.com/hr/docs/script/binary-data/), [Funkcije Modbus](https://taphome.com/hr/docs/script/modbus/).

## BOOLCOLLECTION

`BOOLCOLLECTION` stvara `collection<bool>` od 1 – 2048 vrijednosti `FALSE`, obično za upis coil registara Modbus funkcijom `MODBUSWBLOCK`.

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

**Dostupno** — TapHome Next 2026.1.39016+.
