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

Zum Inhalt

# Kontrolloperatoren

## Programmierung

## Kontrolloperatoren

### Programmfluss

Wir beschreiben zunächst die Operatoren, die es ermöglichen, bedingte Verzweigungen und verschiedene Arten von Schleifen zu erzeugen. Der Benutzer sollte beachten, dass es auch andere schleifenähnliche Strukturen gibt, die sich aus den verschiedenen Möglichkeiten zum Durchlaufen von Listen ergeben. Sie werden in dem Abschnitt Elementare Listenoperationen beschrieben.

#### Der bedingte Operator: `if(<bool>,<expr>)`

Beschreibung: Der Ausdruck `<expr>` wird ausgewertet, wenn die boolesche Bedingung `<bool>` zu `true` ausgewertet wird. In diesem Fall ist der Rückgabewert der `if`-Funktion . Ansonsten wird `___` zurückgegeben. Eine typische Verwendung des `if`-Operators ist die bedingte Auswertung von Nebenwirkungen.

Beispiel: Dieses Code-Fragment gibt eine Nachricht auf der Konsole aus, wenn `x` einen negativen Wert hat.

    if(x<0,println("x is now negative"))

#### Der bedingte Verzweigungsoperator: `if(<bool>,<expr1>,<expr2>)`

Beschreibung: Der Ausdruck `<expr1>` wird ausgewertet, wenn die boolesche Bedingung `<bool>` zu `true` ausgewertet wird. Wenn `<bool>` zu `false` ausgewertet wird, wird `<expr2>` ausgewertet. In jedem Fall wird der Wert des ausgewerteten Ausdrucks zurückgegeben. Somit codiert diese ternäre Version des `if`-Operators eine if/then/else-Funktionalität. Es gibt zwei typische Verwendungen dieser Version des `if`-Operators: Erstens wird der `if`-Operator verwendet, um die bedingte Auswertung von Programmteilen zu erzwingen (was normalerweise Nebenwirkungen verursacht).

Beispiel: Dieses Code-Fragment gibt eine Nachricht auf der Konsole aus, die zeigt, ob `x` positiv, negativ oder null ist.

    if(x<0,
       println("x is now negative"),
       if (x>0,
          println("x is now positive"),
          println("x is zero")
       )
     )

Eine zweite Verwendung des `if`-Operators besteht darin, einen bestimmten Wert abhängig von der durch `<bool>` codierten Bedingung zurückzugeben. Dies ist besonders nützlich bei der Definition von Funktionen.

Beispiel: Dieses Code-Fragment definiert die Funktion `f(x)` als die Absolutwertfunktion (für reelle Werte von `x`).

    f(x):=if(x>0,x,-x)

Beispiel: Dieses Code-Fragment nimmt ein geometrisches Element A (wahrscheinlich ein Punkt) und setzt seine Farbe auf Rot oder Blau abhängig vom Wert seiner x-Koordinate.

    A.color=if(A.x>0,(1,0,0),(0,0,1))

#### Der Trigger-Operator: `trigger(<bool>,<expr>)`

Beschreibung: Der `trigger`-Operator ähnelt sehr dem `if`-Operator. Im Gegensatz zu `if` hat der `trigger`-Operator einen dynamischen Charakter. Der Ausdruck `<expr>` wird ausgewertet, wenn `<bool>` von `false` zu `true` wechselt. Dies bedeutet, dass während des Ziehens einer Konstruktion `<expr>` ausgewertet wird, wenn `<bool>` in der vorherigen Instanz `false` war und jetzt `true` ist. Der Zweck dieses Operators besteht darin, Nebenwirkungen auszulösen, wenn ein Ereignis während des Ziehens der Konstruktion auftritt. Das folgende Code-Fragment zeigt dieses Verhalten.

Beispiel: Dieses Code-Fragment gibt eine Nachricht aus, wenn Punkt `A` die y-Achse kreuzt.

    trigger(A.x<0,println("A now entered the x-negative half-plane"))
    trigger(A.x>0,println("A now entered the x-positive half-plane"))

#### Die while-Schleife: `while(<bool>,<expr>)`

Beschreibung: Der `while`-Operator wertet den Ausdruck `<expr>` aus, solange die Bedingung `<bool>` wahr ist. Das Ergebnis der letzten Auswertung wird als Wert der Funktion zurückgegeben.

Beispiel:

    x=0;
    sum=0;
    erg=while(x<4,
             x=x+1;
             sum=sum+x;
             println(x+"  -->  "+sum);
             sum
          );
    println(erg);

Dieses Code-Fragment erzeugt die Ausgabe

    1  -->  1
    2  -->  3
    3  -->  6
    4  -->  10
    10

Nach seiner Auswertung hat die Variable `erg` den Wert `10`. Eine Warnung: Man sollte sich bewusst sein, dass `while`-Operationen leicht zu Endlosschleifen führen können, wenn die Bedingung nie erfüllt wird.

#### Die repeat-Schleife: `repeat(<number>,<expr>)`

Beschreibung: Dieser Operator bietet die einfachste Art von Schleife in CindyScript: `<expr>` wird `<number>`-mal ausgewertet. Das Ergebnis der letzten Auswertung wird zurückgegeben. Während der Auswertung von `<expr>` enthält die spezielle Variable `#` die Laufvariable der Schleife.

Beispiel: Dieses Code-Fragment erzeugt eine Liste der ersten 100 ganzen Zahlen zusammen mit ihren Quadraten.

    repeat(100,
        println(#+" squared is "+#^2)
    )

Modifizierer: Die `repeat`-Schleife unterstützt eine Vielzahl von Modifizierern. Diese Modifizierer können verwendet werden, um Startwert, Stopwert und Schrittweite der Schleife zu steuern. Der Modifizierer `start` legt den Startwert der Schleife fest. Der Modifizierer `stop` legt den Stopwert der Schleife fest. Der Modifizierer `step` legt die Schrittweite fest. Beliebige Kombinationen von Modifizierern sind möglich. Solange nicht alle drei Modifizierer gesetzt sind, wird die Schleife immer `<number>`-mal ausgeführt. Für die Modifizierer sind nur reelle Werte erlaubt. Die folgende Tabelle zeigt verschiedene Verwendungen der Modifizierer.

Code | Ergebnis
--- | ---
`repeat(6, println(#+" "))` | `1 2 3 4 5 6`
`repeat(6, start->4, println(#+" "))` | `4 5 6 7 8 9`
`repeat(6, stop->2, println(#+" "))` | `-3 -2 -1 0 1 2`
`repeat(6, step->3, println(#+" "))` | `1 4 7 10 13 16`
`repeat(6, stop->12, step->4, println(#+" "))` | `-8 -4 0 4 8 12`
`repeat(6, start->3, step->2, println(#+" "))` | `3 5 7 9 11 13`
`repeat(6, start->3, stop->4, println(#+" "))` | `3 3.2 3.4 3.6 3.8 4`
`repeat(6, start->0, stop->-3, println(#+" "))` | `0 -0.6 -1.2 -1.8 -2.4 -3`
`repeat(6, start->3, stop->4, step->0.4,println(#+" "))` | `3 3.4 3.8`

#### Die repeat-Schleife: `repeat(<number>,<var>,<expr>)`

Beschreibung: Dieser Operator ist identisch mit dem Operator `repeat(<number>,<expr>)`, mit einer Ausnahme: Die Laufvariable wird nun `<var>` zugewiesen. Dies ermöglicht die Verwendung verschachtelter Schleifen mit verschiedenen Laufvariablen.

Beispiel: Dieses Code-Fragment zeichnet ein 10 × 10 Array von Punkten.

    repeat(10,i,
       repeat(10,j,
          draw((i,j))
       )
    )

#### Die forall-Schleife: `forall(<list>,<expr>)`

Beschreibung: Dieser Operator nimmt eine `<list>` als erstes Argument. Er erzeugt eine Schleife, in der `<expr>` für jeden Eintrag der Liste ausgewertet wird. In jeder Iteration nimmt die Laufvariable `#` den Wert des entsprechenden Listeneintrags an.

Beispiel:

    a=["this","is","a","list"];
    forall(a,println(#))

Dieses Code-Fragment erzeugt die Ausgabe

    this
    is
    a
    list

#### Die forall-Schleife: `forall(<list>,<var>,<expr>)`

Beschreibung: Ähnlich wie `forall(<list>,<expr>)`, aber die Laufvariable hat nun den Namen `<var>`.

#### Auswertung erzwingen: `eval(<expr>,<modif1>,<modif2>,…)`

Beschreibung: Dieser Operator erzwingt die Auswertung des Ausdrucks . Freie Variablen des Ausdrucks können mithilfe einer Liste von Modifizierern ersetzt werden. Die Variablen für die Ersetzung werden nur lokal zugewiesen. Danach werden die Variablen auf die Werte zurückgesetzt, die sie vor der Auswertung hatten.

Beispiel: Dieses Code-Fragment wertet zu `7` aus.

    eval(x+y,x->2,y->5)

### Variablenverwaltung

Die folgenden Beschreibungen erklären, wie lokale Variablen absichtlich erstellt oder zerstört werden. Der Benutzer sollte beachten, dass es für die meisten Zwecke völlig ausreichend ist, Variablen direkt zu erstellen, indem Werte ihnen zugewiesen werden. Solche Variablen sind standardmäßig global. Die Verwendung lokaler Variablen kann notwendig oder empfohlen sein, wenn rekursive Funktionen erzeugt werden oder wenn man eine Funktionsbibliothek erstellen möchte.

#### Variablen erstellen: `createvar(<varname>)`

und

#### Variablen zerstören: `removevar(<varname>)`

Beschreibung: Diese Operatoren helfen bei der manuellen Verwaltung der Erstellung lokaler Variablen. `createvar(x)` erstellt eine neue Variable namens `x`, während der alte Wert auf einem Stack abgelegt wird. `removevar(x)` entfernt die lokale Variable und stellt den Wert vom Stack wieder her. Beachten Sie, dass Variablen normalerweise nicht explizit erstellt werden müssen. Sie werden automatisch generiert, wenn sie zum ersten Mal verwendet werden. Die `createvar`- und `removevar`-Operatoren sollten nur verwendet werden, wenn man einen Variablennamen für eine bestimmte lokale Region des Codes reservieren möchte.

Beispiel:

    x=10;
    println("x is now "+x);
    createvar(x);
    x=5;
    println("x is now "+x);
    removevar(x);
    println("x is now "+x);

Dieses Code-Fragment erzeugt die Ausgabe

    x is now 10
    x is now 5
    x is now 10

#### Erstellen vieler lokaler Variablen für eine Funktion: `regional(name1,name2,...)`

Beschreibung: Diese Anweisung kann am Anfang einer Funktion verwendet werden. Sie hat fast die gleiche Wirkung wie die `local`-Anweisung und erstellt mehrere lokale Variablen. Im Gegensatz zur `local`-Anweisung werden die Variablen jedoch automatisch entfernt, wenn die Funktion beendet wird. Daher ist kein expliziter Aufruf von `release` notwendig. Meistens ist es viel bequemer, `regional` zu verwenden als `local`.

Variablen haben eine Art Persistenz innerhalb von CindyScript. Wenn der Wert einer Variablen in einer Anweisung gesetzt wird, bleibt er gesetzt, bis er geändert wird. Man kann Variablen explizit mit den folgenden Operatoren löschen. Oft ist es nützlich, eine `clear()`-Anweisung unter das `init`-Ereignis des Programms zu setzen.

#### Alle Variablen löschen: `clear()`

Beschreibung: Dieser Operator löscht alle Variablen.

#### Eine bestimmte Variable löschen: `clear(<var>)`

Beschreibung: Dieser Operator löscht die Variable `<var>`.

#### Schlüssel von Objekten: `keys(<var>)`

Beschreibung: Gibt eine Liste aller Schlüssel an, die einem Objekt über eine `<object>:<key>=<something>`-Deklaration zugeordnet sind.

Beispiel: Es ist möglich, einem Objekt unter einem frei gewählten Schlüssel einen Wert zuzuordnen. Dies kann durch Code wie folgt erfolgen:

    A:"age"=34;
    A:"haircolor"="brown";

Diese Zuweisungen können auch durch eine ähnliche Syntax wie folgt aufgerufen werden:

    println(A:"age");
    println(A:"haircolor");

Der Operator `keys` gibt eine Liste aller zugeordneten Schlüssel eines Objekts zurück. In diesem Beispiel

    println(keys(A));

wird die Liste `["age","haircolor"]` zurückgegeben.

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