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
.