Variablen und Funktionen - Cinderella Dokumentation
Description: The user's guide to the Interactive Geometry Software Cinderella

Zum Inhalt

# Variablen und Funktionen

In CindyScript werden Variablen und Funktionen nicht explizit deklariert. Sie werden bei Bedarf erstellt und sind nicht explizit typisiert. Dies steht in starkem Gegensatz zu vielen anderen Programmiersprachen. In diesem Abschnitt erfahren Sie, unter welchen Umständen Funktionen und Variablen erstellt werden können. Sie werden auch erfahren, wie Sie Variablen zerstören oder löschen können und wie es sich mit ihrem Geltungsbereich verhält.

### Funktionen definieren

Funktionen in CindyScript zu definieren ist sehr einfach. Man muss einfach den Namen einer Funktion angeben, eine Parameterliste bereitstellen und den Funktionsrumpf schreiben. Eine explizite Typisierung von Argumenten oder Funktionswerten ist nicht erforderlich. Im Folgenden stellen wir einige Beispiele für einfache Funktionen bereit. Beispielsweise berechnet die Funktion `f`, die durch

    f(n):=sum(1..n,i,i^2)

definiert ist, die Summe der ersten `n` Quadrate. Nach dieser Definition ergibt beispielsweise `f(4)` den Wert `30`.

Funktionen mit mehr als einem Argument können ähnlich definiert werden. Die folgende Funktion geht davon aus, dass `a` und `b` zweidimensionale Vektoren sind, und zeichnet ein Quadrat, dessen Kante durch diese beiden Vektoren definiert ist:

    sq(a,b):=(
      n=(b-a);
      n2=(-n_2,n_1);
      draw(a,b);
      draw(a,a-n2);
      draw(b,b-n2);
      draw(a-n2,b-n2);
    )

In diesem Code passieren einige interessante Dinge. Erstens ist der Code im Prinzip prozedural. Der Funktionsrumpf hat die Form `(statement_1;…;statement_k)`. Darüber hinaus verwendet die Funktion die Variablen `n` und `n2`. Diese Variablen werden bei der ersten Ausführung der Funktion erstellt. Sie sind jedoch (standardmäßig) nicht lokal. Ihre Werte sind auch nach dem Funktionsaufruf sichtbar.

Der Rückgabewert einer Funktion ist der Wert der zuletzt ausgewerteten Anweisung in der Funktion. Daher berechnet die folgende Funktion das arithmetische Mittel von drei Einträgen.

    mean(a,b,c):=(
      sum=a+b+c;
      sum/3;
    )

Da Funktionen nicht explizit typisiert sind, ist es auch möglich, komplexere Objekte als Funktionsargumente zu übergeben. Die Funktion ist automatisch so polymorph wie möglich, beschränkt nur durch die Allgemeinheit der in der Funktion verwendeten Operationen. Beispielsweise ergibt `mean([3,4],[2,7],[4,7])` `[3,6]`.

### Rekursive Funktionen

Funktionen können auch rekursiv definiert werden. Dann wird für jede Rekursionsebene eine neue Instanz jedes Funktionsparameters erstellt. Der folgende Code berechnet die Fakultät einer Zahl:

    fac(n):=if(n==0,1,n*fac(n-1));

Der folgende komplexere Code berechnet den größten gemeinsamen Teiler zweier positiver Zahlen:

    gcd(a,b):=if(b==0,                //End of recursion reached
                   a,                 //Then return the number a
                   if(b>a,            //Perhaps switch parameters
                     gcd(b,a),        //switched version
                     gcd(b,mod(a,b))  //Recursion
                     )
                 );

### Variablen definieren

Variablen in CindyScript werden bei ihrer ersten Verwendung im Code definiert. Nach der Definition bleiben Variablen für den Rest des Programms zugänglich. Eine Variable kann jeden Objekttyp enthalten (Zahlen, Zeichenketten, Boolesche Werte, Listen, geometrische Punkte oder sogar Programme, …). Das Programm

    x=3;
    b=[x^2,x^3];
    c=2*b;

weist der Variablen `x` den Wert `3` zu, der Variablen `b` den Wert `[9,27]` und der Variablen `c` den Wert `[18,54]`. Eine in einer Funktion definierte Variable bleibt auch außerhalb des Geltungsbereichs der Funktion sichtbar. Ausnahmen von dieser Regel sind die Parameter der Funktion und Variablen, die explizit als lokal definiert sind. Das folgende Programm veranschaulicht den Geltungsbereich von Variablen:

    f(x):= (
      x=x+x;
      println(x);
      y="User"
    );
    x="Hello ";
    y="World";
    println(x+y);
    f(x);
    println(x+y);

Es erzeugt die Ausgabe

    Hello World
    Hello Hello
    Hello User

Lokale Variablen in einer Funktion können explizit mit dem Operator `regional(…)` definiert werden. Sie werden automatisch entfernt, wenn die Funktion beendet wird. Im folgenden Code-Snippet wird als leichte Variation des obigen Programms `y` als lokale Variable innerhalb der Funktion definiert:

    f(x):= (
      regional(y);
      x=x+x;
      println(x);
      y="User";
    );
    x="Hello ";
    y="World";
    println(x+y);
    f(x);
    println(x+y);

Das Programm erzeugt die Ausgabe

    Hello World
    Hello Hello
    Hello World

Laufvariablen in Schleifen werden auch als lokale Variablen behandelt.

### Variablen an Funktionen binden

Variablen in einer Funktion (sofern nicht als lokale Variablen definiert) bleiben nach der Ausführung der Funktion sichtbar. Darüber hinaus können Variablen, die in Funktionen verwendet werden, Anfangswerte haben, die die Auswertung der Funktion beeinflussen.

Beispielsweise erzeugt das folgende Codefragment

    a=3;
    timesa(x):= x*a;
    println(timesa(2));
    a=5;
    println(timesa(2));

die Ausgabe

    6
    10

Der Rückgabewert von `timesa(2)` hängt vom aktuellen Wert der (globalen) Variablen `a` zum Zeitpunkt der Auswertung der Funktion ab. Nach der Neudefinition von `a` ändert sich das Verhalten der Funktion `timesa`. Manchmal ist dieser Effekt beabsichtigt, manchmal nicht. Es kann vorkommen, dass man das Verhalten einer Funktion einfrieren möchte, so dass es von den Variablenwerten zum Zeitpunkt der Funktionsdefinition abhängt. Dies kann durch Verwendung des Operators `::=` zur Funktionsdefinition erreicht werden. Dieser Operator kopiert alle Variablenzuweisungen und bindet sie an die Funktion. Daher erzeugt das Programm

    a=3;
    timesa(x)::= x*a;
    println(timesa(2));
    a=5;
    println(timesa(2));

die Ausgabe

    6
    6

Jedes Mal, wenn die Funktion aufgerufen wird, wird der ursprüngliche Wert von `a` wiederhergestellt. Dieser Bindungsprozess erstreckt sich nicht nur auf alle Variablen, die in der Funktion selbst verwendet werden. Er erstreckt sich auf alle Variablen, die für die Ausführung der Funktion relevant sein können.

Es gibt einen Weg, diese Bindung absichtlich zu umgehen: Der Wert von `a` kann explizit mit einem Modifizierer gesetzt werden. Ein Beispiel dafür ist in folgendem Codefragment zu sehen:

    a=3;
    timesa(x)::= x*a;
    println(timesa(2));
    println(timesa(2,a->10));

Dieses Programmfragment erzeugt die folgende Ausgabe

    6
    20

### Vordefinierte Konstanten

In der Mathematik ist es oft notwendig, mathematische Konstanten wie `pi` oder die imaginäre Einheit `i` zu verwenden. Diese Konstanten sind in CindyScript als Variablen vordefiniert. Dies ermöglicht es, beispielsweise eine komplexe Zahl als `3+i*5` zu schreiben. Es können jedoch verschiedene Werte diesen Variablen zugewiesen werden. Beispielsweise ist es immer noch möglich, diese Variablen als Laufvariablen in Schleifen zu verwenden. Das folgende Programm veranschaulicht diese Funktion:

    println(i);
    repeat(4,i,println(i));
    println(i);

Es erzeugt die folgende Ausgabe:

    0 + i*1
    1
    2
    3
    4
    0 + i*1

Wenn beispielsweise die komplexe Einheit benötigt wird, die Variable `i` aber überschrieben ist, ist es immer noch möglich, die komplexe Einheit über die Funktion `complex([0,1])` zu erreichen. Andere vordefinierte Variablen sind `true` und `false` für die logischen Konstanten sowie die leere Liste, `nil`.

Es gibt noch einen anderen wichtigen Typ von vordefinierten Variablen. Auf jedes geometrische Element in einer Konstruktion kann als vordefinierte Variable des entsprechenden Namens verwiesen werden. Beispielsweise kann auf einen Punkt A über die Variable `A` zugegriffen werden. Ausführlichere Informationen zu diesem Thema finden Sie im Abschnitt Zugriff auf geometrische Elemente.

### Benutzerdefinierte Daten

Es besteht auch die Möglichkeit, benutzerdefinierte Daten mit geometrischen Elementen zu verknüpfen. Dies kann mit dem Operator `:` erfolgen. Dies ist eine einfache, aber sehr leistungsstarke Funktion. Nach dem Doppelpunkt kann eine beliebige Zeichenkettenwert als Schlüssel hinzugefügt werden, um auf die Daten zuzugreifen. Dieser Schlüssel dient als Variable, an die beliebige Werte angehängt werden können.

Die Verwendung dieses Operators wird am besten anhand von Beispielen erklärt. Angenommen, A und B sind geometrische Objekte. Der folgende Code verknüpft einige Daten mit ihnen:

    A:"age"=17;
    B:"age"=34;
    A:"haircolor"="brown";
    B:"haircolor"="blonde";

Der Zugriff auf die Daten erfolgt über denselben Schlüssel. Der folgende Code

      forall(allpoints(),p,
        println(p:"age");
        println(p:"haircolor");
    )

erzeugt die Ausgabe

    17
    brown
    34
    blonde

Eine Liste aller Schlüssel eines geometrischen Objekts kann über den Operator `keys(...)` erreicht werden. Im obigen Beispiel erzeugt der Code

    print(keys(A));

die folgende Ausgabe:

    ["age","haircolor"];

Es ist auch möglich, Schlüsselinformationen an Listen anzuhängen. Dadurch können Sie auch benutzerdefinierte Daten erstellen, die über Variablen weitergegeben werden. Der folgende Code veranschaulicht dieses Verhalten.

      a=[];
      a:"data"=18
      print(a:"data")

Warnung: Die Funktionalität zum Anhängen von Schlüsseldaten unterliegt noch Änderungen. Es ist geplant, objektorientierte Datenstrukturen zu unterstützen. Die derzeit implementierte Funktion ist möglicherweise nicht mit zukünftigen Versionen kompatibel.

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