info@a-coding-project.de

ActionScript: Kontrollstrukturen

Kontrollstrukturen sind im Allgemeinen programmiersprachliche Konstrukte zur Steuerung des Scriptablaufs bzw. im Speziellen des Flusses eines Flash films. Mithilfe derer können beispielsweise Anweisungen in Abhängigkeit von Bedingungen ausgeführt bzw. wiederholt werden. Die wichtigsten dieser Strukturen zählen auch zur Sprachbasis von ActionScript .

Bedingte Anweisungen

Das Prinzip der bedingten Anweisungen ist das wohl denkbar einfachste. Die Ausführung von Anweisungen wird hierbei von der Erfüllung einer oder mehrere Bedingungen (engl condition), also eines booleschen Ausdrucks, abhängig gemacht.
Die in ActionScript reservierten Schlüsselwörter if ("wenn"), else ("oder" bzw. andernfalls) und else if ("oder wenn") stehen zur Konstruktion von bedingten Anweisungen zur Verfügung.
Die primitivste Form stellt in diesem Zusammenhang die bloße if-Anweisung dar, welche die Ausführung von Anweisungen vom Erfülltsein eines booleschen Ausdrucks abhängig macht ohne dabei alternativ auszuführende Anweisungen festzulegen:

var myNumber = 5;

if(myNumber < 5) 
{
  trace("Zahl kleiner 5");
}

Im obigen Beispiel wird die trace - Anweisung im Anweisungsblock der if - Anweisung nicht ausgeführt, da die vorangestellte Ausführungsbedingung nicht erfüllt, die Auswertung derer also falsch, ist. Es kommt also zu keiner Ausgabe im Fenster. Soll wie in diesem Beispiel lediglich die Ausführung einer Anweisung von der Bedingung abhängig gemacht werden, so können die geschweiften Klammern des Anweisungsblocks natürlich weggelassen werden.
Häufig ist es jedoch nicht ausreichend, derartige bedingte Anweisungen ohne alternative Scriptabläufe zu formulieren. In diesem Zusammenhang wäre es bei obigem Beispiel eventuell wünschenswert, eine alternative Ausgabe für den Fall, dass die Auswertung des booleschen Ausdrucks den Wahrheitswert false liefert, anzugeben. Dies ist durch Konstruktion eines alternativen Zweigs mit Hilfe des Schlüsselworts else möglich, dessen Anweisungsblock nur dann ausgeführt wird, wenn die einleitende if - Bedingung nicht erfüllt ist. Das erweiterte Beispiel könnte dann so aussehen:

var myNumber = 5;

if(myNumber < 5) 
{
  trace("Zahl kleiner 5");                        
  //Anweisung 1
}
else
{
  trace("Zahl größer oder gleich 5");        
  //Anweisung 2
}

Anweisung 1 wird wie bereits erläutert nicht ausgeführt. Anstelle dessen springt der Interpreter zur else - Verzweigung, also zum Alternativfall, und führt die in diesem Anweisungsblock notierte Anweisung (Anweisung 2) aus.
Es können darüber hinaus noch weitere bedingte Anweisungen angeknüpft werden, um eine beliebige Anzahl von Alternativen realisieren zu können. Ihre Auswertung erfolgt jeweils nur dann, wenn die Auswertung sämtlicher vorangehender Bedingungen des Konstrukts den Wahrheitswert false liefert.
Bezogen auf das behandelte Beispiel wäre in diesem Sinne folgende Erweiterung sinnvoll:

var myNumber = 5;

if(myNumber < 5)
{
  trace("Zahl kleiner 5");        
  //Anweisung 1
}
else if(myNumber > 5)        
{
  trace("Zahl größer 5");        
  //Anweisung 2
}
else        
{
  trace("Zahl gleich 5");        
  //Anweisung 3
}

Das Argument der else-if-Bedingung (myNumber > 5) wird nur überprüft, wenn myNumber größer oder gleich 5 ist, d.h. die Auswertung des vorher gehenden booleschen Ausdrucks (myNumber < 5) den Wahrheitswert false liefert. Da hier deren Auswertung wiederum false liefert, wird nur die Anweisung des else-Zweigs (Anweisung 3) ausgeführt.
Einfache il-else-Bedingungen können unter Verwendung des Operators ?: auch verkürzt dargestellt werden, wobei zu beachten bleibt, dass pro Zweig nur eine Anweisung notiert werden kann, da die Verwendung von geschweiften Klammern hier nicht erlaubt ist: Außerdem muss das gesamte Konstrukt, da es vom Interpreter als eine Anweisung verstanden wird, mit der Notation eines Semikolons (;) abgeschlossen werden. Das oben erwähnte Beispiel für eine einfache if-else-Konstruktion könnte auf diese Weise wie folgt verkürzt dargestellt werden:

var myNumber = 5;

myNumber < 5 ? trace("Zahl kleiner 5") : 
                  trace("Zahl größer oder gleich 5");

switch-case-Anweisungen

Eine elegantere, weil übersichtlichere Möglichkeit derartige Mehrfachverzweigungen zu realisieren, stellt die switch-case-Anweisung dar. Innerhalb dieser Anweisung werden verschiedene Sprungmarken (cases) definiert, welche möglichen Auswertungsergebnissen eines beliebigen Ausdrucks, welchen switch als Argument erwartet, entsprechen. Diese Sprungmarken können im gebräuchlichen Sinne auch als Labels verstanden werden, da mit der Ausführung der Anweisungen fortgefahren wird, welche hinter des zum Ausdruck passenden Labels stehen. Alle vorigen werden also übersprungen. Des Weiteren kann bei Bedarf ein Alternativzweig (default), also analog zur if-else if-Anweisung ein else-Zweig, definiert werden, dessen Anweisungen genau dann ausgeführt werden, wenn die Werte aller anderen case-Zweige nicht zum ausgewerteten Ausdruck passen. Ein Beispiel:

var myNumber = 2;

switch(myNumber)
{
  case 1:
  {
     trace("Wert von myNumber ist 1");
     break;
  }
  case 2:
  {
     trace("Wert von myNumber ist 2");
     break;
  }
  default:        
  {
     trace("Wert von myNumber ist weder 1 noch 2");
     break;
  }
}

Die Auswertung von myNumber liefert das Ergebnis 2, so dass die Anweisungen des entsprechenden case-Zweiges ausgeführt werden. Die geschweiften Klammern hinter den case-Labels sind nicht zwingend notwendig, tragen jedoch zu einer besseren Lesbarkeit des Scripts bei. Letzt genannter Fakt deutet bereits darauf, dass es sich bei den Anweisungen eines einzelnen case-Zweigs nicht um einen Anweisungsblock handelt. Die Labels markieren jeweils eine Sprungstelle, ab der bei passendem Wert mit der Ausführung der Folgeanweisungen fortgefahren, nicht aber automatisch bei Vorkommen der nächsten Sprungmarke abgebrochen wird. Hier kommen die break-Anweisungen ins Spiel, welche die einzelnen case-Zweige abschließen und die gewünschte strikt getrennte Ausführung der Zweige im Sinne der if-else if-Anweisung gewährleistet. Sie weisen nämlich Flash an, die Ausführung der gesamten switch-case-Anweisung an dieser Stelle sofort abzubrechen und die ihr im Script folgenden Anweisungen auszuführen. Der Eigenschaft von Sprungmarken folgend würden bei Verzicht auf diese break-Anweisungen also in diesem Beispiel neben den Anweisungen des case 2-Zweigs auch noch die der folgenden Sprungmarken, in diesem Falle also auch die des default-Zweigs, ausgeführt werden. Die Ausgabe im Fenster lautete demnach nicht nur:

Wert von myNumber ist 2

sondern:

Wert von myNumber ist 2
Wert von myNumber ist weder 1 noch 2

Das switch-Argument kann wie bereits erwähnt ein beliebiger Ausdruck sein und muss bei dessen Auswertung nicht zwangsläufig, wie in anderen Programmiersprachen häufig anzutreffen, auf einen numerischen Wert zurückgeführt werden können.

while-Schleifen

Die Implementierung von Schleifen macht immer dann Sinn, wenn bestimmte Anweisungen mehrfach ausgeführt werden sollen. Bei while-Schleifen wird zunächst die oberhalb des Schleifenkörpers notierte Bedingung überprüft. Diese kann durchaus als Ausführungsbedingung der Schleife verstanden werden, da der Schleifenrumpf, d.h. der ihr folgende Anweisungsblock, nur dann ausgeführt wird, wenn die Auswertung dieser true liefert. Nach Ausführung des Schleifenrumpfs wird die Bedingung erneut geprüft, so dass als Folge der Anweisungsblock des Rumpfs solange ausgeführt wird, wie die Auswertung der einleitenden Bedingung true liefert. Ein Beispiel:

var myNumber = 0;

while(myNumber < 5)
{
        myNumber++;
        trace(myNumber);        
}

Der Rumpf der Schleife, in dem der Wert von myNumber (anfangs mit 0 initialisiert) pro Durchlauf inkrementiert, d.h. um eins erhöht, wird, wird solange wiederholt, bis der Wert von myNumber nicht mehr kleiner als Fünf ist.
Für den Fall, dass myNumber zu Beginn gleich mit einem Wert größer oder gleich Fünf initialisiert geworden wäre, tritt die charakteristische Eigenschaft dieser Schleife zutage. Deren Rumpf wird dann nämlich gar nicht ausgeführt, da die Auswertung der Bedingung von vornherein false liefert.

do-while-Schleifen

Bei do-while-Schleifen hingegen wird der Schleifenrumpf ausgeführt, bevor die Bedingung (erstmals) geprüft wird. Die Bedingung kann hier also eher als Abbruchsbedingung der Schleife verstanden werden. Die Anweisungen im Rumpf der Schleife werden also in jedem Fall mindestens einmal ausgeführt. Anschließend wird die Bedingung überprüft und bei Wahrheit der Schleifenrumpf wiederholt ausgeführt. Ein Beispiel:

var myNumber = 0;

do
{
  myNumber++;
  trace(myNumber);        
}
while(myNumber < 5)

Dieses Beispiel führt zwar zur gleichen Ausgabe wie jenes der while-Schleife, funktioniert jedoch nach eben beschriebenem Prinzip, so dass auch im Falle einer Initialisierung von myNumber mit einem Wert größer oder gleich 5 der Schleifenrumpf einmal ausgeführt wird, wobei hier die Ausgabe des Werts 6 erfolgt.

for-Schleifen

For-Schleifen funktionieren im Allgemeinen ähnlich wie eine while-Schleife, wobei sämtliche Steuerungsanweisungen für die Schleife in deren Kopf vereinbart werden.
Erwartet werden drei Ausdrücke: Im ersten wird eine Zählvariable initialisiert, d.h. ihr Anfangswert festgelegt. Der folgende Ausdruck beschreibt die Ausführungsbedingung und der letzte einen Zuweisungsausdruck zur Wertveränderung der Zählvariable.
Zunächst wird also die Zählvariable initialisiert und anschließend die Ausführungsbedingung geprüft. Liefert diese Auswertung den Wahrheitswert true, wird der Schleifenrumpf ausgeführt sowie im Anschluss der Zählvariablen nach im dritten Ausdruck im Schleifenkopf beschriebenem Algorithmus ein neuer Folgewert zugewiesen. Ein Beispiel:

for (var myNumber = 1; myNumber < 10; myNumber++)
{
  trace(myNumber);        
}

Das erste for-Argument initialisiert die Zählvariable myNumber mit dem Wert 0. Darauf folgend wird die Ausführungsbedingung der Schleife formuliert, welche in diesem Beispiel die Ausführung des Schleifenrumpfs abbricht, wenn der Wert von myNumber nicht mehr kleiner Zehn ist. Der dritte Ausdruck gibt an, dass der Wert der Zählvariablen pro Schleifendurchlauf um eins erhöht (Inkrementierung) werden soll. Der Schleifenrumpf wird also solange ausgeführt, wie die Auswertung der Bedingung im zweiten Ausdruck true liefert. Dies rechtfertigt die Bezeichnung solcher Schleifen als Zählschleifen. For-Schleifen eignen sich aufgrund dieser Eigenschaft besonders für Ereignisse, bei denen von vornherein klar ist, wie oft der Schleifenrumpf ausgeführt werden soll.

for-in-Schleifen

Die for-in-Schleife stellt eine komfortablere sowie verkürzte Form der for-Schleife dar, mit deren Hilfe sich beispielsweise sämtliche Attribute bzw. Eigenschaften eines beliebigen Objekts (z.B. Array, Movieclip, usw.) durchlaufen lassen. Ein allgemeines Beispiel für ein beliebiges Objekt:

myObject = new Object();

myObject.Attribute1 = 1; 
myObject.Attribute2 = 2;

for (myAttribute in myObject) 
{
  trace (myObject[myAttribute]);
}

Abstrahiert für die Eigenschaften eines Arrays, wäre beispielsweise folgende Schleife geeignet, um alle Elemente eines Arrays auszugeben:

myArray = new Array(1,2,3,4,5);

for(myIndex in myArray)
{
  trace(myArray[myIndex]);        
}

Diese verkürzten Schleifen lassen sich natürlich auch syntaktisch äquivalent mithilfe von for-Schleifen konstruieren.

break

Das Schlüsselwort break zählt zu den vordefinierten Anweisungen zur Scriptsteuerung und kann im Wesentlichen in jeder der vier genannten Schleifenformen (while, do-while, for, for-in) oder - wie bereits gezeigt - einem switch-case-Konstrukt auftauchen. Stößt der Interpreter auf eine solche Anweisung, so bricht er umgehend die Interpretation des aktuellen Anweisungsblocks, d.h. Rumpf der Schleife bzw. switch-case-Konstrukts, ab und führt die Anweisungen, welche hinter diesem Anweisungsblock notiert sind, fort. Alle dazwischen stehenden Anweisungen, d.h. die übrigen Anweisungen nach der break-Anweisung innerhalb des aktuellen Anweisungsblocks, werden also ignoriert. Auf diese Weise können Schleifen bei vordefinierten Ereignissen kontrolliert abgebrochen werden, wie folgendes Beispiel zeigt:

var myCounter = 0;

do
{
  myCounter++;
  if(myCounter == 3) 
  {
    break;
  }
  trace(myCounter);
}
while(myCounter < 5)

/*
Ausgabe im Fenster:
1
2
*/

Aufgrund der break-Anweisung im Anweisungsblock der bedingten Anweisung wird der Durchlauf der do-while-Schleife abgebrochen, wenn myCounter den Wert 5 besitzt, obwohl die Abbruchsbedingung der Schleife noch nicht erfüllt ist. Anschließend wird die der Schleife folgenden Scriptanweisungen interpretiert.

continue

Die continue-Anweisung ist in ActionScript ebenfalls eine Anweisung zur Scriptsteuerung. In den verschiedenen Schleifentypen einsetzbar, veranlasst sie Flash , den aktuellen Durchlauf des Schleifenrumpfs abzubrechen und die Bedingung der Schleife erneut zu prüfen. Im Falle einer for-in-Schleife wird die folgende Eigenschaft angesprochen. Es wird im Gegensatz der break-Anweisung also nicht die gesamte Schleife, sondern nur deren aktueller Durchlauf, d.h. die aktuelle Phase des Zyklus, abgebrochen. Modifiziert man das eben gezeigte Beispiel etwas, wird die Funktionsweise von continue im Vergleich zu break deutlich:

var myCounter = 0;

do
{
  myCounter++;
  if(myCounter == 3) 
  {
     continue;
  }
  trace(myCounter);
}
while(myCounter < 5)

/*
Ausgabe im Fenster:
1
2
4
5
*/

Erhält myCounter den Wert 3, wird der aktuelle Schleifendurchlauf abgebrochen, die Bedingung erneut geprüft und ein neuer Durchlauf begonnen.

tellTarget

Diese Anweisung gilt seit der Einführung von Flash 5 zwar als veraltet, ist jedoch noch heute relativ häufig anzutreffen. Mithilfe dieser Anweisung kann man ebenso wie mit with oder dem Punktoperator (.) ein Objekt (Movieclip) ansprechen und Anweisungen für dieses definieren. Sie erwartet einen String-Parameter mit dem Zielpfad zum entsprechenden Objekt. Innerhalb des Anweisungsblocks kann so auf den Zielpfad verzichtet werden. Ein Beispiel:

tellTarget("_level1.myMovieClip")
{
  _x = 100;                 
  //setzt myMovieClip horizontal auf 100 px
  _visible = true;         
  //macht myMovieClip sichtbar
  play();                
  //startet die Wiedergabe von myMovieClip
}

Im Beispiel wird tellTarget ein Pfad zum Movieclip myMovieClip auf Stufe 1 (_level1) übergeben, so dass im nachfolgenden Anweisungsblock zwei Eigenschaften manipuliert und eine seiner Methoden aufgerufen werden können, ohne den Zielpfad jedes Mal notieren zu müssen.
Es sei jedoch empfohlen auf diese Anweisung künftig zu verzichten, da sie - wie im Folgeabschnitt gezeigt - vollständig durch gängige Konstrukte ersetzt werden kann.

with

Die Anweisung with erwartet als Parameter einen Objektnamen mit eventuell dazugehörigem Zielpfad, welcher jedoch nicht in Anführungsstrichen notiert werden darf. Auf diese Weise nimmt man auf das angegebene Objekt Bezug, so dass dessen Eigenschaften und Methoden innerhalb des Anweisungsblocks von with ohne Zielpfad notiert werden können. Im folgenden Beispiel geschieht dasselbe wie im obigen:

with(_level1.myMovieClip)
{
  _x = 100;
  _visible = true;
  play();
}

Weiterlesen: ⯈ Operatoren

Über uns

Stefan Wienströer

Wir entwickeln Webanwendungen mit viel Leidenschaft. Unser Wissen geben wir dabei gerne weiter. Mehr über a coding project

Auch interessant