Variablen und Datentypen

Variablen werden in AS über das Schlüsselwort var deklariert. Hinter dem Schlüsselwort muss ein Name angegeben werden, welcher innerhalb des aktuellen Blocks und der darin verschachtelten folgenden Blöcke eindeutig sein muss. Hinter dem Namen muss nun noch ein Doppelpunkt : sowie der Datentyp angegeben werden. Da es sich bei dieser sogenannten Deklaration (also dem Reservieren bzw. Anlegen der Variable) um eine Anweisung handelt, muss am Ende noch ein Semikolon ; angegeben werden.

var NAME:TYP;

Um einer Variable einen Wert zuzuweisen (Wertzuweisung), notieren wir den Namen der Variable gefolgt von einem Gleichtheitszeichen = (Zuweisungsoperator). Anschließend wird der zuzuweisende Wert angegeben. Dabei kann es sich um eine Konstante, den Wert einer anderen Variablen oder um den Rückgabewert einer Funktion handeln. Auch hier darf das Semikolon ; nicht vergessen werden. Der Wert von Variablen kann mehrmals zugewiesen werden, jedoch sollten Sie Variablen immer nur zu einem bestimmten Zweck verwenden, welchen Sie im Variablennamen zum Ausdruck bringen sollten.

NAME = WERT;

Das erste Zuweisen einer Variablen wird als Initialisierung bezeichnet. Die Variableninitialisierung kann in einer Wertzuweisungs-Anweisung oder direkt bei der Deklaration (siehe folgendes Beispiel) vorgenommen werden.

var NAME:TYP = WERT;

Zeichenkette

Bei einer Zeichenkette (engl. String) handelt es sich um die Aneinanderreihung von Zeichen. Eine Zeichenkette kann dabei kein, ein oder mehrere Zeichen enthalten. Zeichenketten zeichnen sich durch den Typ String aus. Werte von Zeichenketten müssen in Anführungszeichen angegeben werden (doppelte oder einfache Anführungszeichen). Um eine Zeichenkette mit einer anderen zu verbinden, können wir das Pluszeichen + verwenden.

var meinName:String = "Peter";

Zum Vereinfachen der Arbeit mit Zeichenketten gibt es einige sogenannte String-Funktionen. Um diese String-Funktionen zu nutzen, benötigen wir den im vorherigen Thema angesprochenen Punktoperator. Dabei wird der Variablenname oder der Wert von einem Punkt gefolgt angegeben. Anschließend wird die Eigenschaft oder die Funktion notiert. Die Eigenschaft length enthält einen lesbaren Wert, welcher die Länge der Zeichenkette enthält. Die Funktionen substring() und substr() erlauben das Extrahieren einer Teilzeichenkette aus einer Zeichenkette. Beiden Funktionen muss mindestens ein Parameter mitgegeben werden, bei welchem es sich um den Startindex handelt. Dieser stellt die Nummer des Zeichens dar (erstes Zeichen entspricht dem Index 0, zweites Zeichen dem Index 1 usw.). Der Funktion substring() kann optional ein zweiter Parameter übergeben werden, wobei es sich um den Endindex handelt. substr() verfügt ebenfalls über einen zweiten optionalen Parameter, welcher die Länge der Teilzeichenkette angibt. Die Funktion indexOf() erlaubt die Suche innerhalb einer Zeichenkette. Als Parameter wird der Funktion eine Zeichenkette übergeben, welche gesucht werden soll. Als Rückgabe gibt die Funktion den Index des ersten Vorkommens der angegebenen Zeichenkette zurück. Bleibt die Suche erfolglos, so gibt die Funktion -1 zurück. Mit der Funktion lastIndexOf() kann eine Suche vom Ende zum Anfang durchgeführt werden, um somit das letzte Vorkommen zu finden.

var ausgabeMeldung:String;
var vorname:String = "Peter";
var nachname:String = "Meyer";

ausgabeMeldung = "Hallo, mein Name ist " + vorname + " " + nachname + "!";

trace(ausgabeMeldung);
trace("Länge: " + ausgabeMeldung.length);
trace("Teil 7-32: " + ausgabeMeldung.substring(7, 32));
trace("Teil 0-L5: " + ausgabeMeldung.substr(0, 5));
trace("1. Komma: " + ausgabeMeldung.indexOf(","));
trace("letztes Leerzeichen: " + ausgabeMeldung.lastIndexOf(" "));

Ausgabe:

Hallo, mein Name ist Peter Meyer!
Länge: 33
Teil 7-32: mein Name ist Peter Meyer
Teil 0-L5: Hallo
1. Komma: 5
letztes Leerzeichen: 26

Nummer

Für nummerische Werte gibt es die drei Datentypen: Number, int und uint. Die Datentypen int und uint werden für 32-bit große Ganzzahlen verwendet. Variablen des Typs uint sind vorzeichenlos und können dadurch Werte zwischen 0 und 4.294.967.295 besitzen. Werte vom Typ int hingegen von -2.147.483.648 bis +2.147.483.647. Der Datentyp Number kann neben Ganzzahlen auch Gleitkommazahlen mit doppelter Genauigkeit (64-bit nach IEEE-754) enthalten. Es ist jedoch zu empfehlen, den Datentyp Number nur für Gleitkommazahlen sowie Ganzzahlen größer 32bit zu verwenden. Zu beachten ist, dass Gleitkommazahlen mit einem Punkt dargestellt werden (für 2,4 also 2.4).

var innenTemperatur:Number = 22.3;

Um die einfachen mathematischen Grundrechenarten zu nutzen, können die dafür standardisierten Zeichen + (Addition), - (Subtraktion), * (Multiplikation), / (Division) und % (Modulo) genutzt werden.

a = (b + c) * d;

Wichtig: Bei der „Addition“ einer Zahl mit einer Zeichenkette wird die Zahl automatisch in eine Zeichenkette umgewandelt (man spricht hier von der sogenannten Typkonvertierung). So wird z. B. aus "CO" + 2 "CO2" und aus "1" + 2 "12".

Für die meisten Operatoren sind zusätzlich einige Kurzoperatoren verfügbar, welche in der folgenden Tabelle mit Beispielen aufgelistet sind.

Name	Formel	Formel (kurz)			Formel (schrittweise)
Addition	x = y + z	x += y	≙	x = x + y	x++	≙	x += 1	≙	x = x + 1
Subtraktion	x = y - z	x -= y	≙	x = x - y	x--	≙	x -= 1	≙	x = x - 1
Multiplikation	x = y * z	x *= y	≙	x = x * y	-
Division	x = y / z	x /= y	≙	x = x / y	-
Modulo	x = y % z	x %= y	≙	x = x % y	-

Übrigens: Das Erhöhen einer Variablen mittels dem ++-Operator wird als Inkrementierung bezeichnet. Beim ---Operator wird von der Dekrementierung gesprochen.

Wichtig: An Stelle von x++ und x-- können wir auch ++x und --x notieren. Der Unterschied besteht darin, dass bei x++ die Inkrementierung nach der Zuweisung stattfindet. Bei ++x wird zuerst inkrementiert und dann der Wert zugewiesen. Das Gleiche gilt natürlich auch für x-- und --x. Die Verwendung von x++ oder ++x bzw. x-- oder --x spielt also nur dann eine Rolle, wenn diese Anweisung einer anderen Variablen zugewiesen wird.

Auch für Zahlen sind ein paar Hilfsfunktionen verfügbar. Mit der Funktion toFixed() können wir die anzuzeigenden Nachkommastellen für Gleitkommazahlen begrenzen. Zur Konvertierung einer Zeichenkette in eine Zahl können wir die Funktionen parseInt() und parseFloat() nutzen. Schlägt die Konvertierung von parseInt() und parseFloat() fehl, so geben die Funktionen den Wert NaN zurück. Um zu überprüfen, ob eine Variable den Wert NaN hat, können wir die Funktion isNaN() verwenden. Einige weitere Hilfsfunktionen befinden sich in der Math-Klasse. Um auf diese zuzugreifen, notieren wir den Klassennamen Math gefolgt von einem Punkt . und dem Funktionsnamen. Zum Runden von Zahlen stehen die Funktionen ceil(), floor() und round() zur Verfügung. floor() rundet auf die nächstkleinere Ganzzahl, ceil() auf die nächstgrößere und round() nach dem kaufmännischem Prinzip (2,4 zu 2 und 2,6 zu 3). Den Funktionen min() und max() kann eine Liste von Zahlen übergeben werden, aus welchem das Minimum oder Maximum ermittelt werden soll.

var ergebnis:int;
var temperatur1:Number = 25.64;
var temperatur2:Number = 21.91;
var temperaturDifferenz:Number;

ergebnis = parseInt("23") + parseInt("5");
temperaturDifferenz = temperatur1 - temperatur2;

trace("23 + 5 = " + ergebnis);
trace("Temperatur-Differenz: " + temperaturDifferenz.toFixed(1) + " - " + Math.floor(temperaturDifferenz) + " - " + Math.ceil(temperaturDifferenz) + " - " + Math.round(temperaturDifferenz));
trace("Minimum: " + Math.min(12, 43, 23, 8, 37, 49, 15, 6, 31, 28));
trace("Maximum: " + Math.max(12, 43, 23, 8, 37, 49, 15, 6, 31, 28));

Ausgabe:

23 + 5 = 28
Temperatur-Differenz: 3.7 - 3 - 4 - 4
Minimum: 6
Maximum: 49

Wahrheitswert

Ein Wahrheitswert kennzeichnet sich durch den Typ Boolean und kennt lediglich zwei Zustände: wahr (true) und unwahr (false).

var benutzerAngemeldet:Boolean = false;

Neben der Verwendung bei Variablen wird ein solcher Wahrheitswert bei Abfragen und Schleifen für die sogenannte Bedingung benötigt. Hier wird oftmals nicht eine Variable vom Typ Boolean abgefragt, sondern über bestimmte Operatoren ein Wert vom Typ Boolean erzeugt. Die folgende Tabelle zeigt eine Auflistung von diesen Vergleichsoperatoren:

a == b	Wert a ist gleich b
a === b	Wert und Typ a ist gleich b
a != b	Wert a ist ungleich b
a !== b	Wert und Typ a ist ungleich b
a > b	Wert a ist größer als b
a >= b	Wert a ist größer als oder gleich b
a < b	Wert a ist kleiner als b
a <= b	Wert a ist kleiner als oder gleich b

Wichtig: Beim Vergleich mittels === und !== wird im Gegensatz zu anderen Operatoren keine automatische Konvertierung durchgeführt, so ergibt z. B. 123 == "123" true, die Bedingung 123 === "123" hingegen false.

Übrigens: Um mehrere Teilbedingung zu verbinden, gibt es das logische Und (Zeichen &&) und das logische Oder (Zeichen ||). Auch eine Kombination beider Operatoren ist möglich. Hier müssen dann jedoch evtl. Klammern gesetzt werden, um Teilbedingungen zu gruppieren.

a > b && a < c

Wichtig: Natürlich können die mit diesen Operatoren erstellten Werte vom Typ Boolean nicht nur bei Bedingungen verwendet werden, sondern auch einer Variablen zugewiesen werden.

Array

Bei einem Array handelt es sich um einen sogenannten komplexen Datentyp, welcher es erlaubt, mehrere Werte innerhalb einer Variablen zu speichern. Die Deklaration eines Arrays ist mit der normalen Variablendeklaration zu vergleichen. Bei der Zuweisung eines Arrays wird als Wert das Schlüsselwort new sowie der Datentypname Array, gefolgt von einem runden Klammernpaar, angegeben. Innerhalb der Klammer können wir nun (falls gewünscht) das Array bereits mit Werten füllen. Diese können dabei von einem beliebigen Datentyp sein und müssen wie Funktionsparameter mit einem Komma getrennt angegeben werden.

var namensListe:Array = new Array("Peter", "Lisa", "Kai", "Anna");

Um auf ein einzelnes Element des Arrays zuzugreifen, notieren wir den Variablennamen gefolgt von einem Paar von eckigen Klammern. Innerhalb der Klammern wird der sogenannte Index angegeben. Der erste Wert hat den Index 0, der zweite Wert den Index 1, der dritte Wert den Index 2 usw.. Der Wert kann über diese sogenannte Indexierung lediglich gelesen werden (z. B. zur Ausgabe), aber auch verändert werden.

trace(namensListe[1]);    // Gibt "Lisa" aus

Ein Array kann jederzeit verändert werden. Hierfür dienen die Funktionen push(), pop(), unshift() und shift(). push() und unshift() erlauben das Hinzufügen eines Wertes zum Array. pop() und shift() hingegen entfernen jeweils einen Wert. push() und pop() beziehen sich auf das Ende des Arrays, d. h. die Funktion push() fügt einen Wert (auch als Element bezeichnet) an das Ende an und pop() entfernt das letzte Element. Im Gegensatz dazu bezieht sich unshift() und shift() auf den Array-Anfang. Die Funktionen pop() und shift() geben jeweils den entfernten Wert des Arrays zurück. Die Eigenschaft length enthält einen Wert, welcher die Länge des Arrays (also die Anzahl der darin enthaltenen Werte) wiederspiegelt. Mit Hilfe der Funktion indexOf() und lastIndexOf() lassen sich Elemente im Array suchen. Dabei sind die Funktionen mit den bereits bekannten String-Funktionen indexOf() und lastIndexOf() zu vergleichen. Auch hier muss beachtet werden, dass das erste Element den Index 0 besitzt (nicht 1). Die Funktion join() fügt alle Werte in einer Zeichenkette zusammen. Als Parameter wird der Funktion das dafür zu verwendete Trennzeichen übergeben. Die Funktion sort() erlaubt das Sortieren des Arrays. Wird der Funktion kein Parameter übergeben, so erfolgt die Sortierung nach den darin enthaltenen Zeichen (mit Beachtung der Groß- und Kleinschreibung). Eine nummerische Sortierung kann mit der Konstante Array.NUMERIC als Parameter durchgeführt werden.

var zahlenListe:Array = new Array(12, 43, 23, 8, 37, 49, 15, 6, 31, 28);

// Array verändern
trace("Erstes Element (entfernt): " + zahlenListe.shift());
trace("Letztes Element (entfernt): " + zahlenListe.pop());
zahlenListe.unshift(13);
zahlenListe.push(24);

// Informationen abrufen
trace("Länge: " + zahlenListe.length);
trace("Position von 12: " + zahlenListe.indexOf(12));		// Wird nicht gefunden, da vorher entfenrt
trace("Position von 37: " + zahlenListe.indexOf(37));
trace("Position von 24: " + zahlenListe.indexOf(24));		// Wird gefunden, da vorher hinzugefügt

// Listenausgabe und sortieren
trace("Liste (Ursprung): " + zahlenListe.join(", "));
zahlenListe.sort();
trace("Liste (Sort.): " + zahlenListe.join(", "));
zahlenListe.sort(Array.NUMERIC);
trace("Liste (Num. Sort.): " + zahlenListe.join(", "));

Ausgabe:

Erstes Element (entfernt): 12
Letztes Element (entfernt): 28
Länge: 10
Position von 12: -1
Position von 37: 4
Position von 24: 9
Liste (Ursprung): 13, 43, 23, 8, 37, 49, 15, 6, 31, 24
Liste (Sort.): 13, 15, 23, 24, 31, 37, 43, 49, 6, 8
Liste (Num. Sort.): 6, 8, 13, 15, 23, 24, 31, 37, 43, 49

Vektor

Bei dem Datentyp Vector handelt es sich um eine Abwandlung des Array-Datentyps. Vektoren (engl. vector) sind an einen bestimmten Datentyp gebunden und können zudem „fixiert“ werden. Die Deklaration von Vektoren ist etwas komplexer, da in der Deklaration noch der Datentyp angegeben wird. Innerhalb der Klammern können optional zwei Parameter angegeben werden, wodurch die Länge (1. Parameter) und die Fixierung (2. Parameter) angegeben werden kann. Wird ein Vektor fixiert, so umfasst der Datentyp immer die festgelegte Anzahl an Werten. Das dynamische Hinzufügen oder Entfernen von Werten ist dann nicht möglich.

var namensListe:Vector.<String> = new Vector.<String>();
var temperaturWerte:Vector.<Number> = new Vector.<Number>(100, true);  // Fixierter Vektor mit 100 Werten

Des Weiteren bleiben alle oben beschriebenen Array-Eigenschaften und -Funktionen erhalten. Jedoch gilt zu beachten, dass die Funktionen push(), pop(), shift() und unshift() bei einem fixierten Vektor nicht verwendet werden darf. Ob ein Vektor fixiert ist, kann mit der Eigenschaft fixed abgerufen werden. Der Zugriff mittels der Indexierung wird auch beim Vektor benutzt.

var zahlenListe:Vector.<Number> = new Vector.<Number>(10, true);

zahlenListe[0] = 12;
zahlenListe[1] = 43;
zahlenListe[2] = 23;
zahlenListe[3] = 8;
zahlenListe[4] = 37;
zahlenListe[5] = 49;
zahlenListe[6] = 15;
zahlenListe[7] = 6;
zahlenListe[8] = 31;
zahlenListe[9] = 28;

// Informationen abrufen
trace("Fixiert: " + zahlenListe.fixed);
trace("Länge: " + zahlenListe.length);
trace("Position von 43: " + zahlenListe.indexOf(43));
trace("Position von 15: " + zahlenListe.indexOf(15));

// Listenausgabe
trace("Liste: " + zahlenListe.join(", "));

Ausgabe:

Fixiert: true
Länge: 10
Position von 43: 1
Position von 15: 6
Liste: 12, 43, 23, 8, 37, 49, 15, 6, 31, 28

Datum

Um in AS einen Datumswert (ggf. mit Uhrzeit) darzustellen, benötigen wir den Datentyp Date. Die Erzeugung eines Date-Datentyps erfolgt ebenfalls mit dem Schlüsselwort new, dem Datentypname und einem runden Klammernpaar. Wird hier kein Parameter angegeben, so enthält die Date-Variable das aktuelle Datum mit Uhrzeit. Alternativ kann dieser sogenannten Konstruktorfunktion ein Millisekundenwert (UNIX-Zeitstempel: Millisekunden seit dem 1.1.1970 00:00:00 Uhr) übergeben werden. Des Weiteren ist es auch möglich, der Funktion das Jahr, den Monat, den Tag (des Monats), die Stunden, die Minuten, die Sekunden und die Millisekunden als Parameter in der gerade genannten Reihenfolge zu übergeben.

Zum Auslesen und Setzen der Datums- und Uhrzeitbestandteile gibt es einige Funktionen und Eigenschaften, die in den folgenden Tabellen aufgelistet sind:

Lokalzeit
Eigenschaft	Lese-Funktion	Setz-Funktion	Beschreibung
fullYear	getFullYear()	setFullYear()	Jahr
month	getMonth()	setMonth()	Monat (0 für Januar, 1 für Februar, ..., 11 für Dezember)
date	getDate()	setDate()	Tag des Monats (0 - 31)
day	getDay()	-	Tag der Woche (0 für Sonntag, 1 für Montag, ..., 6 für Samstag)
hours	getHours()	setHours()	Stunde (0 - 23)
minutes	getMinutes()	setMinutes()	Minute (0 - 59)
seconds	getSeconds()	setSeconds()	Sekunde (0 - 59)
milliseconds	getMilliseconds()	setMilliseconds()	Millisekunde (0 - 999)

UTC-Zeit
Eigenschaft	Lese-Funktion	Setz-Funktion	Beschreibung
fullYearUTC	getUTCFullYear()	setUTCFullYear()	Jahr
monthUTC	getUTCMonth()	setUTCMonth()	Monat (0 für Januar, 1 für Februar, ..., 11 für Dezember)
dateUTC	getUTCDate()	setUTCDate()	Tag des Monats (0 - 31)
dayUTC	getUTCDay()	-	Tag der Woche (0 für Sonntag, 1 für Montag, ..., 6 für Samstag)
hoursUTC	getUTCHours()	setUTCHours()	Stunde (0 - 23)
minutesUTC	getUTCMinutes()	setUTCMinutes()	Minute (0 - 59)
secondsUTC	getUTCSeconds()	setUTCSeconds()	Sekunde (0 - 59)
millisecondsUTC	getUTCMilliseconds()	setUTCMilliseconds()	Millisekunde (0 - 999)

Die Funktionen toDateString(), toTimeString(), toString() und toUTCString() geben eine Zeichenkette mit dem Datum bzw. der Uhrzeit zurück. Das Format der Ausgabe kann nicht beeinflusst werden und ist von Adobe festgelegt. Ist ein anderes Format gewünscht, so müssen Sie das Zusammenbauen der Bestandteile selbst übernehmen.

var aktuellesDatum:Date = new Date();
var webseitenGruendung:Date = new Date(2013, 0, 29, 20, 0, 0, 0);

trace("Aktuelles Datum: " + aktuellesDatum.toDateString());
trace("Aktuelle Uhrzeit: " + aktuellesDatum.toTimeString());
trace("Aktuelles Datum mit Uhrzeit (UTC): " + aktuellesDatum.toUTCString());

trace("Die Webseite wurde am " + webseitenGruendung.date + "." + (webseitenGruendung.month + 1) + "." + webseitenGruendung.fullYear + " um " + webseitenGruendung.hours + " Uhr gegründet!");
webseitenGruendung.fullYear = aktuellesDatum.fullYear;
trace("Die Webseite wird / wurde am " + webseitenGruendung.date + "." + (webseitenGruendung.month + 1) + "." + webseitenGruendung.fullYear + " um " + webseitenGruendung.hours + " Uhr " + (aktuellesDatum.fullYear - 2013) + " Jahre alt!");

Ausgabe:

Aktuelles Datum: Wed Aug 10 2016
Aktuelle Uhrzeit: 12:11:33 GMT+0200
Aktuelles Datum mit Uhrzeit (UTC): Wed Aug 10 10:11:33 2016 UTC
Die Webseite wurde am 29.1.2013 um 20 Uhr gegründet!
Die Webseite wird / wurde am 29.1.2016 um 20 Uhr 3 Jahre alt!

Übrigens: Sie können in ActionScript auch sogenannte Konstanten definieren. Konstanten müssen bei der Deklaration zugewiesen werden und können danach nicht mehr verändert werden. Bei Konstanten wird an Stelle des Schlüsselworts var const verwendet.

const mwstFaktor = 0.19;

Wichtig: Uniinitialisierte Variablen besitzen je nach Typ einen anderen Wert. false für Boolean, 0 für int und uint, NaN für Number und null für Object und String. null ist ein Wert, welcher eine fehlende Referenz angibt. Objekte (dazu zählen auch Array, Vector und Date) werden auf dem sogenannten Heap gespeichert. In der Variablen selbst wird daher nicht das ganze Objekt, sondern lediglich eine Referenz auf einen Speicher gespeichert. Fehlt diese Referenz (wie es der Fall ist, wenn eine Objekt-Variable deklarierter jedoch nicht zugewiesen ist) so ist der Wert eben null.