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.

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