if-Anweisung: Alternierendes Wölben der Kurvensegmente nach oben und unten

Eine andere Sichtweise auf die Wiederholung der Grundkurve

Im letzten Arbeitsschritt wurde als Grundkurve der Linienverlauf von 0 bis 200 angenommen.
Der obigen Grafik zeigt jedoch, dass man die Grundkurve auch zwischen 0 und 100 annehmen kann (gelber Bereich), der fünfmal wiederholt wird.
Es gibt daher sechs Abschnitte, die sich nur durch die schrittweise Linksverschiebung um 100 Pixel und die Wölbungsrichtung unterscheiden.
Wir führen nun wieder eine Zähvariable i für die Abschnitte ein, die nacheinander die Werte von 0 bis 5 annimmt. i=0 entspricht dem ersten Abschnitt ("nullte" Wiederholung, Abschnitt 0) und i=5 entspricht dem sechste und letzten Abschnitt (fünfte Wiederholung, Abschnitt 5).
Bei den geraden Abschnitten ( i=0, 2 und 4) wird die Kurve nach oben gewölbt, bei den ungeraden (i=1, 3 und 5) nach unten.

Man muss daher im Anweisungsblock der Schleife gleich am Anfang abfragen, ob in der Zahlvariablen momentan eine gerade oder ungerade Zahl abgespeichert ist, und in Abhängigkeit davon die Kurve nach oben oder unten wölben.

Es ist ein Grundprinzip in der Programmierung wie im täglichen Leben, dass man in Abhängigkeit von bestimmten (Speicher-)Zuständen unterschiedliche Entscheidungen trifft und nachfolgend auf Grund der Entscheidung andere Schritte (Anweisungen) durchführt.
Es gibt daher in jeder Programmiersprache das Konstrukt der bedingten Anweisung.

Bedingte Anweisungen, Verzweigungen

if-then-else-Anweisung

Am Beginn einer if-Anweisung steht immer eine Frage, die mit ja oder nein beantwortet werden kann, oder eine Bedingung, die wahr oder falsch ist.
Wenn (if) die Frage mit Ja beantwortet wird bzw. die Bedingung wahr (true) ist, wird der Anweisungsblock 1 ausgeführt, sonst (else) der Anweisungsblock 2.
Das ist der Grundaufbau einer Entweder-Oder-Entscheidung: if-then-else

if-then-Anweisung

Eine vereinfache Form der if-then-else-Anweisung ist die if-then-Anweisung bei der nur im Fall, dass die Bedingung wahr ist, ein Anweisungsblock aufgeführt wird. Im anderen Fall passiert nichts und der Programmzähler springt zur nächsten Anweisung nach der if-Anweisung.

if-then-else if-Anweisung

Mehrere immer im else-Zweig geschachtelte if-then-else-Anweisungen können vereinfacht zu einer if-then-else if-Anweisung zusammengefasst werden.
Dabei hat man eine Folge von Bedingungen (Bedingung 1 bis Bedingung n). Wenn die erste Bedingung wahr ist wird der dazugehörige Anweisungblock 1 abgearbeitet. Falls nicht wird die zweite Bedingung geprüft. Falls diese wahr ist wird der zweite Anweisungsblock abgearbeitet. Falls auch die zweite Bedingung falsch ist, wird die dritte abgefragt usw. Wenn keine der Bedingungen wahr ist, wird optional ein abschließender Anweisungsblock ausgewführt.

Beispiel: if-then-else if-Anweisung als if-then-else-Anweisung geschrieben

if (Bedingung 1){
   Anweisungsblock 1
}  else if (Bedingung 2){
   Anweisungsblock 2
}  else if (Bedingung 3){
   Anweisungsblock 3
}  else {
   Anweisungsblock 4
};

entspricht

if (Bedingung 1){
   Anweisungsblock 1
}  else {
   if (Bedingung 2){
      Anweisungsblock 2
   }  else {
      if (Bedingung 3){
         Anweisungsblock 3
      }  else {
         Anweisungsblock 4
      };
   };   
};

case-Anweisung Fallunterscheidung

Eine spezielle Form der if-then-else if-Anweisung ist die Fallunterscheidung (switch- oder case-Anweisung).
Bei dieser wird zuerst ein Term festgelegt und anschließend werden möglich Fälle(Zustände) des Terms aufgelistet, bei denen bestimmte Anweisungsblöcke ausgeführt werden sollen.

Beispiel: switsch-Anweisung als if-then-else if-Anweisung geschrieben

switch (term){
   case Fall_1:
      Anweisungsblock 1;
      break;
   case Fall_2:
      Anweisungsblock 2;
      break;
   case Fall_3:
      Anweisungsblock 3;
      break;
   default:
      Anweisungsblock 4;
      break;
};

entspricht

if (term erfüllt Fall_1){
   Anweisungsblock 1
}  else if (term erfüllt Fall_2){
   Anweisungsblock 2
}  else if (term erfüllt Fall_3){
   Anweisungsblock 3
}  else {
   Anweisungsblock 4
};

 

Ergebnis einer Zwischenlösung als swf-Datei

Die Kurvenlinie wird mit Hilfe einer for-Schleife in 6 Schleifendurchgängen gezeichnet.
Dabei wird noch nicht zwischen der Wölbungsrichtung unterschieden.

Der Programmcode der Zwischenlösung mit Erklärungen

Codeabschnitte, die sich nicht vom vorigen Arbeitsschritt unterscheiden, werden grau geschrieben.

// BÜHNENRECHTECK MIT FARBE FÜLLEN UND KONTURIEREN
//
this.lineStyle(1, 0x000000);
this.beginFill(0xFFFFCC);
this.moveTo(0, 0);
this.lineTo(Stage.width-1, 0);
this.lineTo(Stage.width-1, Stage.height-1);
this.lineTo(0, Stage.height-1);
this.lineTo(0, 0);
this.endFill();
/*
ZEICHNEN DER WELLENLINIE
*/
this.lineStyle(2, 0xFF0000);
var m:Number = Stage.height/2;
this.moveTo(0, m);

for (var i:Number = 0; i<6; i++) {
   this.curveTo(i*100+50, m-70, i*100+100, m);
}

Auf Grund der obigen Überlegungen wird das Grundkurvensegment, das zwischen 0 und 100 verläuft, fünfmal wiederholt. Wobei bei jeder Wiederholung der Startpunkt um 100 Pixel (= Breite des Grundkurevnsegments) nach rechts verschoben wird. Für jedes Segment (= bei jedem Schleifendurchgang) pendeln die y-Koordinaten der Steuer- und Ankerpunkte zwischen m-70 und m. Daher nur die Wölbung nach oben.

Ergebnis der endgültigen Lösung als swf-Datei

Die Kurvenlinie wird mit Hilfe einer for-Schleife in 6 Schleifendurchgängen gezeichnet.
Dabei wird mit Hilfe einer if-then-else-Anweisung zwischen geraden und ungeraden Schleifendurchgängen unterschieden und die Wölbung entsprechend gezeichnet.

Der Programmcode der Lösung ohne Erklärungen

Codeabschnitte, die sich nicht vom vorigen Arbeitsschritt unterscheiden, werden grau geschrieben.

// BÜHNENRECHTECK MIT FARBE FÜLLEN UND KONTURIEREN
//
this.lineStyle(1, 0x000000);
this.beginFill(0xFFFFCC);
this.moveTo(0, 0);
this.lineTo(Stage.width-1, 0);
this.lineTo(Stage.width-1, Stage.height-1);
this.lineTo(0, Stage.height-1);
this.lineTo(0, 0);
this.endFill();
/*
ZEICHNEN DER WELLENLINIE
*/
this.lineStyle(2, 0xFF0000);
var m:Number = Stage.height/2;
this.moveTo(0, m);

for (var i:Number = 0; i<6; i++) {
   if (i/2 == Math.floor(i/2)) {
      this.curveTo(i*100+50, m-70, i*100+100, m);
   } else {
      this.curveTo(i*100+50, m+70, i*100+100, m);
   }
}


Der Programmcode der Lösung mit Erklärungen

Aus den Anfangsüberlegungen ergibt sich folgende for-Schleife mit der Zählvariablen i vom Typ Number:
Initialisierung von i : i = 0 , wir beginnen bei null zu zählen.
Bedingung von i : Wir zählen bis 5, d.h. i muss kleiner als 6 oder kleiner-oder-gleich 5 sein, i < 6 oder i <= 5 , beide Schreibweisen sind m�glich.
Update von i : Um eins nach oben zählen, d.h. i wird um eins erhöht i++

for (var i:Number = 0; i<6; i++) {

.......

}

Abfrage: gerade - ungerade

Eine gerade Zahl lässt sich ganzzahlig durch 2 dividieren, eine ungerade nicht.
Die Division einer ungeraden Zahl mit 2 ergibt immer eine Dezimalzahl mit ,5.
Nach der Division kann man die größte ganze Zahl kleiner-oder-gleich dem Divisionsergebnis bilden.
Bei einer geraden Ausgangszahl ändert sich im Gegensatz zu einer ungeraden Ausgangszahl dadurch nichts. Damit kann man eine Unterscheidung treffen.

Beispiel:
4 ist gerade. 4:2=2. Die größte ganze Zahl kleiner-oder-gleich 2 ist 2. 2 ist gleich 2
5 ist ungerade. 5:2=2,5. Die größte ganze Zahl kleiner-oder-gleich 2,5 ist 2. 2 ist ungleich 2,5.

Somit lässt sich eine gerade bzw.ungerade Zahl durch folgende Bedingung ermitteln:

i/2 == Math.floor(i/2)

Im linken Term der Bedingung wird die Zählvariable i nur durch 2 dividiert, im rechten Term wird auf das Divisionsergebnis noch die Math.floor-Funktion angewandt.
Bei einer geraden Zahl sind die beiden Terme gleich, bei einer ungeraden Zahl ungleich.

Mit == kann man zwei Terme auf Gleicheit überprüfen.
Als Ergebnis des Vergleichs wird ein Wert von Typ Boolean geliefert, nämlich true oder false .
Eine Variable vom Typ Boolean kann die Werte true und false annehmen.

Math.floor(z) liefert die größte ganze Zahl kleiner-oder-gleich der Ausgangszahl z .
Math ist dabei ein ActionScript-Objekt, das mathematische Methoden und Konstanten enthält. Man kann über das Math-Objekt viele bekannte mathematische Funktionen aufrufen.

Geschachtelte Terme, Funktionen

i/2 == Math.floor(i/2)

Der obige Term ist ein geschachtelter Term. Geschachtelte Terme werden immer von innen nach außen ausgewertet.
Beim rechten Teilterm wird zuerst der Inhalt der Variablen i ermittelt. Dieser dient gemeinsam mit der Zahl 2 als Input für die Division. Auf das Zwischenergebnis der Division wird anschließend die Math.floor-Funktion angewandt. Das Ergebnis wird abschließend mit dem Ergebnis der linken Termauswertung verglichen.