Kapitel 7 Werte und Datentypen
Variablen und Eigenschaften erstellen und verändern
Sämtliche Daten eines Programms müssen für die Bearbeitung in irgendeiner Form zugänglich sein. Das Mehl für einen Kuchen wird ja auch nicht einfach in den Raum gestreut, sondern liegt üblicherweise in irgendeiner Art Behälter.
02_Programmierung\Werte und Variablen
Ein Wertebehälter wird in einer Programmiersprache als Variable bezeichnet. Die folgenden Anweisungen beschreiben einige Variablen und die in ihnen enthaltenen Daten für ein Kochrezept:
// Deklaration der Variablen für einen Pfannkuchen
mehlInGramm = 100;
milchInLiter = 0.125;
eierInStueck = 3;
salzInPrisen = 1;
In diesem Beispiel besteht die Datenstruktur nur aus einigen wenigen Zutaten, die darüber hinaus ohne Hierarchie sind. Die Objektorientierung (siehe Teil III) besitzt hier mächtige Werkzeuge, um die Strukturierung der Daten noch zu optimieren. Bei dieser Art der Datenverwaltung spricht man dann in Flash auch von Eigenschaften. In vielen Fällen ist in ActionScript aber ohnehin kaum ein Unterschied zwischen Eigenschaften und Variablen zu erkennen (die meisten Variablen sind nämlich nichts anderes als selbst definierte Eigenschaften von Movieclip-Instanzen).
7.1 Variablen
Um eine Variable zu verwenden, geben Sie deren Namen in einem Stück an (siehe Kapitel 5, »Regeln«). Nur für den Fall, dass ein Variablenbezeichner dynamisch ermittelt werden muss, arbeiten Sie mit Zeichenketten, die entweder über die Funktion eval, die Anweisung set oder die Array-Zugriffsoperatoren [ und ] in eine Variable verwandelt werden (siehe »DOM« auf Seite 276):
// Variablenbezeichner ist myVariable zzgl. einer Zahl
this["myVariable"+String(1)] = "Yep!";
this["myVariable"+String(2)] = eval("myVariable"+String(1));
set("myVariable"+String(3), eval("myVariable"+String(1)));
Einsatzzweck
Variablen verwenden Sie entweder, um Werte zu setzen oder um Werte zu ermitteln. Im Falle der Wertermittlung verhält die Variable sich so, als ob der in ihr enthaltene Wert an der Stelle steht: Sie agiert als Platzhalter.
Das Setzen und Ermitteln von Werten macht ActionScript meist von der Position innerhalb eines Ausdrucks der Variablen abhängig. Kommt die Variable auf der linken Seite eines Ausdrucks mit Zuweisungsoperator wie dem Gleichheitszeichen vor (left hand site expression), dann handelt es sich um eine Zuweisung, sonst um einen Platzhalter:
// Zuweisung (Variable auf der linken Seite)
meineVariable = "Dies ist eine Zeichenkette";
// Ermittlung des Wertes (Variable auf der rechten Seite)
neueVariable = meineVariable;
Auf der linken Seite ist eval nicht erlaubt!
eval kann seit Flash 6 nicht mehr verwendet werden, um einem dynamischen Variablenbezeichner einen Wert zuzuweisen. Verwenden Sie stattdessen besser die Schreibweise mit dem Array-Zugriffsoperator oder die set-Anweisung:
// nicht mehr erlaubt
eval("myVariable"+String(1)) = "Wert";
// erlaubt
this["myVariable"+String(1)] = "Wert";
set("myVariable"+String(1), "Wert");
7.1.1 Gültigkeitsbereich (engl. Scope)
Variablen besitzen zwei Bereiche. Das eine ist der durch den Datentyp vorgegebene Wertebereich. Dieser Wertebereich legt fest, welche Werte eine Variable annehmen kann. Umgangssprachlich entspricht der Wertebereich dem Typ und dem Volumen eines Behälters. In eine Zuckerdose passen beispielsweise zwischen 1 und 500 Gramm Zucker.
Außerdem ist es wichtig zu wissen, in welchen Bereichen die Variable gültig ist. Dieser Gültigkeitsbereich beschreibt den Bekanntheitsgrad! Sollten Sie in ihrer Wohnung beispielsweise mehrere Zuckerdosen haben, dann müssen Sie wissen, wo diese stehen und wie Sie an deren Inhalt gelangen, Ihr Nachbar hat aber höchstwahrscheinlich keine Kenntnis des Gültigkeitsbereichs.
Ortsbeschreibungen
ActionScript unterscheidet hier grundsätzlich zwischen drei Ortsbeschreibungen:
|
Lokal: Eine Variable, die nur in einer Funktion oder einer Methode gültig ist, heißt lokale Variable und wird mit Hilfe von var erstellt oder als Parameter an die Funktion übergeben. |
|
Global: Eine Variable, die überall bekannt ist, heißt globale Variable und wird mit Hilfe des globalen Objektes verwaltet (_global) – so gesehen ist eine globale Variable eine Eigenschaft des globalen Objektes. |
|
Eigenschaft: Alle restlichen Variablen sind identisch mit Eigenschaften und gehören entweder zu einer Movieclip-Instanz oder einem anderen Objekt. |
7.1.2 Eigenschaften
Die meisten Algorithmen erfordern zusammengesetzte Daten, die über einfache Variablen hinausgehen. Deren Struktur legen Sie in einer Programmiersprache wie ActionScript über Objekte mit Eigenschaften und Fähigkeiten fest. Objekte, die so beschaffen sind, heißen Datenstrukturen.
ActionScript gibt Ihnen die Möglichkeit, alle relevanten Objekte sowie Veränderungen dieser Objekte zu definieren. Bei einem Kochrezept sind die Zutaten und das fertige Gericht die Objekte. Die Anweisungen im Rezept führen die gewünschten Veränderungen der Datenstruktur durch oder erzeugen neue Objekte. Bei einer Flash-Anwendung sind Ihre Zutaten Movieclips oder XML-Elemente, die z.B. durch Bewegen eines Movieclips oder das Hinzufügen eines XML-Attributes ein neues »Gericht« ergeben!
// Datenstruktur Pfannkuchen (hier ohne Fähigkeiten)
meinPfannkuchen = new Object();
meinPfannkuchen.mehlInGramm = 100;
meinPfannkuchen.milchInLiter = 0.125;
meinPfannkuchen.eierInStueck = 3;
meinPfannkuchen.salzInPrisen = 1;
Der Aufbau und die Struktur der verwendeten Daten sind sehr wichtig, damit Algorithmen optimal funktionieren. Aus diesem Grund sollten Sie sich viel Zeit für den Entwurf der Datenstruktur nehmen. Bei einem Kochrezept kann es beispielsweise fatal sein, wenn Sie keinen gemahlenen Pfeffer, sondern Pfefferkörner, aber keine Pfeffermühle haben. Auch die Organisation einer Adressliste in einer Flash-Anwendung ist von großer Bedeutung, denn andernfalls finden Sie die Adressen nicht oder nicht schnell genug.
Die Bestandteile eines solchen komplexen Datentyps sind Eigenschaften und Fähigkeiten. Diese entsprechen den Variablen. Der einzige Unterschied ist, dass diese Variablen zu einer Struktur gehören und nicht global bzw. nur lokal existieren. Und selbst die globalen Variablen sind nichts anderes als Eigenschaften des globalen Objektes (siehe den Teil »Objektorientierung« ab Seite 274).
Immer dann, wenn Sie einer Variablen das erste Mal einen Wert zuweisen, ohne _global oder var zu verwenden, wird diese Variable entweder automatisch zu einer Eigenschaft des Movieclips, in dem das Skript platziert ist, oder des Objektes, dessen Pfad Sie der Eigenschaft vorangestellt haben.
Anderer Gültigkeitsbereich in Flash 5
Bis Flash 5 wird eine Eigenschaft immer der Instanz hinzugefügt, in deren Rahmen sie erzeugt wird (solange nicht explizit ein Instanzpfad angegeben ist). Das folgende Skript generiert zum Beispiel eine Eigenschaft der Instanz, da die Methode zu der Instanz gehört und nichts anderes angegeben ist:
instanz.methode = function() {
eigenschaft = "wert";
};
instanz.methode();
Seit Flash 6 wird eine Eigenschaft immer in der Instanz gesetzt, in der das Skript definiert ist. D. h., dass das vorherige Skript in diesem Fall keine Eigenschaft der Instanz generiert, sondern eine Eigenschaft des Movieclips, in dem es steht – in diesem Fall also die Hauptzeitleiste (_level0 oder _root).
Um an dieser Stelle Probleme zu vermeiden, kann auch immer ein Instanzpfad vorangestellt werden.
Das folgende Skript erzeugt dank dem this-Schlüsselwort immer eine Eigenschaft der Instanz – egal ob es sich um Flash 5 oder Flash 6 handelt -, da das this eine Referenz auf die Instanz enthält, in deren Kontext die Funktion abgearbeitet wird:
instanz.methode = function() {
this.eigenschaft = "wert";
};
instanz.methode();
Weitere Information zu diesem Thema erhalten Sie im Teil zur Objektorientierung.
7.1.3 Konstanten
Als Konstanten bezeichnet man Variablen und Eigenschaften, die ihren Wert nicht ändern können. Dazu zählen false, true, null, newline und undefined.
In ActionScript gibt es nur wenige Elemente, die dieser Definition genügen. Darüber hinaus ist es auch mit »normalen« Mitteln nicht möglich, Konstanten zu definieren. Deshalb betrachten Entwickler ebenfalls Eigenschaften und Variablen als Konstanten, wenn von der potenziellen Möglichkeit einer Veränderung kein Gebrauch gemacht wird.
In diesem Sinne sind beispielsweise die globalen Variablen NaN und Infinity Konstanten. Außerdem besitzen viele Objekte konstante Werte. Dazu zählen Tastenwerte des Key-Objektes und Konstanten des Math-Objektes wie Math.PI.
Konstanten erstellen
Um Eigenschaften zu erstellen, deren Werte vor einem Überschreiben geschützt sind, verwenden Sie in Flash 6 die addProperty-Methode (siehe die Kapitel 13 und 15):
// Konstante in Flash MX definieren
Object.prototype.addProperty("meineKonstante", function () {return "wert"}, null);
meineKonstante="unsinn"; / keine Wirkung
trace(meineKonstante);
In ActionScript 2 gibt es einen ähnlichen Weg, der mit Hilfe von Getter-/Setter-Methoden realisiert wird (siehe »ActionScript 2« ab Seite 396).
7.1.4 Variablen mit set deklarieren
Die Aktion set wird verwendet, um einer Variablen einen Wert zuzuweisen. Sollte die Variable noch nicht existieren, wird sie automatisch erzeugt.
|
Bemerkung: |
|
Diese Aktion steht seit dem Flash Player 4 zur Verfügung. Als Alternative sollte der Zuweisungsoperator eingesetzt werden. Für dynamisch erzeugte Bezeichner sollten die eckigen Klammern als Zugriffsoperator in der Form objekt["meineVariable"] = wert; verwendet werden. |
|
|
|
Syntax: |
set(variable, wert);
|
Parameter: |
|
Der erste Parameter gibt den Variablenbezeichner als Zeichenkette an. Da die Zeichenkette dynamisch erzeugt werden kann, sind hier auch dynamische Variablenbezeichner erlaubt. Der zweite Parameter legt den Wert der Variablen als beliebigen Ausdruck fest. |
|
|
|
Beispiel: |
// String
set("meineVariable1", "zeichenkette");
trace(meineVariable1);
trace(typeof meineVariable1);
// Number
set("meineVariable2", 123);
trace(meineVariable2);
trace(typeof meineVariable2);
// Boolean
set("meineVariable3", true);
trace(meineVariable3);
trace(typeof meineVariable3);
// Null
set("meineVariable4", null);
trace(meineVariable4);
trace(typeof meineVariable4);
// Undefined
set("meineVariable5", undefined);
trace(meineVariable5);
trace(typeof meineVariable5);
// Object
set("meineVariable6", new Object());
trace(meineVariable6);
trace(typeof meineVariable6);
// Dynamischer Variablenbezeichner
set("meineVariable"+String(7), 10*5);
trace(meineVariable7);
trace(typeof meineVariable7);
Unzulässige Bezeichnernamen erzeugen
Um Programmcode unleserlich zu gestalten, ist set gut geeignet. Denn so können auch eigentlich unerlaubte Bezeichnernamen erzeugt werden.
Einen Bezeichner, der sogar Zeilenumbrüche enthält, erzeugt die folgende Anweisung:
set("bezeichner\rmit\rZeilenumbrüchen", "Wert");
Um diese Variable wieder auszulesen, kommen die eckigen Klammern als Zugriffsoperator zum Einsatz:
trace(["bezeichner\rmit\rZeilenumbrüchen"]);
Als Alternative bietet sich eine Schreibweise an, die komplett auf die eckigen Klammern als Zugriffsoperator zurückgreift:
this["bezeichner\rmit\rZeilenumbrüchen"] = "aaa";
trace(this["bezeichner\rmit\rZeilenumbrüchen"]);
7.1.5 Variablen mit dem Zuweisungsoperator deklarieren
Das Gleichheitszeichen ist der übliche Weg für die Deklaration und Wertzuweisung bei Variablen und Eigenschaften. Auf der linken Seite dieses Operators platzieren Sie den Variablenbezeichner und auf der rechten Seite den Ausdruck, der den Wert für die Variable bestimmt. Der Ausdruck auf der rechten Seite darf auch Formeln und Funktionen enthalten. Die linke Seite muss aus einer Variablen oder Eigenschaft bestehen. Funktionen und zusammengesetzte Ausdrücke sind nicht erlaubt. Neben dem Gleichheitszeichen bietet ActionScript eine Reihe weiterer so genannter zusammengesetzter Zuweisungsoperatoren an:
a = 10;
b = 6;
a %= b;
trace(a);
// Ergebnis: 4
a = 10;
b = 6;
a &= b;
trace(a);
// Ergebnis: 2
a = 10;
b = 6;
a *= b;
trace(a);
// Ergebnis: 60
a = 10;
b = 6;
a /= b;
trace(a);
// Ergebnis: 1.66666666666667
a = 10;
b = 6;
a ^= b;
trace(a);
// Ergebnis: 12
a = 10;
b = 6;
a |= b;
trace(a);
// Ergebnis: 14
a = 10;
b = 6;
a += b;
trace(a);
// Ergebnis: 16
a = 4;
b = 1;
a <<= b;
trace(a);
// Ergebnis: 8
a = 10;
b = 6;
a = b;
trace(a);
// Ergebnis: 6
a = 10;
b = 6;
a = b;
trace(a);
// Ergebnis: 4
a = 4;
b = 1;
a >>= b;
trace(a);
// Ergebnis: 2
a = 4;
b = 1;
a >>>= b;
trace(a);
// Ergebnis: 2
Operatoren
In vielen Fällen sind Daten jeglicher Art nicht direkt, sondern innerhalb einer Berechnung oder eines Vergleiches erforderlich. Dafür bietet Flash eine Reihe meist aus der Mathematik entliehener Operatoren. Zu den bekanntesten zählen die Grundrechenarten + (Addition), – (Subtraktion), / (Division) und * (Multiplikation) sowie einige Vergleichsoperatoren wie > (größer), < (kleiner) und == (gleich).
Eine Besonderheit in Flash sind die Zuweisungsoperatoren. Diese schreiben den auf der rechten Seite stehenden Wert in den Wertebehälter auf der linken Seite. Bitte beachten Sie, dass der Vergleichsoperator im Gegensatz zum Zuweisungsoperator = mit zwei aufeinander folgenden Gleichheitszeichen == geschrieben wird (siehe Kapitel »Ausdrücke und Operatoren« ab Seite 198).
Tabelle 7.1
Zuweisungsoperatoren
Operator
|
Beschreibung
|
Wirkung
|
%=
|
Modulo-Zuweisung
|
a = a % b
|
&=
|
bitweise AND-Zuweisung
|
a = a & b
|
*=
|
Multiplikationszuweisung
|
a = a*b
|
/=
|
Divisionszuweisung
|
a = a/b
|
^=
|
bitweise XOR-Zuweisung
|
a = a^b
|
|=
|
bitweise OR-Zuweisung
|
a = a|b
|
+=
|
Additionszuweisung
|
a = a+b
|
<<=
|
bitweise Verschiebung nach links und Zuweisung
|
a = a<<b
|
=
|
Zuweisung
|
a = b
|
-=
|
Subtraktionszuweisung
|
a = a-b
|
>>=
|
bitweise Verschiebung nach rechts und Zuweisung
|
a = a>>b
|
>>>=
|
vorzeichenlose bitweise Verschiebung nach rechts und Zuweisung
|
a = a >>> b
|
7.1.6 Lokale Variablen mit var deklarieren
Mit dem Schlüsselwort var kennzeichnen Sie lokale Variablen, die nur innerhalb eines Funktions- oder Methodenblocks gültig sind.
|
Bemerkung: |
|
Dieses Schlüsselwort steht seit dem Flash Player 5 zur Verfügung. Sollte dieses Schlüsselwort außerhalb eines Funktions- oder Methodenblocks verwendet werden, erzeugt Flash anstelle lokaler Variablen ganz normale Variablen, die als Eigenschaften einem Objekt zugeordnet werden. |
|
|
|
Syntax: |
var bezeichner;
var bezeichner1, bezeichner2,...;
var bezeichner = wert;
var bezeichner1 = wert1, bezeichner2 = wert2,...;
|
Parameter: |
|
Die Bezeichner legen die Namen für die lokalen Variablen fest. Diesen Variablen darf bei der Deklaration optional ein Initialwert zugewiesen werden. |
|
|
|
Beispiel: |
function alterInMinuten(jahre) {
var tage = jahre*364;
var stunden = tage*24;
var minuten = stunden*60;
return (minuten);
}
trace(alterInMinuten(30));
Lokale Variablen
Verwenden Sie innerhalb Funktionen oder Methoden möglichst immer lokale Variablen – insbesondere dann, wenn die Variablen nicht außerhalb der Funktion oder Methode benötigt werden.
7.1.7 Globale Variablen mit _global deklarieren
Siehe auch Kapitel »Funktionen« ab Seite 242
Der Bezeichner _global ist ein Zeiger auf das globale Objekt in Flash. Alle in diesem Objekt abgelegten Eigenschaften und Methoden stehen überall in einer Flash-Anwendung zur Verfügung.
|
Bemerkung: |
|
Diese Eigenschaft steht seit dem Flash Player 6 zur Verfügung. |
|
|
|
Syntax: |
_global.bezeichner();
_global.bezeichner;
|
Parameter: |
|
Der Bezeichner steht für eine Eigenschaft oder Methode des globalen Objektes. Es dürfen auch neue Eigenschaften und Objekte hinzugefügt werden. Bereits deklarierte globale Variablen sind auch ohne die Angabe von _global zu erreichen, sollten sie nicht von anderen gleichnamigen Variablen überdeckt werden. |
|
|
|
Beispiel: |
_global.globaleVariable="wert";
trace(_global.globaleVariable);
trace(globaleVariable);
globaleVariable="unsinn";
trace(_global.globaleVariable);
trace(globaleVariable); // gibt unsinn aus
Globale Variablen
Gehen Sie mit globalen Variablen möglichst sparsam um. Denn globale Variablen »verschmutzen« den Arbeitsspeicher. Zum einen machen sie aufgrund Ihrer dauerhaften Existenz das Erkennen von Fehlern schwer, und zum anderen verbrauchen sie Speicherplatz, auch wenn sie nicht mehr benötigt werden. Verwenden Sie globale Variablen also nur dann, wenn Sie zwingend Eigenschaften und Methoden des Projektes an mehreren unabhängigen Stellen benötigen.
7.1.8 Variablen löschen
Siehe »Operatoren« auf Seite 238
Um eine Eigenschaft oder Variable zu löschen, verwenden Sie den delete-Operator. Bei einem gut durchdachten Programmcode und der intensiven Nutzung von lokalen Variablen sollte das nur selten nötig sein. Ungenutzte Variablen entfernt ActionScript ohnehin durch eine automatische Aufräumfunktion (Garbage Collection). Movieclips lassen sich auf diese Art nicht entfernen. Verwenden Sie dafür die removeMovieClip-Methode.
Sollten Sie dennoch auf das manuelle Löschen einer Eigenschaft oder Variablen angewiesen sein, dann verwenden Sie den Operator in der folgenden Form:
delete bezeichner;
Beachten Sie unbedingt, dass dieser Operator bereits in Flash MX korrekt groß- und kleingeschrieben werden muss!
7.1.9 Den Typ einer Variablen ermitteln
Siehe
Operatoren
Den Datentyp einer Variablen oder Eigenschaft ermittelt der typeof-Operator. Verwenden Sie den Operator in der folgenden Form:
typeof bezeichner;
Beachten Sie unbedingt, dass dieser Operator bereits in Flash MX korrekt groß- und kleingeschrieben werden muss!
|