TapHome

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.

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, EQUALS auf Logik und Diagnose. Die Sammlungstypen beschreibt Datentypen.

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.

LENGTH("Hello World");
# Result: 11
LENGTH(40);
# Result: 8 (a decimal literal is a double)
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.

1

GETAT(value, index)

Rückgabewert — für einen String ein char, keinen String aus einem Buchstaben; vergleichen Sie es mit einem Zeichenliteral wie 'l'.

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.

1

SETAT(value, index, newValue)

SETAT("Hello", 1, "a");
# Result: "Hallo"
SETAT("Hello", 4, "o World");
# Result: "Hello World"
VAR c := {1, 2, 4};
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.

1

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).

VAR c := {1, 2};
APPEND(c, 3);
# Result: {1, 2, 3}, and c is now {1, 2, 3}
APPEND(c, {4, 5});
# Result: {1, 2, 3, 4, 5}
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.

1

INSERT(value, index, what)

INSERT("Hello", 5, " World");
# Result: "Hello World"
INSERT("Hello", 1, "i");
# Result: "Hiello"
INSERT({1, 2, 4}, 2, 3);
# Result: {1, 2, 3, 4}

REMOVEAT

REMOVEAT entfernt ab einem Index count Zeichen oder Elemente, standardmäßig 1.

1
2

REMOVEAT(value, index)
REMOVEAT(value, index, count)

REMOVEAT("Hello", 1);
# Result: "Hllo"
REMOVEAT("Hello", 3, 2);
# Result: "Hel"
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.

1
2
3

COPY(value)
COPY(value, from)
COPY(value, from, length)

COPY("Hello World", 2);
# Result: "llo World"
COPY("Hello World", 2, 4);
# Result: "llo "
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.

1

INDEXOF(value, what)

INDEXOF("Hello World", "Wor");
# Result: 6
INDEXOF("Hello World", "or12");
# Result: -1
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.

1

REPLACE(value, what, replacement)

REPLACE("Hello", "l", "");
# Result: "Heo"
REPLACE("Hello", "lo", "22");
# Result: "Hel22"
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<string> zurück; leere Teile bleiben erhalten.

1

SPLIT(string, separator)

Parameter — separator ist ein char, ein String, eine collection<char> oder eine collection<string>.

SPLIT("1;2;3;4", ";");
# Result: {"1", "2", "3", "4"}
SPLIT("1;2;3.4", "2;");
# Result: {"1;", "3.4"}
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.

1
2

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.

COMPARE("abc", "abc");
# Result: 0
COMPARE("abc", "ABC");
# Result: 32
COMPARE("a", "c");
# Result: -2
COMPARE("abc", "ABC", CompareOptions.IgnoreCase);
# Result: 0

Fehler — COMPARE arguments 1 and 2 must be strings.

BYTECOLLECTION

BYTECOLLECTION erstellt eine collection<uint8>, entweder aus einem String mit Hexadezimalziffern oder gefüllt mit einer angegebenen Anzahl Nullbytes (1 – 2048).

1
2

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.

BYTECOLLECTION("00 0A FF");
# Result: {0x00, 0x0A, 0xFF}
BYTECOLLECTION("aa, be1-1,fe");
# Result: {0xAA, 0xBE, 0x11, 0xFE}
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<uint16> aus 1 – 2048 Nullen, die typischerweise mit PACKVALUE gefüllt und mit MODBUSWBLOCK in Modbus-Register geschrieben wird.

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

Verfügbar — Core 2026.1, Build 39001 und neuer.

Siehe auch — Binärdaten, Modbus-Funktionen.

BOOLCOLLECTION

BOOLCOLLECTION erstellt eine collection<bool> aus 1 – 2048 Werten FALSE, typischerweise zum Schreiben von Modbus-Coils mit MODBUSWBLOCK.

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

Verfügbar — Core 2026.1, Build 39001 und neuer.