--- title: "Text und Sammlungen" description: "Funktionen für Text und Sammlungen in TapHome-Skripten: LENGTH, GETAT, SETAT, APPEND, INSERT, REMOVEAT, COPY, INDEXOF, REPLACE, SPLIT, COMPARE und BYTECOLLECTION, UINT16COLLECTION, BOOLCOLLECTION." url: "https://taphome.com/de/docs/script/text-string-and-byte-array/" language: de lastmod: 2026-11-06 generator: hugo ai: topics: ["string-functions","byte-array","collections","scripting-language"] questions: ["Wie ermittle ich in einem TapHome-Skript die Länge eines Strings?","Wie teile ich in TapHome einen String an einem Trennzeichen auf?","Wie ersetze ich in TapHome Text innerhalb eines Strings?","Wie erstelle ich eine Bytesammlung aus Hexadezimalwerten?","Wie finde ich den Index eines Elements in einem String oder einer Sammlung?","Erzeugt APPEND eine neue Sammlung oder ändert es die ursprüngliche?","Wie vergleiche ich in einem TapHome-Skript zwei Strings?"] --- # Text und Sammlungen Funktionen der TapHome-Skripte für Strings, Sammlungen und Bytefelder — LENGTH, GETAT, SETAT, APPEND, INSERT, REMOVEAT, COPY, INDEXOF, REPLACE, SPLIT, COMPARE, BYTECOLLECTION, UINT16COLLECTION, BOOLCOLLECTION. Zuletzt aktualisiert: 2026-11-06 Diese Funktionen nehmen einen String oder eine Sammlung als erstes Argument und arbeiten mit Zeichen oder Elementen über einen nullbasierten Index. - Eine **Sammlung** wird von `APPEND`, `INSERT`, `REMOVEAT`, `SETAT` und `REPLACE` **direkt** geändert; sie geben dieselbe Sammlung zurück. Für einen **String** geben sie einen neuen String zurück. - Ein **Blob**, etwa `RECEIVEDMSG.PAYLOAD`, wird nur von `LENGTH`, `GETAT`, `COPY` und `INDEXOF` akzeptiert. - Ein erstes Argument `Null` bricht das Skript mit *Parameter 1 is null* ab, außer bei `LENGTH` (0), `INDEXOF` (-1) und `SPLIT` (eine leere Sammlung); `COMPARE` meldet *COMPARE arguments 1 and 2 must be strings*. `ENCODE` und `DECODE` (XML, Base64) stehen auf [Datentypkonvertierungen](https://taphome.com/de/docs/script/data-type-conversions/), `EQUALS` auf [Logik und Diagnose](https://taphome.com/de/docs/script/logic-and-diagnostics/#equals). Die Sammlungstypen beschreibt [Datentypen](https://taphome.com/de/docs/script/data-types/). ## LENGTH `LENGTH` gibt die Anzahl der Zeichen eines Strings, der Elemente einer Sammlung oder der Bytes eines Blobs zurück; für eine Zahl gibt es die Größe ihres Typs in Bytes zurück und für `Null` 0. ```taphome # Zeichen in einem String LENGTH("Hello World"); # Result: 11 # Länge einer Zahl LENGTH(40); # Result: 8 (a decimal literal is a double) # Bytes in einer Byte-Sammlung LENGTH(BYTECOLLECTION("010203")); # Result: 3 ``` ## GETAT `GETAT` gibt das Element an einem Index zurück: ein `char` eines Strings, ein Element einer Sammlung oder ein Byte eines Blobs. ```text GETAT(value, index) ``` **Rückgabewert** — für einen String ein `char`, keinen String aus einem Buchstaben; vergleichen Sie es mit einem Zeichenliteral wie `'l'`. ```taphome GETAT("Hello", 2); # Result: 'l' (Char) GETAT({1, 2, 4}, 2); # Result: 4 ``` ## SETAT `SETAT` ersetzt das Element an einem Index; eine Sammlung wird direkt geändert, bei einem String wird das Zeichen am Index durch den Text von `newValue` ersetzt. ```text SETAT(value, index, newValue) ``` ```taphome # ein Zeichen ersetzen SETAT("Hello", 1, "a"); # Result: "Hallo" # ein Zeichen durch längeren Text ersetzen SETAT("Hello", 4, "o World"); # Result: "Hello World" # eine Sammlung zum Ändern VAR c := {1, 2, 4}; # ein Element direkt ersetzen SETAT(c, 2, 3); # Result: {1, 2, 3}, and c is now {1, 2, 3} ``` ## APPEND `APPEND` fügt einen Wert am Ende eines Strings oder einer Sammlung an; eine Sammlung wird direkt geändert und zurückgegeben, nicht kopiert. ```text APPEND(value, what) ``` **Hinweise** — Das Anhängen einer Sammlung mit demselben Elementtyp fügt alle ihre Elemente hinzu. Ein einzelner Wert wird als ein Element hinzugefügt. Eine Sammlung eines anderen Elementtyps ist ein Fehler (*Cannot append 'UInt8' collection to 'Double' collection*). ```taphome # eine Sammlung zum Erweitern VAR c := {1, 2}; # ein Element direkt anfügen APPEND(c, 3); # Result: {1, 2, 3}, and c is now {1, 2, 3} # mehrere Elemente direkt anfügen APPEND(c, {4, 5}); # Result: {1, 2, 3, 4, 5} # Text an einen String anfügen APPEND("abc", "def"); # Result: "abcdef" ``` ## INSERT `INSERT` fügt einen Wert an einem Index ein: einen Teilstring in einen String oder ein Element direkt in eine Sammlung. ```text INSERT(value, index, what) ``` ```taphome # einen Teilstring einfügen INSERT("Hello", 5, " World"); # Result: "Hello World" # ein Zeichen einfügen INSERT("Hello", 1, "i"); # Result: "Hiello" # ein Element in eine Sammlung einfügen INSERT({1, 2, 4}, 2, 3); # Result: {1, 2, 3, 4} ``` ## REMOVEAT `REMOVEAT` entfernt ab einem Index `count` Zeichen oder Elemente, standardmäßig 1. ```text REMOVEAT(value, index) REMOVEAT(value, index, count) ``` ```taphome # ein Zeichen entfernen REMOVEAT("Hello", 1); # Result: "Hllo" # 2 Zeichen ab Index 3 entfernen REMOVEAT("Hello", 3, 2); # Result: "Hel" # 2 Elemente aus einer Sammlung entfernen REMOVEAT({1, 2, 3, 4}, 2, 2); # Result: {1, 2} ``` ## COPY `COPY` gibt einen neuen String, eine neue Sammlung oder einen neuen Blob mit `length` Einträgen ab `from` zurück; ohne `length` kopiert es bis zum Ende, ohne `from` den ganzen Wert. ```text COPY(value) COPY(value, from) COPY(value, from, length) ``` ```taphome # ab Index 2 bis zum Ende kopieren COPY("Hello World", 2); # Result: "llo World" # 4 Zeichen ab Index 2 kopieren COPY("Hello World", 2, 4); # Result: "llo " # 1 Byte aus einem Blob kopieren COPY(BYTECOLLECTION("01020304"), 2, 1); # Result: {0x03} ``` **Fehler** — *Parameter 1 must be a non-empty string* beim Kopieren aus einem leeren String. ## INDEXOF `INDEXOF` gibt die Position des ersten Vorkommens eines Werts in einem String, einer Sammlung oder einem Blob zurück, oder `-1`, wenn er nicht gefunden wird. ```text INDEXOF(value, what) ``` ```taphome # Position eines Teilstrings INDEXOF("Hello World", "Wor"); # Result: 6 # nicht gefunden ergibt -1 INDEXOF("Hello World", "or12"); # Result: -1 # Position eines Elements in einem Blob INDEXOF(BYTECOLLECTION("ab cd ee ff 01 02"), 2); # Result: 5 ``` **Fehler** — *Parameter 2 must be a non-empty string* bei der Suche nach einem leeren String in einem String. ## REPLACE `REPLACE` ersetzt jedes Vorkommen eines Werts: Ein String ergibt einen neuen String, in einer Sammlung werden die passenden Elemente direkt ersetzt. ```text REPLACE(value, what, replacement) ``` ```taphome # jedes l entfernen REPLACE("Hello", "l", ""); # Result: "Heo" # einen Teilstring ersetzen REPLACE("Hello", "lo", "22"); # Result: "Hel22" # ein Element in einem Blob ersetzen REPLACE(BYTECOLLECTION("050607"), 5, 9); # Result: {0x09, 0x06, 0x07} ``` **Fehler** — *Empty string to replace*, wenn `what` ein leerer String ist. ## SPLIT `SPLIT` teilt einen String an jedem Trennzeichen auf und gibt eine `collection` zurück; leere Teile bleiben erhalten. ```text SPLIT(string, separator) ``` **Parameter** — `separator` ist ein `char`, ein String, eine `collection` oder eine `collection`. ```taphome # an einem Trennzeichen teilen SPLIT("1;2;3;4", ";"); # Result: {"1", "2", "3", "4"} # Trennzeichen länger als ein Zeichen SPLIT("1;2;3.4", "2;"); # Result: {"1;", "3.4"} # mehrere Trennzeichen auf einmal SPLIT("1;2;3.4", {"2", "3."}); # Result: {"1;", ";", "4"} ``` ## COMPARE `COMPARE` vergleicht zwei Strings und gibt eine negative Zahl zurück, wenn der erste vor dem zweiten einsortiert wird, 0, wenn sie gleich sind, und eine positive Zahl, wenn er danach einsortiert wird; verlassen Sie sich nur auf das Vorzeichen, nicht auf den Betrag. ```text COMPARE(string1, string2) COMPARE(string1, string2, CompareOptions) ``` **Hinweise** — Ohne Optionen gibt eine Steuereinheit die Differenz der Zeichencodes der ersten unterschiedlichen Zeichen zurück, daher werden Großbuchstaben vor Kleinbuchstaben einsortiert. Mit `CompareOptions` (`IgnoreCase`, `IgnoreNonSpace`, `IgnoreSymbols`, `IgnoreKanaType`, `IgnoreWidth`, `OrdinalIgnoreCase`, `StringSort`, `Ordinal`, `None`) werden die Strings nach den sprachlichen Regeln der invarianten Kultur verglichen, auf jeder Steuereinheit gleich, angepasst durch diese Optionen. ```taphome # gleiche Strings ergeben 0 COMPARE("abc", "abc"); # Result: 0 # andere Groß-/Kleinschreibung ergibt eine positive Zahl COMPARE("abc", "ABC"); # Result: 32 # erster String wird vor dem zweiten einsortiert COMPARE("a", "c"); # Result: -2 # Groß-/Kleinschreibung ignorieren ergibt 0 COMPARE("abc", "ABC", CompareOptions.IgnoreCase); # Result: 0 ``` **Fehler** — *COMPARE arguments 1 and 2 must be strings*. ## BYTECOLLECTION `BYTECOLLECTION` erstellt eine `collection`, entweder aus einem String mit Hexadezimalziffern oder gefüllt mit einer angegebenen Anzahl Nullbytes (1 – 2048). ```text BYTECOLLECTION(hexString) BYTECOLLECTION(count) ``` **Hinweise** — Zeichen des Strings, die keine Hexadezimalziffern sind, werden ignoriert; Leerzeichen, Kommas und Bindestriche können also die Bytes trennen. Die Anzahl der verbleibenden Ziffern muss gerade sein. ```taphome # Bytes aus Hex-Text BYTECOLLECTION("00 0A FF"); # Result: {0x00, 0x0A, 0xFF} # Hex-Text mit gemischten Trennzeichen BYTECOLLECTION("aa, be1-1,fe"); # Result: {0xAA, 0xBE, 0x11, 0xFE} # eine Zahl ergibt so viele Nullbytes BYTECOLLECTION(6); # Result: 6 zero bytes ``` **Fehler** — *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` erstellt eine `collection` aus 1 – 2048 Nullen, die typischerweise mit `PACKVALUE` gefüllt und mit `MODBUSWBLOCK` in Modbus-Register geschrieben wird. ```taphome collection regs := UINT16COLLECTION(4); PACKVALUE(regs, 0, BigEndianFloat, 21.5); PACKVALUE(regs, 2, Uint16, 100); MODBUSWBLOCK(H, 200, regs); ``` **Verfügbar** — TapHome Next 2026.1.39016+. **Siehe auch** — [Binärdaten](https://taphome.com/de/docs/script/binary-data/), [Modbus-Funktionen](https://taphome.com/de/docs/script/modbus/). ## BOOLCOLLECTION `BOOLCOLLECTION` erstellt eine `collection` aus 1 – 2048 Werten `FALSE`, typischerweise zum Schreiben von Modbus-Coils mit `MODBUSWBLOCK`. ```taphome collection coils := BOOLCOLLECTION(8); SETAT(coils, 0, TRUE); MODBUSWBLOCK(C, 0, coils); ``` **Verfügbar** — TapHome Next 2026.1.39016+.