String-Operatoren - Cinderella Dokumentation
Description: The user's guide to the Interactive Geometry Software Cinderella

Zum Inhalt

# 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