Stand: 09. 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
Bedeutungen
farbliche Markierung von Syntax-Elementen

die Details von Quellcode-Dateien
bedingte Codeausführung
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
Eingabe
wenn_-_Bedingung
§wenn_-_Codeblock§
ansonsten_wenn_-_Bedingung_-_n
§ansonsten_wenn_-_Codeblock_-_n§
§ansonsten_-_Codeblock§
Ausgabe
erfüllt
Anmerkungen
siehe auch
Funktionen
abbrechen
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
Eingabe
Parameter_-_Ausgabe_-_n_-_Name
Parameter_-_Ausgabe_-_n_-_Wert
definieren
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
Eingabe
Funktion_-_Name_-_n
Parameter_-_Ausgabe_-_n_-_Name_-_n
Parameter_-_Ausgabe_-_n_-_Standardwert
Parameter_-_Eingabe_-_n_-_Name_-_n
Parameter_-_Eingabe_-_n_-_Standardwert
§Codeblock§
Klassen
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
Eingabe
Klasse_-_Name_-_n
Initialisierungsroutine_-_Parameter_-_n_-_Name_-_n
Initialisierungsroutine_-_Parameter_-_n_-_Standardwert
§Codeblock§
Kommentare
Block
Beispiele
Definition
allgemein
Syntax
Parameter
Eingabe
Kommentartext
Zeile
Beispiele
Definition
allgemein
Syntax
Parameter
Eingabe
Kommentartext
Operatoren
Addition (Plus rechnen)
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
zurückgebende Form
speichernde Form "+="
speichernde Form "=+"
Parameter
Eingabe
Wert_-_primärer
Wert_-_sekundärer
Ergebnis_speichern
Eingabe und Ausgabe
Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer
siehe auch
Anhängung
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
zurückgebende Form
speichernde Form "&="
speichernde Form "=&"
Parameter
Eingabe
Wert_-_Anfang
Wert_-_Ende
Ergebnis_speichern
Eingabe und Ausgabe
Ergebnis_oder_Wert_-_Anfang_oder_Wert_-_Ende
siehe auch
ist gleich
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
zurückgebende Form
speichernde Formen
Parameter
Eingabe
Wert_-_primärer
Wert_-_sekundärer
Ergebnis_speichern
Eingabe und Ausgabe
Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer
siehe auch
ist größer als
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
zurückgebende Form
speichernde Form "=ist_größer_als"
speichernde Form "ist_größer_als="
Parameter
Eingabe
Wert_-_primärer
Wert_-_sekundärer
Ergebnis_speichern
Eingabe und Ausgabe
Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer
siehe auch
ist größer oder gleich
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
siehe auch
ist kleiner als
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
siehe auch
ist kleiner oder gleich
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
siehe auch
ist nichts
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
zurückgebende Form
speichernde Formen
Parameter
Eingabe
Wert
Ergebnis_speichern
Eingabe und Ausgabe
Ergebnis_oder_Wert
ist ungleich
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
zurückgebende Form
speichernde Formen
Parameter
siehe auch
Merkhilfe
oder
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
siehe auch
Subtraktion (Minus rechnen)
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
zurückgebende Form
speichernde Form "-="
speichernde Form "=-"
Parameter
Eingabe
Anfangswert
Abzug
Ergebnis_speichern
Eingabe und Ausgabe
Ergebnis_oder_Anfangswert_oder_Abzug
siehe auch
und
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
siehe auch
Schleifen
abbrechen
einzelnen Durchlauf
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
mehrere Durchläufe
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
Anmerkungen
Daten emittieren
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
Eingabe
Schlüssel_-_einzufügen
Wert_-_einzufügen
Anmerkungen
durchlaufen
ohne einer zu durchlaufenden Variable
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
Eingabe
Zählerwert_-_Anfang
Zählerwert_-_Ende
Schrittgröße
Bedingung_-_Anfang
§Codeblock§
Bedingung_-_Ende
Ausgabe
Liste_-_Ausgabe
Zählerwert_-_momentan
mit einer Liste
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
Eingabe
Liste_-_Eingabe
Bedingung_-_Anfang
§Codeblock§
Bedingung_-_Ende
Ausgabe
Liste_-_Ausgabe
Index_-_momentan
Schlüssel_-_momentan
Wert_-_momentan
mit einer Zeichenkette
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter
Eingabe
Zeichenkette
Bedingung_-_Anfang
§Codeblock§
Bedingung_-_Ende
Ausgabe
Liste_-_Ausgabe
Index_-_momentan
Zeichen_-_momentan
neustarten
Beispiele
Definition
allgemein
Schreibweisen, welche zulässig sind
Syntax
Parameter

Stichwortverzeichnis
Ausdrücke
Kommentare
Operatoren
Variablen mit spezieller Funktion

weiteres Material zu diesem Thema
Dokumente
Sonstiges

über dieses Dokument

was es hierin gibt

Dieses Dokument
Dieses Dokument ist keine Schritt-für-Schritt-Anweisung (Tutorial). Dennoch sollte jemand, mit geringen Vorkenntnissen in einer anderen Programmier- oder Skriptsprache, mit der Hilfe von diesem Dokument in der Lage sein, die Verwendung von Quellcode von der Sprache "Minicode" vollständig zu erlernen.

Alle anderen Informationen über Minicode, inklusiv den anderen 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.

Bedeutungen

farbliche Markierung von Syntax-Elementen

Für das Hervorheben vom Syntax-Elementen verwende ich in dieser Dokumentation folgende Farben:
Bedeutung: Beispiel(e): Farbe:
Ausdrücke
  • kehre zurück
 blau
Funktion
  • meine_Funktion(2, 5)
 lila
Klasse
  • Instanz_3 = meine_Klasse()
 braun
Kommentar
  • # dies ist ein Zeilenkommentar
  • /*
    Dies
    ist ein
    Blockkommentar.
    */
grün
Variablentyp
  • Ganzzahl
 türkies
Wert
  • 2.56
  • nichts
  • wahr
  • "Sträßchen"
  • "c"
 rosa

die Details von Quellcode-Dateien

bedingte Codeausführung

Beispiele

# Ganzzahl prüfen [Start]
# eine Variable definieren
meine_Bedingung = -5

/*
Da meine_Bedingung
- eine Ganzzahl aber
- nicht den Wert "0"
gespeichert hat, wird "Die Bedingung wurde erfüllt." ausgegeben.
*/

wenn meine_Bedingung
# "Die Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde erfüllt.")

/*
Da der Wert "0" als "nichts" angesehen wird, wird "Die Bedingung wurde nicht erfüllt."
ausgegeben.
*/

wenn 0
# "Die Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
# "Die Bedingung wurde nicht erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")
# Ganzzahl prüfen [Ende]

# Wahrheitsangabe prüfen [Start]
/*
Beim Variablentyp "Wahrheitsangabe" wird
- der Wert "wahr" als Erfüllung von der Bedingung angesehen und
- der Wert "falsch", dass die Bedingung nicht erfüllt wurde.
Das Nachfolgende wird daher "Die 2. Bedingung wurde erfüllt." ausgeben.
*/

wenn falsch
# "Die 1. Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Die 1. Bedingung wurde erfüllt.")
ansonsten wenn wahr
# "Die 2. Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Die 2. Bedingung wurde erfüllt.")

/*
Die nachfolgenden 3 Operationen werden alle "falsch" zurückgeben, daher wird "Keine
Bedingung wurde erfüllt." ausgegeben.
*/

wenn 2 == 5
# "2 ist gleich 5." ausgeben
Konsole.schreiben("2 ist gleich 5.")
ansonsten wenn 3 == 5
# "3 ist gleich 5." ausgeben
Konsole.schreiben("3 ist gleich 5.")
ansonstenwenn 4 == 5
# "4 ist gleich 5." ausgeben
Konsole.schreiben("4 ist gleich 5.")
ansonsten
# "Keine Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Keine Bedingung wurde erfüllt.")
# Wahrheitsangabe prüfen [Ende]

# Aufgabe_Garten definieren
Aufgabe_Garten = "Blumen gießen"

# Aufgabe im Garten abarbeiten [Start]
/*
Wenn
- eine von den "wenn"- oder "ansonsten wenn"-Bedingungen vom
  gesamten Konstrukt der bedingten Codeausführung erfüllt wurde (eine Bedingung
  wurde erfüllt),
dann
- wird die Variable "erfüllt" auf "wahr" gesetzt.
Ansonsten, d. h. wenn
- keine Bedingung erfüllt wurde und
- somit der "ansonsten"-Codeblock ausgeführt wird, oder
- kein Codeblock ausgeführt wird, weil kein "ansonsten"-Codeblock existiert,
dann
- wird die Variable "erfüllt" auf "falsch" gesetzt.
*/

wenn Aufgabe_Garten == "Blumen gießen"
Blumen_gießen()
ansonsten wenn Aufgabe_Garten == "Frühbeet gießen"
Frühbeet_gießen()
ansonsten wenn Aufgabe_Garten == "Rasen gießen"
Rasen_gießen()
ansonsten
# "unbekannte Aufgabe im Garten" ausgeben
Konsole.schreiben("unbekannte Aufgabe im Garten")

wenn erfüllt
# "Die Aufgabe im Garten wurde erledigt." ausgeben
Konsole.schreiben("Die Aufgabe im Garten wurde erledigt.")
# Aufgabe im Garten abarbeiten [Ende]

# Aufgabe_Küche definieren
Aufgabe_Küche = "Gläser spühlen"

# Aufgabe in der Küche abarbeiten [Start]
wenn Aufgabe_Küche == "Besteck spühlen"
Besteck_spühlen()
ansonsten wenn Aufgabe_Küche == "Gläser spühlen"
Gläser_spühlen()
ansonsten wenn Aufgabe_Küche == "Teller spühlen"
Teller_spühlen()
ansonsten wenn Aufgabe_Küche == nichts
# "Heute gibt es in der Küche nichts zu tun." ausgeben
Konsole.schreiben("Heute gibt es in der Küche nichts zu tun.")
ansonsten
# "unbekannte Aufgabe in der Küche" ausgeben
Konsole.schreiben("unbekannte Aufgabe in der Küche")

wenn erfüllt und (Aufgabe_Küche != nichts)
# "Die Aufgabe in der Küche wurde erledigt." ausgeben
Konsole.schreiben("Die Aufgabe in der Küche wurde erledigt.")
# Aufgabe in der Küche abarbeiten [Ende]

Definition

allgemein

Name: wenn
Beschreibung: Ermittelt zunächst, ob die Bedingung erfüllt ist:
Bedingung: Variablentyp:
Es handelt sich nicht um den Wert "0". Ganzzahl
Es handelt sich nicht um den Wert "0.0". Kommazahl
Die Liste enthält mindestens 1 Eintrag. Liste
Es handelt sich nicht um den Wert "nichts". Dies ist nie möglich. Nichtigkeitsangabe
Die Rohdatenkette enthält mindestens 1 Element. Rohdatenkette
Es handelt sich um den Wert "wahr". Wahrheitsangabe
Die Zeichenkette enthält mindestens 1 Zeichen. Zeichenkette

Wenn
  • die Bedingung erfüllt ist,
dann
  • wird der nachfolgende Codeblock ausgeführt.

    Anschließend wird das gesamte Konstrukt der bedingten Codeausführung verlassen. Es werden also
    • die nachfolgenden "ansonsten wenn"-Anweisungen garnicht mehr geprüft und
    • eine nachfolgende "ansonsten"-Anweisung wird ebenfalls ignoriert.
Ansonsten
  • wird der nachfolgende Codeblock nicht ausgeführt.

    Anschließend werden die Bedingungen von den nachfolgenden "ansonsten wenn"-Anweisungen geprüft.

Wenn
  • die Bedingung von
    • der "wenn"-Anweisung oder
    • irgendeiner "ansonsten wenn"-Anweisung
    erfüllt ist,
dann
  • wird die Variable "erfüllt" auf "wahr" gesetzt.
Ansonsten
  • wird die Variable "erfüllt" auf "falsch" gesetzt und
  • wird der Codeblock von der "ansonsten"-Anweisung ausgeführt, sofern eine "ansonsten"-Anweisung vorhanden ist.

Schreibweisen, welche zulässig sind

wenn:
  • Falls
  • falls
  • If
  • if
  • Wenn
  • wenn
ansonsten wenn:
  • ansonsten falls
  • Ansonsten falls
  • ansonsten wenn
  • Ansonsten wenn
  • ansonstenfalls
  • Ansonstenfalls
  • Ansonstenwenn
  • ansonstenwenn
  • Elif
  • elif
  • Else if
  • else if
  • Elseif
  • elseif
  • sonst falls
  • Sonst falls
  • Sonst wenn
  • sonst wenn
  • sonstfalls
  • Sonstfalls
  • Sonstwenn
  • sonstwenn
ansonsten:
  • ansonsten
  • Ansonsten
  • Else
  • else
  • sonst
  • Sonst

Syntax

Art: Ausdruck
Formen:
  • wenn wenn_-_Bedingung
    §wenn_-_Codeblock§
    /°ansonsten wenn ansonsten_wenn_-_Bedingung_-_1
    §ansonsten_wenn_-_Codeblock_-_1§
    /°ansonsten wenn ansonsten_wenn_-_Bedingung_-_2
    §ansonsten_wenn_-_Codeblock_-_2§
    /°ansonsten wenn ansonsten_wenn_-_Bedingung_-_3
    §ansonsten_wenn_-_Codeblock_-_3§
    /°...°/°/°/°/
    /°ansonsten
    §ansonsten_-_Codeblock§°/

Parameter

Eingabe
Anzahl: mindestens 2

wenn_-_Bedingung
Beispiel: (a > b)
Beschreibung: ein Wert, welcher geprüft werden soll, ob er etwas ist, und damit angibt, ob die Bedingung erfüllt ist
Standardwert: Für diesen Parameter muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

§wenn_-_Codeblock§
Beispiel: # "(a + b) ist nicht 0." ausgeben
Konsole.schreiben("(a + b) ist nicht 0.")
Beschreibung: Quellcode, welcher ausgeführt werden soll, wenn der Wert vom Parameter "wenn_-_Bedingung" etwas ist
Standardwert: Wenn
  • für diesen Parameter kein Quellcode übergeben wird,
dann
  • wird kein Quellcode verwendet.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern Quellcode
erwartet.

ansonsten_wenn_-_Bedingung_-_n
Beispiel: Anzahl_der_Versuche > 5
Beschreibung: Wenn
  • die obige(n) Bedingung(en) nicht erfüllt wurden,
dann
  • wird geprüft, ob der Wert von diesem Parameter etwas ist, und damit, ob die Bedingung erfüllt ist.
Standardwert: Wenn
  • eine "ansonsten wenn"-Anweisung verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

§ansonsten_wenn_-_Codeblock_-_n§
Beispiel: # '"Anzahl_der_Versuche" ist größer als 5.' ausgeben
Konsole.schreiben("\"Anzahl_der_Versuche\" ist größer als 5.")
Beschreibung: Quellcode, welcher ausgeführt werden soll, wenn der Wert vom Parameter "ansonsten_wenn_-_Bedingung_-_n" etwas ist
Standardwert: Wenn
  • für diesen Parameter kein Quellcode übergeben wird,
dann
  • wird kein Quellcode verwendet.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern Quellcode
erwartet.

§ansonsten_-_Codeblock§
Beispiel: # '(a + b) ist 0 und "Anzahl_der_Versuche" ist <= 5.' ausgeben
Konsole.schreiben("(a + b) ist 0 und \"Anzahl_der_Versuche\" ist <= 5.")
Beschreibung: Quellcode, welcher ausgeführt werden soll, wenn keine von den obigen Bedingungen erfüllt wurde
Standardwert: Wenn
  • für diesen Parameter kein Quellcode übergeben wird,
dann
  • wird kein Quellcode verwendet.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern Quellcode
erwartet.

Ausgabe
Anzahl: 1

erfüllt
Beispiel: wahr
Beschreibung: Mit der Hilfe von dieser Variable wird zurückgegeben, ob
  • die "wenn"-Bedingung oder
  • eine von den "ansonsten wenn"-Bedingungen
erfüllt wurde.
Schreibweisen,
welche zulässig sind:
  • erfüllt
  • met

Mit der Bezeichnung
  • "erfüllt" wird verkürzt "eine Bedingung wurde erfüllt" ausgedrückt.
  • "met" wird verkürzt "a condition is met" ausgedrückt.
Variablentypen,
welche für die Ausgabe verwendet werden:
  • Wahrheitsangabe

Anmerkungen

  • Dieser Code:
    wenn Bedingung_-_1
        # etwas Code
    ansonstenwenn Bedingung_-_2
        # anderer Code

    und dieser Code:
    wenn Bedingung_-_1
        # etwas Code
    ansonsten
        wenn Bedingung_-_2
            # anderer Code

    sind funktional identisch.

siehe auch


Funktionen

abbrechen

Beispiele

/*
Das manuelle Zurückkehren aus einer Funktion läuft ähnlich ab, wie bei einem
Funktionsaufruf. Zuvor wird jedoch die Funktion
    - mit oder
    - ohne
ihre
    - Ausgabe-Parameter und
    - Eingabe-Parameter
definiert. Bei einem Funktionsaufruf werden
    - die Eingabe-Parameter übergeben und
    - die Ausgabe-Parameter entgegen genommen.
Bei einem manuellen Zurückkehren werden lediglich die Ausgabe-Parameter übergeben.
Das "return", wie man es aus etlichen
    - Programmiersprachen und
    - Skriptsprachen
kennt, wird in Minicode vom Syntax her wie ein Funktionsaufruf verwendet. Es handelt
sich jedoch um keine Funktion im eigentlichen Sinn.
*/

Funktion meine_Funktion_0
    # etwas ausgeben
    Konsole.schreiben("Hallo Welt!")

    # Funktionsdurchlauf abbrechen
    kehre zurück

    # dies wird nie ausgegeben
    Konsole.schreiben("abc")

Funktion (Rückgabewert) = meine_Funktion_1
    # einen Kommazahl zurückgeben
    gib zurück(2.5)

Funktion (Text, Status) = meine_Funktion_2
    # Ausgangsparameterwerte zurückgeben
    zurückgeben(
        "Hallo Welt!",
        Status = wahr
    )

# Funktion aufrufen
(meine_Wahrheitsangabe = Status, meine_Zeichenkette) = meine_Funktion_2()

Funk (
    gelesene_Zeichenkette = none
) = meine_Funktion_3(
    Länge_in_Byte = 5
)
    /*
    Es kann auch das Ergebnis von einer anderen Funktion oder eine Variable
    zurückgegeben werden.
    */

    zurück(Konsole.lesen(Länge_in_Byte))

Definition

allgemein
Name: kehre zurück
Beschreibung: bricht den Funktionsdurchlauf am Ende von der Zeile ab und gibt gegebenenfalls die Ausgabe-Parameterwerte zurück

Schreibweisen, welche zulässig sind
  • gib zurück
  • kehre zurück
  • ret
  • return
  • zurück
  • zurückgeben
  • zurückkehren

Syntax
Art: Ausdruck
Formen: Wenn
  • die Klammern erforderlich sind,
dann
  • kehre zurück(/°
        /°Parameter_-_Ausgabe_-_1_-_Name = °/Parameter_-_Ausgabe_-_1_-_Wert/°
        /°Parameter_-_Ausgabe_-_2_-_Name = °/Parameter_-_Ausgabe_-_2_-_Wert/°
        /°Parameter_-_Ausgabe_-_3_-_Name = °/Parameter_-_Ausgabe_-_3_-_Wert/°
        ...°/°/°/°/
    )
ansonsten
  • kehre zurück/°(/°
        /°Parameter_-_Ausgabe_-_1_-_Name = °/Parameter_-_Ausgabe_-_1_-_Wert/°
        /°Parameter_-_Ausgabe_-_2_-_Name = °/Parameter_-_Ausgabe_-_2_-_Wert/°
        /°Parameter_-_Ausgabe_-_3_-_Name = °/Parameter_-_Ausgabe_-_3_-_Wert/°
        ...°/°/°/°/
    )°/

Anstatt den runden Klammern können auch die üblichen anderen Klammern verwendet werden ("[", "]", "{" und "}"). Es sollen die selben Klammern verwendet werden, wie bei der Definition von der Funktion für die Ausgabe-Parameter verwendet wurden.

Parameter
Eingabe
Anzahl: beliebig

Parameter_-_Ausgabe_-_n_-_Name
Beispiel: Summe
Beschreibung: eine von den zulässigen Bezeichnungen für diesen Ausgabeparameter
Standardwert: Wenn
  • für diesen Parameter keine Bezeichnung übergeben wird,
dann
  • wird der Parameter - wie bei einem Funktionsaufruf - ohne der Verwendung von einer Bezeichnung bestimmt.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern eine Bezeichnung für einen Parameter
erwartet.

Parameter_-_Ausgabe_-_n_-_Wert
Beispiel: berechnete_Summe
Beschreibung: ein Wert, welcher zurückgegeben werden soll
Standardwert: Die Antwort auf die Frage, ob ein Standardwert für diesen Parameter vorhanden ist, ergibt sich daraus, ob bei der Definition von der Funktion ein Standardwert für diesen Parameter angegeben wurde.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

definieren

Beispiele

Funktion meine_Funktion_1
# diese Funktion tut nichts

Funktion (zweckloser_Ausgabeparameter = 5) = meine_Funktion_2 = my_function_2(zweckloser_Eingabeparameter)
/°
diese Funktion läuft unter 2 verschiedenen Namen:
- "meine_Funktion_2" und
- "my_function_2"
°/

/*
Es ist insofern sinnvoll, Parameter mit definierten Standardwerten ans Ende zu setzen,
damit beim Funktionsaufruf der Standardwert genutzt werden kann, ohne dass die
Wertübergabe übersprungen werden muss. Die nachfolgende Funktion kann daher
folgendermaßen aufgerufen werden:
meine_Funktion_3("im Uhrzeigersinn")
anstatt dass ein Aufruf in dieser Form erforderlich ist:
meine_Funktion_3(, "im Uhrzeigersinn")

Ein weiterer Anwendungszweck davon, Parameter mit einem Standardwert ans Ende zu
setzen besteht darin, dass es hierdurch möglich wird, den Programmierer, welcher den
Quellcode lediglich liest, um den Ablauf nachvollziehen zu können, von einer Befassung
mit dem Parameter zu entlasten, da bei einem Funktionsaufruf der Parameter nicht
auftaucht. Dies kann die Komplexität vom Quellcode reduzieren.
*/

Funk () = meine_Funktion_3(
Richtung
Größe_in_Byte = Länge_in_Byte = 10
)
/*
Diese Funktion hat 2 Eingabeparameter. Der zweite Eingabeparameter läuft unter 2
verschiedenen Namen.

Wenn
- beim Aufrufen der Wert für den zweiten Parameter nicht aktiv übergeben wird,
dann
- erhält der Parameter automatisch den Standardwert "10".

Es gibt unter anderem die folgenden Möglichkeiten, die Funktion aufzurufen:
- meine_Funktion_3("im Uhrzeigersinn")
- meine_Funktion_3("im Uhrzeigersinn", 7)
- meine_Funktion_3("im Uhrzeigersinn", Größe_in_Byte = 7)
- meine_Funktion_3("im Uhrzeigersinn", Länge_in_Byte = 7)
- meine_Funktion_3(Richtung = "im Uhrzeigersinn", Länge_in_Byte = 7)
- meine_Funktion_3(Länge_in_Byte = 7, Richtung = "im Uhrzeigersinn")
- meine_Funktion_3(
Länge_in_Byte = 7
"im Uhrzeigersinn"
  )
*/

# Parameterwert ausgeben
Konsole.schreiben(Länge_in_Byte)

/*
Es ist möglich, dass mehrere Funktionen existieren, welche den selben Namen haben.
Dies ergibt beispielsweise dann Sinn, wenn diese Funktionen funktional praktisch
identisch sind, jedoch mit der Hilfe von verschiedenen Klammern ausgedrückt werden
soll, dass ein anderer Ausgabeparameter angefordert wird, oder dass ein anderer
Eingabeparameter übergeben wird. Es folgt ein Beispiel, bei welchem
    - sowohl die Ausgabeparameter,
    - als auch die Eingabeparameter
besonders gekennzeichnet sind.
*/

Funktion (
Schlüssel
Wert
} = einen_Eintrag_suchen(
Liste
Index
]
...

Funktion [
Index
Wert
} = einen_Eintrag_suchen(
Liste
Schlüssel
)
...

Funktion [
Index
Schlüssel
) = einen_Eintrag_suchen(
Liste
Wert
}
...

/*
Auf diese Weise sind bis zu 81 verschiedene Funktionen mit dem gleichen Namen möglich.

Wenn
- mehrere Funktionen mit dem selben Namen existieren und
- eine von diesen Funktionen aufgerufen werden soll,
dann
- müssen die entsprechenden Klammern gesetzt werden,
  unabhängig davon, ob Parameter übergeben werden,
  um die Funktion eindeutig zu benennen.
*/

Definition

allgemein
Name: Funktion
Beschreibung: definiert eine Funktion

Schreibweisen, welche zulässig sind
  • func
  • function
  • Funk
  • Funktion

Syntax
Art: Ausdruck und Konstrukt
Formen: Wenn
  • die Klammern nicht erforderlich sind,
dann
  • Funktion /°() = °/Funktion_-_Name_-_1/° = Funktion_-_Name_-_2°//° = Funktion_-_Name_-_3°//° = ...°//°()°//°
    §Codeblock§°/
ansonsten wenn
  • die Klammern für die Ausgabeparameter erforderlich sind,
dann
  • Funktion (/°
    /°Parameter_-_Ausgabe_-_1_-_Name_-_1°//° = Parameter_-_Ausgabe_-_1_-_Name_-_2°//° = Parameter_-_Ausgabe_-_1_-_Name_-_3°//° = ...°//° = Parameter_-_Ausgabe_-_1_-_Standardwert°//°
    /°Parameter_-_Ausgabe_-_2_-_Name_-_1°//° = Parameter_-_Ausgabe_-_2_-_Name_-_2°//° = Parameter_-_Ausgabe_-_2_-_Name_-_3°//° = ...°//° = Parameter_-_Ausgabe_-_2_-_Standardwert°//°
    /°Parameter_-_Ausgabe_-_3_-_Name_-_1°//° = Parameter_-_Ausgabe_-_3_-_Name_-_2°//° = Parameter_-_Ausgabe_-_3_-_Name_-_3°//° = ...°//° = Parameter_-_Ausgabe_-_3_-_Standardwert°//°
    ...
    °/°/°/°/) = Funktion_-_Name_-_1/° = Funktion_-_Name_-_2°//° = Funktion_-_Name_-_3°//° = ...°//°()°//°
    §Codeblock§°/
ansonsten wenn
  • die Klammern für die Eingabeparameter erforderlich sind,
dann
  • Funktion /°() = °/Funktion_-_Name_-_1/° = Funktion_-_Name_-_2°//° = Funktion_-_Name_-_3°//° = ...°/(/°
    Parameter_-_Eingabe_-_1_-_Name_-_1/° = Parameter_-_Eingabe_-_1_-_Name_-_2°//° = Parameter_-_Eingabe_-_1_-_Name_-_3°//° = ...°//° = Parameter_-_Eingabe_-_1_-_Standardwert°//°
    Parameter_-_Eingabe_-_2_-_Name_-_1/° = Parameter_-_Eingabe_-_2_-_Name_-_2°//° = Parameter_-_Eingabe_-_2_-_Name_-_3°//° = ...°//° = Parameter_-_Eingabe_-_2_-_Standardwert°//°
    Parameter_-_Eingabe_-_3_-_Name_-_1/° = Parameter_-_Eingabe_-_3_-_Name_-_2°//° = Parameter_-_Eingabe_-_3_-_Name_-_3°//° = ...°//° = Parameter_-_Eingabe_-_3_-_Standardwert°//°
    ...
    °/°/°/°/)/°
    §Codeblock§°/
ansonsten wenn
  • die Klammern für beide Parametertypen erforderlich sind,
dann
  • Funktion (/°
    /°Parameter_-_Ausgabe_-_1_-_Name_-_1°//° = Parameter_-_Ausgabe_-_1_-_Name_-_2°//° = Parameter_-_Ausgabe_-_1_-_Name_-_3°//° = ...°//° = Parameter_-_Ausgabe_-_1_-_Standardwert°//°
    /°Parameter_-_Ausgabe_-_2_-_Name_-_1°//° = Parameter_-_Ausgabe_-_2_-_Name_-_2°//° = Parameter_-_Ausgabe_-_2_-_Name_-_3°//° = ...°//° = Parameter_-_Ausgabe_-_2_-_Standardwert°//°
    /°Parameter_-_Ausgabe_-_3_-_Name_-_1°//° = Parameter_-_Ausgabe_-_3_-_Name_-_2°//° = Parameter_-_Ausgabe_-_3_-_Name_-_3°//° = ...°//° = Parameter_-_Ausgabe_-_3_-_Standardwert°//°
    ...
    °/°/°/°/) = Funktion_-_Name_-_1/° = Funktion_-_Name_-_2°//° = Funktion_-_Name_-_3°//° = ...°/(/°
    Parameter_-_Eingabe_-_1_-_Name_-_1/° = Parameter_-_Eingabe_-_1_-_Name_-_2°//° = Parameter_-_Eingabe_-_1_-_Name_-_3°//° = ...°//° = Parameter_-_Eingabe_-_1_-_Standardwert°//°
    Parameter_-_Eingabe_-_2_-_Name_-_1/° = Parameter_-_Eingabe_-_2_-_Name_-_2°//° = Parameter_-_Eingabe_-_2_-_Name_-_3°//° = ...°//° = Parameter_-_Eingabe_-_2_-_Standardwert°//°
    Parameter_-_Eingabe_-_3_-_Name_-_1/° = Parameter_-_Eingabe_-_3_-_Name_-_2°//° = Parameter_-_Eingabe_-_3_-_Name_-_3°//° = ...°//° = Parameter_-_Eingabe_-_3_-_Standardwert°//°
    ...
    °/°/°/°/)/°
    §Codeblock§°/

Anstatt den runden Klammern können auch die üblichen anderen Klammern verwendet werden ("[", "]", "{" und "}").
Anmerkungen: Als Trennzeichen zwischen den einzelnen Parametern kann
  • sowohl ein Zeilenumbruch,
  • als auch ein Komma,
  • als auch beides
verwendet werden.

Die kommalose Form hat den Vorteil, dass nach einem Ändern von der Parameterreihenfolge die Kommas nicht korrigiert werden müssen. Beispiel für das Problem:
vorher: nach der Neuanordnung: nach der Komma-Korrektur:
meine_Funktion(
Parameter_-_Eingabe_-_a = 7,
Parameter_-_Eingabe_-_c = 10,
Parameter_-_Eingabe_-_b = 5
) 		meine_Funktion(
Parameter_-_Eingabe_-_a = 7,
Parameter_-_Eingabe_-_b = 5
Parameter_-_Eingabe_-_c = 10,
) 		meine_Funktion(
Parameter_-_Eingabe_-_a = 7,
Parameter_-_Eingabe_-_b = 5,
Parameter_-_Eingabe_-_c = 10
)

Beispiel für die kommalose Form:
vorher: nach der Neuanordnung:
meine_Funktion(
Parameter_-_Eingabe_-_a = 7
Parameter_-_Eingabe_-_c = 10
Parameter_-_Eingabe_-_b = 5
) 		meine_Funktion(
Parameter_-_Eingabe_-_a = 7
Parameter_-_Eingabe_-_b = 5
Parameter_-_Eingabe_-_c = 10
)

Eine entsprechende Änderung kann
  • sowohl beim Aufrufen,
  • als auch beim Definieren
von einer Funktion gewünscht sein.

Parameter
Eingabe
Anzahl:
  mindestens 1 (Funktion_-_Name_-_n)
+ beliebig (Parameter_-_Ausgabe_-_n_-_Name_-_n)
+ beliebig (Parameter_-_Ausgabe_-_n_-_Standardwert)
+ beliebig (Parameter_-_Eingabe_-_n_-_Name_-_n)
+ beliebig (Parameter_-_Eingabe_-_n_-_Standardwert)
+ 0 oder 1 (§Codeblock§)

Funktion_-_Name_-_n
Beispiel: Summe_bilden
Beschreibung: eine Bezeichnung dafür, welche Aufgabe die Funktion erfüllt
Standardwert: Für den Parameter "Funktion_-_Name_-_0" muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern eine Bezeichnung für die Funktion
erwartet.

Parameter_-_Ausgabe_-_n_-_Name_-_n
Beispiel: Summe
Beschreibung: eine Bezeichnung für einen Ausgabeparameter, welchen die Funktion beim Zurückkehren zurückgeben kann
Standardwert: Wenn
  • für diesen Parameter keine Bezeichnung übergeben wird,
dann
  • kann der Parameter bei der Entgegennahme von den Werten nicht anhand von einer Bezeichnung bestimmt werden.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern eine Bezeichnung für einen Parameter
erwartet.

Parameter_-_Ausgabe_-_n_-_Standardwert
Beispiel: 6
Beschreibung: ein Wert, welcher für den Ausgabeparameter verwendet werden soll, wenn beim Zurückkehren kein Wert zurückgegeben wird
Standardwert: Wenn
  • für diesen Parameter kein Wert übergeben wird,
dann
  • wird für den Parameter "Parameter_-_Ausgabe_-_n" kein Standardwert verwendet.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

Parameter_-_Eingabe_-_n_-_Name_-_n
Beispiel: Einzelwerte
Beschreibung: eine Bezeichnung für einen Eingabeparameter, welcher der Funktion beim Aufrufen übergeben werden kann
Standardwert: Wenn
  • dieser Parameter verwendet werden soll,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern eine Bezeichnung für einen Parameter
erwartet.

Parameter_-_Eingabe_-_n_-_Standardwert
Beispiel: <1, 2, 3>
Beschreibung: ein Wert, welcher für den Eingabeparameter verwendet werden soll, wenn beim Aufrufen kein Wert übergeben wird
Standardwert: Wenn
  • für diesen Parameter kein Wert übergeben wird,
dann
  • wird für den Parameter "Parameter_-_Eingabe_-_n" kein Standardwert verwendet.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

§Codeblock§
Beispiel: # "berechnete_Summe" definieren
berechnete_Summe = 0

# Summe berechnen
durchlaufe Einzelwerte als Einzelwert
berechnete_Summe += Einzelwert

# berechnete Summe zurückgeben
gib zurück(Summe = berechnete_Summe)
Beschreibung: Quellcode, welcher jedes mal ausgeführt werden soll, wenn die Funktion aufgerufen wurde
Standardwert: Wenn
  • für diesen Parameter kein Quellcode übergeben wird,
dann
  • wird kein Quellcode verwendet.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern Quellcode
erwartet.

Klassen

Beispiele

Klasse meine_Klasse_-_1
/*
Dieser Code wird jedes mal ausgeführt, wenn eine Instanz von der Klasse erzeugt wird.
*/

# Meldung ausgeben
Konsole.schreiben("Eine Instanz wurde erzeugt.")

Klasse meine_Klasse_-_2 = my_class_-_2(Parameterwert_für_die_Initialisierungsroutine = "Eine Instanz wurde erzeugt.")
/*
Diese Klasse läuft unter 2 verschiedenen Namen. Die Initialisierungsroutine hat 1
Parameter. Wenn
- eine Instanz erzeugt wird,
dann
- kann der Initialisierungsroutine ein Parameterwert übergeben werden.
*/

# den Parameterwert ausgeben
Konsole.schreiben(Parameterwert_für_die_Initialisierungsroutine)

# den Parameterwert als ein Ding von der Instanz speichern
diese.Parameterwert_für_die_Initialisierungsroutine = Parameterwert_für_die_Initialisierungsroutine

Funktion eine_Funktion_mit_Parameter(meine_Zahl)
# (meine_Zahl * 5) ausgeben
Konsole.schreiben(meine_Zahl * 5)

# "Hallo Welt!" ausgeben
diese.eine_Funktion_ohne_Parameter()

Funktion eine_Funktion_ohne_Parameter()
# "Hallo Welt!" ausgeben
Konsole.schreiben("Hallo Welt!")

Funktion Parameterwert_erneut_ausgeben()
# Parameterwert_für_die_Initialisierungsroutine ausgeben
Konsole.schreiben(this.Parameterwert_für_die_Initialisierungsroutine)

Klasse meine_Klasse_-_3()
/*
Wenn
- eine Instanz von dieser Klasse erzeugt wird,
dann
- erhält die Instanz alle Dinge von der Klasse "meine_Klasse_-_2".

Zunächst wird die Initialisierungsroutine von dieser Klasse ausgeführt. Die
Ausführung wird allerdings beim Erreichen von der "übernehmen"-Anweisung unterbrochen,
um
- die Dinge zu übernehmen und
- die Initialisierungsroutine von der Klasse "meine_Klasse_-_2" auszuführen.

Durch das Übernehmen von Dingen von einer anderen Klasse gehen die Dinge von dieser
Klasse nicht verloren - es sei denn, es besteht ein Ding mit dem selben Namen, da
in diesem Fall dieses Ding überschrieben wird.
*/

# "Hallo Zelt!" ausgeben
diese.eine_Funktion_ohne_Parameter()

diese.übernehmen(meine_Klasse_-_2("Von der Klasse \"meine_Klasse_-_2\" wurde eine Instanz erzeugt."))

# "Hallo Welt!" ausgeben
diese.eine_Funktion_ohne_Parameter()

Funktion eine_Funktion_ohne_Parameter()
# "Hallo Zelt!" ausgeben
Konsole.schreiben("Hallo Zelt!")

# eine Instanz von der Klasse "meine_Klasse_-_3" erzeugen
# hierdurch wird wegen der Anweisung in der Initialisierungsroutine
# indirekt auch eine Instanz von der Klasse "meine_Klasse_-_2" erzeugt
meine_Instanz_von_meine_Klasse_-_3 = meine_Klasse_-_3()

# einen Wert speichern, welcher zu einem Teil von der Instanz wird
meine_Instanz_von_meine_Klasse_-_3.ein_Wert = 8

# eine Funktion aufrufen
meine_Instanz_von_meine_Klasse_-_3.eine_Funktion_mit_Parameter(meine_Instanz_von_meine_Klasse_-_3.ein_Wert)

Definition

allgemein

Name: Klasse
Beschreibung: Definiert eine Klasse, also eine Gruppe von Dingen.

Ein Ding ist
  • eine Funktion,
  • eine Konstante oder
  • eine Variable.

Schreibweisen, welche zulässig sind

diese:
  • diese
  • selbst
  • self
  • this
Klasse:
  • class
  • Klasse
übernehmen:
  • adopt
  • adoptieren
  • erben
  • inherit
  • übernehmen

Syntax

Art: Ausdruck und Konstrukt
Formen:
  • Klasse Klasse_-_Name_-_1/° = Klasse_-_Name_-_2°//° = Klasse_-_Name_-_3°//° = ...°//°(/°
    Initialisierungsroutine_-_Parameter_-_1_-_Name_-_1/° = Initialisierungsroutine_-_Parameter_-_1_-_Name_-_2°//° = Initialisierungsroutine_-_Parameter_-_1_-_Name_-_3°//° = ...°//° = Initialisierungsroutine_-_Parameter_-_1_-_Standardwert°//°
    Initialisierungsroutine_-_Parameter_-_2_-_Name_-_1/° = Initialisierungsroutine_-_Parameter_-_2_-_Name_-_2°//° = Initialisierungsroutine_-_Parameter_-_2_-_Name_-_3°//° = ...°//° = Initialisierungsroutine_-_Parameter_-_2_-_Standardwert°//°
    Initialisierungsroutine_-_Parameter_-_3_-_Name_-_1/° = Initialisierungsroutine_-_Parameter_-_3_-_Name_-_2°//° = Initialisierungsroutine_-_Parameter_-_3_-_Name_-_3°//° = ...°//° = Initialisierungsroutine_-_Parameter_-_3_-_Standardwert°//°
    ...°/°/°/°/
    )°//°
    §Codeblock§°/
Anmerkungen: Als Trennzeichen zwischen den einzelnen Parametern kann
  • sowohl ein Zeilenumbruch,
  • als auch ein Komma,
  • als auch beides
verwendet werden.

Die kommalose Form hat den Vorteil, dass nach einem Ändern von der Parameterreihenfolge die Kommas nicht korrigiert werden müssen. Beispiel: siehe hier

Parameter

Eingabe
Anzahl:
  mindestens 1 (Klasse_-_Name_-_n)
+ beliebig (Initialisierungsroutine_-_Parameter_-_n_-_Name_-_n)
+ beliebig (Initialisierungsroutine_-_Parameter_-_n_-_Standardwert)
+ 0 oder 1 (§Codeblock§)

Klasse_-_Name_-_n
Beispiel: Physik
Beschreibung: eine Bezeichnung für die Klasse, also die Gruppe von Dingen
Standardwert: Für den Parameter "Klasse_-_Name_-_0" muss ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern eine Bezeichnung für die Klasse
erwartet.

Initialisierungsroutine_-_Parameter_-_n_-_Name_-_n
Beispiel: Außendruck
Beschreibung: eine Bezeichnung für einen Parameter, welcher der Initialisierungsroutine von der Klasse beim Erzeugen von einer Instanz übergeben wird
Standardwert: Wenn
  • dieser Parameter verwendet werden soll,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern eine Bezeichnung für einen Parameter
erwartet.

Initialisierungsroutine_-_Parameter_-_n_-_Standardwert
Beispiel: 1.0
Beschreibung: ein Wert, welcher für den Parameter verwendet werden soll, wenn beim Erzeugen von einer Instanz kein Wert übergeben wird
Standardwert: Wenn
  • für diesen Parameter kein Wert übergeben wird,
dann
  • wird für den Parameter "Initialisierungsroutine_-_Parameter_-_n" kein Standardwert verwendet.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

§Codeblock§
Beispiel: # "Hallo Welt!" ausgeben
Konsole.schreiben("Hallo Welt!")
Beschreibung: Quellcode für die Initialisierungsroutine. Sie wird jedes mal ausgeführt, wenn eine Instanz von der Klasse erzeugt wird.
Standardwert: Wenn
  • für diesen Parameter kein Quellcode übergeben wird,
dann
  • wird kein Quellcode verwendet.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern Quellcode
erwartet.

Kommentare

Block

Beispiele

/*
Ich bin ein Blockkommentar.
Ich kann also über mehrere Zeilen verlaufen
    - um etwas ausführlich zu beschreiben oder
    - um mehrere Zeilen Code auszukommentieren.
*/

/* Ich kann auch als Zeilenkommentar benutzt werden. */

/* Ich kann auch /* verschachtelt */ auftauchen. */

Definition

allgemein
Name: Blockkommentar
Beschreibung: ein "Blockkommentar", also ein Kommentar, welches über mehrere Zeilen laufen kann

Syntax
Art: Bereich mit einer speziellen Funktion
Formen:
  • /*/°Kommentartext°/*/

Parameter
Eingabe
Anzahl: 0 oder 1

Kommentartext
Beispiel: Autor:        ich
Beschreibung: alle LEDs 3 mal blinken lassen
Version:      1.0.0
Beschreibung: der Text, welcher als Kommentar dienen soll
Standardwert: Wenn
  • für diesen Parameter kein Wert übergeben wird,
dann
  • wird für das Kommentar kein Kommentartext verwendet.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern ein Kommentartext
erwartet.

Zeile

Beispiele

# Ich bin ein Zeilenkommentar.

# Ich kann auch als
# Blockkommentar benutzt werden.

## mehrere Raute-Zeichen ("#") in der selben Zeile bewirken nicht, dass das Kommentar auskommentiert wird, oder dass es vor dem Zeilenende endet

Definition

allgemein
Name: Zeilenkommentar
Beschreibung: ein "Zeilenkommentar", also ein Kommentar, welches beim Raute-Zeichen ("#") beginnt und am Ende von der Zeile automatisch endet

Syntax
Art: Bereich mit einer speziellen Funktion
Formen:
  • #/°Kommentartext°/

Parameter
Eingabe
Anzahl: 0 oder 1

Kommentartext
Beispiel: Temperatur ausgeben
Beschreibung: der Text, welcher als Kommentar dienen soll
Standardwert: Wenn
  • für diesen Parameter kein Wert übergeben wird,
dann
  • wird für das Kommentar kein Kommentartext verwendet.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern ein Kommentartext
erwartet.

Operatoren

Addition (Plus rechnen)

Beispiele

# zurückgebende Form [Start]
# den Wert "7" als Ergebnis speichern
Ergebnis = 5 + 2

# den Wert "6" als Ergebnis speichern
Ergebnis = 5 + wahr

# den Wert "5" als Ergebnis speichern
Ergebnis = 5 + falsch
# zurückgebende Form [Ende]

# speichernde Formen [Start]
# =+ [Start]
/*
Die Operation
- "Ergebnis =+ Wert"
entspricht der Operation
- "Ergebnis = Ergebnis + Wert".
*/

# den Wert "5" in der Variable "Ergebnis" speichern
Ergebnis = 5

# den Wert "2" hinzuaddieren, so dass anschließend die Summe "7" gespeichert ist
Ergebnis =+ 2

# den Wert "wahr" hinzuaddieren, so dass anschließend die Summe "8" gespeichert ist
Ergebnis =+ wahr

# den Wert "falsch" hinzuaddieren, so dass anschließend die Summe "8" gespeichert ist
Ergebnis =+ falsch
# =+ [Ende]

# += [Start]
/*
Die Operation
- "Ergebnis += Wert"
entspricht der Operation
- "Ergebnis = Wert + Ergebnis".
*/

/*
Bei diesem Operator sind beide speichernden Formen
- "=+" und
- "+="
funktional identisch.
*/

# den Wert "5" in der Variable "Ergebnis" speichern
Ergebnis = 5

# zum Wert "2" den Wert aus der Variable "Ergebnis" hinzuaddieren; anschließend die Summe "7" in der Variable "Ergebnis" speichern
Ergebnis += 2

# zum Wert "wahr" den Wert aus der Variable "Ergebnis" hinzuaddieren; anschließend die Summe "8" in der Variable "Ergebnis" speichern
Ergebnis += wahr

# zum Wert "falsch" den Wert aus der Variable "Ergebnis" hinzuaddieren; anschließend die Summe "8" in der Variable "Ergebnis" speichern
Ergebnis += falsch
# += [Ende]
# speichernde Formen [Ende]

Definition

allgemein
Name: +
Beschreibung: addiert 2 Werte miteinander und
  • speichert das Ergebnis oder
  • gibt das Ergebnis zurück

Schreibweisen, welche zulässig sind
addieren:
  • add
  • addieren
  • Plus_rechnen
+:
  • +
  • add
  • addieren
  • Plus_rechnen
+=:
  • +=
  • add=
  • addieren=
  • Plus_rechnen=
=+:
  • =+
  • =add
  • =addieren
  • =Plus_rechnen

Syntax
zurückgebende Form
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.addieren(
    Wert_-_primärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion zurückgebend wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "falsch" übergeben werden.
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.addieren(
    Wert_-_sekundärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion zurückgebend wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "falsch" übergeben werden.
  • Wert_-_primärer + Wert_-_sekundärer

speichernde Form "+="
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.addieren(
    Wert_-_primärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion speichernd wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "wahr" übergeben werden.
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer += Wert_-_primärer

speichernde Form "=+"
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.addieren(
    Wert_-_sekundärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion speichernd wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "wahr" übergeben werden.
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer =+ Wert_-_sekundärer

Parameter
Eingabe
Anzahl: 1 bis 2

Wert_-_primärer
Beispiel: 5
Beschreibung: Mit der Hilfe von diesem Parameter wird der Anfangswert übergeben, zu welchem der Aufschlag hinzuaddiert werden soll.

Unabhängig von der verwendeten Form wird das Ergebnis nie in diesem Parameter gespeichert.
Schreibweisen,
welche zulässig sind:
  • Anfangswert
  • primary_value
  • primärer_Wert
  • Primärwert
  • start_value
  • Startwert
  • value_-_beginning
  • value_-_primary
  • value_-_start
  • Wert_-_Anfang
  • Wert_-_primärer
  • Wert_-_Start
Standardwert: Wenn
  • ein Funktionsaufruf verwendet wird,
dann
  • muss
    • entwerder für den Parameter "Wert_-_primärer"
    • oder für den Parameter "Wert_-_sekundärer"
    ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "+" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "+=" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "=+" verwendet wird,
dann
  • darf für diesen Parameter kein Wert übergeben werden, da er nicht zur Verfügung steht.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Nichtigkeitsangabe
  • Wahrheitsangabe

Wert_-_sekundärer
Beispiel: 2
Beschreibung: Mit der Hilfe von diesem Parameter wird der Aufschlag übergeben, welcher zum Anfangswert hinzuaddiert werden soll.

Unabhängig von der verwendeten Form wird das Ergebnis nie in diesem Parameter gespeichert.
Schreibweisen,
welche zulässig sind:
  • addend
  • Aufschlag
  • secondary_value
  • sekundärer_Wert
  • Sekundärwert
  • value_-_secondary
  • Wert_-_sekundärer
  • Zusatz
Standardwert: Wenn
  • ein Funktionsaufruf verwendet wird,
dann
  • muss
    • entwerder für den Parameter "Wert_-_primärer"
    • oder für den Parameter "Wert_-_sekundärer"
    ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "+" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "+=" verwendet wird,
dann
  • darf für diesen Parameter kein Wert übergeben werden, da er nicht zur Verfügung steht.
Ansonsten wenn
  • der Operator "=+" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Nichtigkeitsangabe
  • Wahrheitsangabe

Ergebnis_speichern
Beispiel: falsch
Beschreibung: Mit der Hilfe von diesem Parameter wird angegeben, ob das Ergebnis
  • 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 "wahr" verwendet.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

Eingabe und Ausgabe
Anzahl: 0 oder 1

Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer
Beispiel: 5
Beschreibung: Wenn
  • ein Funktionsaufruf verwendet wird und
  • der Parameter "Wert_-_primärer" definiert wurde,
dann
  • wird mit der Hilfe von diesem Parameter der sekundäre Wert übergeben.
Ansonsten wenn
  • ein Funktionsaufruf verwendet wird und
  • der Parameter "Wert_-_sekundärer" definiert wurde,
dann
  • wird mit der Hilfe von diesem Parameter der primäre Wert übergeben.
Ansonsten wenn
  • der Operator "+" verwendet wird,
dann
  • steht dieser Parameter nicht zur Verfügung.
Ansonsten wenn
  • der Operator "+=" verwendet wird,
dann
  • wird mit der Hilfe von diesem Parameter der sekundäre Wert übergeben und
  • dient dieser Parameter auch als Ausgabeparameter, um das Ergebnis zu speichern.
Ansonsten wenn
  • der Operator "=+" verwendet wird,
dann
  • wird mit der Hilfe von diesem Parameter der primäre Wert übergeben und
  • dient dieser Parameter auch als Ausgabeparameter, um das Ergebnis zu speichern.
Standardwert: Wenn
  • dieser Parameter zur Verfügung steht,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Nichtigkeitsangabe
  • Wahrheitsangabe
Variablentypen,
welche für die Ausgabe verwendet werden:
  • Ganzzahl
  • Kommazahl

siehe auch

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

Anhängung

Beispiele

# zurückgebende Form [Start]
# "Hallo " und "Welt!" zu "Hallo Welt!" verketten und dann ausgeben
Konsole.schreiben("Hallo " & "Welt!")

# eine Liste definieren
Liste_Anfang = <
"a" : 1
"b" : 2
"c" : 3
>

# eine weitere Liste definieren
Liste_Ende = <
"d" : 1
"b" : 22
"e" : 4
>

/*
Die beiden Listen verketten und diese neue Liste erzeugen:

<
"a" : 1
"b" : 22
"c" : 3
"d" : 1
"e" : 4
>
*/
Liste_Gesamt = Liste_Anfang & Liste_Ende

# aus 2 Variablen von unterschiedlichen Typen den neuen Wert "16 Bundesländer" vom Variablentyp "Zeichenkette" erzeugen
Zeichenkette_Gesamt = 16 & " Bundesländer"
# zurückgebende Form [Ende]

# speichernde Formen [Start]
# =& [Start]
# die Zeichenkette "Hallo " in der Variable "Ergebnis" speichern
Ergebnis = "Hallo "

# die Zeichenkette "Welt!" ans Ende anhängen, sodass anschließend die Zeichenkette "Hallo Welt!" in der Variable "Ergebnis" gespeichert ist
Ergebnis =& "Welt!"

# eine Liste definieren
Liste_Gesamt = <
"a" : 1
"b" : 2
"c" : 3
>

# eine weitere Liste definieren
Liste_Ende = <
"d" : 1
"b" : 22
"e" : 4
>

/*
Die beiden Listen verketten, sodass diese Liste entsteht:

<
"a" : 1
"b" : 22
"c" : 3
"d" : 1
"e" : 4
>
*/
Liste_Gesamt =& Liste_Ende
# =& [Ende]

# &= [Start]
# die Zeichenkette "Welt!" in der Variable "Ergebnis" speichern
Ergebnis = "Welt!"

# die Zeichenkette "Hallo " an den Anfang anhängen, sodass anschließend die Zeichenkette "Hallo Welt!" in der Variable "Ergebnis" gespeichert ist
Ergebnis &= "Hallo "

# eine Liste definieren
Liste_Gesamt = <
"a" : 1
"b" : 2
"c" : 3
>

# eine weitere Liste definieren
Liste_Anfang = <
"d" : 1
"b" : 22
"e" : 4
>

/*
Die beiden Listen verketten, sodass diese Liste entsteht:

<
"d" : 1
"b" : 2
"e" : 4
"a" : 1
"c" : 3
>
*/
Liste_Gesamt &= Liste_Anfang
# &= [Ende]
# speichernde Formen [Ende]

Definition

allgemein
Name: &
Beschreibung: Erzeugt einen Wert, welcher eine Hintereinanderhängung von beiden Parameterwerten ist. Es wird kein Trennzeichen zwischen die beiden Parameterwerte eingefügt. Der
  • primäre Parameterwert wird am Anfang platziert.
  • sekundäre Parameterwert wird am Ende platziert.

Bei der
  • zurückgebenden Form "Wert_-_Anfang & Wert_-_Ende" ist
    • der linke Wert "Wert_-_Anfang" der primäre Parameterwert.
    • der rechte Wert "Wert_-_Ende" der sekundäre Parameterwert.
  • speichernden Form "Ergebnis =& Wert_-_Ende" ist
    • der linke Wert "Ergebnis" der primäre Parameterwert.
    • der rechte Wert "Wert_-_Ende" der sekundäre Parameterwert.
  • speichernden Form "Ergebnis &= Wert_-_Anfang" ist
    • der linke Wert "Ergebnis" der sekundäre Parameterwert.
    • der rechte Wert "Wert_-_Anfang" der primäre Parameterwert.

Es gibt folgende Kombinationsmöglichkeiten:
Variablentyp vom primären Wert: Variablentyp vom sekundären Wert: Variablentyp vom neu erzeugten Wert:
Ganzzahl Ganzzahl Zeichenkette
Kommazahl Zeichenkette
Liste - nicht kombinierbar -
Nichtigkeitsangabe Zeichenkette
Rohdatenkette Rohdatenkette
Wahrheitsangabe Zeichenkette
Zeichenkette Zeichenkette
Kommazahl Ganzzahl Zeichenkette
Kommazahl Zeichenkette
Liste - nicht kombinierbar -
Nichtigkeitsangabe Zeichenkette
Rohdatenkette Rohdatenkette
Wahrheitsangabe Zeichenkette
Zeichenkette Zeichenkette
Liste Ganzzahl - nicht kombinierbar -
Kommazahl - nicht kombinierbar -
Liste Liste
Nichtigkeitsangabe - nicht kombinierbar -
Rohdatenkette - nicht kombinierbar -
Wahrheitsangabe - nicht kombinierbar -
Zeichenkette - nicht kombinierbar -
Nichtigkeitsangabe Ganzzahl Zeichenkette
Kommazahl Zeichenkette
Liste - nicht kombinierbar -
Nichtigkeitsangabe Zeichenkette
Rohdatenkette Rohdatenkette
Wahrheitsangabe Zeichenkette
Zeichenkette Zeichenkette
Rohdatenkette Ganzzahl Rohdatenkette
Kommazahl Rohdatenkette
Liste - nicht kombinierbar -
Nichtigkeitsangabe Rohdatenkette
Rohdatenkette Rohdatenkette
Wahrheitsangabe Rohdatenkette
Zeichenkette Rohdatenkette
Wahrheitsangabe Ganzzahl Zeichenkette
Kommazahl Zeichenkette
Liste - nicht kombinierbar -
Nichtigkeitsangabe Zeichenkette
Rohdatenkette Rohdatenkette
Wahrheitsangabe Zeichenkette
Zeichenkette Zeichenkette
Zeichenkette Ganzzahl Zeichenkette
Kommazahl Zeichenkette
Liste - nicht kombinierbar -
Nichtigkeitsangabe Zeichenkette
Rohdatenkette Rohdatenkette
Wahrheitsangabe Zeichenkette
Zeichenkette Zeichenkette

Wenn
  • beide Parameter vom Variablentyp "Liste" sind,
dann gilt das Folgende:
Wenn
  • ein Schlüssel aus der Liste vom sekundären Parameter bereits in der Liste vom primären Parameter existiert,
dann
  • erhält der Eintrag in der neuen Liste
    • die selbe Position, wie er in der Liste vom primären Parameter hat, und
    • den Wert aus der Liste vom sekundären Parameter.
Ansonsten
  • wird der Eintrag aus der Liste vom sekundären Parameter ans Ende von der neuen Liste angehängt.

Schreibweisen, welche zulässig sind
anhängen:
  • anfügen
  • anhängen
  • anschließen
  • append
  • erweitern
  • extend
  • fuse
  • fusionieren
  • hinzufügen
  • join
  • merge
  • verbinden
  • zusammenfügen
&:
  • &
  • anfügen
  • anhängen
  • anschließen
  • append
  • erweitern
  • extend
  • fuse
  • fusionieren
  • hinzufügen
  • join
  • merge
  • verbinden
  • zusammenfügen
&=:
  • &=
  • anfügen=
  • anhängen=
  • anschließen=
  • append=
  • erweitern=
  • extend=
  • fuse=
  • fusionieren=
  • hinzufügen=
  • join=
  • merge=
  • verbinden=
  • zusammenfügen=
=&:
  • =&
  • =anfügen
  • =anhängen
  • =anschließen
  • =append
  • =erweitern
  • =extend
  • =fuse
  • =fusionieren
  • =hinzufügen
  • =join
  • =merge
  • =verbinden
  • =zusammenfügen

Syntax
zurückgebende Form
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert_-_Anfang_oder_Wert_-_Ende.anhängen(
    Wert_-_Ende
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion zurückgebend wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "falsch" übergeben werden.
  • Wert_-_Anfang & Wert_-_Ende

speichernde Form "&="
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert_-_Anfang_oder_Wert_-_Ende.anhängen(
    Wert_-_Anfang
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion speichernd wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "wahr" übergeben werden.
  • Ergebnis_oder_Wert_-_Anfang_oder_Wert_-_Ende &= Wert_-_Anfang

speichernde Form "=&"
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert_-_Anfang_oder_Wert_-_Ende.anhängen(
    Wert_-_Ende
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion speichernd wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "wahr" übergeben werden.
  • Ergebnis_oder_Wert_-_Anfang_oder_Wert_-_Ende =& Wert_-_Ende

Parameter
Eingabe
Anzahl: 1 bis 2

Wert_-_Anfang
Beispiel: "Bodensee:"
Beschreibung: Mit der Hilfe von diesem Parameter wird der primäre Wert übergeben. Dies ist also jener Wert, welcher im neuen Wert am Anfang platziert wird.

Unabhängig von der verwendeten Form wird das Ergebnis nie in diesem Parameter gespeichert.
Schreibweisen,
welche zulässig sind:
  • Anfangswert
  • prefix
  • Prefix
  • primary_value
  • primärer_Wert
  • Primärwert
  • start_value
  • Startwert
  • value_-_beginning
  • value_-_primary
  • value_-_start
  • Wert_-_Anfang
  • Wert_-_primärer
  • Wert_-_Start
Standardwert: Wenn
  • ein Funktionsaufruf verwendet wird,
dann
  • muss
    • entwerder für den Parameter "Wert_-_Anfang"
    • oder für den Parameter "Wert_-_Ende"
    ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "&" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "&=" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "=&" verwendet wird,
dann
  • darf für diesen Parameter kein Wert übergeben werden, da er nicht zur Verfügung steht.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

Wert_-_Ende
Beispiel: " ein Gewässer zwischen Deutschland, Österreich und der Schweiz"
Beschreibung: Mit der Hilfe von diesem Parameter wird der sekundäre Wert übergeben. Dies ist also jener Wert, welcher im neuen Wert in der Regel am Ende platziert wird. Abweichungen von der Regel bestehen bei Listen, welche übereinstimmende Schlüssel besitzen.

Unabhängig von der verwendeten Form wird das Ergebnis nie in diesem Parameter gespeichert.
Schreibweisen,
welche zulässig sind:
  • end_value
  • Endwert
  • secondary_value
  • sekundärer_Wert
  • Sekundärwert
  • Suffix
  • suffix
  • terminal_value
  • terminative_value
  • value_-_end
  • value_-_secondary
  • Wert_-_Ende
  • Wert_-_sekundärer
Standardwert: Wenn
  • ein Funktionsaufruf verwendet wird,
dann
  • muss
    • entwerder für den Parameter "Wert_-_Anfang"
    • oder für den Parameter "Wert_-_Ende"
    ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "&" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "&=" verwendet wird,
dann
  • darf für diesen Parameter kein Wert übergeben werden, da er nicht zur Verfügung steht.
Ansonsten wenn
  • der Operator "=&" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

Ergebnis_speichern
Beispiel: falsch
Beschreibung: Mit der Hilfe von diesem Parameter wird angegeben, ob das Ergebnis
  • 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 "wahr" verwendet.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

Eingabe und Ausgabe
Anzahl: 0 oder 1

Ergebnis_oder_Wert_-_Anfang_oder_Wert_-_Ende
Beispiel: "Bodensee:"
Beschreibung: Wenn
  • ein Funktionsaufruf verwendet wird und
  • der Parameter "Wert_-_Anfang" definiert wurde,
dann
  • wird mit der Hilfe von diesem Parameter der Endwert übergeben.
Ansonsten wenn
  • ein Funktionsaufruf verwendet wird und
  • der Parameter "Wert_-_Ende" definiert wurde,
dann
  • wird mit der Hilfe von diesem Parameter der Anfangswert übergeben.
Ansonsten wenn
  • der Operator "&" verwendet wird,
dann
  • steht dieser Parameter nicht zur Verfügung.
Ansonsten wenn
  • der Operator "&=" verwendet wird,
dann
  • wird mit der Hilfe von diesem Parameter der Endwert übergeben und
  • dient dieser Parameter auch als Ausgabeparameter, um das Ergebnis zu speichern.
Ansonsten wenn
  • der Operator "=&" verwendet wird,
dann
  • wird mit der Hilfe von diesem Parameter der Anfangswert übergeben und
  • dient dieser Parameter auch als Ausgabeparameter, um das Ergebnis zu speichern.
Standardwert: Wenn
  • dieser Parameter zur Verfügung steht,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette
Variablentypen,
welche für die Ausgabe verwendet werden:
  • Liste
  • Rohdatenkette
  • Zeichenkette

siehe auch

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

ist gleich

Beispiele

# zurückgebende Form [Start]
# Prüfung von gleichen Variablentypen [Start]
# prüfen, ob 2 und 5 gleich sind, und dann "false" ausgeben
Konsole.schreiben(2 == 5)

# prüfen, ob (2 + 3) und 5 gleich sind, und dann "true" ausgeben
Konsole.schreiben((2 + 3) == 5)

# Liste_1 definieren
Liste_1 = <"a", "b", "c">

# Liste_2 definieren
Liste_2 = <"a", "b">

# prüfen, ob Liste_1 und Liste_2 gleich sind, und dann meine_Wahrheitsangabe mit
# dem Wert "falsch" definieren
meine_Wahrheitsangabe = Liste_1 == Liste_2

# "c" an Liste_2 anhängen
Liste_2.anhängen{"c"}

# prüfen, ob Liste_1 und Liste_2 gleich sind, und dann meine_Wahrheitsangabe mit
# dem Wert "wahr" definieren
meine_Wahrheitsangabe = Liste_1 == Liste_2
# Prüfung von gleichen Variablentypen [Ende]

# Prüfung von unterschiedlichen Variablentypen [Start]
# prüfen, ob 5.0 und 5 gleich sind, und dann "Die Bedingung wurde erfüllt." ausgeben
wenn 5.0 == 5
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")

# prüfen, ob "101" und 101 gleich sind, und dann meine_Wahrheitsangabe mit dem Wert
# "falsch" definieren, da bei Zeichenketten die Basis vom Zahlensystem nicht geraten
# wird
meine_Wahrheitsangabe = "101" == 101

# prüfen, ob falsch und nichts gleich sind, und dann meine_Wahrheitsangabe mit dem
# Wert "falsch" definieren
meine_Wahrheitsangabe = falsch == nichts

# prüfen, ob falsch und 0 gleich sind, und dann meine_Wahrheitsangabe mit dem
# Wert "falsch" definieren
meine_Wahrheitsangabe = falsch == 0

# prüfen, ob falsch und "" gleich sind, und dann meine_Wahrheitsangabe mit dem
# Wert "falsch" definieren
meine_Wahrheitsangabe = falsch == ""
# Prüfung von unterschiedlichen Variablentypen [Ende]
# zurückgebende Form [Ende]

# speichernde Form [Start]
# den Wert "2" in der Variable "Ergebnis" speichern
Ergebnis = 2

# prüfen, ob 2 == 5 ist und anschließend den Wert "falsch" in der Variable "Ergebnis" speichern
Ergebnis === 5
# speichernde Form [Ende]

Definition

allgemein
Name: ==
Beschreibung: Prüft, ob 2 Werte gleich sind. Das Ergebnis ist ein neuer Wert vom Variablentyp "Wahrheitsangabe".

Das Ergebnis kann in den meisten Fällen nur dann der Wert "wahr" sein, wenn
  • beide Parameter vom selben Variablentyp sind, oder
    • der eine Parameter vom Variablentyp "Ganzzahl" ist, und
    • der andere Parameter vom Variablentyp "Kommazahl".

Im Dokument 'die Bibliothek "logic/total_values"' ist im Kapitel "die Details - Funktionen - Logik - mit 2 Operanden - is_equal - allgemein - Beschreibung" das exakte Verhalten beschrieben.

Schreibweisen, welche zulässig sind
ist_gleich:
  • equals
  • is_equal
  • ist_gleich
  • stimmt_überein
==:
  • ==
  • equals
  • is_equal
  • ist_gleich
  • stimmt_überein
===:
  • ===
  • =equals
  • =is_equal
  • =ist_gleich
  • =stimmt_überein
  • equals=
  • is_equal=
  • ist_gleich=
  • stimmt_überein=

Syntax
zurückgebende Form
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.ist_gleich(
    Wert_-_primärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion zurückgebend wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "falsch" übergeben werden.
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.ist_gleich(
    Wert_-_sekundärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion zurückgebend wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "falsch" übergeben werden.
  • Wert_-_primärer == Wert_-_sekundärer

speichernde Formen
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.ist_gleich(
    Wert_-_primärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion speichernd wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "wahr" übergeben werden.
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.ist_gleich(
    Wert_-_sekundärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion speichernd wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "wahr" übergeben werden.
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer === Wert_-_primärer
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer === Wert_-_sekundärer

Parameter
Eingabe
Anzahl: 1 bis 2

Wert_-_primärer
Beispiel: 5.0
Beschreibung: Mit der Hilfe von diesem Parameter wird der primäre Wert übergeben, welcher mit dem sekundären Wert verglichen werden soll.

Formal gesehen handelt es sich bei diesem Parameterwert um den primären Wert. Aufgrund von der Operation sind jedoch
  • der primäre Wert und
  • der sekundäre Wert
austauschbar.

Unabhängig von der verwendeten Form wird das Ergebnis nie in diesem Parameter gespeichert.
Schreibweisen,
welche zulässig sind:
  • Anfangswert
  • primary_value
  • primärer_Wert
  • Primärwert
  • start_value
  • Startwert
  • value_-_beginning
  • value_-_primary
  • value_-_start
  • Wert_-_Anfang
  • Wert_-_primärer
  • Wert_-_Start
Standardwert: Wenn
  • ein Funktionsaufruf verwendet wird,
dann
  • muss
    • entwerder für den Parameter "Wert_-_primärer"
    • oder für den Parameter "Wert_-_sekundärer"
    ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "==" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "===" verwendet wird,
dann
  • muss
    • entwerder für den Parameter "Wert_-_primärer"
    • oder für den Parameter "Wert_-_sekundärer"
    ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

Wert_-_sekundärer
Beispiel: 5
Beschreibung: Mit der Hilfe von diesem Parameter wird der sekundäre Wert übergeben, welcher mit dem primären Wert verglichen werden soll.

Formal gesehen handelt es sich bei diesem Parameterwert um den sekundären Wert. Aufgrund von der Operation sind jedoch
  • der primäre Wert und
  • der sekundäre Wert
austauschbar.

Unabhängig von der verwendeten Form wird das Ergebnis nie in diesem Parameter gespeichert.
Schreibweisen,
welche zulässig sind:
  • secondary_value
  • sekundärer_Wert
  • Sekundärwert
  • value_-_secondary
  • Wert_-_sekundärer
Standardwert: Wenn
  • ein Funktionsaufruf verwendet wird,
dann
  • muss
    • entwerder für den Parameter "Wert_-_primärer"
    • oder für den Parameter "Wert_-_sekundärer"
    ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "==" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "===" verwendet wird,
dann
  • muss
    • entwerder für den Parameter "Wert_-_primärer"
    • oder für den Parameter "Wert_-_sekundärer"
    ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

Ergebnis_speichern
Beispiel: falsch
Beschreibung: Mit der Hilfe von diesem Parameter wird angegeben, ob das Ergebnis
  • 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 "wahr" verwendet.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

Eingabe und Ausgabe
Anzahl: 0 oder 1

Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer
Beispiel: 5.0
Beschreibung: Wenn
  • ein Funktionsaufruf verwendet wird und
  • der Parameter "Wert_-_primärer" definiert wurde,
dann
  • wird mit der Hilfe von diesem Parameter der sekundäre Wert übergeben.
Ansonsten wenn
  • ein Funktionsaufruf verwendet wird und
  • der Parameter "Wert_-_sekundärer" definiert wurde,
dann
  • wird mit der Hilfe von diesem Parameter der primäre Wert übergeben.
Ansonsten wenn
  • der Operator "==" verwendet wird,
dann
  • steht dieser Parameter nicht zur Verfügung.
Ansonsten wenn
  • der Operator "===" verwendet wird und
  • links vom Operator der primäre Wert definiert wurde,
dann
  • wird mit der Hilfe von diesem Parameter der sekundäre Wert übergeben und
  • dient dieser Parameter auch als Ausgabeparameter, um das Ergebnis zu speichern.
Ansonsten wenn
  • der Operator "===" verwendet wird und
  • links vom Operator der sekundäre Wert definiert wurde,
dann
  • wird mit der Hilfe von diesem Parameter der primäre Wert übergeben und
  • dient dieser Parameter auch als Ausgabeparameter, um das Ergebnis zu speichern.
Standardwert: Wenn
  • dieser Parameter zur Verfügung steht,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette
Variablentypen,
welche für die Ausgabe verwendet werden:
  • Wahrheitsangabe

siehe auch

  • Im Kapitel "Operatoren - ist nichts" wird gezeigt, wie ein einzelner Wert geprüft werden kann, ob er nichts ist, also
    • 0,
    • 0.0,
    • eine leere Liste,
    • nichts,
    • eine Rohdatenkette, bestehend aus 0 Elementen,
    • falsch oder
    • eine Zeichenkette, bestehend aus 0 Zeichen.
  • Im Kapitel "Operatoren - ist ungleich" wird gezeigt, wie ein Wert mit einem anderen verglichen werden kann, bei welchem das Ergebnis invertiert wird.

ist größer als

Beispiele

# zurückgebende Form [Start]
/*
Der folgende Code wird "Die Bedingung wurde nicht erfüllt." ausgeben.
*/

wenn 2 > 5
# "Die Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
# "Die Bedingung wurde nicht erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")

Funktion falsch_zurückgeben()
# "falsch wird jetzt zurückgegeben ..." ausgeben
Konsole.schreiben("falsch wird jetzt zurückgegeben ...")

# falsch zurückgeben
gib zurück falsch

Funktion wahr_zurückgeben()
# "wahr wird jetzt zurückgegeben ..." ausgeben
Konsole.schreiben("wahr wird jetzt zurückgegeben ...")

# wahr zurückgeben
gib zurück wahr

/*
Der folgende Code wird
- "falsch wird jetzt zurückgegeben ...",
- "wahr wird jetzt zurückgegeben ..." und dann
- "Die Bedingung wurde nicht erfüllt."
ausgeben.
*/

wenn falsch_zurückgeben() > wahr_zurückgeben()
# "Die Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
# "Die Bedingung wurde nicht erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")

/*
Der folgende Code wird
- "wahr wird jetzt zurückgegeben ...",
- "falsch wird jetzt zurückgegeben ..." und dann
- "Die Bedingung wurde erfüllt."
ausgeben.
*/

wenn wahr_zurückgeben() > falsch_zurückgeben()
# "Die Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
# "Die Bedingung wurde nicht erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")
# zurückgebende Form [Ende]

# speichernde Formen [Start]
# =ist_größer_als [Start]
# den Wert "2" in der Variable "Ergebnis" speichern
Ergebnis = 2

# prüfen, ob 2 > 5 ist und anschließend den Wert "falsch" in der Variable "Ergebnis" speichern
Ergebnis =ist_größer_als 5

# den Wert "7.0" in der Variable "Ergebnis" speichern
Ergebnis = 7.0

# prüfen, ob 7.0 > 5 ist und anschließend den Wert "wahr" in der Variable "Ergebnis" speichern
Ergebnis =ist_größer_als 5
# =ist_größer_als [Ende]

# ist_größer_als= [Start]
# den Wert "2" in der Variable "Ergebnis" speichern
Ergebnis = 2

# prüfen, ob 5 > 2 ist und anschließend den Wert "wahr" in der Variable "Ergebnis" speichern
Ergebnis ist_größer_als= 5

# den Wert "7.0" in der Variable "Ergebnis" speichern
Ergebnis = 7.0

# prüfen, ob 5 > 7.0 ist und anschließend den Wert "falsch" in der Variable "Ergebnis" speichern
Ergebnis ist_größer_als= 5
# ist_größer_als= [Ende]
# speichernde Formen [Ende]

Definition

allgemein
Name: >
Beschreibung: Wenn
  • der primäre Wert größer als der sekundäre Wert ist,
dann
  • wird der Wert "wahr"
    • gespeichert oder
    • zurückgegeben.
Ansonsten
  • wird der Wert "falsch"
    • gespeichert oder
    • zurückgegeben.

Schreibweisen, welche zulässig sind
ist_größer_als:
  • above
  • greater
  • greater_than
  • größer
  • größer_als
  • is_above
  • is_greater
  • is_greater_than
  • ist_größer
  • ist_größer_als
>:
  • >
  • above
  • greater
  • greater_than
  • größer
  • größer_als
  • is_above
  • is_greater
  • is_greater_than
  • ist_größer
  • ist_größer_als
=ist_größer_als:
  • =above
  • =greater
  • =greater_than
  • =größer
  • =größer_als
  • =is_above
  • =is_greater
  • =is_greater_than
  • =ist_größer
  • =ist_größer_als
ist_größer_als=:
  • above=
  • greater=
  • greater_than=
  • größer=
  • größer_als=
  • is_above=
  • is_greater=
  • is_greater_than=
  • ist_größer=
  • ist_größer_als=

Syntax
zurückgebende Form
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.ist_größer_als(
    Wert_-_sekundärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion zurückgebend wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "falsch" übergeben werden.
  • Wert_-_primärer > Wert_-_sekundärer

speichernde Form "=ist_größer_als"
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.ist_größer_als(
    Wert_-_sekundärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion speichernd wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "wahr" übergeben werden.
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer =ist_größer_als Wert_-_sekundärer

speichernde Form "ist_größer_als="
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.ist_größer_als(
    Wert_-_primärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion speichernd wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "wahr" übergeben werden.
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer ist_größer_als= Wert_-_primärer

Parameter
Eingabe
Anzahl: 1 bis 2

Wert_-_primärer
Beispiel: 2
Beschreibung: Mit der Hilfe von diesem Parameter wird der primäre Wert übergeben, welcher mit dem sekundären Wert verglichen werden soll.

Unabhängig von der verwendeten Form wird das Ergebnis nie in diesem Parameter gespeichert.
Schreibweisen,
welche zulässig sind:
  • primary_value
  • primärer_Wert
  • Primärwert
  • value_-_primary
  • Wert_-_primärer
Standardwert: Wenn
  • ein Funktionsaufruf verwendet wird,
dann
  • muss
    • entwerder für den Parameter "Wert_-_primärer"
    • oder für den Parameter "Wert_-_sekundärer"
    ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator ">" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "ist_größer_als=" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "=ist_größer_als" verwendet wird,
dann
  • darf für diesen Parameter kein Wert übergeben werden, da er nicht zur Verfügung steht.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Nichtigkeitsangabe (zählt als "0")
  • Wahrheitsangabe (zählt als "0" oder "1")

Wert_-_sekundärer
Beispiel: wahr
Beschreibung: Mit der Hilfe von diesem Parameter wird der sekundäre Wert übergeben, welcher mit dem primären Wert verglichen werden soll.

Unabhängig von der verwendeten Form wird das Ergebnis nie in diesem Parameter gespeichert.
Schreibweisen,
welche zulässig sind:
  • secondary_value
  • sekundärer_Wert
  • Sekundärwert
  • value_-_secondary
  • Wert_-_sekundärer
Standardwert: Wenn
  • ein Funktionsaufruf verwendet wird,
dann
  • muss
    • entwerder für den Parameter "Wert_-_primärer"
    • oder für den Parameter "Wert_-_sekundärer"
    ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator ">" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "ist_größer_als=" verwendet wird,
dann
  • darf für diesen Parameter kein Wert übergeben werden, da er nicht zur Verfügung steht.
Ansonsten wenn
  • der Operator "=ist_größer_als" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Nichtigkeitsangabe (zählt als "0")
  • Wahrheitsangabe (zählt als "0" oder "1")

Ergebnis_speichern
Beispiel: falsch
Beschreibung: Mit der Hilfe von diesem Parameter wird angegeben, ob das Ergebnis
  • 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 "wahr" verwendet.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

Eingabe und Ausgabe
Anzahl: 0 oder 1

Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer
Beispiel: 2
Beschreibung: Wenn
  • ein Funktionsaufruf verwendet wird und
  • der Parameter "Wert_-_primärer" definiert wurde,
dann
  • wird mit der Hilfe von diesem Parameter der sekundäre Wert übergeben.
Ansonsten wenn
  • ein Funktionsaufruf verwendet wird und
  • der Parameter "Wert_-_sekundärer" definiert wurde,
dann
  • wird mit der Hilfe von diesem Parameter der primäre Wert übergeben.
Ansonsten wenn
  • der Operator ">" verwendet wird,
dann
  • steht dieser Parameter nicht zur Verfügung.
Ansonsten wenn
  • der Operator "ist_größer_als=" verwendet wird,
dann
  • wird mit der Hilfe von diesem Parameter der sekundäre Wert übergeben und
  • dient dieser Parameter auch als Ausgabeparameter, um das Ergebnis zu speichern.
Ansonsten wenn
  • der Operator "=ist_größer_als" verwendet wird,
dann
  • wird mit der Hilfe von diesem Parameter der primäre Wert übergeben und
  • dient dieser Parameter auch als Ausgabeparameter, um das Ergebnis zu speichern.
Standardwert: Wenn
  • dieser Parameter zur Verfügung steht,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Nichtigkeitsangabe (zählt als "0")
  • Wahrheitsangabe (zählt als "0" oder "1")
Variablentypen,
welche für die Ausgabe verwendet werden:
  • Wahrheitsangabe

siehe auch

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

ist größer oder gleich

Beispiele

siehe: im Kapitel "ist größer als - Beispiele"

Definition

allgemein
siehe: im Kapitel "ist größer als - Definition - allgemein"

Schreibweisen, welche zulässig sind
ist_größer_oder_gleich:
  • above_or_equal
  • above_or_equal_to
  • größer_als_oder_gleich
  • größer_gleich
  • größer_oder_gleich
  • größergleich
  • is_above_or_equal
  • is_above_or_equal_to
  • is_greater_or_equal
  • is_greater_or_equal_to
  • is_greater_than_or_equal
  • is_greater_than_or_equal_to
  • ist_größer_als_oder_gleich
  • ist_größer_gleich
  • ist_größer_oder_gleich
  • ist_größergleich
>=:
  • >=
  • above_or_equal
  • above_or_equal_to
  • größer_als_oder_gleich
  • größer_gleich
  • größer_oder_gleich
  • größergleich
  • is_above_or_equal
  • is_above_or_equal_to
  • is_greater_or_equal
  • is_greater_or_equal_to
  • is_greater_than_or_equal
  • is_greater_than_or_equal_to
  • ist_größer_als_oder_gleich
  • ist_größer_gleich
  • ist_größer_oder_gleich
  • ist_größergleich
=>=:
  • =>=
  • =above_or_equal
  • =above_or_equal_to
  • =größer_als_oder_gleich
  • =größer_gleich
  • =größer_oder_gleich
  • =größergleich
  • =is_above_or_equal
  • =is_above_or_equal_to
  • =is_greater_or_equal
  • =is_greater_or_equal_to
  • =is_greater_than_or_equal
  • =is_greater_than_or_equal_to
  • =ist_größer_als_oder_gleich
  • =ist_größer_gleich
  • =ist_größer_oder_gleich
  • =ist_größergleich
>==:
  • >==
  • above_or_equal=
  • above_or_equal_to=
  • größer_als_oder_gleich=
  • größer_gleich=
  • größer_oder_gleich=
  • größergleich=
  • is_above_or_equal=
  • is_above_or_equal_to=
  • is_greater_or_equal=
  • is_greater_or_equal_to=
  • is_greater_than_or_equal=
  • is_greater_than_or_equal_to=
  • ist_größer_als_oder_gleich=
  • ist_größer_gleich=
  • ist_größer_oder_gleich=
  • ist_größergleich=

Syntax
siehe: im Kapitel "ist größer als - Definition - Syntax"

Parameter
siehe: im Kapitel "ist größer als - Definition - Parameter"

siehe auch

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

ist kleiner als

Beispiele

siehe: im Kapitel "ist größer als - Beispiele"

Definition

allgemein
siehe: im Kapitel "ist größer als - Definition - allgemein"

Schreibweisen, welche zulässig sind
ist_kleiner_als:
  • below
  • is_below
  • is_smaller
  • is_smaller_than
  • ist_kleiner
  • ist_kleiner_als
  • kleiner
  • kleiner_als
  • smaller
  • smaller_than
<:
  • <
  • below
  • is_below
  • is_smaller
  • is_smaller_than
  • ist_kleiner
  • ist_kleiner_als
  • kleiner
  • kleiner_als
  • smaller
  • smaller_than
=ist_kleiner_als:
  • =below
  • =is_below
  • =is_smaller
  • =is_smaller_than
  • =ist_kleiner
  • =ist_kleiner_als
  • =kleiner
  • =kleiner_als
  • =smaller
  • =smaller_than
ist_kleiner_als=:
  • below=
  • is_below=
  • is_smaller=
  • is_smaller_than=
  • ist_kleiner=
  • ist_kleiner_als=
  • kleiner=
  • kleiner_als=
  • smaller=
  • smaller_than=

Syntax
siehe: im Kapitel "ist größer als - Definition - Syntax"

Parameter
siehe: im Kapitel "ist größer als - Definition - Parameter"

siehe auch

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

ist kleiner oder gleich

Beispiele

siehe: im Kapitel "ist größer als - Beispiele"

Definition

allgemein
siehe: im Kapitel "ist größer als - Definition - allgemein"

Schreibweisen, welche zulässig sind
ist_kleiner_oder_gleich:
  • below_or_equal
  • below_or_equal_to
  • is_below_or_equal
  • is_below_or_equal_to
  • is_smaller_or_equal
  • is_smaller_or_equal_to
  • is_smaller_than_or_equal
  • is_smaller_than_or_equal_to
  • ist_kleiner_als_oder_gleich
  • ist_kleiner_gleich
  • ist_kleiner_oder_gleich
  • ist_kleinergleich
  • kleiner_als_oder_gleich
  • kleiner_gleich
  • kleiner_oder_gleich
  • kleinergleich
<=:
  • <=
  • below_or_equal
  • below_or_equal_to
  • is_below_or_equal
  • is_below_or_equal_to
  • is_smaller_or_equal
  • is_smaller_or_equal_to
  • is_smaller_than_or_equal
  • is_smaller_than_or_equal_to
  • ist_kleiner_als_oder_gleich
  • ist_kleiner_gleich
  • ist_kleiner_oder_gleich
  • ist_kleinergleich
  • kleiner_als_oder_gleich
  • kleiner_gleich
  • kleiner_oder_gleich
  • kleinergleich
<==:
  • <==
  • below_or_equal=
  • below_or_equal_to=
  • is_below_or_equal=
  • is_below_or_equal_to=
  • is_smaller_or_equal=
  • is_smaller_or_equal_to=
  • is_smaller_than_or_equal=
  • is_smaller_than_or_equal_to=
  • ist_kleiner_als_oder_gleich=
  • ist_kleiner_gleich=
  • ist_kleiner_oder_gleich=
  • ist_kleinergleich=
  • kleiner_als_oder_gleich=
  • kleiner_gleich=
  • kleiner_oder_gleich=
  • kleinergleich=
=<=:
  • =<=
  • =below_or_equal
  • =below_or_equal_to
  • =is_below_or_equal
  • =is_below_or_equal_to
  • =is_smaller_or_equal
  • =is_smaller_or_equal_to
  • =is_smaller_than_or_equal
  • =is_smaller_than_or_equal_to
  • =ist_kleiner_als_oder_gleich
  • =ist_kleiner_gleich
  • =ist_kleiner_oder_gleich
  • =ist_kleinergleich
  • =kleiner_als_oder_gleich
  • =kleiner_gleich
  • =kleiner_oder_gleich
  • =kleinergleich

Syntax
siehe: im Kapitel "ist größer als - Definition - Syntax"

Parameter
siehe: im Kapitel "ist größer als - Definition - Parameter"

siehe auch

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

ist nichts

Beispiele

# zurückgebende Form [Start]
# Prüfung von Ganzzahlen [Start]
# prüfen, ob 0 nichts ist, und dann "true" ausgeben
Konsole.schreiben(! 0)

# prüfen, ob -5 nichts ist, und dann "false" ausgeben
Konsole.schreiben(! -5)

# prüfen, ob 5 nichts ist, und dann "false" ausgeben
Konsole.schreiben(! 5)
# Prüfung von Ganzzahlen [Ende]

# Prüfung von Kommazahlen [Start]
# prüfen, ob 0.0 nichts ist, und dann meine_Wahrheitsangabe mit "wahr" definieren
meine_Wahrheitsangabe = ! 0.0

# prüfen, ob -5.0 nichts ist, und dann meine_Wahrheitsangabe mit "falsch" definieren
meine_Wahrheitsangabe = ! -5.0

# prüfen, ob 5.0 nichts ist, und dann meine_Wahrheitsangabe mit "falsch" definieren
meine_Wahrheitsangabe = ! 5.0
# Prüfung von Kommazahlen [Ende]

# Prüfung von Listen [Start]
# prüfen, ob <> nichts ist, also ob die Liste leer ist, und dann "Die Bedingung wurde
# erfüllt." ausgeben
wenn ! <>
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")

# prüfen, ob <"a"> nichts ist, also ob die Liste leer ist, und dann "Die Bedingung
# wurde nicht erfüllt." ausgeben
wenn ! <"a">
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")

# prüfen, ob <falsch> nichts ist, also ob die Liste leer ist, und dann "Die Bedingung
# wurde nicht erfüllt." ausgeben
wenn ! <falsch>
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")
# Prüfung von Listen [Ende]

# Prüfung von Nichtigkeitsangaben [Start]
# prüfen, ob der Wert "nichts" nichts ist, und dann meine_Wahrheitsangabe mit "wahr" definieren
meine_Wahrheitsangabe = ! nichts
# Prüfung von Nichtigkeitsangaben [Ende]

# Prüfung von Wahrheitsangaben [Start]
# prüfen, ob der Wert "wahr" nichts ist, und dann meine_Wahrheitsangabe mit "falsch" definieren
meine_Wahrheitsangabe = ! wahr

# prüfen, ob der Wert "falsch" nichts ist, und dann meine_Wahrheitsangabe mit "wahr" definieren
meine_Wahrheitsangabe = ! falsch
# Prüfung von Wahrheitsangaben [Ende]

# Prüfung von Zeichenketten [Start]
# prüfen, ob "abc" nichts ist, also ob die Zeichenkette keine Zeichen enthält, und
# dann meine_Wahrheitsangabe mit false definieren
meine_Wahrheitsangabe = ! "abc"

# prüfen, ob "" nichts ist, also ob die Zeichenkette keine Zeichen enthält, und dann
# meine_Wahrheitsangabe mit dem Wert "wahr" definieren
meine_Wahrheitsangabe = ! ""
# Prüfung von Zeichenketten [Ende]
# zurückgebende Form [Ende]

# speichernde Formen [Start]
/*
Bei der speichernden Form sind zwar beide Schreibweisen
- "=ist_nichts" und
- "ist_nichts="
zulässig, jedoch gibt es bei diesem Operator nur 1 Parameter,
sodass mit der Hilfe von der Schreibweise nicht die Reihenfolge
bestimmt werden kann.
*/

# den Wert "0" in der Variable "Ergebnis" speichern
Ergebnis = 0

# prüfen, ob 0 nichts ist, und dann den Wert "wahr" speichern
Ergebnis =ist_nichts

# den Wert "-5" in der Variable "Ergebnis" speichern
Ergebnis = -5

# prüfen, ob -5 nichts ist, und dann den Wert "falsch" speichern
Ergebnis =ist_nichts

# den Wert "5" in der Variable "Ergebnis" speichern
Ergebnis = 5

# prüfen, ob 5 nichts ist, und dann den Wert "falsch" speichern
Ergebnis ist_nichts=
# speichernde Formen [Ende]

Definition

allgemein
Name: !
Beschreibung: Ermittelt zunächst, ob die Bedingung erfüllt ist:
Bedingung: Variablentyp:
Es handelt sich um den Wert "0". Ganzzahl
Es handelt sich um den Wert "0.0". Kommazahl
Die Liste enthält keinen Eintrag. Liste
Es handelt sich um den Wert "nichts". Dies ist bei diesem Variablentyp immer der Fall. Nichtigkeitsangabe
Die Rohdatenkette enthält kein Element. Rohdatenkette
Es handelt sich um den Wert "falsch". Wahrheitsangabe
Die Zeichenkette enthält kein Zeichen. Zeichenkette

Wenn
  • die Bedingung erfüllt ist,
dann
  • wird wahr
    • gespeichert oder
    • zurückgegeben.
Ansonsten
  • wird falsch
    • gespeichert oder
    • zurückgegeben.

Schreibweisen, welche zulässig sind
ist_nichts:
  • is_empty
  • is_nothing
  • is_null
  • is_zero
  • ist_leer
  • ist_nichts
  • ist_Null
  • ist_null
!:
  • !
  • is_empty
  • is_nothing
  • is_null
  • is_zero
  • ist_leer
  • ist_nichts
  • ist_Null
  • ist_null
=ist_nichts:
  • =is_empty
  • =is_nothing
  • =is_null
  • =is_zero
  • =ist_leer
  • =ist_nichts
  • =ist_Null
  • =ist_null
ist_nichts=:
  • is_empty=
  • is_nothing=
  • is_null=
  • is_zero=
  • ist_leer=
  • ist_nichts=
  • ist_Null=
  • ist_null=

Syntax
zurückgebende Form
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert.ist_nichts(/°
    Ergebnis_speichern = wahr
    °/)

    Damit die Funktion zurückgebend wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "falsch" übergeben werden.
  • ! Wert

speichernde Formen
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert.ist_nichts(/°
    Ergebnis_speichern = wahr
    °/)

    Damit die Funktion speichernd wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "wahr" übergeben werden.
  • Ergebnis_oder_Wert =ist_nichts
  • Ergebnis_oder_Wert ist_nichts=

Parameter
Eingabe
Anzahl: 0 bis 2

Wert
Beispiel: 2
Beschreibung: Wenn
  • ein Funktionsaufruf verwendet wird,
dann
  • steht dieser Parameter nicht zur Verfügung.
Ansonsten wenn
  • der Operator "!" verwendet wird,
dann
  • wird mit der Hilfe von diesem Parameter der Wert übergeben, welcher geprüft werden soll.
Ansonsten wenn
  • der Operator "=ist_nichts" verwendet wird oder
  • der Operator "ist_nichts=" verwendet wird,
dann
  • steht dieser Parameter nicht zur Verfügung.

Unabhängig von der verwendeten Form wird das Ergebnis nie in diesem Parameter gespeichert.
Schreibweisen,
welche zulässig sind:
  • value
  • Wert
Standardwert: Wenn
  • dieser Parameter zur Verfügung steht,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

Ergebnis_speichern
Beispiel: falsch
Beschreibung: Mit der Hilfe von diesem Parameter wird angegeben, ob das Ergebnis
  • 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 "wahr" verwendet.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

Eingabe und Ausgabe
Anzahl: 0 oder 1

Ergebnis_oder_Wert
Beispiel: 2
Beschreibung: Wenn
  • ein Funktionsaufruf verwendet wird,
dann
  • wird mit der Hilfe von diesem Parameter der Wert übergeben, welcher geprüft werden soll.
Ansonsten wenn
  • der Operator "!" verwendet wird,
dann
  • steht dieser Parameter nicht zur Verfügung.
Ansonsten wenn
  • der Operator "=ist_nichts" verwendet wird oder
  • der Operator "ist_nichts=" verwendet wird,
dann
  • wird mit der Hilfe von diesem Parameter der Wert übergeben, welcher geprüft werden soll, und
  • dient dieser Parameter auch als Ausgabeparameter, um das Ergebnis zu speichern.
Standardwert: Wenn
  • dieser Parameter zur Verfügung steht,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette
Variablentypen,
welche für die Ausgabe verwendet werden:
  • Wahrheitsangabe

ist ungleich

Beispiele

# zurückgebende Form [Start]
# Prüfung von gleichen Variablentypen [Start]
# prüfen, ob 2 und 5 ungleich sind, und dann "true" ausgeben
Konsole.schreiben(2 != 5)

# prüfen, ob (2 + 3) und 5 ungleich sind, und dann "false" ausgeben
Konsole.schreiben((2 + 3) != 5)

# Liste_1 definieren
Liste_1 = <"a", "b", "c">

# Liste_2 definieren
Liste_2 = <"a", "b">

# prüfen, ob Liste_1 und Liste_2 ungleich sind, und dann meine_Wahrheitsangabe mit
# dem Wert "wahr" definieren
meine_Wahrheitsangabe = Liste_1 != Liste_2

# "c" an Liste_2 anhängen
Liste_2.anhängen{"c"}

# prüfen, ob Liste_1 und Liste_2 ungleich sind, und dann meine_Wahrheitsangabe mit
# dem Wert "falsch" definieren
meine_Wahrheitsangabe = Liste_1 != Liste_2
# Prüfung von gleichen Variablentypen [Ende]

# Prüfung von unterschiedlichen Variablentypen [Start]
# prüfen, ob 5.0 und 5 ungleich sind, und dann "Die Bedingung wurde nicht erfüllt."
# ausgeben
wenn 5.0 != 5
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")

# prüfen, ob "101" und 101 ungleich sind, und dann meine_Wahrheitsangabe mit dem Wert
# "wahr" definieren, da bei Zeichenketten die Basis vom Zahlensystem nicht geraten wird
meine_Wahrheitsangabe = "101" != 101

# prüfen, ob falsch und nichts ungleich sind, und dann meine_Wahrheitsangabe mit
# dem Wert "wahr" definieren
meine_Wahrheitsangabe = falsch != nichts

# prüfen, ob falsch und 0 ungleich sind, und dann meine_Wahrheitsangabe mit dem
# Wert "wahr" definieren
meine_Wahrheitsangabe = falsch != 0

# prüfen, ob falsch und "" ungleich sind, und dann meine_Wahrheitsangabe mit dem
# Wert "wahr" definieren
meine_Wahrheitsangabe = falsch != ""
# Prüfung von unterschiedlichen Variablentypen [Ende]
# zurückgebende Form [Ende]

# speichernde Formen [Start]
/*
Bei diesem Operator sind beide speichernden Formen
- "=!=" und
- "!=="
funktional identisch.
*/

# den Wert "2" in der Variable "Ergebnis" speichern
Ergebnis = 2

# prüfen, ob 2 != 5 ist und anschließend den Wert "wahr" in der Variable "Ergebnis" speichern
Ergebnis =!= 5

# den Wert "2" in der Variable "Ergebnis" speichern
Ergebnis = 2

# prüfen, ob 5 != 2 ist und anschließend den Wert "wahr" in der Variable "Ergebnis" speichern
Ergebnis !== 5
# speichernde Formen [Ende]

Definition

allgemein
Name: !=
Beschreibung: Prüft, ob 2 Werte ungleich sind. Das Ergebnis ist ein neuer Wert vom Variablentyp "Wahrheitsangabe".

Das Ergebnis kann in den meisten Fällen nur dann der Wert "falsch" sein, wenn
  • beide Parameter vom selben Variablentyp sind, oder
    • der eine Parameter vom Variablentyp "Ganzzahl" ist, und
    • der andere Parameter vom Variablentyp "Kommazahl".

Im Dokument 'die Bibliothek "logic/total_values"' ist im Kapitel "die Details - Funktionen - Logik - mit 2 Operanden - is_equal - allgemein - Beschreibung" das exakte Verhalten beschrieben, wenn auf Gleichheit geprüft wird. Beim Prüfen auf Ungleichheit ist das Verhalten negiert.

Schreibweisen, welche zulässig sind
ist_ungleich:
  • is_unequal
  • ist_ungleich
  • stimmt_nicht_überein
!=:
  • !=
  • is_unequal
  • ist_ungleich
  • stimmt_nicht_überein
!==:
  • !==
  • is_unequal=
  • ist_ungleich=
  • stimmt_nicht_überein=
=!=:
  • =!=
  • =is_unequal
  • =ist_ungleich
  • =stimmt_nicht_überein

Syntax
zurückgebende Form
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.ist_ungleich(
    Wert_-_primärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion zurückgebend wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "falsch" übergeben werden.
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.ist_ungleich(
    Wert_-_sekundärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion zurückgebend wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "falsch" übergeben werden.
  • Wert_-_primärer != Wert_-_sekundärer

speichernde Formen
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.ist_ungleich(
    Wert_-_primärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion speichernd wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "wahr" übergeben werden.
  • Ergebnis_oder_Wert_-_primärer_oder_Wert_-_sekundärer.ist_ungleich(
    Wert_-_sekundärer
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion speichernd wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "wahr" übergeben werden.
  • Ergebnis !== Wert_-_primärer
  • Ergebnis =!= Wert_-_sekundärer

Parameter
siehe: im Kapitel "ist gleich - Definition - Parameter"

siehe auch

  • Im Kapitel "Operatoren - ist gleich" wird gezeigt, wie ein Wert mit einem anderen verglichen werden kann, ohne dass das Ergebnis invertiert wird.
  • Im Kapitel "Operatoren - ist nichts" wird gezeigt, wie ein einzelner Wert geprüft werden kann, ob er nichts ist, also
    • 0,
    • 0.0,
    • eine leere Liste,
    • nichts,
    • eine Rohdatenkette, bestehend aus 0 Elementen,
    • falsch oder
    • eine Zeichenkette, bestehend aus 0 Zeichen.

Merkhilfe

Vielleicht hilft die nachfolgende Darstellung, um im Kopf zu behalten, welche speichernde Form für welchen Zweck dient:
speichernde Form Beispiel: Ergebnis =- 5 Ergebnis -= 5
Formel: Ergebnis =- Abzug Ergebnis -= Anfangswert
entsprechende zurückgebenede Form Beispiel: Ergebnis = 2 - 5 Ergebnis = 5 - 2
Formel: Ergebnis = Ergebnis - Abzug Ergebnis = Anfangswert - Ergebnis
Bedeutung Farben: der linke Teil vom Operator ist lila
der rechte Teil vom Operator ist rot
Zeichen: = ≙ Ergebnis
- ≙ Abzug 		- ≙ Anfangswert
= ≙ Ergebnis

oder

Beispiele

# zurückgebende Form [Start]
/*
Der folgende Code wird "Die Bedingung wurde erfüllt." ausgeben.
*/

wenn (5 > 10) oder (5 == 5)
# "Die Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
# "Die Bedingung wurde nicht erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")

Funktion falsch_zurückgeben()
# "falsch wird jetzt zurückgegeben ..." ausgeben
Konsole.schreiben("falsch wird jetzt zurückgegeben ...")

# falsch zurückgeben
gib zurück falsch

Funktion wahr_zurückgeben()
# "wahr wird jetzt zurückgegeben ..." ausgeben
Konsole.schreiben("wahr wird jetzt zurückgegeben ...")

# wahr zurückgeben
gib zurück wahr

/*
Der folgende Code wird
- "falsch wird jetzt zurückgegeben ...",
- "wahr wird jetzt zurückgegeben ..." und dann
- "Die Bedingung wurde erfüllt."
ausgeben.
*/

wenn falsch_zurückgeben() oder wahr_zurückgeben()
# "Die Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
# "Die Bedingung wurde nicht erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")

/*
Der folgende Code wird
- "wahr wird jetzt zurückgegeben ..." und dann
- "Die Bedingung wurde erfüllt."
ausgeben.
*/

wenn wahr_zurückgeben() oder falsch_zurückgeben()
# "Die Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
# "Die Bedingung wurde nicht erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")
# zurückgebende Form [Ende]

# speichernde Formen [Start]
# =oder [Start]
# den Wert "2" in der Variable "Ergebnis" speichern
Ergebnis = 2

# bei der folgenden Prüfung wird die Funktion "wahr_zurückgeben" nicht aufgerufen,
# stattdessen bleibt in der Variable "Ergebnis" der Wert "2" gespeichert
Ergebnis =oder wahr_zurückgeben()

# den Wert "0" in der Variable "Ergebnis" speichern
Ergebnis = 0

# bei der folgenden Prüfung wird die Funktion "wahr_zurückgeben" aufgerufen,
# anschließend wird in der Variable "Ergebnis" der Wert "wahr" gespeichert
Ergebnis =oder wahr_zurückgeben()
# =oder [Ende]

# oder= [Start]
# den Wert "2" in der Variable "Ergebnis" speichern
Ergebnis = 2

# bei der folgenden Prüfung wird die Funktion "wahr_zurückgeben" aufgerufen,
# anschließend wird in der Variable "Ergebnis" der Wert "wahr" gespeichert
Ergebnis oder= wahr_zurückgeben()

# den Wert "2" in der Variable "Ergebnis" speichern
Ergebnis = 2

# bei der folgenden Prüfung wird die Funktion "falsch_zurückgeben" aufgerufen,
# dennoch bleibt in der Variable "Ergebnis" der Wert "2" gespeichert
Ergebnis oder= falsch_zurückgeben()
# oder= [Ende]
# speichernde Formen [Ende]

Definition

allgemein
Name: oder
Beschreibung: Durchläuft folgenden Ablauf:
  1. Wenn
    • der primäre Wert etwas ist,
    dann
    • wird der primäre Wert zurückgegeben oder gespeichert und
    • wird der Ablauf mit diesem Schritt beendet.
    Ansonsten
    • wird der nächste Schritt ausgeführt.
  2. Gibt den sekundären Wert zurück oder speichert ihn.

Schreibweisen, welche zulässig sind
oder:
  • oder
  • or
oder:
  • oder
  • or
=oder:
  • =oder
  • =or
oder=:
  • oder=
  • or=

Syntax
siehe: im Kapitel "ist größer als - Definition - Syntax"

Parameter
siehe: im Kapitel "ist größer als - Definition - Parameter"

siehe auch

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

Subtraktion (Minus rechnen)

Beispiele

# zurückgebende Form [Start]
# den Wert "3" als Ergebnis speichern
Ergebnis = 5 - 2

# den Wert "4" als Ergebnis speichern
Ergebnis = 5 - wahr

# den Wert "5" als Ergebnis speichern
Ergebnis = 5 - falsch
# zurückgebende Form [Ende]

# speichernde Formen [Start]
# =- [Start]
/*
Die Operation
- "Ergebnis =- Abzug"
entspricht der Operation
- "Ergebnis = Ergebnis - Abzug".
*/

# den Wert "5" in der Variable "Ergebnis" speichern
Ergebnis = 5

# den Wert "2" subtrahieren, so dass anschließend das Ergebnis "3" gespeichert ist
Ergebnis =- 2

# den Wert "wahr" subtrahieren, so dass anschließend das Ergebnis "2" gespeichert ist
Ergebnis =- wahr

# den Wert "falsch" subtrahieren, so dass anschließend das Ergebnis "2" gespeichert
# ist
Ergebnis =- falsch
# =- [Ende]

# -= [Start]
/*
Die Operation
- "Ergebnis -= Anfangswert"
entspricht der Operation
- "Ergebnis = Anfangswert - Ergebnis".
*/

# den Wert "5" in der Variable "Ergebnis" speichern
Ergebnis = 5

# vom Wert "2" den Wert aus der Variable "Ergebnis" subtrahieren
# anschließend das Ergebnis "-3" in der Variable "Ergebnis" speichern
Ergebnis -= 2

# vom Wert "wahr" den Wert aus der Variable "Ergebnis" subtrahieren
# anschließend das Ergebnis "4" in der Variable "Ergebnis" speichern
Ergebnis -= wahr

# vom Wert "falsch" den Wert aus der Variable "Ergebnis" subtrahieren
# anschließend das Ergebnis "-4" in der Variable "Ergebnis" speichern
Ergebnis -= falsch
# -= [Ende]
# speichernde Formen [Ende]

Definition

allgemein
Name: -
Beschreibung: subtrahiert einen Wert von einem anderen Wert und
  • speichert das Ergebnis oder
  • gibt das Ergebnis zurück

Schreibweisen, welche zulässig sind
subtrahieren:
  • Minus_rechnen
  • subtract
  • subtrahieren
-:
  • -
  • Minus_rechnen
  • subtract
  • subtrahieren
-=:
  • -=
  • Minus_rechnen=
  • subtract=
  • subtrahieren=
=-:
  • =-
  • =Minus_rechnen
  • =subtract
  • =subtrahieren

Syntax
zurückgebende Form
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Anfangswert_oder_Abzug.subtrahieren(
    Abzug
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion zurückgebend wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "falsch" übergeben werden.
  • Anfangswert - Abzug

speichernde Form "-="
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Anfangswert_oder_Abzug.subtrahieren(
    Anfangswert
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion speichernd wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "wahr" übergeben werden.
  • Ergebnis_oder_Anfangswert_oder_Abzug -= Anfangswert

speichernde Form "=-"
Art: Funktionsaufruf Operation
Formen:
  • Ergebnis_oder_Anfangswert_oder_Abzug.subtrahieren(
    Abzug
    /°Ergebnis_speichern = wahr
    °/)

    Damit die Funktion speichernd wirkt, muss für den Parameter "Ergebnis_speichern" der Wert "wahr" übergeben werden.
  • Ergebnis_oder_Anfangswert_oder_Abzug =- Abzug

Parameter
Eingabe
Anzahl: 1 bis 2

Anfangswert
Beispiel: 5
Beschreibung: Mit der Hilfe von diesem Parameter wird der Anfangswert übergeben, von welchem der Abzug subtrahiert werden soll.

Unabhängig von der verwendeten Form wird das Ergebnis nie in diesem Parameter gespeichert.
Schreibweisen,
welche zulässig sind:
  • Anfangswert
  • Minuend
  • minuend
  • primary_value
  • primärer_Wert
  • Primärwert
  • start_value
  • Startwert
  • value_-_beginning
  • value_-_primary
  • value_-_start
  • Wert_-_Anfang
  • Wert_-_primärer
  • Wert_-_Start
Standardwert: Wenn
  • ein Funktionsaufruf verwendet wird,
dann
  • muss
    • entwerder für den Parameter "Anfangswert"
    • oder für den Parameter "Abzug"
    ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "-" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "-=" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "=-" verwendet wird,
dann
  • darf für diesen Parameter kein Wert übergeben werden, da er nicht zur Verfügung steht.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Nichtigkeitsangabe
  • Wahrheitsangabe

Abzug
Beispiel: 2
Beschreibung: Mit der Hilfe von diesem Parameter wird der Abzug übergeben, welcher vom Anfangswert subtrahiert werden soll.

Unabhängig von der verwendeten Form wird das Ergebnis nie in diesem Parameter gespeichert.
Schreibweisen,
welche zulässig sind:
  • Abzug
  • secondary_value
  • sekundärer_Wert
  • Sekundärwert
  • Subtrahend
  • subtrahend
  • value_-_secondary
  • Wert_-_sekundärer
Standardwert: Wenn
  • ein Funktionsaufruf verwendet wird,
dann
  • muss
    • entwerder für den Parameter "Anfangswert"
    • oder für den Parameter "Abzug"
    ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "-" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Ansonsten wenn
  • der Operator "-=" verwendet wird,
dann
  • darf für diesen Parameter kein Wert übergeben werden, da er nicht zur Verfügung steht.
Ansonsten wenn
  • der Operator "=-" verwendet wird,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Nichtigkeitsangabe
  • Wahrheitsangabe

Ergebnis_speichern
Beispiel: falsch
Beschreibung: Mit der Hilfe von diesem Parameter wird angegeben, ob das Ergebnis
  • 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 "wahr" verwendet.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

Eingabe und Ausgabe
Anzahl: 0 oder 1

Ergebnis_oder_Anfangswert_oder_Abzug
Beispiel: 5
Beschreibung: Wenn
  • ein Funktionsaufruf verwendet wird und
  • der Parameter "Anfangswert" definiert wurde,
dann
  • wird mit der Hilfe von diesem Parameter der Abzug übergeben.
Ansonsten wenn
  • ein Funktionsaufruf verwendet wird und
  • der Parameter "Abzug" definiert wurde,
dann
  • wird mit der Hilfe von diesem Parameter der Anfangswert übergeben.
Ansonsten wenn
  • der Operator "-" verwendet wird,
dann
  • steht dieser Parameter nicht zur Verfügung.
Ansonsten wenn
  • der Operator "-=" verwendet wird,
dann
  • wird mit der Hilfe von diesem Parameter der Abzug übergeben und
  • dient dieser Parameter auch als Ausgabeparameter, um das Ergebnis zu speichern.
Ansonsten wenn
  • der Operator "=-" verwendet wird,
dann
  • wird mit der Hilfe von diesem Parameter der Anfangswert übergeben und
  • dient dieser Parameter auch als Ausgabeparameter, um das Ergebnis zu speichern.
Standardwert: Wenn
  • dieser Parameter zur Verfügung steht,
dann
  • muss für diesen Parameter ein Wert übergeben werden, da er keinen Standardwert hat.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Nichtigkeitsangabe
  • Wahrheitsangabe
Variablentypen,
welche für die Ausgabe verwendet werden:
  • Ganzzahl
  • Kommazahl

siehe auch

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

und

Beispiele

# zurückgebende Form [Start]
/*
Der folgende Code wird "Die Bedingung wurde erfüllt." ausgeben.
*/

wenn (5 > 2) und (5 < 10)
# "Die Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
# "Die Bedingung wurde nicht erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")

Funktion falsch_zurückgeben()
# "falsch wird jetzt zurückgegeben ..." ausgeben
Konsole.schreiben("falsch wird jetzt zurückgegeben ...")

# falsch zurückgeben
gib zurück falsch

Funktion wahr_zurückgeben()
# "wahr wird jetzt zurückgegeben ..." ausgeben
Konsole.schreiben("wahr wird jetzt zurückgegeben ...")

# wahr zurückgeben
gib zurück wahr

/*
Der folgende Code wird
- "wahr wird jetzt zurückgegeben ...",
- "falsch wird jetzt zurückgegeben ..." und dann
- "Die Bedingung wurde nicht erfüllt."
ausgeben.
*/

wenn wahr_zurückgeben() und falsch_zurückgeben()
# "Die Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
# "Die Bedingung wurde nicht erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")

/*
Der folgende Code wird
- "falsch wird jetzt zurückgegeben ..." und dann
- "Die Bedingung wurde nicht erfüllt."
ausgeben.
*/

wenn falsch_zurückgeben() und wahr_zurückgeben()
# "Die Bedingung wurde erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde erfüllt.")
ansonsten
# "Die Bedingung wurde nicht erfüllt." ausgeben
Konsole.schreiben("Die Bedingung wurde nicht erfüllt.")
# zurückgebende Form [Ende]

# speichernde Formen [Start]
# =und [Start]
# den Wert "2" in der Variable "Ergebnis" speichern
Ergebnis = 2

# bei der folgenden Prüfung wird die Funktion "wahr_zurückgeben" aufgerufen,
# anschließend wird in der Variable "Ergebnis" der Wert "wahr" gespeichert
Ergebnis =und wahr_zurückgeben()

# den Wert "0" in der Variable "Ergebnis" speichern
Ergebnis = 0

# bei der folgenden Prüfung wird die Funktion "wahr_zurückgeben" nicht aufgerufen,
# stattdessen bleibt in der Variable "Ergebnis" der Wert "0" gespeichert
Ergebnis =und wahr_zurückgeben()
# =und [Ende]

# und= [Start]
# den Wert "2" in der Variable "Ergebnis" speichern
Ergebnis = 2

# bei der folgenden Prüfung wird die Funktion "wahr_zurückgeben" aufgerufen,
# dennoch bleibt in der Variable "Ergebnis" der Wert "2" gespeichert
Ergebnis und= wahr_zurückgeben()

# den Wert "2" in der Variable "Ergebnis" speichern
Ergebnis = 2

# bei der folgenden Prüfung wird die Funktion "falsch_zurückgeben" aufgerufen,
# anschließend wird in der Variable "Ergebnis" der Wert "falsch" gespeichert
Ergebnis und= falsch_zurückgeben()
# und= [Ende]
# speichernde Formen [Ende]

Definition

allgemein
Name: und
Beschreibung: Durchläuft folgenden Ablauf:
  1. Wenn
    • der primäre Wert etwas ist,
    dann
    • wird der nächste Schritt ausgeführt.
    Ansonsten
    • wird der primäre Wert zurückgegeben und
    • wird der Ablauf mit diesem Schritt beendet.
  2. Gibt den sekundären Wert zurück.

Schreibweisen, welche zulässig sind
und:
  • and
  • und
und:
  • and
  • und
=und:
  • =and
  • =und
und=:
  • and=
  • und=

Syntax
siehe: im Kapitel "ist größer als - Definition - Syntax"

Parameter
siehe: im Kapitel "ist größer als - Definition - Parameter"

siehe auch

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

Schleifen

abbrechen

einzelnen Durchlauf

Beispiele
/*
Die folgende Schleife wird
- "0" und dann
- "2"
ausgeben.
*/

durchlaufe ... 3 als Zahl
wenn Zahl == 1
# diesen Durchlauf abbrechen und mit der nächsten Zahl fortfahren
überspringe

# Zahl ausgeben
Konsole.schreiben(Zahl)

/*
Das Folgende wird
- "Der Anfang vom Durchlauf #0 wurde erreicht.",
- "Der Anfang vom Durchlauf #1 wurde erreicht.",
- "Der Anfang vom Durchlauf #2 wurde erreicht." und dann
- "Der gesamte Schleifendurchlauf wurde ohne Abbruch beendet."
ausgeben.
*/

durchlaufe ... 3 als Zahl
# "Der Anfang vom Durchlauf #* wurde erreicht." ausgeben
Konsole.schreiben("Der Anfang vom Durchlauf #" & Zahl & " wurde erreicht.")

# diesen einzelnen Durchlauf abbrechen
überspringe

# "Das Ende vom Durchlauf #* wurde erreicht." ausgeben
Konsole.schreiben("Das Ende vom Durchlauf #" & Zahl & " wurde erreicht.")

wenn erledigt
Konsole.schreiben("Der gesamte Schleifendurchlauf wurde ohne Abbruch beendet.")
ansonsten
Konsole.schreiben("Der gesamte Schleifendurchlauf wurde abgebrochen.")

Definition
allgemein
Name: überspringe
Beschreibung: Bricht einen einzelnen Schleifendurchlauf an dieser Stelle ab und fährt mit dem nächsten Durchlauf fort.

Die Verwendung vom Ausdruck "überspringe" hat keine Auswirkungen auf die Variablen
  • "abgebrochen" und
  • "erledigt".

Schreibweisen, welche zulässig sind
  • auslassen
  • lasse aus
  • omit
  • skip
  • skip over
  • überspringe
  • überspringen

Syntax
Art: Ausdruck
Formen:
  • überspringe

Parameter
Anzahl: 0

mehrere Durchläufe

Beispiele
/*
Die folgende Schleife wird
- "0",
- "1" und dann
- "2"
ausgeben.
*/

durchlaufe als Zahl
# Zahl ausgeben
Konsole.schreiben(Zahl)

wenn Zahl == 2
breche ab

/*
Das Folgende wird
- "0",
- "1",
- "2" und dann
- "Der Schleifendurchlauf wurde ohne Abbruch beendet."
ausgeben.
*/

durchlaufe ... 3 als Zahl
# Zahl ausgeben
Konsole.schreiben(Zahl)

wenn erledigt
Konsole.schreiben("Der Schleifendurchlauf wurde ohne Abbruch beendet.")
ansonsten
Konsole.schreiben("Der Schleifendurchlauf wurde abgebrochen.")

/*
Das Folgende wird
- "0",
- "1",
- "2" und dann
- "Der Schleifendurchlauf wurde ohne Abbruch beendet."
ausgeben.
*/

durchlaufe ... 3 als Zahl
# Zahl ausgeben
Konsole.schreiben(Zahl)

wenn abgebrochen
Konsole.schreiben("Der Schleifendurchlauf wurde abgebrochen.")
ansonsten
Konsole.schreiben("Der Schleifendurchlauf wurde ohne Abbruch beendet.")

/*
Das Folgende wird
- "0",
- "1" und dann
- "Der Schleifendurchlauf wurde abgebrochen."
ausgeben.
*/

durchlaufe ... 3 als Zahl
# Zahl ausgeben
Konsole.schreiben(Zahl)

wenn Zahl == 1
breche ab

wenn abgebrochen
Konsole.schreiben("Der Schleifendurchlauf wurde abgebrochen.")

/*
Das Folgende wird
- "Der Anfang vom Durchlauf #0 wurde erreicht.",
- "Das Ende vom Durchlauf #0 wurde erreicht." und dann
- "Der Anfang vom Durchlauf #1 wurde erreicht."
ausgeben.
*/

durchlaufe ... 3 als Zahl
# "Der Anfang vom Durchlauf #* wurde erreicht." ausgeben
Konsole.schreiben("Der Anfang vom Durchlauf #" & Zahl & " wurde erreicht.")

wenn Zahl == 1
breche ab

# "Das Ende vom Durchlauf #* wurde erreicht." ausgeben
Konsole.schreiben("Das Ende vom Durchlauf #" & Zahl & " wurde erreicht.")

Definition
allgemein
Name: breche ab
Beschreibung: Durch das Erreichen vom Ausdruck wird
  • der gesamte Schleifendurchlauf an dieser Stelle abgebrochen und
    • die Variable "abgebrochen" auf "wahr" und
    • die Variable "erledigt" auf "falsch"
    gesetzt.

Schreibweisen, welche zulässig sind
breche ab:
  • abbrechen
  • abort
  • breche ab
  • cancel
abgebrochen
  • abgebrochen
  • aborted
  • canceled
  • cancelled
erledigt:
  • done
  • erledigt

Syntax
Art: Ausdruck
Formen:
  • breche ab

Parameter
Anzahl: 0

Anmerkungen
  • Wenn
    • eine Schleife ohne den Ausdruck "breche ab" beendet wird, also wenn der Wert von der Variable "Zählerwert_-_momentan" den Wert von der Variable "Zählerwert_-_Ende" erreicht hat,
    dann
    • wird
      • die Variable "abgebrochen" auf "falsch" und
      • die Variable "erledigt" auf "wahr"
      gesetzt.

Daten emittieren

Beispiele

/*
Das Folgende wird diese Liste erzeugen:
<
: 0
: 4
: 8
>
*/

meine_Liste = durchlaufe ... 3 als Zahl
# (Zahl * 4) als Wert in meine_Liste einfügen
emittiere , Zahl * 4

/*
Das Folgende wird diese Liste erzeugen:
<
0 :
2 :
4 :
>
*/

meine_Liste = durchlaufe ... 3 als Zahl
/* das Komma (",") am Ende kann in diesem Fall weggelassen werden */
# (Zahl * 2) als Schlüssel in meine_Liste einfügen
emittiere Zahl * 2,

/*
Das Folgende wird diese Liste erzeugen:
<
0 : 0
2 : 4
4 : 8
>
*/

meine_Liste = durchlaufe ... 3 als Zahl
#     - (Zahl * 2) als Schlüssel und
#     - (Zahl * 4) als Wert
# in meine_Liste einfügen
emittiere Zahl * 2, Zahl * 4

/*
Das Folgende wird diese Liste erzeugen:
<
0 : 0
2 : 4
4 : 8
>
*/

meine_Liste = durchlaufe ... 3 als Zahl
# Schlüssel definieren
Schlüssel = Zahl * 2

# Wert definieren
Wert = Zahl * 4

# Schlüssel und Wert in meine_Liste einfügen
emittiere Schlüssel, Wert

Definition

allgemein
Name: emittiere
Beschreibung: Fügt einen Eintrag in eine Liste ein. Diese Liste wird erst nach dem Verlassen von der Schleife in der Variable gespeichert, welche links vom Gleichheitszeichen ("=") angegeben ist.

Schreibweisen, welche zulässig sind
  • emit
  • emittiere
  • emittieren

Syntax
Art: Ausdruck und Konstrukt
Formen:
  • emittiere/° /°Schlüssel_-_einzufügen = nichts°//°, /°Wert_-_einzufügen = nichts°/°/°/

Parameter
Eingabe
Anzahl: 0 bis 2

Schlüssel_-_einzufügen
Beispiel: "Name vom Fluß"
Beschreibung: Jedes mal, wenn
  • der Ausdruck "emittiere" im Schleifenkörper erreicht wird,
dann
  • wird ein Eintrag in eine Liste eingefügt. Dieser Eintrag erhält
    • die Variable oder
    • den Wert
    als Schlüssel, welcher mit der Hilfe von diesem Parameter angegeben wurde.
Standardwert: Wenn
  • 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_-_einzufügen
Beispiel: "Donau"
Beschreibung: Jedes mal, wenn
  • der Ausdruck "emittiere" im Schleifenkörper erreicht wird,
dann
  • wird ein Eintrag in eine Liste eingefügt. Dieser Eintrag erhält
    • die Variable oder
    • den Wert
    als Wert, welcher mit der Hilfe von diesem Parameter angegeben wurde.
Standardwert: Wenn
  • 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

Anmerkungen
  • Wenn
    • die Variable, welche links vom Gleichheitszeichen ("=") angegeben ist, bereits eine Liste gespeichert hält, welche Einträge enthält,
    dann
    • werden die neuen Einträge, welche durch den Ausdruck "emittiere" emittiert werden,
      • nicht zu dieser Liste hinzugefügt.
      • Stattdessen wird für das Sammeln von den neuen Einträgen eine neue Liste erzeugt. Diese neue Liste wird beim Verlassen von der Schleife der Variable zugewiesen, sodass die ursprüngliche Liste, wenn sie nicht noch anderorts gespeichert ist, verloren geht.

durchlaufen

ohne einer zu durchlaufenden Variable

Beispiele
/*
Die folgende Schleife wird "unendlich" oft durchlaufen.
*/

durchlaufe
# "Hallo Welt!" ausgeben
Konsole.schreiben("Hallo Welt!")

/*
Die folgende Schleife wird
- "Hallo",
- "Hallo" und dann
- "Hallo"
ausgeben.
*/

durchlaufe ... 3
# "Hallo" ausgeben
Konsole.schreiben("Hallo")

/*
Die folgende Schleife wird
- "0",
- "1" und dann
- "2"
ausgeben.
*/

durchlaufe ... 3 als Zahl
# Zahl ausgeben
Konsole.schreiben(Zahl)

/*
Die folgende Schleife wird
- "2",
- "3" und dann
- "4"
ausgeben.
*/

durchlaufe von 2 bis 5 als Zahl
# Zahl ausgeben
Konsole.schreiben(Zahl)

/*
Die folgenden beiden Schleifen werden beide jeweils
- "2",
- "4" und dann
- "6"
ausgeben.
*/

durchlaufe von 2 bis 7 Schrittgröße 2 als Zahl
# Zahl ausgeben
Konsole.schreiben(Zahl)

durchlaufe von 2 bis 8 Schrittgröße 2 als Zahl
# Zahl ausgeben
Konsole.schreiben(Zahl)

/*
Die folgende Schleife wird
- "5",
- "4" und dann
- "3"
ausgeben.
*/

durchlaufe von 5 bis 2 Schrittgröße -1 als Zahl
# Zahl ausgeben
Konsole.schreiben(Zahl)

/*
Die folgenden beiden Schleifen werden beide jeweils
- "0",
- "1" und dann
- "2"
ausgeben.
*/

Bedingung = wahr
Zahl = 0
durchlaufe solange Bedingung
# Zahl ausgeben
Konsole.schreiben(Zahl)

wenn Zahl == 2
Bedingung = falsch

# weiterzählen
Zahl =+ 1

Bedingung = wahr
durchlaufe als Zahl solange Bedingung
# Zahl ausgeben
Konsole.schreiben(Zahl)

wenn Zahl == 2
Bedingung = falsch

/*
Die folgende Schleife wird
nichts
ausgeben.
*/

Bedingung = falsch
durchlaufe als Zahl solange Bedingung
# Zahl ausgeben
Konsole.schreiben(Zahl)

/*
Die folgende Schleife wird
- "0"
ausgeben.
*/

Bedingung = falsch
durchlaufe als Zahl
# Zahl ausgeben
Konsole.schreiben(Zahl)
solange Bedingung

/*
Die folgende Schleife wird
- "0",
- "1" und dann
- "2"
ausgeben.
*/

Bedingung_-_Anfang = wahr
Bedingung_-_Ende = wahr
durchlaufe als Zahl solange Bedingung_-_Anfang
# Zahl ausgeben
Konsole.schreiben(Zahl)

wenn Zahl == 2
Bedingung_-_Ende = falsch
solange Bedingung_-_Ende

Definition
allgemein
Name: durchlaufe
Beschreibung: Mit der Hilfe von diesem Schlüsselwort wird angegeben, dass ein Codeblock mehrmals durchlaufen werden soll.

Schleifenkopf:
  1. gegebenenfalls in den Schleifenfuß springen
  2. Einsprungziel für jeden Durchlauf
  3. Bedingung_-_Anfang prüfen
  4. gegebenenfalls ans Ende vom Schleifenfuß springen
Schleifenkörper:
  1. Codeblock ausführen
Schleifenfuß:
  1. Bedingung_-_Ende prüfen
  2. gegebenenfalls ans Ende vom Schleifenfuß springen
  3. Zählerwert ändern
  4. Einsprungziel für den ersten Durchlauf
  5. Zählerwert prüfen
  6. gegebenenfalls in den Schleifenkopf springen
  7. Einsprungziel für das Verlassen von der Schleife

Schreibweisen, welche zulässig sind
durchlaufe:
  • durchlaufe
  • laufe
  • loop
  • traverse
von:
  • from
  • von
bis:
  • ...
  • bis
  • to
Schrittgröße:
  • Schritt
  • Schrittgröße
  • Schrittlänge
  • step
  • step size
als:
  • als
  • as
solange:
  • solange
  • while

Syntax
Art: Ausdruck
Formen:
  • /°Liste_-_Ausgabe = °/durchlaufe/° /°von °/Zählerwert_-_Anfang = 0°//° bis Zählerwert_-_Ende = nichts°//° Schrittgröße Schrittgröße = 1°//° als Zählerwert_-_momentan°//° solange Bedingung_-_Anfang°//°
    §Codeblock§°/
    /°solange Bedingung_-_Ende°/

Parameter
Eingabe
Anzahl: 0 bis 6

Zählerwert_-_Anfang
Beispiel: 5
Beschreibung: Mit der Hilfe von diesem Parameter wird der Wert übergeben, bei welchem der Zählvorgang beginnen soll.
Standardwert: Wenn
  • für diesen Parameter kein Wert übergeben wird,
dann
  • wird der Wert "0" verwendet.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl

Zählerwert_-_Ende
Beispiel: 10
Beschreibung: Mit der Hilfe von diesem Parameter wird der Wert übergeben, bei welchem der Schleifendurchlauf abgebrochen werden soll, wenn der momentane Zählerwert diesen Wert
  • erreicht oder
  • über-/unterschritten
hat.

Wenn
  • der Schleifendurchlauf nicht abgebrochen werden soll, nur weil der momentane Zählerwert einen bestimmten Wert
    • erreicht oder
    • über-/unterschritten
    hat,
dann
  • kann der Wert "nichts" verwendet werden.
Standardwert: Wenn
  • 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
  • Nichtigkeitsangabe

Schrittgröße
Beispiel: 2
Beschreibung: Mit der Hilfe von diesem Parameter wird der Wert übergeben, welcher jedes Mal zum momentanen Zählerwert hinzuaddiert werden soll, wenn der Schleifenkörper erfolgreich durchlaufen wurde.

Ein
  • positiver Wert bewirkt, dass
    • beim Durchlaufen von der Schleife der momentane Zählerwert Schritt-für-Schritt erhöht wird.
    • im Schleifenfuß die Bedingung "Zählerwert_-_momentan < Zählerwert_-_Ende" erfüllt sein muss, damit der Schleifenkörper erneut ausgeführt wird.
  • negativer Wert bewirkt, dass
    • beim Durchlaufen von der Schleife der momentane Zählerwert Schritt-für-Schritt gesenkt wird.
    • im Schleifenfuß die Bedingung "Zählerwert_-_momentan > Zählerwert_-_Ende" erfüllt sein muss, damit der Schleifenkörper erneut ausgeführt wird.
Standardwert: Wenn
  • für diesen Parameter kein Wert übergeben wird,
dann
  • wird der Wert "1" verwendet.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl

Bedingung_-_Anfang
Beispiel: Anzahl_der_Empfänger > 0
Beschreibung: Mit der Hilfe von diesem Parameter wird ein Wert angegeben, welcher geprüft werden soll, ob er etwas ist.

Wenn
  • der Wert nichts ist,
dann
  • wird die Schleife nicht weiter ausgeführt.

Hier ist eine Übersicht, in welcher eingesehen werden kann, wann welche Bedingung geprüft wird.
Standardwert: Wenn
  • für diesen Parameter kein Wert übergeben wird,
dann
  • wird diese Bedingung nicht geprüft und
  • kann der Schleifendurchlauf nicht aufgrund von dieser Bedingung abgebrochen werden.
Variablentypen,
welche für die Eingabe zulässig sind:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

§Codeblock§
Beispiel: # "Hallo Welt!" ausgeben
Konsole.schreiben("Hallo Welt!")
Beschreibung: Mit der Hilfe von diesem Parameter wird Quellcode angegeben, welcher jedes Mal ausgeführt werden soll, wenn der Schleifenkörper durchlaufen wird.
Standardwert: Wenn
  • für diesen Parameter kein Quellcode übergeben wird,
dann
  • wird kein Quellcode verwendet.
Variablentypen,
welche für die Eingabe zulässig sind: 		Für diesen Parameter wird
  • kein Parameterwert mit einem spezifischem Variablentyp,
  • sondern Quellcode
erwartet.

Bedingung_-_Ende
Beispiel: sind_weitere_Briefe_vorhanden()
Beschreibung: siehe: hier
Standardwert: siehe: hier
Variablentypen,
welche für die Eingabe zulässig sind: 		siehe: hier

Ausgabe
Anzahl: 0 bis 2

Liste_-_Ausgabe
Beispiel: gesammelte_Werte
Beschreibung: Mit der Hilfe von diesem Parameter wird eine Bezeichnung für eine Liste angegeben, in welcher die emittierten
  • Schlüssel und
  • Werte
gespeichert werden sollen.
Variablentypen,
welche für die Ausgabe verwendet werden:
  • Liste

Zählerwert_-_momentan
Beispiel: momentane_Durchlaufsnummer
Beschreibung: Mit der Hilfe von diesem Parameter wird eine Bezeichnung für eine Variable angegeben, in welcher der aktuelle Zählerwert gespeichert werden soll.

Für einige Programmierer ist es üblich, diese Variable "i" ("integer") zu nennen.
Variablentypen,
welche für die Ausgabe verwendet werden: 		Es wird der Variablentyp vom Eingabeparameter "Schrittgröße" verwendet.

mit einer Liste

Beispiele
# meine_Liste definieren
meine_Liste = <
"Berlin" : "Berlin"
"Bayern" : "München"
"Baden-Württemberg" : "Stuttgart"
>

/*
Die folgende Schleife wird
- "Hallo Welt!",
- "Hallo Welt!" und dann
- "Hallo Welt!"
ausgeben.
*/

durchlaufe meine_Liste
# "Hallo Welt!" ausgeben
Konsole.schreiben("Hallo Welt!")

/*
Die folgende Schleife wird
- "Wert: Berlin",
- "Wert: München" und dann
- "Wert: Stuttgart"
ausgeben.
*/

durchlaufe meine_Liste als , , Wert_-_momentan
# Wert_-_momentan ausgeben
Konsole.schreiben("Wert: " & Wert_-_momentan)

/*
Die folgende Schleife wird
- "Schlüssel: Berlin, Wert: Berlin",
- "Schlüssel: Bayern, Wert: München" und dann
- "Schlüssel: Baden-Württemberg, Wert: Stuttgart"
ausgeben.
*/

durchlaufe meine_Liste als , Schlüssel_-_momentan, Wert_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Schlüssel: " & Schlüssel_-_momentan & ", Wert: " & Wert_-_momentan)

/*
Die folgende Schleife wird
- "Index: 0, Schlüssel: Berlin, Wert: Berlin",
- "Index: 1, Schlüssel: Bayern, Wert: München" und dann
- "Index: 2, Schlüssel: Baden-Württemberg, Wert: Stuttgart"
ausgeben.
*/

durchlaufe meine_Liste als Index_-_momentan, Schlüssel_-_momentan, Wert_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Schlüssel: " & Schlüssel_-_momentan & ", Wert: " & Wert_-_momentan)

/*
Die folgende Schleife wird
- "Index: 0, Wert: Berlin",
- "Index: 1, Wert: München" und dann
- "Index: 2, Wert: Stuttgart"
ausgeben.
*/

durchlaufe meine_Liste als Index_-_momentan, , Wert_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Wert: " & Wert_-_momentan)

/*
Die folgende Schleife wird
- "Index: 1, Schlüssel: Bayern"
ausgeben.
*/

durchlaufe meine_Liste[1 ... 2] als Index_-_momentan, Schlüssel_-_momentan,
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Schlüssel: " & Schlüssel_-_momentan)

/*
Die folgende Schleife wird
- "Index: 2, Wert: Stuttgart",
- "Index: 1, Wert: München" und dann
- "Index: 0, Wert: Berlin"
ausgeben.
*/

durchlaufe meine_Liste[... Schrittgröße -1] als Index_-_momentan, , Wert_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Wert: " & Wert_-_momentan)

/*
Die folgende Schleife wird
- "Index: 1, Wert: München" und dann
- "Index: 0, Wert: Berlin"
ausgeben.
*/

durchlaufe meine_Liste[1 ... Schrittgröße -1] als Index_-_momentan, , Wert_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Wert: " & Wert_-_momentan)

/*
Die folgenden 4 Schleifen werden jeweils
- "Index: 2, Wert: Stuttgart" und dann
- "Index: 1, Wert: München"
ausgeben.
*/

durchlaufe meine_Liste[2 ... 0 Schrittgröße -1] als Index_-_momentan, , Wert_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Wert: " & Wert_-_momentan)

durchlaufe meine_Liste("Baden-Württemberg" ... "Berlin" Schrittgröße -1) als Index_-_momentan, , Wert_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Wert: " & Wert_-_momentan)

durchlaufe meine_Liste{"Stuttgart" ... "Berlin" Schrittgröße -1} als Index_-_momentan, , Wert_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Wert: " & Wert_-_momentan)

durchlaufe meine_Liste{"Stuttgart" ... 0 Schrittgröße -1] als Index_-_momentan, , Wert_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Wert: " & Wert_-_momentan)

Definition
allgemein
siehe: hier

Schreibweisen, welche zulässig sind
siehe: hier

Syntax
Art: Ausdruck
Formen:
  • /°Liste_-_Ausgabe = °/durchlaufe Liste_-_Eingabe/° als /°Index_-_momentan°//°, /°Schlüssel_-_momentan°//°, /°Wert_-_momentan°/°/°/°//° solange Bedingung_-_Anfang°//°
    §Codeblock§°/
    /°solange Bedingung_-_Ende°/

Parameter
Eingabe
Anzahl: 1 bis 4

Liste_-_Eingabe
Beispiel: Städtenamen
Beschreibung: Mit der Hilfe von diesem Parameter wird eine Liste angegeben, welche durchlaufen 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:
  • Liste

Bedingung_-_Anfang
siehe: hier

§Codeblock§
siehe: hier

Bedingung_-_Ende
siehe: hier

Ausgabe
Anzahl: 0 bis 4

Liste_-_Ausgabe
siehe: hier

Index_-_momentan
Beispiel: aktueller_Index
Beschreibung: Mit der Hilfe von diesem Parameter wird eine Bezeichnung für eine Variable angegeben, in welcher der Index vom aktuellen Eintrag gespeichert werden soll.
Variablentypen,
welche für die Ausgabe verwendet werden:
  • Ganzzahl

Schlüssel_-_momentan
Beispiel: aktueller_Schlüssel
Beschreibung: Mit der Hilfe von diesem Parameter wird eine Bezeichnung für eine Variable angegeben, in welcher der Schlüssel vom aktuellen Eintrag gespeichert werden soll.
Variablentypen,
welche für die Ausgabe verwendet werden:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

Wert_-_momentan
Beispiel: aktueller_Wert
Beschreibung: Mit der Hilfe von diesem Parameter wird eine Bezeichnung für eine Variable angegeben, in welcher der Wert vom aktuellen Eintrag gespeichert werden soll.
Variablentypen,
welche für die Ausgabe verwendet werden:
  • Ganzzahl
  • Kommazahl
  • Liste
  • Nichtigkeitsangabe
  • Rohdatenkette
  • Wahrheitsangabe
  • Zeichenkette

mit einer Zeichenkette

Beispiele
# meine_Zeichenkette definieren
meine_Zeichenkette = "abc"

/*
Die folgende Schleife wird
- "Hallo Welt!",
- "Hallo Welt!" und dann
- "Hallo Welt!"
ausgeben.
*/

durchlaufe meine_Zeichenkette
# "Hallo Welt!" ausgeben
Konsole.schreiben("Hallo Welt!")

/*
Die folgende Schleife wird
- "Zeichen: a",
- "Zeichen: b" und dann
- "Zeichen: c"
ausgeben.
*/

durchlaufe meine_Zeichenkette als , Zeichen_-_momentan
# Zeichen ausgeben
Konsole.schreiben("Zeichen: " & Zeichen_-_momentan)

/*
Die folgende Schleife wird
- "Index: 0, Zeichen: a",
- "Index: 1, Zeichen: b" und dann
- "Index: 2, Zeichen: c"
ausgeben.
*/

durchlaufe meine_Zeichenkette als Index_-_momentan, Zeichen_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Zeichen: " & Zeichen_-_momentan)

/*
Die folgende Schleife wird
- "Index: 0",
- "Index: 1" und dann
- "Index: 2"
ausgeben.
*/

durchlaufe meine_Zeichenkette als Index_-_momentan,
# Index ausgeben
Konsole.schreiben("Index: " & Index_-_momentan)

/*
Die folgende Schleife wird
- "Index: 1, Zeichen: b"
ausgeben.
*/

durchlaufe meine_Zeichenkette[1 ... 2] als Index_-_momentan, Zeichen_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Zeichen: " & Zeichen_-_momentan)

/*
Die folgende Schleife wird
- "Index: 2, Zeichen: c",
- "Index: 1, Zeichen: b" und dann
- "Index: 0, Zeichen: a"
ausgeben.
*/

durchlaufe meine_Zeichenkette[... Schrittgröße -1] als Index_-_momentan, Zeichen_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Zeichen: " & Zeichen_-_momentan)

/*
Die folgende Schleife wird
- "Index: 1, Zeichen: b" und dann
- "Index: 0, Zeichen: a"
ausgeben.
*/

durchlaufe meine_Zeichenkette[1 ... Schrittgröße -1] als Index_-_momentan, Zeichen_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Zeichen: " & Zeichen_-_momentan)

/*
Die folgenden 3 Schleifen werden jeweils
- "Index: 2, Zeichen: c" und dann
- "Index: 1, Zeichen: b"
ausgeben.
*/

durchlaufe meine_Zeichenkette[2 ... 0 Schrittgröße -1] als Index_-_momentan, Zeichen_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Zeichen: " & Zeichen_-_momentan)

durchlaufe meine_Zeichenkette{"c" ... "a" Schrittgröße -1} als Index_-_momentan, Zeichen_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Zeichen: " & Zeichen_-_momentan)

durchlaufe meine_Zeichenkette{"c" ... 0 Schrittgröße -1] als Index_-_momentan, Zeichen_-_momentan
# Eintrag ausgeben
Konsole.schreiben("Index: " & Index_-_momentan & ", Zeichen: " & Zeichen_-_momentan)

Definition
allgemein
siehe: hier

Schreibweisen, welche zulässig sind
siehe: hier

Syntax
Art: Ausdruck
Formen:
  • /°Liste_-_Ausgabe = °/durchlaufe Zeichenkette/° als /°Index_-_momentan°//°, /°Zeichen_-_momentan°/°/°//° solange Bedingung_-_Anfang°//°
    §Codeblock§°/
    /°solange Bedingung_-_Ende°/

Parameter
Eingabe
Anzahl: 1 bis 4

Zeichenkette
Beispiel: "Hallo Welt!"
Beschreibung: Mit der Hilfe von diesem Parameter wird eine Zeichenkette angegeben, welche durchlaufen 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:
  • Zeichenkette

Bedingung_-_Anfang
siehe: hier

§Codeblock§
siehe: hier

Bedingung_-_Ende
siehe: hier

Ausgabe
Anzahl: 0 bis 3

Liste_-_Ausgabe
siehe: hier

Index_-_momentan
siehe: hier

Zeichen_-_momentan
Beispiel: aktuelles_Zeichen
Beschreibung: Mit der Hilfe von diesem Parameter wird eine Bezeichnung für eine Variable angegeben, in welcher das Zeichen vom aktuellen Eintrag gespeichert werden soll.
Variablentypen,
welche für die Ausgabe verwendet werden:
  • Zeichenkette

neustarten

Beispiele

/*
Der folgende Code simuliert eine Maschine, welche 4 Flaschen in eine Kiste stellt
und dabei die Variable "Protokoll" füllt.

Nach jedem Mal, wenn eine Flasche in die Kiste gestellt wurde, wird das Gewicht
gemessen und geprüft, ob das Gewicht bei der Anzahl der Flaschen realistisch ist.

Wenn
- das Gewicht nicht stimmt,
dann
- wird die Kiste beiseite geschoben, damit sich ein Mensch anschauen kann,
  was da los ist. Es wird dann eine neue, leere Kiste gefüllt.

Bei den verwendeten Funktionen wird davon ausgegangen, dass
- sie irgendwo definiert werden und
- das machen, was man vom Namen her erwarten würde.
*/

Protokoll = durchlaufe 1 ... 5 als Anzahl_der_Flaschen_in_der_Kiste
falls Anzahl_der_Flaschen_in_der_Kiste == 1
# Protokoll füttern
emittiere , "Es wird nun eine leere Kiste in die Maschine geschoben ..."

# leere Kiste in die Maschine schieben
leere_Kiste_in_die_Maschine_schieben()

# Protokoll füttern
emittiere , "... Es ist nun eine leere Kiste in der Maschine."

# Protokoll füttern
emittiere , "Es wird nun eine Flasche in die Kiste gestellt ..."

# eine Flasche in die Kiste stellen
eine_Flasche_in_die_Kiste_stellen()

falls Gewicht_von_der_Kiste_prüfen(Anzahl_der_Flaschen_in_der_Kiste) != "ok"
# Protokoll füttern
emittiere , "... Es wurde keine volle Flasche in die Kiste gestellt."

# Protokoll füttern
emittiere , "Es wird nun die Kiste zum Mitarbeiter geschoben ..."

# Kiste zum Mitarbeiter schieben
Kiste_zum_Mitarbeiter_schieben()

# Protokoll füttern
emittiere , "... Es ist nun keine Kiste in der Maschine."

# den Füllvorgang neustarten
starte neu

# Protokoll füttern
emittiere , "... Es sind nun " & Anzahl_der_Flaschen_in_der_Kiste & " Flasche(n) in der Kiste."

/*
Die Variable "Protokoll" hält nun eine Liste gespeichert, welche beispielsweise wie
folgt definiert ist:
<
: "Es wird nun eine leere Kiste in die Maschine geschoben ..."
: "... Es ist nun eine leere Kiste in der Maschine."
: "Es wird nun eine Flasche in die Kiste gestellt ..."
: "... Es sind nun 1 Flasche(n) in der Kiste."
: "Es wird nun eine Flasche in die Kiste gestellt ..."
: "... Es wurde keine volle Flasche in die Kiste gestellt."
: "Es wird nun die Kiste zum Mitarbeiter geschoben ..."
: "... Es ist nun keine Kiste in der Maschine."
: "Es wird nun eine leere Kiste in die Maschine geschoben ..."
: "... Es ist nun eine leere Kiste in der Maschine."
: "Es wird nun eine Flasche in die Kiste gestellt ..."
: "... Es sind nun 1 Flasche(n) in der Kiste."
: "Es wird nun eine Flasche in die Kiste gestellt ..."
: "... Es sind nun 2 Flasche(n) in der Kiste."
: "Es wird nun eine Flasche in die Kiste gestellt ..."
: "... Es sind nun 3 Flasche(n) in der Kiste."
: "Es wird nun eine Flasche in die Kiste gestellt ..."
: "... Es sind nun 4 Flasche(n) in der Kiste."
>
*/

Definition

allgemein
Name: starte neu
Beschreibung: Bricht einen einzelnen Schleifendurchlauf an dieser Stelle ab und setzt den Zähler auf den Anfangswert zurück. Anschließend wird der nächste Schleifendurchlauf gestartet.

Die Verwendung vom Ausdruck "starte neu" hat keine Auswirkungen auf die Variablen
  • "abgebrochen" und
  • "erledigt".

Schreibweisen, welche zulässig sind
  • neustarten
  • restart
  • starte neu

Syntax
Art: Ausdruck
Formen:
  • starte neu

Parameter
Anzahl: 0

Stichwortverzeichnis

Ausdrücke


Kommentare


Operatoren

Addition (Plus rechnen)


Anhängung


ist gleich


ist größer als


ist größer oder gleich


ist kleiner als


ist kleiner oder gleich


ist nichts


ist ungleich


oder


Subtraktion (Minus rechnen)


und


Wertzuweisung


Variablen mit spezieller Funktion

weiteres Material zu diesem Thema

Dokumente

Name vom Sprache: Umfang vom Inhalt: Weblink:
Autor: Dokument:
die Bibliothek "logic/total_values" deutsch
  • enthält allgemeine Informationen über die Bibliothek "logic/total_values"
  • enthält im Kapitel "die Details - Funktionen - Logik - mit 2 Operanden - is_equal - allgemein - Beschreibung" das exakte Verhalten vom Operand "ist gleich "
 OnTheServer.de/Downloads/
Minicode - allgemeine Informationen
  • enthält allgemeine Informationen über die Programmiersprache "Minicode"
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 - Liste
  • beschreibt die Klasse "Liste" 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
Zeichenkodierungen
  • beschreibt verschiedene Zeichenkodierungen; unter anderem auch die, welche von Minicode unterstützt werden
Zeit - Standort-abhängige Einflüsse auf Zeitangaben
  • beschreibt die Begriffe
    • "globale Zeit" und "lokale Zeit",
    • "Sommer-" und "Winterzeit" und
    • "Zeitzonen"
Zeit - Zeitsysteme
  • beschreibt verschiedene Zeitsysteme; unter anderem auch die, welche von Minicode unterstützt werden

Sonstiges

Name vom Beschreibung: Sprache: Weblink:
Autor: Material:
Beispiele für Quellcode-Dateien Bei den Bibliotheken befinden sich zum Teil Beispiele für Quellcode-Dateien, da manche von den Demonstrationsprogrammen in Minicode geschrieben sind. Manche Demonstrationsprogramme sind allerdings in Maschinensprache geschrieben. Minicode OnTheServer.de/Downloads/