Stand: 16. August 2020

Inhaltsverzeichnis

über dieses Dokument

was es hierin gibt
wo man die neuste Version bekommt
wie man den Verfasser kontaktiert
welche gesetzlichen Einschränkungen es gibt

Lizenzlosigkeit
Verfasserschutz
Vorbehalt für zusätzliche Einschränkungen für zukünftige Versionen

allgemeine Informationen

Zweck
Schreibweisen, welche zulässig sind

die Details

Funktionen

- Initialisierungsroutine -

Beispiele
Beschreibung
Syntax
Parameter

Eingabe

Schlüssel_-_n
Wert_-_n

Ausgabe

Instanz_von_der_Klasse_Liste

ändern

Beispiele
Beschreibung
Schreibweisen, welche zulässig sind
Syntax
Parameter

Eingabe

Eintrag
Index
Schlüssel
Wert

siehe auch

anhängen
einfügen

Beispiele
Beschreibung
Schreibweisen, welche zulässig sind
Syntax
Parameter

Eingabe

Index
Schlüssel
Wert

Eingabe und Ausgabe

Instanz_von_der_Klasse_Liste

siehe auch

in_eine_Zeichenkette_umwandeln

Beispiele
Beschreibung
Schreibweisen, welche zulässig sind
Syntax
Parameter

Eingabe

Instanz_von_der_Klasse_Liste
Trennzeichen_-_dezimal
Trennzeichen_-_Tausend
Rekusionstiefe_-_maximal
Einrückung
Liste_-_Anfang
Liste_-_Ende
Liste_-_Platzhalter
Trennzeichen_-_Partikel
Ergebnis_speichern

Ausgabe

Instanz_von_der_Klasse_Zeichenkette

ist_gleich
ist_nichts
ist_ungleich
löschen

Beispiele
Beschreibung
Schreibweisen, welche zulässig sind
Syntax
Parameter

Eingabe

Index_-_zu_suchen
Schlüssel_-_zu_suchen
Wert_-_zu_suchen
Index_-_zu_suchen_-_Anfang
Index_-_zu_suchen_-_Ende
Schlüssel_-_zu_suchen_-_Anfang
Schlüssel_-_zu_suchen_-_Ende
Wert_-_zu_suchen_-_Anfang
Wert_-_zu_suchen_-_Ende

Eingabe und Ausgabe

Liste_-_zu_bearbeiten

Ausgabe

Index_-_gefunden
Schlüssel_-_gefunden
Wert_-_gefunden
Liste_-_gelösche_Einträge

siehe auch

Konstanten und Variablen

ist_Ganzzahl

Beispiele
Beschreibung
Schreibweisen, welche zulässig sind
Syntax
Parameter

Eingabe

Instanz_von_der_Klasse_Liste

Ausgabe

Ergebnis

ist_Kommazahl

Beispiele
Beschreibung
Schreibweisen, welche zulässig sind
Syntax
Parameter

Eingabe

Instanz_von_der_Klasse_Liste

Ausgabe

Ergebnis

ist_Liste

Beispiele
Beschreibung
Schreibweisen, welche zulässig sind
Syntax
Parameter

Eingabe

Instanz_von_der_Klasse_Liste

Ausgabe

Ergebnis

ist_Nichtigkeitsangabe

Beispiele
Beschreibung
Schreibweisen, welche zulässig sind
Syntax
Parameter

Eingabe

Instanz_von_der_Klasse_Liste

Ausgabe

Ergebnis

ist_Rohdatenkette

Beispiele
Beschreibung
Schreibweisen, welche zulässig sind
Syntax
Parameter

Eingabe

Instanz_von_der_Klasse_Liste

Ausgabe

Ergebnis

ist_Wahrheitsangabe

Beispiele
Beschreibung
Schreibweisen, welche zulässig sind
Syntax
Parameter

Eingabe

Instanz_von_der_Klasse_Liste

Ausgabe

Ergebnis

ist_Zeichenkette

Beispiele
Beschreibung
Schreibweisen, welche zulässig sind
Syntax
Parameter

Eingabe

Instanz_von_der_Klasse_Liste

Ausgabe

Ergebnis

Merkhilfe

weiteres Material zu diesem Thema

Dokumente
Aufnahme von weiteren Materialien

über dieses Dokument

was es hierin gibt

Dieses Dokument

• beschreibt die Klasse "Liste" für die Programmiersprache "Minicode".

Alle anderen Informationen über Minicode, inklusiv den Dateitypen, sind in separaten Dokumenten untergebracht. Diese sind im Kapitel "weiteres Material zu diesem Thema - Dokumente" aufgelistet.

wo man die neuste Version bekommt

Derzeit nutze ich OnTheServer.de/Downloads/ um neue Versionen zugänglich zu machen. Sie müsste irgendwo dort in den Unterverzeichnissen sein; das kann sich hin und wieder ein bischen ändern.

Dort gibt es vielleicht auch dieses Dokument in anderen Sprachen.

Die Versions-Angabe von diesem Dokument steht oben rechts ("Stand: ...").

wie man den Verfasser kontaktiert

Der Verfasser von diesem Dokument kann mit der Hilfe von einer elektronischen Nachricht kontaktiert werden. Das hierfür eingerichtete Postfach ist mit der Hilfe von der folgenden Adresse erreichbar:

Kontakt@On(entferne mich)TheServer.de

welche gesetzlichen Einschränkungen es gibt

Lizenzlosigkeit

Dieses Dokument

• ist an keine Lizenz gebunden.
• unterliegt nicht den Einschränkungen durch das Urhebergesetz.
• soll allgemeinfrei (public domain) behandelt werden. Also so, als wenn es sich um ein Eigentum von der Allgemeinheit handelt.

Im Übrigen soll alles, was man auf OnTheServer.de und den Subdomains öffentlich zugänglich findet, entsprechend behandelt werden.

Es gibt auf OnTheServer.de allerdings eine Ausnahme:

Ich lege gelegentlich im Verzeichnis "OnTheServer.de/temp/" urheberrechtlich geschütztes Material ab.

Es ist nicht gestattet, auf irreführendeweise vorzutäuschen, dass das (ursprüngliche) Dokument an eine Lizenz gebunden wäre.

Verfasserschutz

Es ist nicht gestattet, auf irreführendeweise vorzutäuschen, dass man der (ursprüngliche) Verfasser vom Dokument wäre. Der (ursprüngliche) Verfasser muss jedoch nicht namentlich genannt werden.

Vorbehalt für zusätzliche Einschränkungen für zukünftige Versionen

Ich (der ursprüngliche Verfasser) behalte die Möglichkeit, Einschränkungen für

• die Veränderung oder/und
• die Verbreitung

aufzuerlegen. Von den Einschränkungen wären lediglich neue Versionen betroffen. Was bisher veröffentlicht wurde, erhält keine weiteren Einschränkungen.

Von diesem Recht werde ich hoffentlich nie gebrauch machen müssen.

allgemeine Informationen

Zweck

Diese Klasse stellt grundlegende Funktionalität für den Variablentyp "Liste" bereit.

Schreibweisen, welche zulässig sind

• list
• Liste

die Details

Funktionen

- Initialisierungsroutine -

Beispiele

# Liste nur aus Werten definieren
Liste_aus_Werten = <1, 2.5, wahr, "Hallo Welt!">

# Liste aus Schlüsseln und Werten definieren
Liste_aus_Schlüsseln_und_Werten = <"Baden-Württemberg" : "Stuttgart", "Bayern" : "München", "Berlin" : "Berlin">

# das Selbe nochmal, aber besser lesbar
Liste_aus_Schlüsseln_und_Werten = <
    "Baden-Württemberg" : "Stuttgart",
    "Bayern" : "München",
    "Berlin" : "Berlin"
>

/*
Einzelne Einträge können

- sowohl durch Komma,
- als auch durch Zeilenumbrüche

voneinander getrennt werden.
*/

# das Selbe nochmal, aber fehlerunanfälliger und sortierfreundlicher
Liste_aus_Schlüsseln_und_Werten = <
    "Baden-Württemberg" : "Stuttgart"
    "Bayern" : "München"
    "Berlin" : "Berlin"
>

# Liste nur aus Schlüsseln definieren (für alle Werte wird hier die Nichtigkeitsangabe
# "nichts" gespeichert)
Liste_aus_Schlüsseln = <
    "Baden-Württemberg" :
    "Bayern" :
    "Berlin" :
>

# manche Schlüssel manuell definieren und bei anderen Einträgen automatisch die
# Nichtigkeitsangabe "nichts" als Schlüssel nehmen lassen
gemischte_Liste = <
    "Neckar"                          # dieser Eintrag hat die Nichtigkeitsangabe "nichts" als Schlüssel
    "Baden-Württemberg" : "Stuttgart" # dieser Eintrag hat die Zeichenkette "Baden-Württemberg" als Schlüssel
    "Bayern" : "München"              # dieser Eintrag hat die Zeichenkette "Bayern" als Schlüssel
    "Donau"                           # dieser Eintrag hat die Nichtigkeitsangabe "nichts" als Schlüssel
    "Berlin" : "Berlin"               # dieser Eintrag hat die Zeichenkette "Berlin" als Schlüssel
>

/*
Generell kann ein Schlüssel immer nur 1 mal in einer Liste vorkommen, sodass ein
Eintrag anhand vom Schlüssel eindeutig identifiziert werden kann. Abweichend von
dieser Regel ist die Nichtigkeitsangabe "nichts" als Einzige mehrmals in einer Liste als
Schlüssel zulässig.

Solche Einträge, welche die Nichtigkeitsangabe "nichts" als Schlüssel haben, sind später
gegebenenfalls nicht mehr eindeutig anhand vom Schlüssel identifizierbar.
*/

# die Liste nur aus Werten erneut definieren, diesmal jedoch mit einem anderen Syntax
Liste_aus_Werten = Liste(

Wert_-_0 = 1
Wert_-_1 = 2.5
Wert_-_2 = wahr
Wert_-_3 = "Hallo Welt!"

)

# die Liste aus Schlüsseln und Werten erneut definieren, diesmal jedoch mit einem anderen Syntax
Liste_aus_Schlüsseln_und_Werten = Liste(

Schlüssel_-_0 = "Baden-Württemberg"
Wert_-_0 = "Stuttgart"
Schlüssel_-_1 = "Bayern"
Wert_-_1 = "München"
Schlüssel_-_2 = "Berlin"
Wert_-_2 = "Berlin"

)

# die Liste aus Schlüsseln und Werten erneut definieren, diesmal jedoch mit einem anderen Syntax
Liste_aus_Schlüsseln_und_Werten = Liste(

"Baden-Württemberg"
"Stuttgart"
"Bayern"
"München"
"Berlin"
"Berlin"

)

/*
Die folgenden 3 Anweisungen werden jeweils die folgende Liste erzeugen:

<

"Baden-Württemberg" : "Stuttgart"
:
"Berlin" : "Berlin"

>

Der mittlere Eintrag hat jeweils die Nichtigkeitsangabe "nichts"

- sowohl als Schlüssel,
- als auch als Wert.

*/

Liste_aus_Schlüsseln_und_Werten = <
    "Baden-Württemberg" : "Stuttgart"
    :
    "Berlin" : "Berlin"
>

Liste_aus_Schlüsseln_und_Werten = <
    "Baden-Württemberg" : "Stuttgart"

    "Berlin" : "Berlin"
>

Liste_aus_Schlüsseln_und_Werten = Liste(

Schlüssel_-_0 = "Baden-Württemberg"
Wert_-_0 = "Stuttgart"
Schlüssel_-_2 = "Berlin"
Wert_-_2 = "Berlin"

)

# eine Liste definieren, ohne diese in einer Variable zu speichern
Konsole.schreiben(<1, 2.5, wahr, "Hallo Welt!">)

Beschreibung

Beim Durchlaufen von der Initialisierungsroutine wird eine Instanz von der Klasse gebildet. In Minicode sind Variablen also Instanzen von ihrer entsprechenden Klasse.

Eine Liste hat eine beliebige Anzahl von Einträgen.

Jeder Eintrag besteht jeweils aus 3 Partikeln:

1. Der erste Partikel
   • wird "Index" genannt.
   • ist eine fortlaufende Nummer, welche von 0 ausgehend gezählt wird.
   • dient in der Regel dafür, um einen Eintrag mit einer vergleichsweise geringen Verarbeitungsdauer aufzufinden.
   • ist vom Variablentyp "Ganzzahl".
   • muss nicht gespeichert werden, da er sich aus der Position vom Eintrag ergibt.
   
   Dieser Partikel ermöglicht zwar eine eindeutige Identifikation vom Eintrag, sein Wert kann sich aber während der Laufzeit vom Programm ändern, da sich die Position vom Eintrag ändern kann. Wenn
   • beispielsweise der 2. Eintrag gelöscht wird,
   dann
   • bekommt der 5. Eintrag anstatt dem Index "5" automatisch den Index "4", da er nun der 4. Eintrag ist.
2. Der zweite Partikel
   • wird "Schlüssel" genannt.
   • ist eine wählbare, aber in der ganzen Liste nur 1 mal vorkommende, eindeutige Identifikation vom Eintrag.
     
     Eine Abweichung von dieser Regel besteht dann, wenn die Nichtigkeitsangabe "nichts" verwendet wird. Mit der Hilfe von dieser Angabe wird ausgedrückt, dass der Eintrag keinen Schlüssel hat und daher nicht mit diesem Hilfsmittel eindeutig identifiziert werden kann. Es kann also mehrere Einträge geben, welche die Nichtigkeitsangabe "nichts" als Schlüssel haben.
   • dient in der Regel dafür, um einen Eintrag aufzufinden, bei welcher für Quellcode-Betrachter vergleichsweise gut nachvollziehbar ist, um welchen Eintrag es sich handelt.
   • ist von einem beliebigem Variablentyp.
3. Der dritte Partikel
   • wird "Wert" genannt.
   • ist ein wählbarer Wert, welcher in der Liste mehrmals vorkommen kann.
   • dient in der Regel zur Speicherung von der eigentlichen Information.
   • ist von einem beliebigem Variablentyp.

Syntax

Art:	Instanzbildung	Konstrukt
Formen:	/°Instanz_von_der_Klasse_Liste = °/Liste( /°/°Schlüssel_-_0 = nichts°/ /°/°Wert_-_0 = nichts°/ /°/°Schlüssel_-_1 = nichts°/ /°/°Wert_-_1 = nichts°/ /°/°Schlüssel_-_2 = nichts°/ /°/°Wert_-_2 = nichts°/ /°... °/°/°/°/°/°/°/)	/°Instanz_von_der_Klasse_Liste = °/< /°/°/°Schlüssel_-_0 °/:°//° Wert_-_0°/ /°/°/°Schlüssel_-_1 °/:°//° Wert_-_1°/ /°/°/°Schlüssel_-_2 °/:°//° Wert_-_2°/ /°... °/°/°/°/>

Parameter

Eingabe

Anzahl:

  beliebig (Schlüssel_-_n)
+ beliebig (Wert_-_n)

Schlüssel_-_n

Beispiel:	"Kalibrierungswert"
Beschreibung:	Mit der Hilfe von diesem Parameter wird der Schlüssel vom Eintrag mit dem Index "n" angegeben.
Schreibweisen, welche zulässig sind:	Eintrag_n_-_Schlüssel entry_n_-_key key_-_n Schlüssel_-_n
Standardwert:	Wenn der Eintrag mit dem Index "n" existieren soll und für diesen Parameter kein Wert übergeben wird, dann wird der Wert "nichts" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Wert_-_n

Beispiel:	0.815
Beschreibung:	Mit der Hilfe von diesem Parameter wird der Wert vom Eintrag mit dem Index "n" angegeben.
Schreibweisen, welche zulässig sind:	Eintrag_n_-_Wert entry_n_-_value value_-_n Wert_-_n
Standardwert:	Wenn der Eintrag mit dem Index "n" existieren soll und für diesen Parameter kein Wert übergeben wird, dann wird der Wert "nichts" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Ausgabe

Anzahl: 0 oder 1

Instanz_von_der_Klasse_Liste

Beispiel:	meine_Liste
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Bezeichnung für die Variable angegeben, in welcher die Instanz von der Klasse gespeichert werden soll.
Standardwert:	Wenn dieser Parameter verwendet wird, dann muss für diesen Parameter eine Bezeichnung übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern eine Bezeichnung für eine Variable -
Variablentypen, welche für die Ausgabe verwendet werden:	Liste

ändern

Beispiele

# Liste aus Schlüsseln und Werten definieren
meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index "0"
"Hessen" :                        # <- dieser Eintrag hat den Index "1"
: "Potsdam"                       # <- dieser Eintrag hat den Index "2"
"Saarland" :                      # <- dieser Eintrag hat den Index "3"
"Mecklenburg-Vorpommern" :        # <- dieser Eintrag hat den Index "4"
"Rheinland-Pfalz" : "Mainz"       # <- dieser Eintrag hat den Index "5"
:                                 # <- dieser Eintrag hat den Index "6"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index "7"
: "Hamburg"                       # <- dieser Eintrag hat den Index "8"
"Bayern" : "München"              # <- dieser Eintrag hat den Index "9"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "10"
:                                 # <- dieser Eintrag hat den Index "11"
"Sachsen" :                       # <- dieser Eintrag hat den Index "12"

>

# einen Eintrag anhand vom Index suchen und dann ändern
# diese Anweisung entspricht dieser Anweisung:
# meine_Liste[2] = 2, "Brandenburg", "Potsdam"
meine_Liste[2] = , "Brandenburg"

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index  "0"
"Hessen" :                        # <- dieser Eintrag hat den Index  "1"
"Brandenburg" : "Potsdam"         # <- dieser Eintrag hat den Index  "2"
"Saarland" :                      # <- dieser Eintrag hat den Index  "3"
"Mecklenburg-Vorpommern" :        # <- dieser Eintrag hat den Index  "4"
"Rheinland-Pfalz" : "Mainz"       # <- dieser Eintrag hat den Index  "5"
:                                 # <- dieser Eintrag hat den Index  "6"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index  "7"
: "Hamburg"                       # <- dieser Eintrag hat den Index  "8"
"Bayern" : "München"              # <- dieser Eintrag hat den Index  "9"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "10"
:                                 # <- dieser Eintrag hat den Index "11"
"Sachsen" :                       # <- dieser Eintrag hat den Index "12"

>

*/

# einen Eintrag anhand vom Schlüssel suchen und dann ändern
meine_Liste("Sachsen") = 4, "Sachsen-Anhalt", "Magdeburg"

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index  "0"
"Hessen" :                        # <- dieser Eintrag hat den Index  "1"
"Brandenburg" : "Potsdam"         # <- dieser Eintrag hat den Index  "2"
"Saarland" :                      # <- dieser Eintrag hat den Index  "3"
"Sachsen-Anhalt" : "Magdeburg"    # <- dieser Eintrag hat den Index  "4"
"Mecklenburg-Vorpommern" :        # <- dieser Eintrag hat den Index  "5"
"Rheinland-Pfalz" : "Mainz"       # <- dieser Eintrag hat den Index  "6"
:                                 # <- dieser Eintrag hat den Index  "7"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index  "8"
: "Hamburg"                       # <- dieser Eintrag hat den Index  "9"
"Bayern" : "München"              # <- dieser Eintrag hat den Index "10"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "11"
:                                 # <- dieser Eintrag hat den Index "12"

>

*/

# einen Eintrag anhand vom Wert suchen, nicht finden und dann hinzufügen
meine_Liste{"Kiel"} = , , "Kiel"

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index  "0"
"Hessen" :                        # <- dieser Eintrag hat den Index  "1"
"Brandenburg" : "Potsdam"         # <- dieser Eintrag hat den Index  "2"
"Saarland" :                      # <- dieser Eintrag hat den Index  "3"
"Sachsen-Anhalt" : "Magdeburg"    # <- dieser Eintrag hat den Index  "4"
"Mecklenburg-Vorpommern" :        # <- dieser Eintrag hat den Index  "5"
"Rheinland-Pfalz" : "Mainz"       # <- dieser Eintrag hat den Index  "6"
:                                 # <- dieser Eintrag hat den Index  "7"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index  "8"
: "Hamburg"                       # <- dieser Eintrag hat den Index  "9"
"Bayern" : "München"              # <- dieser Eintrag hat den Index "10"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "11"
:                                 # <- dieser Eintrag hat den Index "12"
: "Kiel"                          # <- dieser Eintrag hat den Index "13"

>

*/

/*
Nur bei der Form mit den eckigen Klammern ("[" und "]") bewirkt die Verwendung vom
Standardwert, dass zwangsweise ein neuer Eintrag hinzugefügt wird. Bei

- der Form mit den runden Klammern ("(" und ")") würde nach einem Eintrag mit der
  Nichtigkeitsangabe "nichts" als Schlüssel gesucht werden.
- der Form mit den geschweiften Klammern ("{" und "}") würde nach einem Eintrag
  mit der Nichtigkeitsangabe "nichts" als Wert gesucht werden.

*/
# einen neuen Eintrag hinzufügen
# Diese Anweisung entspricht dieser Anweisung:
# meine_Liste[nichts] = -1, nichts, "Dresden"
meine_Liste[] = , , "Dresden"

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index  "0"
"Hessen" :                        # <- dieser Eintrag hat den Index  "1"
"Brandenburg" : "Potsdam"         # <- dieser Eintrag hat den Index  "2"
"Saarland" :                      # <- dieser Eintrag hat den Index  "3"
"Sachsen-Anhalt" : "Magdeburg"    # <- dieser Eintrag hat den Index  "4"
"Mecklenburg-Vorpommern" :        # <- dieser Eintrag hat den Index  "5"
"Rheinland-Pfalz" : "Mainz"       # <- dieser Eintrag hat den Index  "6"
:                                 # <- dieser Eintrag hat den Index  "7"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index  "8"
: "Hamburg"                       # <- dieser Eintrag hat den Index  "9"
"Bayern" : "München"              # <- dieser Eintrag hat den Index "10"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "11"
:                                 # <- dieser Eintrag hat den Index "12"
: "Kiel"                          # <- dieser Eintrag hat den Index "13"
: "Dresden"                       # <- dieser Eintrag hat den Index "14"

>

*/

# einen Eintrag anhand vom Schlüssel suchen und dann ändern
# diese Anweisung entspricht dieser Anweisung:
# meine_Liste(nichts) = -2, "Nordrhein-Westfalen", "Düsseldorf"
meine_Liste() = -2, "Nordrhein-Westfalen", "Düsseldorf"

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart"    # <- dieser Eintrag hat den Index  "0" bzw. "-15"
"Hessen" :                           # <- dieser Eintrag hat den Index  "1" bzw. "-14"
"Brandenburg" : "Potsdam"            # <- dieser Eintrag hat den Index  "2" bzw. "-13"
"Saarland" :                         # <- dieser Eintrag hat den Index  "3" bzw. "-12"
"Sachsen-Anhalt" : "Magdeburg"       # <- dieser Eintrag hat den Index  "4" bzw. "-11"
"Mecklenburg-Vorpommern" :           # <- dieser Eintrag hat den Index  "5" bzw. "-10"
"Rheinland-Pfalz" : "Mainz"          # <- dieser Eintrag hat den Index  "6" bzw.  "-9"
"Berlin" : "Berlin"                  # <- dieser Eintrag hat den Index  "7" bzw.  "-8"
: "Hamburg"                          # <- dieser Eintrag hat den Index  "8" bzw.  "-7"
"Bayern" : "München"                 # <- dieser Eintrag hat den Index  "9" bzw.  "-6"
"Niedersachen" :                     # <- dieser Eintrag hat den Index "10" bzw.  "-5"
:                                    # <- dieser Eintrag hat den Index "11" bzw.  "-4"
: "Kiel"                             # <- dieser Eintrag hat den Index "12" bzw.  "-3"
"Nordrhein-Westfalen" : "Düsseldorf" # <- dieser Eintrag hat den Index "13" bzw.  "-2"
: "Dresden"                          # <- dieser Eintrag hat den Index "14" bzw.  "-1"

>

*/

/*
Beim Einfügen von einem neuen Eintrag bewirkt die Angabe von einem negativen Index

- nicht nur, dass die Einträge vom Ende von der Liste gezählt werden,
- sondern auch, dass der Eintrag um 1 Position weiter in die Richtung vom Ende platziert wird.

Dies bedeutet beispielsweise beim Index "-1",

- dass der neue Eintrag ans Ende von der Liste angehängt wird,
- anstatt dass wie bei dem positiven Index "14" der letzte Eintrag auf die
  Position "15" verschoben wird, um den neuen Eintrag an der ehemalig letzten
  Position "14" zu platzieren.

Auf diese Weise ist sichergestellt, dass sich der neue Eintrag nach dem Einfügen
tatsächlich an der letzten Position befindet.
*/

# einen Eintrag anhand vom Wert suchen und dann nach unten verschieben
# diese Anweisung entspricht dieser Anweisung:
# meine_Liste{nichts} = 4, "Hessen", nichts
meine_Liste{} = 4, "Hessen"

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart"    # <- dieser Eintrag hat den Index  "0"
"Brandenburg" : "Potsdam"            # <- dieser Eintrag hat den Index  "1"
"Saarland" :                         # <- dieser Eintrag hat den Index  "2"
"Sachsen-Anhalt" : "Magdeburg"       # <- dieser Eintrag hat den Index  "3"
"Hessen" :                           # <- dieser Eintrag hat den Index  "4"
"Mecklenburg-Vorpommern" :           # <- dieser Eintrag hat den Index  "5"
"Rheinland-Pfalz" : "Mainz"          # <- dieser Eintrag hat den Index  "6"
"Berlin" : "Berlin"                  # <- dieser Eintrag hat den Index  "7"
: "Hamburg"                          # <- dieser Eintrag hat den Index  "8"
"Bayern" : "München"                 # <- dieser Eintrag hat den Index  "9"
"Niedersachen" :                     # <- dieser Eintrag hat den Index "10"
:                                    # <- dieser Eintrag hat den Index "11"
: "Kiel"                             # <- dieser Eintrag hat den Index "12"
"Nordrhein-Westfalen" : "Düsseldorf" # <- dieser Eintrag hat den Index "13"
: "Dresden"                          # <- dieser Eintrag hat den Index "14"

>

*/

# einen Eintrag anhand vom Index suchen und dann nach oben verschieben
meine_Liste[4] = 2, "Hessen"

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart"    # <- dieser Eintrag hat den Index  "0"
"Brandenburg" : "Potsdam"            # <- dieser Eintrag hat den Index  "1"
"Hessen" :                           # <- dieser Eintrag hat den Index  "2"
"Saarland" :                         # <- dieser Eintrag hat den Index  "3"
"Sachsen-Anhalt" : "Magdeburg"       # <- dieser Eintrag hat den Index  "4"
"Mecklenburg-Vorpommern" :           # <- dieser Eintrag hat den Index  "5"
"Rheinland-Pfalz" : "Mainz"          # <- dieser Eintrag hat den Index  "6"
"Berlin" : "Berlin"                  # <- dieser Eintrag hat den Index  "7"
: "Hamburg"                          # <- dieser Eintrag hat den Index  "8"
"Bayern" : "München"                 # <- dieser Eintrag hat den Index  "9"
"Niedersachen" :                     # <- dieser Eintrag hat den Index "10"
:                                    # <- dieser Eintrag hat den Index "11"
: "Kiel"                             # <- dieser Eintrag hat den Index "12"
"Nordrhein-Westfalen" : "Düsseldorf" # <- dieser Eintrag hat den Index "13"
: "Dresden"                          # <- dieser Eintrag hat den Index "14"

>

*/

/*
Mit der Hilfe von den nachfolgenden Anweisungen werden jeweils nur die Partikel von
einer bestimmten Art angegeben. Die Partikel von den anderen beiden Arten werden nicht angegeben.
*/

# einen Eintrag anhand vom Index suchen und dann nach unten verschieben
meine_Liste[2][] = 4

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart"    # <- dieser Eintrag hat den Index  "0"
"Brandenburg" : "Potsdam"            # <- dieser Eintrag hat den Index  "1"
"Saarland" :                         # <- dieser Eintrag hat den Index  "2"
"Sachsen-Anhalt" : "Magdeburg"       # <- dieser Eintrag hat den Index  "3"
"Hessen" :                           # <- dieser Eintrag hat den Index  "4"
"Mecklenburg-Vorpommern" :           # <- dieser Eintrag hat den Index  "5"
"Rheinland-Pfalz" : "Mainz"          # <- dieser Eintrag hat den Index  "6"
"Berlin" : "Berlin"                  # <- dieser Eintrag hat den Index  "7"
: "Hamburg"                          # <- dieser Eintrag hat den Index  "8"
"Bayern" : "München"                 # <- dieser Eintrag hat den Index  "9"
"Niedersachen" :                     # <- dieser Eintrag hat den Index "10"
:                                    # <- dieser Eintrag hat den Index "11"
: "Kiel"                             # <- dieser Eintrag hat den Index "12"
"Nordrhein-Westfalen" : "Düsseldorf" # <- dieser Eintrag hat den Index "13"
: "Dresden"                          # <- dieser Eintrag hat den Index "14"

>

*/

# einen Eintrag anhand vom Wert suchen und dann den Schlüssel ändern
meine_Liste{"Dresden"}() = "Sachsen"

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart"    # <- dieser Eintrag hat den Index  "0"
"Brandenburg" : "Potsdam"            # <- dieser Eintrag hat den Index  "1"
"Saarland" :                         # <- dieser Eintrag hat den Index  "2"
"Sachsen-Anhalt" : "Magdeburg"       # <- dieser Eintrag hat den Index  "3"
"Hessen" :                           # <- dieser Eintrag hat den Index  "4"
"Mecklenburg-Vorpommern" :           # <- dieser Eintrag hat den Index  "5"
"Rheinland-Pfalz" : "Mainz"          # <- dieser Eintrag hat den Index  "6"
"Berlin" : "Berlin"                  # <- dieser Eintrag hat den Index  "7"
: "Hamburg"                          # <- dieser Eintrag hat den Index  "8"
"Bayern" : "München"                 # <- dieser Eintrag hat den Index  "9"
"Niedersachen" :                     # <- dieser Eintrag hat den Index "10"
:                                    # <- dieser Eintrag hat den Index "11"
: "Kiel"                             # <- dieser Eintrag hat den Index "12"
"Nordrhein-Westfalen" : "Düsseldorf" # <- dieser Eintrag hat den Index "13"
"Sachsen" : "Dresden"                # <- dieser Eintrag hat den Index "14"

>

*/

# einen Eintrag anhand vom Schlüssel suchen und dann den Wert ändern
meine_Liste("Saarland"){} = "Saarbrücken"

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart"    # <- dieser Eintrag hat den Index  "0"
"Brandenburg" : "Potsdam"            # <- dieser Eintrag hat den Index  "1"
"Saarland" : "Saarbrücken"           # <- dieser Eintrag hat den Index  "2"
"Sachsen-Anhalt" : "Magdeburg"       # <- dieser Eintrag hat den Index  "3"
"Hessen" :                           # <- dieser Eintrag hat den Index  "4"
"Mecklenburg-Vorpommern" :           # <- dieser Eintrag hat den Index  "5"
"Rheinland-Pfalz" : "Mainz"          # <- dieser Eintrag hat den Index  "6"
"Berlin" : "Berlin"                  # <- dieser Eintrag hat den Index  "7"
: "Hamburg"                          # <- dieser Eintrag hat den Index  "8"
"Bayern" : "München"                 # <- dieser Eintrag hat den Index  "9"
"Niedersachen" :                     # <- dieser Eintrag hat den Index "10"
:                                    # <- dieser Eintrag hat den Index "11"
: "Kiel"                             # <- dieser Eintrag hat den Index "12"
"Nordrhein-Westfalen" : "Düsseldorf" # <- dieser Eintrag hat den Index "13"
"Sachsen" : "Dresden"                # <- dieser Eintrag hat den Index "14"

>

*/

# Einen Eintrag anhand vom Schlüssel suchen, welcher jedoch nicht gefunden wird.
# Hierdurch wird ein neuer Eintrag mit diesem Schlüssel angelegt. Anschließend wird
# der Wert definiert.
meine_Liste("Thüringen"){} = "Erfurt"

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart"    # <- dieser Eintrag hat den Index  "0"
"Brandenburg" : "Potsdam"            # <- dieser Eintrag hat den Index  "1"
"Saarland" : "Saarbrücken"           # <- dieser Eintrag hat den Index  "2"
"Sachsen-Anhalt" : "Magdeburg"       # <- dieser Eintrag hat den Index  "3"
"Hessen" :                           # <- dieser Eintrag hat den Index  "4"
"Mecklenburg-Vorpommern" :           # <- dieser Eintrag hat den Index  "5"
"Rheinland-Pfalz" : "Mainz"          # <- dieser Eintrag hat den Index  "6"
"Berlin" : "Berlin"                  # <- dieser Eintrag hat den Index  "7"
: "Hamburg"                          # <- dieser Eintrag hat den Index  "8"
"Bayern" : "München"                 # <- dieser Eintrag hat den Index  "9"
"Niedersachen" :                     # <- dieser Eintrag hat den Index "10"
:                                    # <- dieser Eintrag hat den Index "11"
: "Kiel"                             # <- dieser Eintrag hat den Index "12"
"Nordrhein-Westfalen" : "Düsseldorf" # <- dieser Eintrag hat den Index "13"
"Sachsen" : "Dresden"                # <- dieser Eintrag hat den Index "14"
"Thüringen" : "Erfurt"               # <- dieser Eintrag hat den Index "15"

>

*/

# Einen Eintrag anhand vom Index suchen, welcher jedoch nicht gefunden wird.
# Hierdurch wird ein neuer Eintrag ans Ende von der Liste angehängt. Anschließend wird
# der Wert definiert.
# Diese Anweisung entspricht dieser Anweisung:
# meine_Liste[nichts]{} = "Bremen"
meine_Liste[]{} = "Bremen"

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart"    # <- dieser Eintrag hat den Index  "0"
"Brandenburg" : "Potsdam"            # <- dieser Eintrag hat den Index  "1"
"Saarland" : "Saarbrücken"           # <- dieser Eintrag hat den Index  "2"
"Sachsen-Anhalt" : "Magdeburg"       # <- dieser Eintrag hat den Index  "3"
"Hessen" :                           # <- dieser Eintrag hat den Index  "4"
"Mecklenburg-Vorpommern" :           # <- dieser Eintrag hat den Index  "5"
"Rheinland-Pfalz" : "Mainz"          # <- dieser Eintrag hat den Index  "6"
"Berlin" : "Berlin"                  # <- dieser Eintrag hat den Index  "7"
: "Hamburg"                          # <- dieser Eintrag hat den Index  "8"
"Bayern" : "München"                 # <- dieser Eintrag hat den Index  "9"
"Niedersachen" :                     # <- dieser Eintrag hat den Index "10"
:                                    # <- dieser Eintrag hat den Index "11"
: "Kiel"                             # <- dieser Eintrag hat den Index "12"
"Nordrhein-Westfalen" : "Düsseldorf" # <- dieser Eintrag hat den Index "13"
"Sachsen" : "Dresden"                # <- dieser Eintrag hat den Index "14"
"Thüringen" : "Erfurt"               # <- dieser Eintrag hat den Index "15"
: "Bremen"                           # <- dieser Eintrag hat den Index "16"

>

*/

Beschreibung

Die Funktion

• ändert in einer bestehenden Liste einen bestehenden Eintrag,
• fügt einer bestehenden Liste einen neuen Eintrag hinzu oder
• ändert in einem bestehenden Eintrag in einer bestehenden Liste einen Partikel.

Schreibweisen, welche zulässig sind

• alter
• ändern
• change
• modifizieren
• modify

Syntax

Art:	Funktionsaufruf	Konstrukt
Formen:	Eintrag.ändern[ /°/°Index = Eintrag_-_alter_Index°/ °/] Eintrag.ändern[ /°/°Index = Eintrag_-_alter_Index°/ /°/°Schlüssel = Eintrag_-_alter_Schlüssel°/ °/°/) Eintrag.ändern[ /°/°Index = Eintrag_-_alter_Index°/ /°/°Schlüssel = Eintrag_-_alter_Schlüssel°/ /°/°Wert = Eintrag_-_alter_Wert°/ °/°/°/} Eintrag.ändern(/° /°/°Schlüssel = Eintrag_-_alter_Schlüssel°/ °/) Eintrag.ändern( /°/°Schlüssel = Eintrag_-_alter_Schlüssel°/ /°/°Wert = Eintrag_-_alter_Wert°/ °/°/} Eintrag.ändern{ /°/°Wert = Eintrag_-_alter_Wert°/ °/}	Eintrag = /°Index = Eintrag_-_alter_Index°//°, /°Schlüssel = Eintrag_-_alter_Schlüssel°//°, /°Wert = Eintrag_-_alter_Wert°/°/°/ Eintrag[] = Index Eintrag() = Schlüssel Eintrag{} = Wert

Parameter

Eingabe

Anzahl: 1 bis 4

Eintrag

Beispiel:	meine_Liste[5]
Beschreibung:	Mit der Hilfe von diesem Parameter wird ein Eintrag aus einer Liste angegeben, welcher geändert, gelöscht oder hinzugefügt werden soll.
Standardwert:	Für diesen Parameter muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern ein Eintrag von einer Liste -

Index

Beispiel:	0
Beschreibung:	Mit der Hilfe von diesem Parameter wird der Index vom Eintrag angegeben. Der Parameterwert gibt also die Position vom Eintrag an. Beim Eintrag handelt es sich um den zu ändernden Eintrag oder den neuen Eintrag, welcher in die Liste eingefügt wird. Wenn ein bestehender Eintrag geändert wird, dann wird der bestehende Eintrag zunächst aus der Liste gelöscht, bevor der geänderte Eintrag in die Liste an der angegebenen Position wieder eingefügt wird. Wenn sich an der angegebenen Position bereits ein Eintrag befindet, dann wird der sich im Weg befindliche Eintrag und alle nachfolgenden Einträge von der Liste um 1 Position verschoben, sodass die Indexe von den zu verschiebenden Einträgen anschließend um 1 höher sind. Wenn der angegebene Wert höher ist, als der Index vom letzten Eintrag, dann wird er gegebenenfalls soweit reduziert, dass der einzufügende Eintrag ans Ende von der Liste angehängt wird. Wenn der angegebene Wert negativ ist, dann wird der Eintrag vom Ende von der Liste ausgehend positioniert. Dies heißt, dass der einzufügende Eintrag mit dem Index "-1" der letzte Eintrag von der Liste sein wird. mit dem Index "-2" der zweitletzte Eintrag von der Liste sein wird. ...
Schreibweisen, welche zulässig sind:	Index index Position position
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird der Eintrag an seiner alten Position belassen. Wenn jedoch der Eintrag noch nicht existiert hatte, sodass sein alter Index nicht bekannt ist, dann wird der neue Eintrag ans Ende von der Liste angehängt.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl (die Nachkommastellen werden ignoriert; d. h. 4.9 zählt als 4)

Schlüssel

Beispiel:	"Bayern"
Beschreibung:	Mit der Hilfe von diesem Parameter wird der Schlüssel vom Eintrag angegeben. Beim Eintrag handelt es sich um den zu ändernden Eintrag oder den neuen Eintrag, welcher in die Liste eingefügt wird. Wenn bereits ein weiterer Eintrag mit diesem Schlüssel existiert und nicht die Nichtigkeitsangabe "nichts" angegeben wurde, dann wird zunächst der weitere Eintrag gelöscht.
Schreibweisen, welche zulässig sind:	key Schlüssel
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann behält der Eintrag seinen alten Schlüssel. Wenn jedoch der Eintrag noch nicht existiert hatte, sodass sein alter Schlüssel nicht bekannt ist, dann wird die Nichtigkeitsangabe "nichts" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Wert

Beispiel:	"München"
Beschreibung:	Mit der Hilfe von diesem Parameter wird der Wert vom Eintrag angegeben. Beim Eintrag handelt es sich um den zu ändernden Eintrag oder den neuen Eintrag, welcher in die Liste eingefügt wird.
Schreibweisen, welche zulässig sind:	value Wert
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann behält der Eintrag seinen alten Wert. Wenn jedoch der Eintrag noch nicht existiert hatte, sodass sein alter Wert nicht bekannt ist, dann wird die Nichtigkeitsangabe "nichts" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

siehe auch

• Im Kapitel "Merkhilfe" ist bildlich dargestellt, welche Klammer für welchen Zweck dient.

anhängen

siehe im Dokument "Minicode - Quellcode-Dateien" im Kapitel "die Details von Quellcode-Dateien - Operatoren - Anhängung"

einfügen

Beispiele

# Liste aus Schlüsseln und Werten definieren
meine_Liste = <
    "Baden-Württemberg" : "Stuttgart"
    "Berlin" : "Berlin"
>

# weiteren Eintrag ans Ende anhängen, aber nur
#    - den Wert
# vom Eintrag definieren
meine_Liste.einfügen{"Hamburg"}

# weiteren Eintrag ans Ende anhängen, aber nur
#    - den Schlüssel und
#    - den Wert
# vom Eintrag definieren
meine_Liste.einfügen(

"Bayern"
"München"

}

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <
    "Baden-Württemberg" : "Stuttgart" <- dieser Eintrag hat den Index "0"
    "Berlin" : "Berlin"               <- dieser Eintrag hat den Index "1"
    : "Hamburg"                       <- dieser Eintrag hat den Index "2"
    "Bayern" : "München"              <- dieser Eintrag hat den Index "3"
>

*/

# weiteren Eintrag einfügen, und alle Partikel, das heißt
#    - den Index,
#    - den Schlüssel und
#    - den Wert
# vom Eintrag definieren
# dieser Eintrag wird vor dem Eintrag mit dem Index "1" platziert
meine_Liste.einfügen[

1
"Rheinland-Pfalz"
"Mainz"

}

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <
    "Baden-Württemberg" : "Stuttgart" <- dieser Eintrag hat den Index "0"
    "Rheinland-Pfalz" : "Mainz"       <- dieser Eintrag hat den Index "1"
    "Berlin" : "Berlin"               <- dieser Eintrag hat den Index "2"
    : "Hamburg"                       <- dieser Eintrag hat den Index "3"
    "Bayern" : "München"              <- dieser Eintrag hat den Index "4"
>

*/

# weiteren Eintrag einfügen, aber nur
#    - den Index und
#    - den Schlüssel
# vom Eintrag definieren
# dieser Eintrag wird vor dem Eintrag mit dem Index "1" platziert
meine_Liste.einfügen[

1
"Saarland"

)

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <
    "Baden-Württemberg" : "Stuttgart" <- dieser Eintrag hat den Index "0"
    "Saarland" :                      <- dieser Eintrag hat den Index "1"
    "Rheinland-Pfalz" : "Mainz"       <- dieser Eintrag hat den Index "2"
    "Berlin" : "Berlin"               <- dieser Eintrag hat den Index "3"
    : "Hamburg"                       <- dieser Eintrag hat den Index "4"
    "Bayern" : "München"              <- dieser Eintrag hat den Index "5"
>

*/

# weiteren Eintrag einfügen, aber nur
#    - den Index und
#    - den Schlüssel
# vom Eintrag definieren
# dieser Eintrag wird vor dem Eintrag mit dem Index "1" platziert
meine_Liste.einfügen[

Index = 1
Schlüssel = "Hessen"

)

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <
    "Baden-Württemberg" : "Stuttgart" <- dieser Eintrag hat den Index "0"
    "Hessen" :                        <- dieser Eintrag hat den Index "1"
    "Saarland" :                      <- dieser Eintrag hat den Index "2"
    "Rheinland-Pfalz" : "Mainz"       <- dieser Eintrag hat den Index "3"
    "Berlin" : "Berlin"               <- dieser Eintrag hat den Index "4"
    : "Hamburg"                       <- dieser Eintrag hat den Index "5"
    "Bayern" : "München"              <- dieser Eintrag hat den Index "6"
>

*/

# weiteren Eintrag ans Ende anhängen, aber nur
#    - den Schlüssel
# vom Eintrag definieren
meine_Liste.einfügen("Niedersachsen")

# weiteren Eintrag einfügen, aber nur
#    - den Index und
#    - den Wert
# vom Eintrag definieren
# Dieser Eintrag wird vor dem Eintrag mit dem Index "2" platziert.
meine_Liste.einfügen[

2

"Potsdam"

}

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <
    "Baden-Württemberg" : "Stuttgart" <- dieser Eintrag hat den Index "0"
    "Hessen" :                        <- dieser Eintrag hat den Index "1"
    : "Potsdam"                       <- dieser Eintrag hat den Index "2"
    "Saarland" :                      <- dieser Eintrag hat den Index "3"
    "Rheinland-Pfalz" : "Mainz"       <- dieser Eintrag hat den Index "4"
    "Berlin" : "Berlin"               <- dieser Eintrag hat den Index "5"
    : "Hamburg"                       <- dieser Eintrag hat den Index "6"
    "Bayern" : "München"              <- dieser Eintrag hat den Index "7"
    "Niedersachen" :                  <- dieser Eintrag hat den Index "8"
>

*/

# weiteren Eintrag einfügen, aber nur
#    - den Index
# vom Eintrag definieren
# Dieser Eintrag wird vor dem Eintrag mit dem Index "5" platziert.
meine_Liste.einfügen[5]

# weiteren Eintrag ans Ende anhängen, aber keinen Partikel definieren
meine_Liste.einfügen[]

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <
    "Baden-Württemberg" : "Stuttgart" <- dieser Eintrag hat den Index "0"
    "Hessen" :                        <- dieser Eintrag hat den Index "1"
    : "Potsdam"                       <- dieser Eintrag hat den Index "2"
    "Saarland" :                      <- dieser Eintrag hat den Index "3"
    "Rheinland-Pfalz" : "Mainz"       <- dieser Eintrag hat den Index "4"
    :                                 <- dieser Eintrag hat den Index "5"
    "Berlin" : "Berlin"               <- dieser Eintrag hat den Index "6"
    : "Hamburg"                       <- dieser Eintrag hat den Index "7"
    "Bayern" : "München"              <- dieser Eintrag hat den Index "8"
    "Niedersachen" :                  <- dieser Eintrag hat den Index "9"
    :                                 <- dieser Eintrag hat den Index "10"
>

*/

/*
Anstatt dem Funktionsaufruf kann auch das Konstrukt verwendet werden, dessen primärer
Zweck darin besteht, einen Eintrag zu modifizieren. Hierzu wird

- ein Index,
- ein Schlüssel oder
- ein Wert

gesucht, welcher nicht gefunden werden kann, da im Fall eines Nichtauffindens vom
gesuchten Eintrag ein neuer Eintrag angelegt wird.

Wenn

- nach einem Index gesucht wird, welcher die Nichtigkeitsangabe "nichts" ist,

dann

- kann kein Eintrag gefunden werden, da ein Index immer ein Wert vom
  Variablentyp "Ganzzahl" ist.

Ansonsten wenn

- nach

- einem Schlüssel oder
- einem Wert

gesucht wird, welcher die Nichtigkeitsangabe "nichts" ist,

dann

- kann sehr wohl ein Eintrag gefunden werden.

*/

# weiteren Eintrag ans Ende anhängen, aber nur
#    - den Wert
# vom Eintrag definieren
meine_Liste[nichts] = , , "Erfurt"

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <
    "Baden-Württemberg" : "Stuttgart" <- dieser Eintrag hat den Index "0"
    "Hessen" :                        <- dieser Eintrag hat den Index "1"
    : "Potsdam"                       <- dieser Eintrag hat den Index "2"
    "Saarland" :                      <- dieser Eintrag hat den Index "3"
    "Rheinland-Pfalz" : "Mainz"       <- dieser Eintrag hat den Index "4"
    :                                 <- dieser Eintrag hat den Index "5"
    "Berlin" : "Berlin"               <- dieser Eintrag hat den Index "6"
    : "Hamburg"                       <- dieser Eintrag hat den Index "7"
    "Bayern" : "München"              <- dieser Eintrag hat den Index "8"
    "Niedersachen" :                  <- dieser Eintrag hat den Index "9"
    :                                 <- dieser Eintrag hat den Index "10"
    : "Erfurt"                        <- dieser Eintrag hat den Index "11"
>

*/

# weiteren Eintrag ans Ende anhängen, aber nur
#    - den Schlüssel
# vom Eintrag definieren
meine_Liste[] = , "Sachsen",

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <
    "Baden-Württemberg" : "Stuttgart" <- dieser Eintrag hat den Index "0"
    "Hessen" :                        <- dieser Eintrag hat den Index "1"
    : "Potsdam"                       <- dieser Eintrag hat den Index "2"
    "Saarland" :                      <- dieser Eintrag hat den Index "3"
    "Rheinland-Pfalz" : "Mainz"       <- dieser Eintrag hat den Index "4"
    :                                 <- dieser Eintrag hat den Index "5"
    "Berlin" : "Berlin"               <- dieser Eintrag hat den Index "6"
    : "Hamburg"                       <- dieser Eintrag hat den Index "7"
    "Bayern" : "München"              <- dieser Eintrag hat den Index "8"
    "Niedersachen" :                  <- dieser Eintrag hat den Index "9"
    :                                 <- dieser Eintrag hat den Index "10"
    : "Erfurt"                        <- dieser Eintrag hat den Index "11"
    "Sachsen" :                       <- dieser Eintrag hat den Index "12"
>

*/

# weiteren Eintrag einfügen, aber nur
#    - den Index und
#    - den Schlüssel
# vom Eintrag definieren
meine_Liste[] = 4, "Mecklenburg-Vorpommern"

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <
    "Baden-Württemberg" : "Stuttgart" <- dieser Eintrag hat den Index "0"
    "Hessen" :                        <- dieser Eintrag hat den Index "1"
    : "Potsdam"                       <- dieser Eintrag hat den Index "2"
    "Saarland" :                      <- dieser Eintrag hat den Index "3"
    "Mecklenburg-Vorpommern" :        <- dieser Eintrag hat den Index "4"
    "Rheinland-Pfalz" : "Mainz"       <- dieser Eintrag hat den Index "5"
    :                                 <- dieser Eintrag hat den Index "6"
    "Berlin" : "Berlin"               <- dieser Eintrag hat den Index "7"
    : "Hamburg"                       <- dieser Eintrag hat den Index "8"
    "Bayern" : "München"              <- dieser Eintrag hat den Index "9"
    "Niedersachen" :                  <- dieser Eintrag hat den Index "10"
    :                                 <- dieser Eintrag hat den Index "11"
    : "Erfurt"                        <- dieser Eintrag hat den Index "12"
    "Sachsen" :                       <- dieser Eintrag hat den Index "13"
>

*/

Beschreibung

Die Funktion fügt in eine bestehende Liste einen neuen Eintrag ein.

Schreibweisen, welche zulässig sind

• einfügen
• insert

Syntax

Art:

Funktionsaufruf

Formen:

Instanz_von_der_Klasse_Liste.einfügen[ /°/°Index = Länge_in_Einträgen(Instanz_von_der_Klasse_Liste)°/ °/] Instanz_von_der_Klasse_Liste.einfügen[ /°/°Index = Länge_in_Einträgen(Instanz_von_der_Klasse_Liste)°/ /°/°Schlüssel = nichts°/ °/°/) Instanz_von_der_Klasse_Liste.einfügen[ /°/°Index = Länge_in_Einträgen(Instanz_von_der_Klasse_Liste)°/ /°/°Schlüssel = nichts°/ /°/°Wert = nichts°/ °/°/°/} Instanz_von_der_Klasse_Liste.einfügen(/° /°/°Schlüssel = nichts°/ °/) Instanz_von_der_Klasse_Liste.einfügen( /°/°Schlüssel = nichts°/ /°/°Wert = nichts°/ °/°/} Instanz_von_der_Klasse_Liste.einfügen{ /°/°Wert = nichts°/ °/}

Parameter

Eingabe

Anzahl: 0 bis 3

Index

Beispiel:	0
Beschreibung:	Mit der Hilfe von diesem Parameter wird der Index vom neuen Eintrag angegeben. Der Parameterwert gibt also die Position vom neuen Eintrag an. Wenn sich an der angegebenen Position bereits ein Eintrag befindet, dann wird der sich im Weg befindliche Eintrag und alle nachfolgenden Einträge von der Liste um 1 Position verschoben, sodass ihr Index anschließend um 1 höher ist. Wenn der angegebene Wert höher ist, als der Index vom letzten Eintrag, dann wird er gegebenenfalls soweit reduziert, dass der neue Eintrag ans Ende von der Liste angehängt wird. Wenn der angegebene Wert negativ ist, dann wird der Eintrag vom Ende von der Liste ausgehend positioniert. Dies heißt, dass der neue Eintrag mit dem Index "-1" der letzte Eintrag von der Liste sein wird. mit dem Index "-2" der zweitletzte Eintrag von der Liste sein wird. ...
Schreibweisen, welche zulässig sind:	Index index Position position
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird der Eintrag ans Ende von der Liste angehängt. Der Eintrag erhält also als Index die Anzahl der Einträge von der Liste, bevor der Eintrag eingefügt wurde.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl (die Nachkommastellen werden ignoriert; d. h. 4.9 zählt als 4)

Schlüssel

Beispiel:	"Bayern"
Beschreibung:	Mit der Hilfe von diesem Parameter wird der Schlüssel vom neuen Eintrag angegeben. Wenn bereits ein Eintrag mit diesem Schlüssel existiert und nicht die Nichtigkeitsangabe "nichts" angegeben wurde, dann wird zunächst der bestehende Eintrag gelöscht.
Schreibweisen, welche zulässig sind:	key Schlüssel
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird die Nichtigkeitsangabe "nichts" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Wert

Beispiel:	"München"
Beschreibung:	Mit der Hilfe von diesem Parameter wird der Wert vom neuen Eintrag angegeben.
Schreibweisen, welche zulässig sind:	value Wert
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird die Nichtigkeitsangabe "nichts" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Eingabe und Ausgabe

Anzahl: 1

Instanz_von_der_Klasse_Liste

Beispiel:	<"Baden-Württemberg" : "Stuttgart">
Beschreibung:	Mit der Hilfe von diesem Parameter wird eine Instanz von der Klasse "Liste" angegeben.
Standardwert:	Für diesen Parameter muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	Liste

siehe auch

• Im Kapitel "Merkhilfe" ist bildlich dargestellt, welche Klammer für welchen Zweck dient.

in_eine_Zeichenkette_umwandeln

Beispiele

# eine Liste definieren, welche eine Liste als Wert gespeichert hält
meine_Liste = <

"Eingangskontakt" : 7
"Kalibrierung" : <

"Positionskorrektur" : <

"x" : 0.00214
"y" : 0.00394
"z" : -0.00007

>
"Vorschubkorrektur" : <

"x" : 0
"y" : -2
"z" : 1

>

>
"Türstatus" : "geschlossen"

>

/*
Die folgende Anweisung wird diese Zeichenkette erzeugen:

"<

"Eingangskontakt" : 7
"Kalibrierung" : <

"Positionskorrektur" : <

"x" : 0.002,14
"y" : 0.003,94
"z" : -0.000,07

>
"Vorschubkorrektur" : <

"x" : 0
"y" : -2
"z" : 1

>

>
"Türstatus" : "geschlossen"

>"

*/
meine_Zeichenkette_-_1 = meine_Liste.in_eine_Zeichenkette_umwandeln()

/*
Die folgende Anweisung wird diese Zeichenkette erzeugen:

"<

"Eingangskontakt" : 7
"Kalibrierung" : <

"Positionskorrektur" : list
"Vorschubkorrektur" : list

>
"Türstatus" : "geschlossen"

>"

*/
meine_Zeichenkette_-_2 = meine_Liste.in_eine_Zeichenkette_umwandeln(Rekursionstiefe_-_maximal = 1)

/*
Die folgende Anweisung wird diese Zeichenkette erzeugen:

"<

"Eingangskontakt" : 7
"Kalibrierung" : list
"Türstatus" : "geschlossen"

>"

*/
meine_Zeichenkette_-_3 = meine_Liste.in_eine_Zeichenkette_umwandeln(Rekursionstiefe_-_maximal = 0)

/*
Die folgende Anweisung wird diese Zeichenkette erzeugen:

"<

"x" : 0,002.14
"y" : 0,003.94
"z" : 0,000.07

>"

*/
meine_Zeichenkette_-_4 = meine_Liste("Kalibrierung")("Positionskorrektur").in_eine_Zeichenkette_umwandeln(

Trennzeichen_-_dezimal = ","
Trennzeichen_-_Tausend = "."

)

Beschreibung

Die Funktion erzeugt eine Zeichenkette, welche die Liste mit ihrem Inhalt darstellt.

Schreibweisen, welche zulässig sind

• char_string
• character_string
• chr_string
• convert_to_char_string
• convert_to_character_string
• in_eine_Zeichenkette_umwandeln
• nach_Zeichenkette
• to_char_string
• to_character_string
• Zeichenkette

Syntax

Art:

Funktionsaufruf

Formen:

/°Instanz_von_der_Klasse_Zeichenkette = °/Instanz_von_der_Klasse_Liste.in_eine_Zeichenkette_umwandeln( /°/°Trennzeichen_-_dezimal = "."°/ /°/°Trennzeichen_-_Tausend = ","°/ /°/°Rekusionstiefe_-_maximal = 6°/ /°/°Einrückung = "\t"°/ /°/°Liste_-_Anfang = "<\n"°/ /°/°Liste_-_Ende = ">\n"°/ /°/°Liste_-_Platzhalter = "list"°/ /°/°Trennzeichen_-_Partikel = " : "°/ /°/°Ergebnis_speichern = falsch°/ °/°/°/°/°/°/°/°/°/)

Parameter

Eingabe

Anzahl: 1 bis 10

Instanz_von_der_Klasse_Liste

Beispiel:	4
Beschreibung:	Mit der Hilfe von diesem Parameter wird eine Instanz von der Klasse "Liste" angegeben.
Standardwert:	Für diesen Parameter muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	Liste

Trennzeichen_-_dezimal

Beispiel:	","
Beschreibung:	Mit der Hilfe von diesem Parameter wird das Dezimaltrennzeichen für Schlüssel und Werte vom Variablentyp "Ganzzahl" oder "Kommazahl" angegeben, welches verwendet werden soll. Wenn kein Dezimaltrennzeichen verwendet werden soll, dann kann der Wert "nichts" oder eine leere Zeichenkette übergeben werden.
Schreibweisen, welche zulässig sind:	decimal_separator dezimal-Trennzeichen Dezimal-Trennzeichen Dezimaltrennzeichen separator_-_decimal Trennzeichen_-_dezimal Trennzeichen_-_Dezimal
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird der Wert "." verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Nichtigkeitsangabe Zeichenkette

Trennzeichen_-_Tausend

Beispiel:	"."
Beschreibung:	Mit der Hilfe von diesem Parameter wird das Tausendertrennzeichen für Schlüssel und Werte vom Variablentyp "Ganzzahl" oder "Kommazahl" angegeben, welches verwendet werden soll. Wenn kein Tausendertrennzeichen verwendet werden soll, dann kann der Wert "nichts" oder eine leere Zeichenkette übergeben werden.
Schreibweisen, welche zulässig sind:	separator_-_thousand Tausender-Trennzeichen Tausendertrennzeichen thousands_separator Trennzeichen_-_Tausend
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird der Wert "," verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Nichtigkeitsangabe Zeichenkette

Rekusionstiefe_-_maximal

Beispiel:	8
Beschreibung:	Mit der Hilfe von diesem Parameter wird maximale Rekusionstiefe angegeben. Dieser Wert dient nicht nur dafür, um die Ausgabe bei einer hohen Verschachtelungstiefe von Listen zu begrenzen, sondern auch um eine Endlosschleife zu verhindern, wenn eine Liste in sich selbst gespeichert ist. Wenn die angegebene Rekusionstiefe erreicht wurde, dann werden weitere Listen, welche als Schlüssel oder Wert gespeichert sind, nicht mehr ausgegeben. Stattdessen wird die Platzhalter-Zeichenkette ausgegeben, welche mit der Hilfe vom Parameter "Liste_-_Platzhalter" übergeben wurde. Wenn die Rekusionstiefe nicht begrenzt werden soll, dann kann dies mit der Hilfe von der Nichtigkeitsangabe "nichts" angegeben werden.
Schreibweisen, welche zulässig sind:	maximale_Rekusionstiefe maximum_recursion_depth recursion_depth_-_maximum Rekusionstiefe_-_maximal
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird der Wert "6" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Nichtigkeitsangabe Zeichenkette

Einrückung

Beispiel:	"    "
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Zeichenkette angegeben, welche verwendet werden soll, um die Einträge von der Liste einzurücken. Wenn die Einträge nicht eingerückt werden sollen, dann kann der Wert "nichts" oder eine leere Zeichenkette übergeben werden.
Schreibweisen, welche zulässig sind:	Einrückung Einzug indentation indention
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird der Wert "\t" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Nichtigkeitsangabe Zeichenkette

Liste_-_Anfang

Beispiel:	"\n"
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Zeichenkette angegeben, welche verwendet werden soll, um den Anfang von einer Liste zu kennzeichnen. Wenn der Anfang von einer Liste nicht gekennzeichnet werden soll, dann kann der Wert "nichts" oder eine leere Zeichenkette übergeben werden. ist es vermutlich dennoch sinnvoll, wenigstens einen Zeilenumbruch ("\n") zu übergeben.
Schreibweisen, welche zulässig sind:	list_-_beginning list_-_start Liste_-_Anfang Liste_-_Start
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird der Wert "<\n" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Nichtigkeitsangabe Zeichenkette

Liste_-_Ende

Beispiel:	""
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Zeichenkette angegeben, welche verwendet werden soll, um das Ende von einer Liste zu kennzeichnen. Wenn das Ende von einer Liste nicht gekennzeichnet werden soll, dann kann der Wert "nichts" oder eine leere Zeichenkette übergeben werden.
Schreibweisen, welche zulässig sind:	list_-_end list_-_ending list_-_terminator Liste_-_Abschluss Liste_-_Ende
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird der Wert ">\n" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Nichtigkeitsangabe Zeichenkette

Liste_-_Platzhalter

Beispiel:	"- die Liste wurden wegen einem Erreichen von der maximalen Rekusionstiefe nicht ausgegeben -"
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Zeichenkette angegeben, welche als Platzhalter verwendet werden soll, um anzugeben, dass die Liste nicht ausgegeben wurde, weil die maximale Rekusionstiefe überschritten wurde. Wenn keine Platzhalter-Zeichenkette verwendet werden soll, dann kann der Wert "nichts" oder eine leere Zeichenkette übergeben werden.
Schreibweisen, welche zulässig sind:	list_-_placeholder list_-_replacement Liste_-_Ersatz Liste_-_Platzhalter
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird der Wert "list" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Nichtigkeitsangabe Zeichenkette

Trennzeichen_-_Partikel

Beispiel:	"; Wert: "
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Zeichenkette angegeben, welche als Trennzeichen zwischen den beiden Partikeln "Schlüssel" und "Wert" verwendet werden soll. Wenn kein Partikeltrennzeichen verwendet werden soll, dann kann der Wert "nichts" oder eine leere Zeichenkette übergeben werden.
Schreibweisen, welche zulässig sind:	particle_separator Partikel-Trennzeichen Partikeltrennzeichen separator_-_particle Trennzeichen_-_Partikel
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird der Wert " : " verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Nichtigkeitsangabe Zeichenkette

Ergebnis_speichern

Beispiel:	wahr
Beschreibung:	Mit der Hilfe von diesem Parameter wird angegeben, ob die erzeugte Zeichenkette gespeichert (der übergebene Wert ist etwas) oder zurückgegeben (der übergebene Wert ist nichts) werden soll.
Schreibweisen, welche zulässig sind:	Ergebnis_speichern store_result
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird der Wert "falsch" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Ausgabe

Anzahl: 0 oder 1

Instanz_von_der_Klasse_Zeichenkette

Beispiel:	meine_Zeichenkette
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Bezeichnung für die Variable angegeben, in welcher eine Instanz von der Klasse "Zeichenkette" gespeichert werden soll, welche die erzeugte Zeichenfolge enthält.
Standardwert:	Wenn dieser Parameter verwendet wird, dann muss für diesen Parameter eine Bezeichnung übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern eine Bezeichnung für eine Variable -
Variablentypen, welche für die Ausgabe verwendet werden:	Zeichenkette

ist_gleich

siehe im Dokument "Minicode - Quellcode-Dateien" im Kapitel "die Details von Quellcode-Dateien - Operatoren - ist gleich"

ist_nichts

siehe im Dokument "Minicode - Quellcode-Dateien" im Kapitel "die Details von Quellcode-Dateien - Operatoren - ist nichts"

ist_ungleich

siehe im Dokument "Minicode - Quellcode-Dateien" im Kapitel "die Details von Quellcode-Dateien - Operatoren - ist ungleich"

löschen

Beispiele

# Liste aus Schlüsseln und Werten definieren
meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index "0"
"Hessen" :                        # <- dieser Eintrag hat den Index "1"
: "Potsdam"                       # <- dieser Eintrag hat den Index "2"
"Saarland" :                      # <- dieser Eintrag hat den Index "3"
"Mecklenburg-Vorpommern" :        # <- dieser Eintrag hat den Index "4"
"Rheinland-Pfalz" : "Mainz"       # <- dieser Eintrag hat den Index "5"
:                                 # <- dieser Eintrag hat den Index "6"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index "7"
: "Hamburg"                       # <- dieser Eintrag hat den Index "8"
"Bayern" : "München"              # <- dieser Eintrag hat den Index "9"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "10"
:                                 # <- dieser Eintrag hat den Index "11"
: "Erfurt"                        # <- dieser Eintrag hat den Index "12"
"Sachsen" :                       # <- dieser Eintrag hat den Index "13"

>

# einen Eintrag anhand vom Index suchen und dann löschen
# kein Partikel vom zu löschenden Eintrag entgegen nehmen
meine_Liste.löschen[2]

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index "0"
"Hessen" :                        # <- dieser Eintrag hat den Index "1"
"Saarland" :                      # <- dieser Eintrag hat den Index "2"
"Mecklenburg-Vorpommern" :        # <- dieser Eintrag hat den Index "3"
"Rheinland-Pfalz" : "Mainz"       # <- dieser Eintrag hat den Index "4"
:                                 # <- dieser Eintrag hat den Index "5"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index "6"
: "Hamburg"                       # <- dieser Eintrag hat den Index "7"
"Bayern" : "München"              # <- dieser Eintrag hat den Index "8"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "9"
:                                 # <- dieser Eintrag hat den Index "10"
: "Erfurt"                        # <- dieser Eintrag hat den Index "11"
"Sachsen" :                       # <- dieser Eintrag hat den Index "12"

>

*/

# einen Eintrag anhand vom Schlüssel suchen und dann löschen
# alle Partikel vom zu löschenden Eintrag entgegen nehmen
Index, Schlüssel, Wert = meine_Liste.löschen("Bayern")

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index "0"
"Hessen" :                        # <- dieser Eintrag hat den Index "1"
"Saarland" :                      # <- dieser Eintrag hat den Index "2"
"Mecklenburg-Vorpommern" :        # <- dieser Eintrag hat den Index "3"
"Rheinland-Pfalz" : "Mainz"       # <- dieser Eintrag hat den Index "4"
:                                 # <- dieser Eintrag hat den Index "5"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index "6"
: "Hamburg"                       # <- dieser Eintrag hat den Index "7"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "8"
:                                 # <- dieser Eintrag hat den Index "9"
: "Erfurt"                        # <- dieser Eintrag hat den Index "10"
"Sachsen" :                       # <- dieser Eintrag hat den Index "11"

>

Die Variable "Index"     ist jetzt mit dieser Ganzzahl     definiert: 8
Die Variable "Schlüssel" ist jetzt mit dieser Zeichenkette definiert: "Bayern"
Die Variable "Wert"      ist jetzt mit dieser Zeichenkette definiert: "München"
*/

# einen Eintrag anhand vom Wert suchen und dann löschen
# nur den Wert vom zu löschenden Eintrag entgegen nehmen
, , Wert = meine_Liste.löschen{"Hamburg"}

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index "0"
"Hessen" :                        # <- dieser Eintrag hat den Index "1"
"Saarland" :                      # <- dieser Eintrag hat den Index "2"
"Mecklenburg-Vorpommern" :        # <- dieser Eintrag hat den Index "3"
"Rheinland-Pfalz" : "Mainz"       # <- dieser Eintrag hat den Index "4"
:                                 # <- dieser Eintrag hat den Index "5"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index "6"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "7"
:                                 # <- dieser Eintrag hat den Index "8"
: "Erfurt"                        # <- dieser Eintrag hat den Index "9"
"Sachsen" :                       # <- dieser Eintrag hat den Index "10"

>

Die Variable "Wert" ist jetzt mit dieser Zeichenkette definiert: "Hamburg"
*/

/*
Nur bei der Form mit den eckigen Klammern ("[" und "]") bewirkt die Verwendung vom
Standardwert, dass zwangsweise der letzte Eintrag gelöscht wird. Bei

- der Form mit den runden Klammern ("(" und ")") würde nach einem Eintrag mit der
  Nichtigkeitsangabe "nichts" als Schlüssel gesucht werden.
- der Form mit den geschweiften Klammern ("{" und "}") würde nach einem Eintrag
  mit der Nichtigkeitsangabe "nichts" als Wert gesucht werden.

*/
# den letzten Eintrag löschen
# nur den Schlüssel und den Wert vom zu löschenden Eintrag entgegen nehmen
, Schlüssel, Wert = meine_Liste.löschen[]

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index "0"
"Hessen" :                        # <- dieser Eintrag hat den Index "1"
"Saarland" :                      # <- dieser Eintrag hat den Index "2"
"Mecklenburg-Vorpommern" :        # <- dieser Eintrag hat den Index "3"
"Rheinland-Pfalz" : "Mainz"       # <- dieser Eintrag hat den Index "4"
:                                 # <- dieser Eintrag hat den Index "5"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index "6"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "7"
:                                 # <- dieser Eintrag hat den Index "8"
: "Erfurt"                        # <- dieser Eintrag hat den Index "9"

>

Die Variable "Schlüssel" ist jetzt mit dieser Zeichenkette       definiert: "Sachsen"
Die Variable "Wert"      ist jetzt mit dieser Nichtigkeitsangabe definiert: nichts
*/

# einen Eintrag anhand vom Schlüssel suchen und dann löschen
# nur den Index und den Wert vom zu löschenden Eintrag entgegen nehmen
# diese Anweisung entspricht dieser Anweisung:
# Index, , Wert = meine_Liste.löschen(nichts)
Index, , Wert = meine_Liste.löschen()

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index "0"
"Hessen" :                        # <- dieser Eintrag hat den Index "1"
"Saarland" :                      # <- dieser Eintrag hat den Index "2"
"Mecklenburg-Vorpommern" :        # <- dieser Eintrag hat den Index "3"
"Rheinland-Pfalz" : "Mainz"       # <- dieser Eintrag hat den Index "4"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index "5"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "6"
:                                 # <- dieser Eintrag hat den Index "7"
: "Erfurt"                        # <- dieser Eintrag hat den Index "8"

>

Die Variable "Index" ist jetzt mit dieser Ganzzahl           definiert: 5
Die Variable "Wert"  ist jetzt mit dieser Nichtigkeitsangabe definiert: nichts
*/

# einen Eintrag anhand vom Wert suchen und dann löschen
# nur den Index vom zu löschenden Eintrag entgegen nehmen
# diese Anweisung entspricht dieser Anweisung:
# Index = meine_Liste.löschen{nichts}
Index, , = meine_Liste.löschen{}

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index "0"
"Saarland" :                      # <- dieser Eintrag hat den Index "1"
"Mecklenburg-Vorpommern" :        # <- dieser Eintrag hat den Index "2"
"Rheinland-Pfalz" : "Mainz"       # <- dieser Eintrag hat den Index "3"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index "4"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "5"
:                                 # <- dieser Eintrag hat den Index "6"
: "Erfurt"                        # <- dieser Eintrag hat den Index "7"

>

Die Variable "Index" ist jetzt mit dieser Ganzzahl definiert: 1
*/

# Einträge anhand vom Index auswählen und löschen
# keine zu löschenden Einträge entgegen nehmen
meine_Liste.löschen[2 ... 4]

/*
Die Liste sieht nun wie folgt aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index "0"
"Saarland" :                      # <- dieser Eintrag hat den Index "1"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index "2"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "3"
:                                 # <- dieser Eintrag hat den Index "4"
: "Erfurt"                        # <- dieser Eintrag hat den Index "5"

>

*/

/*
Nur bei der Form mit den eckigen Klammern ("[" und "]") bewirkt die Verwendung vom
Standardwert, dass die zu löschenden Einträge

- vom ersten Eintrag (einschließlich dem ersten Eintrag) oder/und
- bis zum letzten Eintrag (einschließlich dem letzten Eintrag)

ausgewählt werden. Bei

- der Form mit den runden Klammern ("(" und ")") würde nach einem Eintrag mit der
  Nichtigkeitsangabe "nichts" als Schlüssel gesucht werden.
- der Form mit den geschweiften Klammern ("{" und "}") würde nach einem Eintrag
  mit der Nichtigkeitsangabe "nichts" als Wert gesucht werden.

*/

# Einträge anhand vom Schlüssel und Index auswählen und löschen
# die zu löschenden Einträge entgegen nehmen
# diese Anweisung entspricht dieser Anweisung:
# neue_Liste = meine_Liste.löschen(nichts ... nichts]
neue_Liste = meine_Liste.löschen(...]

/*
Die Liste, welche in der Variable "meine_Liste" gespeichert ist, sieht nun wie folgt
aus:

meine_Liste = <

"Baden-Württemberg" : "Stuttgart" # <- dieser Eintrag hat den Index "0"
"Saarland" :                      # <- dieser Eintrag hat den Index "1"
"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index "2"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "3"

>

Die Liste, welche in der Variable "neue_Liste" gespeichert ist, sieht nun wie folgt
aus:

neue_Liste = <

:                                 # <- dieser Eintrag hat den Index "0"
: "Erfurt"                        # <- dieser Eintrag hat den Index "1"

>

*/

# Einträge anhand vom Wert auswählen und löschen
# keine zu löschenden Einträge entgegen nehmen
meine_Liste.löschen{"Stuttgart" ... "Berlin"}

/*
Die Liste, welche in der Variable "meine_Liste" gespeichert ist, sieht nun wie folgt
aus:

meine_Liste = <

"Berlin" : "Berlin"               # <- dieser Eintrag hat den Index "0"
"Niedersachen" :                  # <- dieser Eintrag hat den Index "1"

>

*/

# alle Einträge auswählen und löschen
# keine zu löschenden Einträge entgegen nehmen
meine_Liste.löschen[...]

/*
Die Liste, welche in der Variable "meine_Liste" gespeichert ist, sieht nun wie folgt
aus:

meine_Liste = <
>

*/

Beschreibung

Diese Funktion löscht aus einer bestehenden Liste

• einen einzelnen Eintrag und gibt die ehemaligen Partikel vom gelöschten Eintrag zurück oder
• mehrere Einträge und gibt die gelöschten Einträge als eine neue Liste zurück.

Schreibweisen, welche zulässig sind

löschen:	delete entfernen löschen remove
...:	... bis to

Syntax

Art:

Funktionsaufruf

Formen:

/°/°Index_-_gefunden°//°, /°Schlüssel_-_gefunden°//°, /°Wert_-_gefunden°/°/°/ = °/Liste_-_zu_bearbeiten.löschen[ /°Index_-_zu_suchen = -1°/ ] /°/°Index_-_gefunden°//°, /°Schlüssel_-_gefunden°//°, /°Wert_-_gefunden°/°/°/ = °/Liste_-_zu_bearbeiten.löschen( /°Schlüssel_-_zu_suchen = nichts°/ ) /°/°Index_-_gefunden°//°, /°Schlüssel_-_gefunden°//°, /°Wert_-_gefunden°/°/°/ = °/Liste_-_zu_bearbeiten.löschen{ /°Wert_-_zu_suchen = nichts°/ } /°Liste_-_gelöschte_Einträge = °/Liste_-_zu_bearbeiten.löschen[ /°Index_-_zu_suchen_-_Anfang = 0°/ ... /°Index_-_zu_suchen_-_Ende = Länge_in_Einträgen(Liste_-_zu_bearbeiten)°/ ] /°Liste_-_gelöschte_Einträge = °/Liste_-_zu_bearbeiten.löschen[ /°Index_-_zu_suchen_-_Anfang = 0°/ ... /°Schlüssel_-_zu_suchen_-_Ende = nichts°/ ) /°Liste_-_gelöschte_Einträge = °/Liste_-_zu_bearbeiten.löschen[ /°Index_-_zu_suchen_-_Anfang = 0°/ ... /°Wert_-_zu_suchen_-_Ende = nichts°/ } /°Liste_-_gelöschte_Einträge = °/Liste_-_zu_bearbeiten.löschen( /°Schlüssel_-_zu_suchen_-_Anfang = nichts°/ ... /°Index_-_zu_suchen_-_Ende = Länge_in_Einträgen(Liste_-_zu_bearbeiten)°/ ] /°Liste_-_gelöschte_Einträge = °/Liste_-_zu_bearbeiten.löschen( /°Schlüssel_-_zu_suchen_-_Anfang = nichts°/ ... /°Schlüssel_-_zu_suchen_-_Ende = nichts°/ ) /°Liste_-_gelöschte_Einträge = °/Liste_-_zu_bearbeiten.löschen( /°Schlüssel_-_zu_suchen_-_Anfang = nichts°/ ... /°Wert_-_zu_suchen_-_Ende = nichts°/ } /°Liste_-_gelöschte_Einträge = °/Liste_-_zu_bearbeiten.löschen{ /°Wert_-_zu_suchen_-_Anfang = nichts°/ ... /°Index_-_zu_suchen_-_Ende = Länge_in_Einträgen(Liste_-_zu_bearbeiten)°/ ] /°Liste_-_gelöschte_Einträge = °/Liste_-_zu_bearbeiten.löschen{ /°Wert_-_zu_suchen_-_Anfang = nichts°/ ... /°Schlüssel_-_zu_suchen_-_Ende = nichts°/ ) /°Liste_-_gelöschte_Einträge = °/Liste_-_zu_bearbeiten.löschen{ /°Wert_-_zu_suchen_-_Anfang = nichts°/ ... /°Wert_-_zu_suchen_-_Ende = nichts°/ }

Parameter

Eingabe

Anzahl: 0 bis 4

Index_-_zu_suchen

Beispiel:	0
Beschreibung:	Mit der Hilfe von diesem Parameter wird ein Index angegeben, nach welchem gesucht werden soll. Der Parameterwert gibt also die Position vom zu suchenden Eintrag an. Wenn der angegebene Index in der Liste nicht existiert, dann wird kein Eintrag gefunden und daher auch kein Eintrag gelöscht. Wenn der angegebene Index negativ ist, dann wird der Eintrag vom Ende von der Liste ausgewählt. Dies heißt, dass mit dem Index "-1" der letzte Eintrag von der Liste ausgewählt wird. dem Index "-2" der zweitletzte Eintrag von der Liste ausgewählt wird. ...
Schreibweisen, welche zulässig sind:	Eintrag_-_zu_suchen_-_Index Eintrag_-_zu_suchen_-_Position entry_-_to_look_for_-_index entry_-_to_look_for_-_position entry_-_to_lookup_-_index entry_-_to_lookup_-_position entry_-_to_search_-_index entry_-_to_search_-_position entry_-_to_seek_-_index entry_-_to_seek_-_position index_-_to_look_for index_-_to_lookup index_-_to_search index_-_to_seek Index_-_zu_suchen position_-_to_look_for position_-_to_lookup position_-_to_search position_-_to_seek Position_-_zu_suchen
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird nach dem letzten Eintrag gesucht. Der Parameter erhält also als Wert die Anzahl der Einträge von der Liste - 1, bevor der Eintrag gelöscht wurde.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl (die Nachkommastellen werden ignoriert; d. h. 4.9 zählt als 4)

Schlüssel_-_zu_suchen

Beispiel:	"Baden-Württemberg"
Beschreibung:	Mit der Hilfe von diesem Parameter wird ein Schlüssel angegeben, nach welchem gesucht werden soll. Wenn der angegebene Schlüssel in der Liste nicht existiert, dann wird kein Eintrag gefunden und daher auch kein Eintrag gelöscht.
Schreibweisen, welche zulässig sind:	Eintrag_-_zu_suchen_-_Schlüssel entry_-_to_look_for_-_key entry_-_to_lookup_-_key entry_-_to_search_-_key entry_-_to_seek_-_key key_-_to_look_for key_-_to_lookup key_-_to_search key_-_to_seek Schlüssel_-_zu_suchen
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird die Nichtigkeitsangabe "nichts" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Wert_-_zu_suchen

Beispiel:	"Stuttgart"
Beschreibung:	Mit der Hilfe von diesem Parameter wird ein Wert angegeben, nach welchem gesucht werden soll. Wenn der angegebene Wert in der Liste nicht existiert, dann wird kein Eintrag gefunden und daher auch kein Eintrag gelöscht.
Schreibweisen, welche zulässig sind:	Eintrag_-_zu_suchen_-_Wert entry_-_to_look_for_-_value entry_-_to_lookup_-_value entry_-_to_search_-_value entry_-_to_seek_-_value value_-_to_look_for value_-_to_lookup value_-_to_search value_-_to_seek Wert_-_zu_suchen
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird die Nichtigkeitsangabe "nichts" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Index_-_zu_suchen_-_Anfang

Beispiel:	0
Beschreibung:	Mit der Hilfe von diesem Parameter wird ein Index angegeben, nach welchem gesucht werden soll. Der Parameterwert gibt also die Position vom zu suchenden Eintrag an. Ab diesem Eintrag werden die restlichen Einträge von der Liste gelöscht. Der gefundene Eintrag wird ebenfalls gelöscht. Wenn der angegebene Index in der Liste nicht existiert, dann wird kein Eintrag gefunden und daher auch kein Eintrag gelöscht. Wenn der angegebene Index negativ ist, dann wird der Eintrag vom Ende von der Liste ausgewählt. Dies heißt, dass mit dem Index "-1" der letzte Eintrag von der Liste ausgewählt wird. dem Index "-2" der zweitletzte Eintrag von der Liste ausgewählt wird. ...
Schreibweisen, welche zulässig sind:	Eintrag_-_zu_suchen_-_Anfang_-_Index Eintrag_-_zu_suchen_-_Anfang_-_Position Eintrag_-_zu_suchen_-_Start_-_Index Eintrag_-_zu_suchen_-_Start_-_Position entry_-_to_look_for_-_beginning_-_index entry_-_to_look_for_-_beginning_-_position entry_-_to_look_for_-_start_-_index entry_-_to_look_for_-_start_-_position entry_-_to_lookup_-_beginning_-_index entry_-_to_lookup_-_beginning_-_position entry_-_to_lookup_-_start_-_index entry_-_to_lookup_-_start_-_position entry_-_to_search_-_beginning_-_index entry_-_to_search_-_beginning_-_position entry_-_to_search_-_start_-_index entry_-_to_search_-_start_-_position entry_-_to_seek_-_beginning_-_index entry_-_to_seek_-_beginning_-_position entry_-_to_seek_-_start_-_index entry_-_to_seek_-_start_-_position index_-_to_look_for_-_beginning index_-_to_look_for_-_start index_-_to_lookup_-_beginning index_-_to_lookup_-_start index_-_to_search_-_beginning index_-_to_search_-_start index_-_to_seek_-_beginning index_-_to_seek_-_start Index_-_zu_suchen_-_Anfang Index_-_zu_suchen_-_Start position_-_to_look_for_-_beginning position_-_to_look_for_-_start position_-_to_lookup_-_beginning position_-_to_lookup_-_start position_-_to_search_-_beginning position_-_to_search_-_start position_-_to_seek_-_beginning position_-_to_seek_-_start Position_-_zu_suchen_-_Anfang Position_-_zu_suchen_-_Start
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird nach dem ersten Eintrag gesucht. Der Parameter erhält also den Wert "0".
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl (die Nachkommastellen werden ignoriert; d. h. 4.9 zählt als 4)

Index_-_zu_suchen_-_Ende

Beispiel:	-1
Beschreibung:	Mit der Hilfe von diesem Parameter wird ein Index angegeben, nach welchem gesucht werden soll, nachdem der Anfangs-Eintrag gefunden wurde. Der Parameterwert gibt also die Position vom zu suchenden Eintrag an. Wenn der Anfangs-Eintrag gefunden wurde, dann werden bis zu diesem End-Eintrag die voranstehenden Einträge von der Liste gelöscht. Der gefundene End-Eintrag wird nicht gelöscht. Wenn der angegebene Index in der Liste nicht existiert, dann wird kein Eintrag gefunden und daher alle Einträge ab dem gefundenen Anfangs-Eintrag bis zum Ende gelöscht. Wenn der angegebene Index negativ ist, dann wird der Eintrag vom Ende von der Liste ausgewählt. Dies heißt, dass mit dem Index "-1" der letzte Eintrag von der Liste ausgewählt wird. dem Index "-2" der zweitletzte Eintrag von der Liste ausgewählt wird. ...
Schreibweisen, welche zulässig sind:	Eintrag_-_zu_suchen_-_Ende_-_Index Eintrag_-_zu_suchen_-_Ende_-_Position entry_-_to_look_for_-_end_-_index entry_-_to_look_for_-_end_-_position entry_-_to_lookup_-_end_-_index entry_-_to_lookup_-_end_-_position entry_-_to_search_-_end_-_index entry_-_to_search_-_end_-_position entry_-_to_seek_-_end_-_index entry_-_to_seek_-_end_-_position index_-_to_look_for_-_end index_-_to_lookup_-_end index_-_to_search_-_end index_-_to_seek_-_end Index_-_zu_suchen_-_Ende position_-_to_look_for_-_end position_-_to_lookup_-_end position_-_to_search_-_end position_-_to_seek_-_end Position_-_zu_suchen_-_Ende
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird nach keinem Eintrag gesucht. Der Parameter erhält als Wert die Anzahl der Einträge von der Liste, bevor ein Eintrag gelöscht wurde. Dieser Wert ist also um 1 höher als der Index vom letzten Eintrag.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl (die Nachkommastellen werden ignoriert; d. h. 4.9 zählt als 4)

Schlüssel_-_zu_suchen_-_Anfang

Beispiel:	"Baden-Württemberg"
Beschreibung:	Mit der Hilfe von diesem Parameter wird ein Schlüssel angegeben, nach welchem gesucht werden soll. Ab diesem Eintrag werden die restlichen Einträge von der Liste gelöscht. Der gefundene Eintrag wird ebenfalls gelöscht. Wenn der angegebene Schlüssel in der Liste nicht existiert, dann wird kein Eintrag gefunden und daher auch kein Eintrag gelöscht.
Schreibweisen, welche zulässig sind:	Eintrag_-_zu_suchen_-_Anfang_-_Schlüssel Eintrag_-_zu_suchen_-_Start_-_Schlüssel entry_-_to_look_for_-_beginning_-_key entry_-_to_look_for_-_start_-_key entry_-_to_lookup_-_beginning_-_key entry_-_to_lookup_-_start_-_key entry_-_to_search_-_beginning_-_key entry_-_to_search_-_start_-_key entry_-_to_seek_-_beginning_-_key entry_-_to_seek_-_start_-_key key_-_to_look_for_-_beginning key_-_to_look_for_-_start key_-_to_lookup_-_beginning key_-_to_lookup_-_start key_-_to_search_-_beginning key_-_to_search_-_start key_-_to_seek_-_beginning key_-_to_seek_-_start Schlüssel_-_zu_suchen_-_Anfang Schlüssel_-_zu_suchen_-_Start
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird die Nichtigkeitsangabe "nichts" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Schlüssel_-_zu_suchen_-_Ende

Beispiel:	nichts
Beschreibung:	Mit der Hilfe von diesem Parameter wird ein Schlüssel angegeben, nach welchem gesucht werden soll, nachdem der Anfangs-Eintrag gefunden wurde. Wenn der Anfangs-Eintrag gefunden wurde, dann werden bis zu diesem End-Eintrag die voranstehenden Einträge von der Liste gelöscht. Der gefundene End-Eintrag wird nicht gelöscht. Wenn der angegebene Schlüssel in der Liste nicht existiert, dann wird kein Eintrag gefunden und daher alle Einträge ab dem gefundenen Anfangs-Eintrag bis zum Ende gelöscht.
Schreibweisen, welche zulässig sind:	Eintrag_-_zu_suchen_-_Ende_-_Schlüssel entry_-_to_look_for_-_end_-_key entry_-_to_lookup_-_end_-_key entry_-_to_search_-_end_-_key entry_-_to_seek_-_end_-_key key_-_to_look_for_-_end key_-_to_lookup_-_end key_-_to_search_-_end key_-_to_seek_-_end Schlüssel_-_zu_suchen_-_Ende
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird die Nichtigkeitsangabe "nichts" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Wert_-_zu_suchen_-_Anfang

Beispiel:	"Stuttgart"
Beschreibung:	Mit der Hilfe von diesem Parameter wird ein Wert angegeben, nach welchem gesucht werden soll. Ab diesem Eintrag werden die restlichen Einträge von der Liste gelöscht. Der gefundene Eintrag wird ebenfalls gelöscht. Wenn der angegebene Wert in der Liste nicht existiert, dann wird kein Eintrag gefunden und daher auch kein Eintrag gelöscht.
Schreibweisen, welche zulässig sind:	Eintrag_-_zu_suchen_-_Anfang_-_Wert Eintrag_-_zu_suchen_-_Start_-_Wert entry_-_to_look_for_-_beginning_-_value entry_-_to_look_for_-_start_-_value entry_-_to_lookup_-_beginning_-_value entry_-_to_lookup_-_start_-_value entry_-_to_search_-_beginning_-_value entry_-_to_search_-_start_-_value entry_-_to_seek_-_beginning_-_value entry_-_to_seek_-_start_-_value value_-_to_look_for_-_beginning value_-_to_look_for_-_start value_-_to_lookup_-_beginning value_-_to_lookup_-_start value_-_to_search_-_beginning value_-_to_search_-_start value_-_to_seek_-_beginning value_-_to_seek_-_start Wert_-_zu_suchen_-_Anfang Wert_-_zu_suchen_-_Start
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird die Nichtigkeitsangabe "nichts" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Wert_-_zu_suchen_-_Ende

Beispiel:	nichts
Beschreibung:	Mit der Hilfe von diesem Parameter wird ein Wert angegeben, nach welchem gesucht werden soll, nachdem der Anfangs-Eintrag gefunden wurde. Wenn der Anfangs-Eintrag gefunden wurde, dann werden bis zu diesem End-Eintrag die voranstehenden Einträge von der Liste gelöscht. Der gefundene End-Eintrag wird nicht gelöscht. Wenn der angegebene Wert in der Liste nicht existiert, dann wird kein Eintrag gefunden und daher alle Einträge ab dem gefundenen Anfangs-Eintrag bis zum Ende gelöscht.
Schreibweisen, welche zulässig sind:	Eintrag_-_zu_suchen_-_Ende_-_Wert entry_-_to_look_for_-_end_-_value entry_-_to_lookup_-_end_-_value entry_-_to_search_-_end_-_value entry_-_to_seek_-_end_-_value value_-_to_look_for_-_end value_-_to_lookup_-_end value_-_to_search_-_end value_-_to_seek_-_end Wert_-_zu_suchen_-_Ende
Standardwert:	Wenn für diesen Parameter kein Wert übergeben wird, dann wird die Nichtigkeitsangabe "nichts" verwendet.
Variablentypen, welche für die Eingabe zulässig sind:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Eingabe und Ausgabe

Anzahl: 1

Liste_-_zu_bearbeiten

Beispiel:	<"Baden-Württemberg" : "Stuttgart">
Beschreibung:	Mit der Hilfe von diesem Parameter wird eine Instanz von der Klasse "Liste" angegeben, aus welcher ein Eintrag oder mehrere Einträge gelöscht werden sollen.
Standardwert:	Für diesen Parameter muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	Liste

Ausgabe

Anzahl: 0 bis 3

Index_-_gefunden

Beispiel:	gelöschter_Index
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Bezeichnung für die Variable angegeben, in welcher der Index vom gelöschten Eintrag gespeichert werden soll. Wenn der gesuchte Eintrag nicht gefunden wurde, dann wird die Nichtigkeitsangabe "nichts" gespeichert.
Schreibweisen, welche zulässig sind:	Eintrag_-_gefunden_-_Index Eintrag_-_gefunden_-_Position entry_-_found_-_index entry_-_found_-_position index_-_found Index_-_gefunden position_-_found Position_-_gefunden
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern eine Bezeichnung für eine Variable -
Variablentypen, welche für die Ausgabe verwendet werden:	Ganzzahl Nichtigkeitsangabe

Schlüssel_-_gefunden

Beispiel:	gelöschter_Schlüssel
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Bezeichnung für die Variable angegeben, in welcher der Schlüssel vom gelöschten Eintrag gespeichert werden soll. Wenn der gesuchte Eintrag nicht gefunden wurde, dann wird die Nichtigkeitsangabe "nichts" gespeichert.
Schreibweisen, welche zulässig sind:	Eintrag_-_gefunden_-_Schlüssel entry_-_found_-_key key_-_found Schlüssel_-_gefunden
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern eine Bezeichnung für eine Variable -
Variablentypen, welche für die Ausgabe verwendet werden:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Wert_-_gefunden

Beispiel:	gelöschter_Wert
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Bezeichnung für die Variable angegeben, in welcher der Wert vom gelöschten Eintrag gespeichert werden soll. Wenn der gesuchte Eintrag nicht gefunden wurde, dann wird die Nichtigkeitsangabe "nichts" gespeichert.
Schreibweisen, welche zulässig sind:	Eintrag_-_gefunden_-_Wert entry_-_found_-_value value_-_found Wert_-_gefunden
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern eine Bezeichnung für eine Variable -
Variablentypen, welche für die Ausgabe verwendet werden:	Ganzzahl Kommazahl Liste Nichtigkeitsangabe Rohdatenkette Wahrheitsangabe Zeichenkette

Liste_-_gelösche_Einträge

Beispiel:	gelöschte_Einträge
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Bezeichnung für die Variable angegeben, in welcher die Liste gespeichert werden soll, in welcher sich die gelöschten Einträge befinden sollen. Wenn keine Einträge gelöscht wurden, dann wird die Liste leer sein.
Schreibweisen, welche zulässig sind:	list_-_deleted_entries list_-_found_entries list_-_removed_entries Liste_-_entfernte_Einträge Liste_-_gefundene_Einträge Liste_-_gelöschte_Einträge
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern eine Bezeichnung für eine Variable -
Variablentypen, welche für die Ausgabe verwendet werden:	Liste

siehe auch

• Im Kapitel "Merkhilfe" ist bildlich dargestellt, welche Klammer für welchen Zweck dient.

Konstanten und Variablen

ist_Ganzzahl

Beispiele

# eine Liste aus Werten definieren
meine_Liste = <1, 2.5, wahr, "Hallo Welt!">

# die Zeichenkette "false" ausgeben
/*
Die Konstante "ist_Ganzzahl" ist vom "Variablen"typ "Wahrheitsangabe". In eine
Konsole können jedoch nur Zeichenketten übertragen werden. Aus diesem Grund
wird eine Zeichenkette erzeugt. Diese Zeichenkette wird jedoch nicht in der Konstante
gespeichert.
*/
Konsole.schreiben(meine_Liste.ist_Ganzzahl)

# die selbe Zeichenkette erneut ausgeben, diesmal jedoch ohne der Variablendefinition
Konsole.schreiben(<1, 2.5, wahr, "Hallo Welt!">.ist_Ganzzahl)

Beschreibung

Die Konstante enthält die Information, ob es sich bei der Liste um eine Variable vom Variablentyp "Ganzzahl" handelt. Mit anderen Worten: Die Konstante enthält immer die Wahrheitsangabe "falsch".

Die Konstante kann nicht überschrieben werden, da ihr Wert gegebenenfalls nicht einmal gespeichert wird. Es handelt sich vielmehr um eine Möglichkeit, von einer Variable den Variablentyp zu prüfen. Dies ist im Speziellen dann interessant, wenn

• der Schlüssel oder
• der Wert

von einem Eintrag von einer Liste ausgelesen wurde.

Schreibweisen, welche zulässig sind

• is_integer
• ist_Ganzzahl

Syntax

Art:	Konstrukt
Formen:	/°Ergebnis = °/Instanz_von_der_Klasse_Liste.ist_Ganzzahl

Parameter

Eingabe

Anzahl: 1

Instanz_von_der_Klasse_Liste

Beispiel:	4
Beschreibung:	Mit der Hilfe von diesem Parameter wird eine Instanz von der Klasse "Liste" angegeben.
Standardwert:	Für diesen Parameter muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	Liste

Ausgabe

Anzahl: 0 oder 1

Ergebnis

Beispiel:	meine_Wahrheitsangabe
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Bezeichnung für die Variable angegeben, in welcher eine Instanz von der Klasse "Wahrheitsangabe" gespeichert werden soll, welche die Angabe enthält, ob es sich beim Parameter "Instanz_von_der_Klasse_Liste" um eine Variable vom Variablentyp "Ganzzahl" handelt. Mit anderen Worten: Der Wert ist immer die Wahrheitsangabe "falsch".
Standardwert:	Wenn dieser Parameter verwendet wird, dann muss für diesen Parameter eine Bezeichnung übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern eine Bezeichnung für eine Variable -
Variablentypen, welche für die Ausgabe verwendet werden:	Wahrheitsangabe

ist_Kommazahl

Beispiele

# eine Liste aus Werten definieren
meine_Liste = <1, 2.5, wahr, "Hallo Welt!">

# die Zeichenkette "false" ausgeben
/*
Die Konstante "ist_Kommazahl" ist vom Variablentyp "Wahrheitsangabe". In eine
Konsole können jedoch nur Zeichenketten übertragen werden. Aus diesem Grund
wird eine Zeichenkette erzeugt. Diese Zeichenkette wird jedoch nicht in der Konstante
gespeichert.
*/
Konsole.schreiben(meine_Liste.ist_Kommazahl)

# die selbe Zeichenkette erneut ausgeben, diesmal jedoch ohne der Variablendefinition
Konsole.schreiben(<1, 2.5, wahr, "Hallo Welt!">.ist_Kommazahl)

Beschreibung

Die Konstante enthält die Information, ob es sich bei der Liste um eine Variable vom Variablentyp "Kommazahl" handelt. Mit anderen Worten: Die Konstante enthält immer die Wahrheitsangabe "falsch".

Die Konstante kann nicht überschrieben werden, da ihr Wert gegebenenfalls nicht einmal gespeichert wird. Es handelt sich vielmehr um eine Möglichkeit, von einer Variable den Variablentyp zu prüfen. Dies ist im Speziellen dann interessant, wenn

• der Schlüssel oder
• der Wert

von einem Eintrag von einer Liste ausgelesen wurde.

Schreibweisen, welche zulässig sind

• is_point_value
• ist_Kommazahl

Syntax

Art:	Konstrukt
Formen:	/°Ergebnis = °/Instanz_von_der_Klasse_Liste.ist_Kommazahl

Parameter

Eingabe

Anzahl: 1

Instanz_von_der_Klasse_Liste

Beispiel:	4
Beschreibung:	Mit der Hilfe von diesem Parameter wird eine Instanz von der Klasse "Liste" angegeben.
Standardwert:	Für diesen Parameter muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	Liste

Ausgabe

Anzahl: 0 oder 1

Ergebnis

Beispiel:	meine_Wahrheitsangabe
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Bezeichnung für die Variable angegeben, in welcher eine Instanz von der Klasse "Wahrheitsangabe" gespeichert werden soll, welche die Angabe enthält, ob es sich beim Parameter "Instanz_von_der_Klasse_Liste" um eine Variable vom Variablentyp "Kommazahl" handelt. Mit anderen Worten: Der Wert ist immer die Wahrheitsangabe "falsch".
Standardwert:	Wenn dieser Parameter verwendet wird, dann muss für diesen Parameter eine Bezeichnung übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern eine Bezeichnung für eine Variable -
Variablentypen, welche für die Ausgabe verwendet werden:	Wahrheitsangabe

ist_Liste

Beispiele

# eine Liste aus Werten definieren
meine_Liste = <1, 2.5, wahr, "Hallo Welt!">

# die Zeichenkette "true" ausgeben
/*
Die Konstante "ist_Liste" ist vom Variablentyp "Wahrheitsangabe". In eine
Konsole können jedoch nur Zeichenketten übertragen werden. Aus diesem Grund
wird eine Zeichenkette erzeugt. Diese Zeichenkette wird jedoch nicht in der Konstante
gespeichert.
*/
Konsole.schreiben(meine_Liste.ist_Liste)

# die selbe Zeichenkette erneut ausgeben, diesmal jedoch ohne der Variablendefinition
Konsole.schreiben(<1, 2.5, wahr, "Hallo Welt!">.ist_Liste)

Beschreibung

Die Konstante enthält die Information, ob es sich bei der Liste um eine Variable vom Variablentyp "Liste" handelt. Mit anderen Worten: Die Konstante enthält immer die Wahrheitsangabe "wahr".

Die Konstante kann nicht überschrieben werden, da ihr Wert gegebenenfalls nicht einmal gespeichert wird. Es handelt sich vielmehr um eine Möglichkeit, von einer Variable den Variablentyp zu prüfen. Dies ist im Speziellen dann interessant, wenn

• der Schlüssel oder
• der Wert

von einem Eintrag von einer Liste ausgelesen wurde.

Schreibweisen, welche zulässig sind

• is_list
• ist_Liste

Syntax

Art:	Konstrukt
Formen:	/°Ergebnis = °/Instanz_von_der_Klasse_Liste.ist_Liste

Parameter

Eingabe

Anzahl: 1

Instanz_von_der_Klasse_Liste

Beispiel:	4
Beschreibung:	Mit der Hilfe von diesem Parameter wird eine Instanz von der Klasse "Liste" angegeben.
Standardwert:	Für diesen Parameter muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	Liste

Ausgabe

Anzahl: 0 oder 1

Ergebnis

Beispiel:	meine_Wahrheitsangabe
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Bezeichnung für die Variable angegeben, in welcher eine Instanz von der Klasse "Wahrheitsangabe" gespeichert werden soll, welche die Angabe enthält, ob es sich beim Parameter "Instanz_von_der_Klasse_Liste" um eine Variable vom Variablentyp "Liste" handelt. Mit anderen Worten: Der Wert ist immer die Wahrheitsangabe "wahr".
Standardwert:	Wenn dieser Parameter verwendet wird, dann muss für diesen Parameter eine Bezeichnung übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern eine Bezeichnung für eine Variable -
Variablentypen, welche für die Ausgabe verwendet werden:	Wahrheitsangabe

ist_Nichtigkeitsangabe

Beispiele

# eine Liste aus Werten definieren
meine_Liste = <1, 2.5, wahr, "Hallo Welt!">

# die Zeichenkette "false" ausgeben
/*
Die Konstante "ist_Nichtigkeitsangabe" ist vom Variablentyp "Wahrheitsangabe". In eine
Konsole können jedoch nur Zeichenketten übertragen werden. Aus diesem Grund
wird eine Zeichenkette erzeugt. Diese Zeichenkette wird jedoch nicht in der Konstante
gespeichert.
*/
Konsole.schreiben(meine_Liste.ist_Nichtigkeitsangabe)

# die selbe Zeichenkette erneut ausgeben, diesmal jedoch ohne der Variablendefinition
Konsole.schreiben(<1, 2.5, wahr, "Hallo Welt!">.ist_Nichtigkeitsangabe)

Beschreibung

Die Konstante enthält die Information, ob es sich bei der Liste um eine Variable vom Variablentyp "Nichtigkeitsangabe" handelt. Mit anderen Worten: Die Konstante enthält immer die Wahrheitsangabe "falsch".

Die Konstante kann nicht überschrieben werden, da ihr Wert gegebenenfalls nicht einmal gespeichert wird. Es handelt sich vielmehr um eine Möglichkeit, von einer Variable den Variablentyp zu prüfen. Dies ist im Speziellen dann interessant, wenn

• der Schlüssel oder
• der Wert

von einem Eintrag von einer Liste ausgelesen wurde.

Schreibweisen, welche zulässig sind

• is_voidness_statement
• ist_Nichtigkeitsangabe

Syntax

Art:	Konstrukt
Formen:	/°Ergebnis = °/Instanz_von_der_Klasse_Liste.ist_Nichtigkeitsangabe

Parameter

Eingabe

Anzahl: 1

Instanz_von_der_Klasse_Liste

Beispiel:	4
Beschreibung:	Mit der Hilfe von diesem Parameter wird eine Instanz von der Klasse "Liste" angegeben.
Standardwert:	Für diesen Parameter muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	Liste

Ausgabe

Anzahl: 0 oder 1

Ergebnis

Beispiel:	meine_Wahrheitsangabe
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Bezeichnung für die Variable angegeben, in welcher eine Instanz von der Klasse "Wahrheitsangabe" gespeichert werden soll, welche die Angabe enthält, ob es sich beim Parameter "Instanz_von_der_Klasse_Liste" um eine Variable vom Variablentyp "Nichtigkeitsangabe" handelt. Mit anderen Worten: Der Wert ist immer die Wahrheitsangabe "falsch".
Standardwert:	Wenn dieser Parameter verwendet wird, dann muss für diesen Parameter eine Bezeichnung übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern eine Bezeichnung für eine Variable -
Variablentypen, welche für die Ausgabe verwendet werden:	Wahrheitsangabe

ist_Rohdatenkette

Beispiele

# eine Liste aus Werten definieren
meine_Liste = <1, 2.5, wahr, "Hallo Welt!">

# die Zeichenkette "false" ausgeben
/*
Die Konstante "ist_Rohdatenkette" ist vom Variablentyp "Wahrheitsangabe". In eine
Konsole können jedoch nur Zeichenketten übertragen werden. Aus diesem Grund
wird eine Zeichenkette erzeugt. Diese Zeichenkette wird jedoch nicht in der Konstante
gespeichert.
*/
Konsole.schreiben(meine_Liste.ist_Rohdatenkette)

# die selbe Zeichenkette erneut ausgeben, diesmal jedoch ohne der Variablendefinition
Konsole.schreiben(<1, 2.5, wahr, "Hallo Welt!">.ist_Rohdatenkette)

Beschreibung

Die Konstante enthält die Information, ob es sich bei der Liste um eine Variable vom Variablentyp "Rohdatenkette" handelt. Mit anderen Worten: Die Konstante enthält immer die Wahrheitsangabe "falsch".

Die Konstante kann nicht überschrieben werden, da ihr Wert gegebenenfalls nicht einmal gespeichert wird. Es handelt sich vielmehr um eine Möglichkeit, von einer Variable den Variablentyp zu prüfen. Dies ist im Speziellen dann interessant, wenn

• der Schlüssel oder
• der Wert

von einem Eintrag von einer Liste ausgelesen wurde.

Schreibweisen, welche zulässig sind

• is_crude_data_string
• is_crude_string
• is_raw_data_string
• is_raw_string
• is_string_-_crude
• is_string_-_crude_data
• is_string_-_raw
• is_string_-_raw_data
• ist_Kette_-_Rohdaten
• ist_Rohdatenkette

Syntax

Art:	Konstrukt
Formen:	/°Ergebnis = °/Instanz_von_der_Klasse_Liste.ist_Rohdatenkette

Parameter

Eingabe

Anzahl: 1

Instanz_von_der_Klasse_Liste

Beispiel:	4
Beschreibung:	Mit der Hilfe von diesem Parameter wird eine Instanz von der Klasse "Liste" angegeben.
Standardwert:	Für diesen Parameter muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	Liste

Ausgabe

Anzahl: 0 oder 1

Ergebnis

Beispiel:	meine_Wahrheitsangabe
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Bezeichnung für die Variable angegeben, in welcher eine Instanz von der Klasse "Wahrheitsangabe" gespeichert werden soll, welche die Angabe enthält, ob es sich beim Parameter "Instanz_von_der_Klasse_Liste" um eine Variable vom Variablentyp "Rohdatenkette" handelt. Mit anderen Worten: Der Wert ist immer die Wahrheitsangabe "falsch".
Standardwert:	Wenn dieser Parameter verwendet wird, dann muss für diesen Parameter eine Bezeichnung übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern eine Bezeichnung für eine Variable -
Variablentypen, welche für die Ausgabe verwendet werden:	Wahrheitsangabe

ist_Wahrheitsangabe

Beispiele

# eine Liste aus Werten definieren
meine_Liste = <1, 2.5, wahr, "Hallo Welt!">

# die Zeichenkette "false" ausgeben
/*
Die Konstante "ist_Wahrheitsangabe" ist vom Variablentyp "Wahrheitsangabe". In eine
Konsole können jedoch nur Zeichenketten übertragen werden. Aus diesem Grund
wird eine Zeichenkette erzeugt. Diese Zeichenkette wird jedoch nicht in der Konstante
gespeichert.
*/
Konsole.schreiben(meine_Liste.ist_Wahrheitsangabe)

# die selbe Zeichenkette erneut ausgeben, diesmal jedoch ohne der Variablendefinition
Konsole.schreiben(<1, 2.5, wahr, "Hallo Welt!">.ist_Wahrheitsangabe)

Beschreibung

Die Konstante enthält die Information, ob es sich bei der Liste um eine Variable vom Variablentyp "Wahrheitsangabe" handelt. Mit anderen Worten: Die Konstante enthält immer die Wahrheitsangabe "falsch".

Die Konstante kann nicht überschrieben werden, da ihr Wert gegebenenfalls nicht einmal gespeichert wird. Es handelt sich vielmehr um eine Möglichkeit, von einer Variable den Variablentyp zu prüfen. Dies ist im Speziellen dann interessant, wenn

• der Schlüssel oder
• der Wert

von einem Eintrag von einer Liste ausgelesen wurde.

Schreibweisen, welche zulässig sind

• is_trueness_statement
• is_truth_statement
• ist_Wahrheitsangabe

Syntax

Art:	Konstrukt
Formen:	/°Ergebnis = °/Instanz_von_der_Klasse_Liste.ist_Wahrheitsangabe

Parameter

Eingabe

Anzahl: 1

Instanz_von_der_Klasse_Liste

Beispiel:	4
Beschreibung:	Mit der Hilfe von diesem Parameter wird eine Instanz von der Klasse "Liste" angegeben.
Standardwert:	Für diesen Parameter muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	Liste

Ausgabe

Anzahl: 0 oder 1

Ergebnis

Beispiel:	meine_Wahrheitsangabe
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Bezeichnung für die Variable angegeben, in welcher eine Instanz von der Klasse "Wahrheitsangabe" gespeichert werden soll, welche die Angabe enthält, ob es sich beim Parameter "Instanz_von_der_Klasse_Liste" um eine Variable vom Variablentyp "Wahrheitsangabe" handelt. Mit anderen Worten: Der Wert ist immer die Wahrheitsangabe "falsch".
Standardwert:	Wenn dieser Parameter verwendet wird, dann muss für diesen Parameter eine Bezeichnung übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern eine Bezeichnung für eine Variable -
Variablentypen, welche für die Ausgabe verwendet werden:	Wahrheitsangabe

ist_Zeichenkette

Beispiele

# eine Liste aus Werten definieren
meine_Liste = <1, 2.5, wahr, "Hallo Welt!">

# die Zeichenkette "false" ausgeben
/*
Die Konstante "ist_Zeichenkette" ist vom Variablentyp "Wahrheitsangabe". In eine
Konsole können jedoch nur Zeichenketten übertragen werden. Aus diesem Grund
wird eine Zeichenkette erzeugt. Diese Zeichenkette wird jedoch nicht in der Konstante
gespeichert.
*/
Konsole.schreiben(meine_Liste.ist_Zeichenkette)

# die selbe Zeichenkette erneut ausgeben, diesmal jedoch ohne der Variablendefinition
Konsole.schreiben(<1, 2.5, wahr, "Hallo Welt!">.ist_Zeichenkette)

Beschreibung

Die Konstante enthält die Information, ob es sich bei der Liste um eine Variable vom Variablentyp "Zeichenkette" handelt. Mit anderen Worten: Die Konstante enthält immer die Wahrheitsangabe "falsch".

Die Konstante kann nicht überschrieben werden, da ihr Wert gegebenenfalls nicht einmal gespeichert wird. Es handelt sich vielmehr um eine Möglichkeit, von einer Variable den Variablentyp zu prüfen. Dies ist im Speziellen dann interessant, wenn

• der Schlüssel oder
• der Wert

von einem Eintrag von einer Liste ausgelesen wurde.

Schreibweisen, welche zulässig sind

• is_character_string
• is_string_-_character
• ist_Kette_-_Zeichen
• ist_Zeichenkette

Syntax

Art:	Konstrukt
Formen:	/°Ergebnis = °/Instanz_von_der_Klasse_Liste.ist_Zeichenkette

Parameter

Eingabe

Anzahl: 1

Instanz_von_der_Klasse_Liste

Beispiel:	4
Beschreibung:	Mit der Hilfe von diesem Parameter wird eine Instanz von der Klasse "Liste" angegeben.
Standardwert:	Für diesen Parameter muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	Liste

Ausgabe

Anzahl: 0 oder 1

Ergebnis

Beispiel:	meine_Wahrheitsangabe
Beschreibung:	Mit der Hilfe von diesem Parameter wird die Bezeichnung für die Variable angegeben, in welcher eine Instanz von der Klasse "Wahrheitsangabe" gespeichert werden soll, welche die Angabe enthält, ob es sich beim Parameter "Instanz_von_der_Klasse_Liste" um eine Variable vom Variablentyp "Zeichenkette" handelt. Mit anderen Worten: Der Wert ist immer die Wahrheitsangabe "falsch".
Standardwert:	Wenn dieser Parameter verwendet wird, dann muss für diesen Parameter eine Bezeichnung übergeben werden, da er keinen Standardwert hat.
Variablentypen, welche für die Eingabe zulässig sind:	- kein Variablentyp, sondern eine Bezeichnung für eine Variable -
Variablentypen, welche für die Ausgabe verwendet werden:	Wahrheitsangabe

Merkhilfe

Vielleicht hilft dieses Bild, um im Kopf zu behalten, welche Klammer verwendet werden muss, um anzugeben, dass ein Bezug auf

• den Index,
• den Schlüssel oder
• den Wert

genommen wird:

weiteres Material zu diesem Thema

Dokumente

Name vom		Sprache:	Umfang vom Inhalt:	Weblink:
Autor:	Dokument:
	Minicode - allgemeine Informationen	deutsch	enthält allgemeine Informationen über die Programmiersprache "Minicode"	OnTheServer.de/Downloads/
	Minicode - Export-Definitionsdateien		beschreibt Export-Definitionsdateien für die Programmiersprache "Minicode"
	Minicode - Import-Definitionsdateien		beschreibt Import-Definitionsdateien für die Programmiersprache "Minicode"
	Minicode - Klasse - Ganzzahl		beschreibt die Klasse "Ganzzahl" für die Programmiersprache "Minicode"
	Minicode - Klasse - Kommazahl		beschreibt die Klasse "Kommazahl" für die Programmiersprache "Minicode"
	Minicode - Klasse - Nichtigkeitsangabe		beschreibt die Klasse "Nichtigkeitsangabe" für die Programmiersprache "Minicode"
	Minicode - Klasse - Rohdatenkette		beschreibt die Klasse "Rohdatenkette" für die Programmiersprache "Minicode"
	Minicode - Klasse - Wahrheitsangabe		beschreibt die Klasse "Wahrheitsangabe" für die Programmiersprache "Minicode"
	Minicode - Klasse - Zeichenkette		beschreibt die Klasse "Zeichenkette" für die Programmiersprache "Minicode"
	Minicode - Kompiler-Konfigurationsdateien		beschreibt Kompiler-Konfigurationsdateien für die Programmiersprache "Minicode" zeigt, welche Konfigurationsmöglichkeiten es für den Kompiler gibt
	Minicode - Quellcode-Dateien		beschreibt Quellcode-Dateien für die Programmiersprache "Minicode"

Aufnahme von weiteren Materialien

Wenn

• Sie weitere Materialien zu diesem Thema haben, von welchen Sie wollen, dass sie in diese Auflistungen aufgenommen werden,

dann

• können Sie mir gerne die Materialien oder einen Link zu ihnen zusenden.

Sie dürfen durchaus auch Ihre eigenen Materialien zuschicken.

Bei den zugesendeten Materialien werde ich beurteilen, ob sie sich für die Auflistung eignen. Manche Materialien werden nicht aufgenommen, weil beispielsweise ein Hinweis enthalten ist, dass

• eine Verbreitung nicht gestattet ist oder
• nur unter Bedingungen, welche ich nicht erfüllen will.

Es besteht kein Anspruch darauf, dass zugesendete Materialien aufgenommen werden.

Link zum Kapitel "wie man den Verfasser kontaktiert".