Variablen in ActionScript

ActionScript unterscheidet im Allgemeinen zwei Klassen von Datentypen: die elementaren Datentypen (Grunddatentypen), zu denen Zahlen (numbers), Zeichenketten (Strings), Boolean, null und undefined zählen, sowie Referenzdatentypen wie beispielsweise Objekte (z.B. Arrays) oder Movieclips.

Variablen definieren

Der Datentyp einer Variablen muss bei deren Deklaration bzw. Initialisierung nicht explizit festgelegt werden, da ActionScript die Variablenwerte kontextsensitiv auswertet, was beim Arbeiten mit der Scriptsprache gewisse Erleichterungen mit sich bringt. Variablen werden grundsätzlich auf folgende Weise deklariert:

var myNumber;

Man kann auch einfach ein entsprechendes Objekt erzeugen. Analog zu obigem Beispiel:

var myNumber = new Number();

Man sollte Variablen allerdings sofort bei deren Deklaration auch mit einem Wert initialisieren, wofür zwei Methoden zur Verfügung stehen. Die gängigste Methode ist es, den Zuweisungsoperator (=) zu verwenden. Alternativ kann aber auch die Funktion set(Bezeichner, Wert) dazu genutzt werden:

//Beide Anweisungen erzielen denselben Effekt
var myNumber = 1;
set(myNumber, 1);

Um den Datentyp einer Variablen zu bestimmen, steht die Funktion typeof(variable) zur Verfügung:

trace(typeof(myNumber));
//Gibt Datentyp von myNumber (number) aus

Typenkonvertierung

Aufgrund der Tatsache, dass ActionScript den Datentyp einer Variablen im jeweiligen Kontext bewerten kann, ist auch problemlos eine Umwandlung eines Datentyps in einen anderen möglich. Beispiele:

var myString = "2";
var myNumber = Number(myString);

myString = String(myNumber);
//oder z.B.
myString = myNumber.toString(10);

Gültigkeitsbereiche von Variablen

ActionScript kennt neben den lokalen und globalen Variablen auch noch einen weiteren Gültigkeitsbereich, nämlich die so genannten Zeitleistenvariablen.
Der Vorteil der Einschränkung von Gültigkeitsbereichen besteht darin, dass beispielsweise die Wertänderung einer lokalen Variablen oder Zeitleistenvariablen keinerlei Auswirkungen auf den Wert einer eventuell vorhandenen gleichnamigen globalen Variable hat. Durch diese Praxis können also Bezeichnerkonflikte und ungewollte Wertänderungen von Variablen verhindert werden.
Globale Variablen werden durch Angabe des Schlüsselworts _global definiert. Beispiel:

_global.myNumber = 1;
//Initialisierung der globalen Variable myNumber
//mit dem numerischen Wert 1

Globale Variablen sind an jeder Stelle eines Films sichtbar, so dass deren Werte auch von überall geändert werden können ohne, dass man immer den Pfad zu deren Movieclipinstanzen angeben muss:

myNumber = 2;
//Wertänderung der globalen Variable myNumber auf 2

Zeitleistenvariablen hingegen werden durch das Schlüsselwort var in der Zeitleiste eines Movieclips erstellt. Auf dieses kann auch verzichtet werden oder anstelle dessen this notiert werden:

//Initialisierung einer Variablen myNumber in
//Zeitleiste eines Movieclips

var myNumber = 1;
this.myNumber = 1;
my Number = 1;

Alle drei Varianten erzeugen dasselbe Ergebnis. Die Gültigkeit von Zeitleistenvariablen ist jedoch auf den Movieclip, in dessen Zeitleiste sie definiert wurden, begrenzt, so dass diese außerhalb dieses Movieclips nur mithilfe ihrer Pfade (absolut oder relativ) angesprochen werden können. Unterstellt man, die Zeitleistenvariable myNumber sei nach obiger Filmhierarchie (ohne dynamisch geladenen Filmen) im Movieclip MC_aba definiert, so sind folgende Anweisungen richtig, um deren Wert zu manipulieren:

//Wertänderung unter Angabe eines absoluten Pfades
_root. MC_a.MC_ab.MC_aba.myNumber = 2;

//Wertänderung ausgehend von MC_aa unter
//Angabe eines relativen Pfades
this._parent.MC_ab.MC_aba.myNumber = 2;

Lokale Variablen sind stets lediglich in dem Anweisungsblock sichtbar und zugreifbar, in dem sie definiert wurden. Sind alle Anweisungen des Anweisungsblocks ausgeführt, so wird die Variable automatisch zerstört und der von ihr in Anspruch genommene Speicherplatz wieder freigegeben. Lokale Variablen können nur durch Angabe des Schlüsselworts var beispielsweise in einem Funktionsrumpf definiert werden. Ein Beispiel:

myFunction();
//Aufruf der Funktion myFunction()

trace(myNumber);
//Gibt undefined aus, da lokale Variable myNumber nicht sichtbar

//Funktionen

function myFunction()
{
  var myNumber = 1;
  trace(myNumber);
  //Ausgabe des Werts 1 der lokalen Variable myNumber
}

Zahlen

Hinsichtlich der numerischen Datentypen wird in ActionScript nicht zwischen Ganzzahlen (integer) und Fließkommazahlen (floating point) unterschieden, so dass beide im gleichen Format, einer acht Byte langen Fließkommazahl (Wertebereich: 4.94065645841247^-324 - 1.79769313486231^308), gespeichert werden. Es gibt also lediglich einen numerischen Datentyp, welcher als Number bezeichnet wird. Zahlen lassen sich in ActionScript jedoch in mehreren Notationsarten beschreiben:

//verschiedene Beschreibungsweisen eines
//intern identischen Zahlenwerts
myNumber = 100000;    //Ganzahk
myNumber = 100000.00; //Fließkommazahl
myNumber = 1.0e5;     //Exponentialzahl
myNumber = 0x186A0;   // Hexadezimalzahl
myNumber = 10101;     //Binärzahl

Man kann auch alternativ eine Zahl als Number-Objekt erzeugen:

myNumber = new Number(100000);

Numerische Werte können aufgrund dieses Zusammenhangs mithilfe der objekteigenen Methoden und Eigenschaften verändert werden. Dazu werden sie intern in ein Number-Objekt umgewandelt. Dieses besitzt die folgenden Eigenschaften und Methoden:

Eigenschaft/Konstante	Beschreibung
`MAX_VALUE`	Entspricht der Obergrenze des Wertebereichs von Zahlen
`MIN_VALUE`	Entspricht der Untergrenze des Wertebereichs von Zahlen
`NaN`	Entspricht dem Wert `NaN` (Not a Number)
`NEGATIVE_INFINITY`	Entspricht der negativen Unendlichkeit
`POSITIVE_INFINITY`	Entspricht der positiven Unendlichkeit

Methoden des Number-Objekts

Methode	Parameter	Beispiel	Beschreibung
`toString()`	1. Numerische Basis (Zahl)	`myNumber = 1.23456; myString = myNumber.toString(2);`	Gibt ein Number-Objekt auf Basis des numerischen Werts als Parameter (default: 10) als String zurück
`valueOf()`	keine	`myNumber = 01011; myNumber = myNumber.valueOf();`	Gibt des Grundwert des Number-Objekts zurück (hier interne Umwandlung)

Strings

Strings sind geordnete Aneinanderreihungen von Buchstaben, Ziffern und Sonderzeichen, deren Länge seitens der Programmiersprache unbegrenzt ist, so dass diese im Prinzip lediglich durch den zur Verfügung stehenden Speicherplatz des Systems begrenzt wird.
Stringliterale können entweder von einfachen (single quoted) oder in doppelten Anführungsstrichen (double quoted) umschlossen notiert werden:

var myString;

myString = 'abcdefg'; //single quoted - Notation
myString = "abcdefg"; //double quoted - Notation

Die beiden verschiedenen Notationsmöglichkeiten haben im Grunde keinerlei unterschiedliche Wirkung. Da sie dazu dienen, den String syntaktisch zu begrenzen, dürfen sie selbst innerhalb eines Strings, welcher durch sie begrenzt wird, nicht ohne eine entsprechende Entwertung (Maskierung) vorkommen. Einfache Anführungsstriche dürfen allerdings in Strings, welche von doppelten Anführungsstrichen begrenzt werden, notiert werden. Ein Beispiel:

myString = 'Mein Bezeichner ist myString';
//Notation syntaktisch korrekt
myString = "Mein Bezeichner ist myString";
//Notation syntaktisch korrekt
myString = 'Mein Bezeichner ist 'myString'';
//Notation führt zu Fehler
myString = "Mein Bezeichner ist 'myString'";
//Notation syntaktisch korrekt

In einem String dürfen des Weiteren beliebig viele dieser oder anderer so genannter Steuerzeichen notiert werden, wobei folgende unterschieden werden:

"     doppeltes Anführungszeichen
'     einfaches Anrührungszeichen
     Backslash
b     Backspace (Rückschritt)
e     Escape-Sequenzen
f     Seitenvorschub
n     Zeilenvorschub (newline)
r     Wagenrücklauf (Carriage return)
t     horizontaler Tabulator

Sollen in einem String derartige Zeichenfolgen vorkommen, ohne dass sie die Wirkung des entsprechenden Steuerzeichens hervorrufen sollen, müssen diese mithilfe eines Backslashs () maskiert werden. Der Backslash selbst kann auf dieselbe Art und Weise maskiert werden (), so dass er als bloßes Zeichen im String ohne Steuerfunktion fungiert.

Strings können mithilfe der Operatoren + oder add miteinander verkettet werden, indem man alle zu verbindende Strings als Operanden notiert:

//Verkettung mit Operator +
myString1 = "Moritz";
myString2 = "Max und " + myString1 + " !";

//Verkettung mit Operator add
myString1 = "Moritz";
myString2 = "Max und " add myString1 add " !";

Mithilfe der Eigenschaften und Methoden des Objekts String lassen sich Stringliterale manipulieren. Dazu werden sie intern in ein solches Objekt überführt, dessen Eigenschaften und Methoden im Folgenden aufgelistet werden.

Eigenschaften des String-Objekts

Eigenschaft	Beispiel	Beschreibung
`length`	`myString = "String"; trace(myString.length);`	Gibt die Länge des String-Objekts zurück; Ergebnis hier: 6

Methoden des String-Objekts

Methode	Parameter	Beispiel	Beschreibung
`charAt()`	1. Index (Ganzzahl)	`myString = "String"; thePosition = String.charAt(4);`	Gibt Zeichen zurück, welches sich an Position des Parameters befindet (Beginn bei 0); Ergebnis hier: n
`charCodeAt()`	1. Index (Ganzzahl)	`myString = "String"; theCode = myString.charCodeAt(3);`	Gibt Zeichenwert (ASCII) zurück, welcher dem des Zeichens an Position des Parameters entspricht (Beginn bei 0); Ergebnis hier: 105
`concat()`	1. Beliebige Anzahl von Strings	`myString = "String"; myString = myString.concat("ende");`	Verkettet Wert des String-Objekts mit den Werten der Parameter; Ergebnis hier: Stringende
`fromCharCode()`	1. Beliebige Anzahl von ASCII-Werten (Ganzzahlen)	`myString = "String"; myString = myString + String.fromCharCode(33,63);`	Verkettet Wert des String-Objekts mit String aus ASCII-Zeichen, welchen Parameter entsprechen; Ergebnis hier: String!?
`indexOf()`	1. Teilstring (String oder Ganzzahl) (2. Startindex für Suche (Ganzzahl))	`myString = "String"; myPosition = myString.indexOf("ing");`	Durchsucht String-Objekt nach Teilstring und gibt den Index dessen erstes Vorkommens (bei Nichtvorkommen -1) zurück; bei Angabe eines Startindex wird erst ab diesem gesucht; Ergebnis hier: 3
`lastIndexOf()`	1. Teilstring (String oder Ganzzahl) (2. Startindex für Suche (Ganzzahl))	`myString = "StringString"; myPosition = myString.lastIndexOf("ing");`	Durchsucht String-Objekt nach Teilstring und gibt den Index dessen letztes Vorkommens (bei Nichtvorkommen -1) zurück; bei Angabe eines Startindex wird erst ab diesem gesucht; Ergebnis hier: 9
`splice()`	1. Startindex (Ganzzahl) (2. Endindex (Ganzzahl))	`myString = "String"; mySubString = myString.splice(2,4);`	Extrahiert aus String-Objekt eine Teilzeichenkette ab Startindex (Beginn 0) bis zum Ende des String-Objekts; optional kann der Index des letzten zu extrahierenden Zeichens angegeben werden, Ergebnis hier: ri
`split()`	1. Seperator (String) (2. maximale Anzahl der Elemente des Arrays (Ganzzahl))	`myString = "String_1"; myArray = myString.split("_");`	Zerteilt das String-Objekts anhand des Seperators in mehrere Teilstrings und gibt diese als Elemente eines Arrays zurück; optional kann dessen max. Länge angegeben werden; Ergebnis hier: myArray = ["String","1"];
`substr()`	1. Startindex (Ganzzahl) (2. Länge des Extrakts (Ganzzahl))	`myString = "String"; mySubString = myString.substr(1,3);`	Extrahiert aus String-Objekt eine Teilzeichenkette ab Startindex (Beginn 0) bis zum Ende des String-Objekts; optional kann die Länge der Teilzeichenkette angegeben werden, Ergebnis hier: tri
`substring()`	1. Startindex (Ganzzahl) 2. Endindex (Ganzzahl)	`myString = "String"; mySubString = myString.substring(1,3);`	Extrahiert aus String-Objekt eine Teilzeichenkette ab Startindex (Beginn 0) bis zum Endindex. Das Zeichen bei Endindex wird dabei nicht in den Teilstring mit aufgenommen, Ergebnis hier: tr
`toLowerCase()`	keine	`myString = "String"; myNewString = myString.toLowerCase();`	Wandelt alle Großbuchstaben im Stringobjekt in die entsprechenden Kleinbuchstaben um und gibt den erhaltenen String zurück; Ergebnis hier: string
`toUpperCase()`	keine	`myString = "String"; myNewString = myString.toUpperCase();`	Wandelt alle Kleinbuchstaben im Stringobjekt in die entsprechenden Großbuchstaben um und gibt den erhaltenen String zurück; Ergebnis hier: STRING

Boolean

Die einzigen beiden möglichen Werte von Boolean (boolesche Werte) sind true und false. Darüber hinaus interpretiert ActionScript die numerischen Werte 1 im booleschen Kontext als true sowie 0 in selbigem als false. Der Datentyp wird aufgrund dieser Eigenschaft vorzugsweise zum Auswerten von Ausdrücken mit logischen Operatoren (boolesche Ausdrücke), d.h. zum Feststellen derer Wahrheitswerte, sowie für Kontrollstrukturen verwendet. Zur Verwendung sei folgendes Beispiel angeführt:

var myBoolean = false;
var myNumber1 = 1;
var myNumber2 = 2;

if(myNumber1 < myNumber2)
//Ergebnis d. booleschen Ausdrucks ist true -> Ausführung
{
  trace(myNumber1 + " ist kleiner als " + myNumber2);

/*
Im Folgenden ist das Ergebnis des booleschen Ausdrucks
false, so dass nachfolgende Anweisung nicht ausgeführt wird.
*/
  if(myBoolean == true) trace("myBoolean hat den Wert wahr");
}

Das Boolean-Objekt besitzt die folgenden beiden Methoden:

Methode	Parameter	Beispiel	Beschreibung
`toString()`	keine	`myBoolean = true; myString = myBoolean.toString();`	Gibt den Wert des Boolean-Objekts als String zurück
`valueOf()`	keine	`myBoolean = 1 < 2; myBoolean = myBoolean.valueOf();`	Gibt den Grundwert (Wahrheitswert) des Boolean-Objekts zurück

Der Datentyp null

Dieser Datentyp kann nur einen Wert, nämlich null, speichern, welcher ein Synonym für einen nicht vorhandenen Wert darstellt. Aufgrund dessen kann er einer Variablen zugeordnet werden, welche zu diesem Zeitpunkt keinen brauchbaren Wert enthalten soll. In diesem Zusammenhang können beispielsweise fehlende Werte für die erwarteten Parameter einer Funktion ersetzt werden, um den Aufruf der Funktion im strikten Sinne dennoch gewährleisten zu können:

var myNumber = 1;

myFunction(myNumber,null);

function myFunction(myp1,myp2)
{
trace("Parameter 1: " + myp1 + " und Parameter 2: nbsp;" + myp2);
}

Der Datentyp undefined

Der Datentyp wird in der Regel im Zusammenhang mit Variablen verwendet, welche nur deklariert, aber nicht mit einem Wert initialisiert wurden. Ein Beispiel:

var myNumber;

if(myNumber == undefined)
trace("myNumber wurde nicht initialisiert!");

Arrays

Ein Array ist ein vordefiniertes Objekt, welches wiederum eine Aneinanderreihung von variablen Werten darstellt, deren Anzahl vonseiten der Scriptsprache unbegrenzt ist. Einfache Arrays können dabei stets als Vektoren aufgefasst werden.
Um ein neues Array-Objekt zu erstellen, kann man entweder den Array-Zugriffsoperator ([]) oder den Konstruktur des Array-Objekts, d.h. new Array(), verwenden. Das Array-Objekt wird dann mit dem entsprechend angegebenen Bezeichner referenziert:

var myArray = [1,2,3,4,5,6];
//Erzeugung eines Arrays mit Elemente 1 - 6
var myArray = new Array(1,2,3,4,5,6);
//Erzeugung eines Arrays mit Elemente 1 - 6
var myArray = new Array(6);
//Erzeugung eines Arrays mit 6 Elementen (Wert undefined)

Bei diesem Beispiel gilt es zu beachten, dass die letzte Anweisung durch Angabe eines numerisches Werts als Operatorargument ein Array entsprechender Länge, nicht aber ein Array mit einem Element des Wertes, erzeugt. Der Bezeichner auf das jeweilige Arrayobjekt lautet in jedem Beispiel myArray.
Array-Objekte sind zudem auch nicht typisiert, da bei deren Erzeugung auch kein Datentyp für dessen Elemente, wie es beispielsweise bei den Reihungen in Java üblich ist, angegeben werden muss. So können Arrays auch problemlos Elemente unterschiedlichen Datentyps enthalten:

var myArray = [1,"String1",2,3,"String2"];

Es können auch leere Arrays, d.h. Array-Objekte ohne vordefinierte Elemente, erzeugt werden. Sämtliche Array-Elemente enthalten dann den Wert undefined. Ein Beispiel:

var myArray = [];
var myArray = new Array();

Aufgrund der Tatsache, dass sämtliche Arrayelemente indiziert, also durchnummeriert, sind, kann man auf diese unter Anwendung des Array-Zugriffsoperators ([]) und der entsprechenden Nummer zugreifen. Das erste Array-Element hat dabei jedoch den Index 0, so dass der Index des letzten Arrayelements der Länge des Arrayobjekts minus 1 entspricht. Ein Beispiel:

var myArray = [1,2,3,4,5,6];

trace(myArray[1]);
//Gibt den Wert 2 aus
trace(myArray[5]);
//Gibt den Wert 6 aus
trace(myArray[6]);
//Gibt den Wert undefined aus, da Element nicht definiert ist

Array-Objekte sind in ActionScript stets frei erweiterbar. Dies trifft auch auf Arrays, welche mit einer vordefinierten Anzahl von Elementen erzeugt wurden (siehe oben), zu. Neue Arrayelemente werden wiederum unter Angabe des Array-Zugriffsoperators ([]) und des gewünschten neues Indexes dadurch erzeugt, dass man ihnen einfach den entsprechenden Wert zuweist:

var myArray = new Array(1);

myArray[0] = 1;
//Belegung des bereits definierten Arrayelements
//(Index 0) mit Wert 1
myArray[1] = "String1";
//Erzeugung eines neuen Arrayelements (Index 1)
//mit Wert "String1"

Das Array-Objekt stellt in ActionScript die nachfolgenden Eigenschaften und Methoden zur Verügung.

Eigenschaften des Array-Objekts

Eigenschaft	Beispiel	Beschreibung
`length`	`myArray = new Array(1,2,3,4,5); trace(myArray.length);`	Gibt die Länge des Array-Objekts zurück; Ergebnis hier: 5

Methoden des Array-Objekts

Methode	Parameter	Beispiel	Beschreibung
`concat()`	1. Beliebige Anzahl von Elementen, Zahlen oder Strings	`myArray1 = [1,2]; myArray2 = [3,4]; myNewArray = myArray1.concat(myArray2,5,6);`	Verkette die Elemente der Parameter mit dem Array-Objekt; Ergebnis hier: myNewArray = [1,2,3,4,5,6];
`join()`	1. Seperator (String)	`myArray = ["S","t","r","i","n","g"]; myString = myArray.join("_");`	Fügt die Elemente eines Arrays-Objekts zu einem String zusammen, wobei der String des Parameters als Trennung dient; Ergebnis hier: S_t_r_i_n_g
`pop()`	keine	`myArray = [1,2,3,4,5]; myLast = myArray.pop();`	Entfernt das letzte Element des Array-Objekts und gibt dessen Wert zurück; Ergebnis hier: 5
`push()`	1. Beliebige Anzahl von Werten für anzuhängende Elemente	`myArray = [1,2,3,4,5]; myLength = trace(myArray.push(6,7));`	Fügt die Werte der Parameter dem Array-Objekt als Elemente an und gibt dessen neue Länge zurück; Ergebnis hier: 7
`reverse()`	keine	`myArray = [1,2,3,4,5]; myArray.reverse();`	Dreht die Reihenfolge der Elemente des Array-Objekts um; Ergebnis hier: myArray = [5,4,3,2,1];
`shift()`	keine	`myArray = [1,2,3,4,5]; myFirst = myArray.shift();`	Entfernt das erste Element des Array-Objekts und gibt dessen Wert zurück; Ergebnis hier: 1
`slice()`	1. Startindex (Ganzzahl) 2. Endindex (Ganzzahl)	`myArray = [1,2,3,4,5]; mySliced = myArray.slice(1,3);`	Extrahiert Elemente von Startindex (Beginn 0) bis Endindex aus Array-Objekt und gibt diese als Array zurück; Ergebnis hier: mySliced = [2,3];
`sort()`	(1. Funktion, welche Reihenfolge der Sortierung beschreibt)	`myArray = ["cd","a","cc"]; myArray = myArray.sort();`	Sortiert die Elemente des Array-Objekts nach durch Rückgabewert der Sortierungsfunktion vorgegebene Weise, wobei 3 numerische Rückgabewerte möglich sind. Für zwei Elemente A, B gilt dann: 0: A = B 1: A nach B -1: A vor B Ergebnis hier: myArray = ["a","cc","cd"];
`sortOn()`	1. Wert für Arrayfeld, dass als Sortierwert dienen soll	`myArray = [{ID: 2, Name: "nm2"},{ID: "1", Name: "nm1"}]; myArray.sortOn("Name");`	Sortiert die Elemente eines Array-Objekts (ass. Array) nach dem durch den Parameter festgelegten Feld; Ergebnis hier: myArray[0][ "Name"] = "nm1";
`splice()`	1. Startindex (2. Anzahl der löschenden Elemente) (3. Array von Elementen, welche (anstelle der gelöschten) eingefügt werden sollen)	`//Zweites Element durch 4 ersetzen myArray = [1,2,3]; myArray.splice(1,1,4);`	Löscht Elemente des Array-Objekts ab Startindex, wobei die Anzahl der gelöschten Elemente mit 2. Parameter festgelegt wird, und ersetzt sie ggf. durch die Elemente des 3. Parameters. Wird der 2. Parameter weggelassen, werden alle Elemente ab Startindex gelöscht. Wird für 2. Parameter Wert 0 übergeben, wird kein Element gelöscht; Ergebnis hier: myArray = [1,4,3];
`toString()`	keine	`myArray = [1,2,3,4,5]; myString = myArray.toString();`	Gibt die Elemente des Arrays-Objekts verkettet durch Kommata als Stringwert zurück; Ergebnis hier: 1,2,3,4,5
`unshift()`	1. Beliebige Anzahl von Werten für anzuhängende Elemente	`myArray = [3,4,5]; trace(myArray.unshift(1,2));`	Fügt die Werte der Parameter als Elemente am Anfang des Array-Objekts an und gibt dessen neue Länge zurück; Ergebnis hier: 5

Mehrdimensionale Arrays

Um komplexere Datenstrukturen zu realisieren, ist es oft sinnvoll, ein Array selbst mit anderen zu verschachteln. Auf diese Weise lassen sich im Prinzip Arrays beliebig hoher Dimensionalität, d.h. Schachtelung, erzeugen, wobei auf deren Elemente durch mehrfache Notation des Array-Zugriffsoperators ([]) zugegriffen werden kann.
Im Falle eines zweidimensionalen Arrays, welches eine matrixähnliche Struktur darstellt, kann auf dessen Elemente durch Angabe der Zeilen- sowie Spaltenummer, d.h. der entsprechenden Indizes, zugegriffen werden. Ein Beispiel:

//Erzeugung eines zweidimensionalen Arrays durch
//Aufzählung seiner Elemente
var myArray =  [
                  [1,2,3,4,5,6],
                  [7,8,9,10,11,12]
               ];

trace(myArray[1][4]);
//Gibt Wert des Elements der zweiten Zeile (erster Index 1)
//und der fünften Spalte (zweiter Index 4), also 11, aus

In diesem Beispiel könnte das zweidimensionale Array auch erzeugt werden, indem man für dessen Elemente die Referenzen auch die entsprechenden Arrayobjekte angibt:

var mySubArray1 = [1,2,3,4,5,6];
//Erzeugung eines Arrays mit den Werten 1 - 6
var mySubArray2 = [7,8,9,10,11,12];
//Erzeugung eines Arrays mit den Werten 7 - 12

//Erzeugung eines zweidimensionalen Arrays mit
//Referenzen auf die oben erzeugten Arrays
var myArray = [
                 mySubArray1,
                 mySubArray2
              ];

Assoziative Arrays (Hashes)

Arrays sind wie bereits erwähnt Objekte, so dass assoziative Arrays im Prinzip sehr einfach dadurch konstruiert werden können, dass man Eigenschaften für das (Array-)Objekt festlegt. Auf diese Weise entsteht fiktiv eine Reihung aus Paaren von Wert und eines dazu gehörigen Schlüssels. Die Länge eines assoziativen Arrays ist natürlich ebenfalls lediglich durch den maximal verfügbaren Speicherplatz des Systems begrenzt.
Die einzelnen Werte des Arrays werden nicht über einen Index, sondern über ihren zugeordneten Schlüssel angesprochen. Dies erfolgt wiederum entweder mittels des Array-Zugriffsoperators ([]) oder mittels des Punktoperators (.). Ein Beispiel:

var myArray = new Array();

//Verwendung des Array-Zugriffsoperators
myArray["Tag"] = 12;
myArray["Monat"] = "August";

//Verwendung des Punktoperators
myArray.Tag = 12;
myArray.Monat = "August";

Letztere Methode zeigt deutlich, dass hier im Grunde lediglich die Eigenschaften eines Objekts manipuliert werden. Aus diesem Grund kann jedes beliebige Objekt als assoziatives Array behandelt werden, so dass man auch konsequent anstelle eines Array-Objekts ein leeres Object-Objekt erzeugen könnte. Folgendes Beispiel führt daher zum selben Ergebnis wie die obigen beiden:

var myArray = new Object();

myArray.Tag = 12;
myArray.Monat = "August";

Fässt man die so erzeugten assoziativen Arrays als einelementig auf, so können natürlich auch mehrelementige Arrays von assoziativen Arrays (verschachtelt) erzeugt werden. Diese werden dann jeweils von geschweiften Klammern eingeschlossen und können durch zusätzliche Angabe des Arrayzugriffoperators ([])mit ihrem jeweiligen Index angesprochen werden. Ein entsprechend erweitertes Beispiel:

var myArray = new Array(
                        {Tag: 1, Monat: "Januar"},
                        {Tag: 1, Monat: "Februar"}
                       );
myArray[1].Tag = 2;
myArray[1]["Monat"] = "Januar";

Der Datentyp Movieclip

Der Datentyp Movieclip zählt zu den Referenzdatentypen und ist flashspezifisch. Movieclips sind wie bereits erwähnt nicht anderes als Symbole aus der Bibliothek und verweisen daher auf Grafiken. Instanziert man ein Movieclipsymbol, so erzeugt man im Prinzip ein Objekt der Klasse Movieclip und kann mithilfe des Punktoperators (.) auf eine Fülle seiner Eigenschaften, Methoden, etc. zugreifen. Ein Beispiel für den Movieclip mit dem Bezeichner (Instanznamen) myMovieClip:

//Eigenschaften des Objekts manipulieren
myMovieClip._width = 100;
//Verändert die Größe der Instanz auf 100px

//Methoden des Objekts aufrufen
myMovieClip.stop();
//Stoppt die Wiedergabe der Instanz

Eine sehr gute Übersicht über die Eigenschaften sowie Methoden des Movieclip - Objekts findet sich in der Flash beiliegenden ActionScript - Referenz, wobei einige derer im weiteren Verlauf noch gesondert erwähnt werden.

Du arbeitest in einer Agentur oder als Freelancer?
Dann wirf doch mal einen Blick auf unsere Software FeatValue.

Weiterlesen: ⯈ Kontrollstrukturen

Über uns

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

Variablen in ActionScript

Über uns

Cookie-Einstellungen