String-Operatoren

Dieser Abschnitt listet Operatoren auf, die Zeichenketten als Argumente verwenden. Darüber hinaus werden auch Operatoren behandelt, die Zeichenketten aus anderen Werten erzeugen.

Grundlegende String-Operationen¶

String-Verkettung: `<string1> + <string2>`¶

Beschreibung: Der Operator + kann auch zum Anfügen einer Zeichenkette an eine andere verwendet werden. Das Ergebnis einer solchen Operation ist wieder eine Zeichenkette. Wenn bei einer Additionsoperation mindestens eines der Argumente eine Zeichenkette ist, wird das andere Argument automatisch in eine Zeichenkettendarstellung seines Wertes konvertiert.

Code	Ergebnis
`"Cindy"+"Script"`	`"CindyScript"`
`"Four plus three is "+(4+3)`	`"Four plus three is 7"`
`""+(4+3)`	`"7"`

Siehe auch: Der Operator + wird auch für die Addition von gewöhnlichen numerischen Werten verwendet. Dazu siehe Arithmetische Operatoren.

Konvertierung in String: `text(<expr>)`¶

Beschreibung: Der Operator text(<expr>) bewertet den Ausdruck <expr> und konvertiert das Ergebnis in eine Zeichenkettendarstellung.

Länge einer Zeichenkette: `length(<string>)`¶

Beschreibung: Dieser Operator gibt die Anzahl der Zeichen in einer Zeichenkette zurück.

Beispiel: length("CindyScript") ergibt die ganze Zahl 11.

Siehe auch: Listen und Lineare Algebra

Extrahieren eines Teilstrings: `substring(<string>,<int1>,<int2>)`¶

Beschreibung: Dieser Operator gibt den Teilstring von <string> zurück, der nach dem Zeichen mit dem Index <int1> beginnt und mit dem Zeichen mit dem Index <int2> endet.

Beispiel: substring("abcdefg",3,6) ergibt die Zeichenkette "def".

Suchen nach Vorkommen: `indexof(<string1>,<string2>)`¶

Beschreibung: Dieser Operator sucht nach dem ersten Vorkommen von <string2> in <string1>. Der Index dieses ersten Vorkommens wird zurückgegeben. Wenn <string2> kein Teilstring von <string1> ist, wird der Wert 0 zurückgegeben.

Code	Ergebnis
`indexof("CindyScript","i")`	`2`
`indexof("CindyScript","y")`	`5`
`indexof("CindyScript","z")`	`0`

Suchen nach Vorkommen: `indexof(<string1>,<string2>,<int>)`¶

Beschreibung: Dieser Operator sucht nach dem ersten Vorkommen von <string2> in <string1> nach dem Index i. Der Index dieses ersten Vorkommens wird zurückgegeben. Wenn <string2> nicht in <string1> nach dem Index i vorkommt, wird der Wert 0 zurückgegeben.

Code	Ergebnis
`indexof("CindyScript","i",1)`	`2`
`indexof("CindyScript","i",3)`	`9`
`indexof("CindyScript","i",10)`	`0`

Fortgeschrittene String-Operationen¶

Zerlegen einer Zeichenkette: `tokenize(<string>,<expr>)`¶

Beschreibung: Dieser Operator ist sehr nützlich zum Analysieren von Eingaben. Er erstellt eine Liste von Teilstrings von <string>. Das zweite Argument <expr> muss entweder eine Zeichenkette oder eine Liste von Zeichenketten sein. Wenn <expr> eine Zeichenkette ist, sucht der Operator nach Vorkommen dieser Zeichenkette in <string>. Diese Vorkommen dienen als Markierungen zum Unterteilen von <string> in eine Liste von Teilen.

Wenn <expr> eine Liste von Zeichenketten ist, wird eine hierarchische Liste generiert, die die Unterteilung von <string> rekursiv durch die Token in der Liste darstellt.

tokenize konvertiert normalerweise Zeichenkettendarstellungen von Zahlen in Zahlobjekte. Dies kann zu Informationsverlust führen. Um dieses Verhalten zu deaktivieren, verwenden Sie den Modifizierer autoconvert und setzen ihn auf false.

Code	Ergebnis
`tokenize( "one:two..three:four", ":")`	`["one", "two..three", "four"]`
`tokenize( "one:two..three:four", ".")`	`["one:two", "", "three:four"]`
`tokenize( "one:two..three:four", "..")`	`["one:two", "three:four"]`
`tokenize( "one:two..three:four", [".",":"])`	`[["one", "two"], [""], ["three", "four"]]`
`tokenize( "one:two..three:four", ["..",":"])`	`[["one", "two"], ["three", "four"]]`
`tokenize( "77777777777777777",":")`	`[77777777777777776]`
`tokenize( "77777777777777777",":",autoconvert->false)`	`[77777777777777777]`

Ersetzen in Zeichenketten: `replace(<string1>,<string2>,<string3>)`¶

Beschreibung: Dieser Operator ersetzt alle (!) Vorkommen von <string2> in <string1> durch <string3>.

Dieser Operator ist äußerst nützlich zum Erstellen von Textersetzungssystemen der Art, wie sie in sogenannten Lindenmeyer-Systemen verwendet werden.

Code	Ergebnis
`replace( "one:two..three:four", "o", "XXX")`	`"XXXne:twXXX..three:fXXXur"`
`replace("F", "F", "F+F")`	`"F+F"`
`replace("F+F", "F", "F+F")`	`"F+F+F+F"`

Ersetzen in Zeichenketten: `replace(<string>,<list>)`¶

Beschreibung: Dieser Operator ähnelt dem vorherigen sehr. <list> enthält eine Liste von Ersetzungspaaren, und alle diese Ersetzungen werden gleichzeitig auf <string> angewendet.

Code	Ergebnis
`replace("XYX", [["X","one"], ["Y","two"]])`	`"onetwoone"`

Analysieren einer Zeichenkette: `parse(<string>)`¶

Beschreibung: Dieser Operator analysiert eine Zeichenkette in einen Ausdruck und wertet diesen Ausdruck aus. Dieser Operator ist besonders nützlich bei der Verarbeitung von Benutzereingaben, die aus Textfeldern in einer Konstruktion stammen.

Code	Ergebnis
`parse("3+7")`	`10`

Das Code-Fragment

text="sin(x)+cos(x)";
f(x):=parse(text);

definiert die Funktion f(x) als sin(x)+cos(x).

Erraten einer guten Darstellung einer Zahl: `guess(<number>)`¶

Beschreibung: Dieser sehr leistungsstarke Operator wird ausführlich im Abschnitt Kalkül beschrieben. Er nimmt einen numerischen Ausdruck in Gleitkommadarstellung und versucht, ihn in einen mathematischen Ausdruck zu konvertieren, der diese Gleitkommazahl mit hoher Präzision erzeugt. Dieser Ausdruck wird dann als Zeichenkette dargestellt.

Code	Ergebnis
`guess(8.125)`	`"65/8"`
`guess(0.774596669241483)`	`"sqrt(3/5)"`

Siehe auch: Kalkül

Formatierung einer Zahl mit einer angegebenen Präzision: `format(<number>,<int>)`¶

Beschreibung: Dieser Operator nimmt eine Zahl als erstes Argument und eine ganze Zahl, die die Anzahl der Ziffern nach dem Dezimalkomma angibt. Eine Zeichenkette wird generiert, die die Zahl bis zur angegebenen Genauigkeit entspricht. Bis zu 14 Ziffern sind möglich. Wenn das Argument von format eine Liste von Objekten ist, wird die format-Anweisung rekursiv auf jedes der Objekte angewendet.

Code	Ergebnis
`format(sqrt(2),4)`	`"1.4142"`
`format(pi,14)`	`"3.14159265358979"`
`format([sin(30°),cos(30°)],3)`	`[0.5,0.866]`

Warnung: Die format-Anweisung sollte nur zum Erstellen von formatierten Ausgabeelementen verwendet werden. Die formatierten Werte sind immer Zeichenketten und daher normalerweise keine gültigen Objekte für arithmetische Operationen. Das folgende Beispiel veranschaulicht dies:

Code	Ergebnis
`format(sqrt(2),4)+ format(sqrt(2),4)`	`"1.41421.4142"`

String-Vergleich und Sortierung¶

Wie reelle Zahlen zulassen Zeichenketten eine totale Ordnung. Daher können sie mit den Operatoren >, <, >=, <=, == und != verglichen werden. Bitte lesen Sie Boolesche Operatoren für die Verwendung dieser Beziehungen.

Die für Zeichenketten verwendete Ordnung ist lexikografische (Wörterbuch-) Ordnung. So zum Beispiel:

"a"<"abd"<"abe"<"b"<"blue"<"blunt"<"xxx"

Sortieren von Listen: `sort(<list>)`¶

Sortieren von Listen: `sort(<list>,<expr>)`¶

Sortieren von Listen: `sort(<list>,<var>,<expr>)`¶

Beschreibung: Die verschiedenen Versionen des Operators sort können zum Sortieren von Listen verwendet werden, die Zeichenkettenwerte enthalten. Die Sortierreihenfolge wird normalerweise als die lexikografische Ordnung der Wörter verwendet. Alternativ kann man eine benutzerdefinierte Sortierfunktion angeben, z. B. die Längen der Zeichenketten.

Code	Ergebnis
`sort(["one", "two", "three", "four", "five"])`	`["five","four","one","three","two"]`
`sort(["one", "two", "three", "four", "five"],length(#))`	`["one","two","four","five","three"]`

Siehe auch: Listen und Lineare Algebra

Zugriff auf und Ersetzen von Zeichen¶

Index-Operator: `<string>_<int>`¶

Beschreibung: Der Infix-Operator _, der auf die Felder einer Liste zugreift, kann auch zum Zugriff auf ein Zeichen an einer bestimmten Position in einer Zeichenkette verwendet werden. Zeichen können mit diesem Operator zurückgegeben und gesetzt werden.

Code	Ergebnis
`"CindyScript"_5`	`"y"`
`"CindyScript"_12`	undefined

Nach Auswertung des Code-Fragments

a="CindyScript";
a_5="erella";

enthält die Variable a die Zeichenkette "CinderellaScript".

Diese Seite wurde automatisch mit KI (Claude) übersetzt und wartet noch auf Überprüfung. → Alle KI-übersetzten Seiten

String-Operatoren

Grundlegende String-Operationen¶

String-Verkettung: <string1> + <string2>¶

Konvertierung in String: text(<expr>)¶

Länge einer Zeichenkette: length(<string>)¶

Extrahieren eines Teilstrings: substring(<string>,<int1>,<int2>)¶

Suchen nach Vorkommen: indexof(<string1>,<string2>)¶

Suchen nach Vorkommen: indexof(<string1>,<string2>,<int>)¶

Fortgeschrittene String-Operationen¶

Zerlegen einer Zeichenkette: tokenize(<string>,<expr>)¶

Ersetzen in Zeichenketten: replace(<string1>,<string2>,<string3>)¶

Ersetzen in Zeichenketten: replace(<string>,<list>)¶

Analysieren einer Zeichenkette: parse(<string>)¶

Erraten einer guten Darstellung einer Zahl: guess(<number>)¶

Formatierung einer Zahl mit einer angegebenen Präzision: format(<number>,<int>)¶