Typy danych

Kontrola typów w czasie kompilacji jest często preferowanym rozwiązaniem w dużych projektach, w których elastyczność w użyciu typów danych jest zazwyczaj mniej istotna niż możliwe wczesne wykrywanie wszelkich błędów. Dlatego domyślnie kompilator języka ActionScript w programach Flash Professional i Flash Builder działa w trybie ścisłym.

Aby możliwa była kontrola typów w trakcie wykonywania, kompilator musi dysponować informacjami o typach danych zmiennych lub wyrażeń w kodzie. Aby jawnie zadeklarować typ danych zmiennej, należy za jej nazwą umieścić operator dwukropka ( : ), a następnie nazwę typu. Aby skojarzyć typ danych z parametrem, należy użyć dwukropka wraz z następującą po nim nazwą typu. Na przykład w poniższym kodzie określany jest typ parametru xParam oraz deklarowana jest zmienna myParam o jawnie określonym typie danych:

function runtimeTest(xParam:String) 
{ 
    trace(xParam); 
} 
var myParam:String = "hello"; 
runtimeTest(myParam);

W trybie ścisłym kompilator języka ActionScript zgłasza niezgodności typów jako błędy kompilatora. Na przykład w poniższym kodzie zadeklarowany jest parametr funkcji xParam typu Object, a następnie podejmowana jest próba przypisania temu parametrowi wartości typu String i Number. W trybie ścisłym spowoduje to zgłoszenie błędu przez kompilator.

function dynamicTest(xParam:Object) 
{ 
    if (xParam is String) 
    { 
        var myStr:String = xParam; // compiler error in strict mode 
        trace("String: " + myStr); 
    } 
    else if (xParam is Number) 
    { 
        var myNum:Number = xParam; // compiler error in strict mode 
        trace("Number: " + myNum); 
    } 
}

Jednak nawet w trybie ścisłym możliwe jest selektywne wyłączenie kontrolowania zgodności typów w czasie wykonywania. Należy w tym celu pominąć wskazanie typu po prawej stronie instrukcji przypisania. Zmienną lub wyrażenie można oznaczyć jako niemającą/niemające typu, pomijając wskazanie typu lub używając gwiazdki ( * ) jako nazwy typu. Przykładowo, jeśli parametr xParam z poprzedniego przykładu zostanie zmodyfikowany tak, aby nie był wskazywany jego typ, poniższy kod zostanie skompilowany bez błędów nawet w trybie ścisłym:

function dynamicTest(xParam) 
{ 
    if (xParam is String) 
    { 
        var myStr:String = xParam; 
        trace("String: " + myStr); 
    } 
    else if (xParam is Number) 
    { 
        var myNum:Number = xParam; 
        trace("Number: " + myNum); 
    } 
} 
dynamicTest(100) 
dynamicTest("one hundred");

W środowisku ActionScript 3.0 zgodność typów jest kontrolowana w czasie wykonywania niezależnie od tego, czy kompilacja odbywała się w trybie ścisłym, czy standardowym. Rozważmy sytuację, w której wartość 3 zostanie przekazana jako argument do funkcji, która oczekuje tablicy. W trybie ścisłym kompilator wygeneruje błąd, ponieważ wartość 3 jest niezgodna z typem danych Array. W wypadku wyłączenia trybu ścisłego i kompilacji w trybie standardowym kompilator nie zgłosi niezgodności typów, ale kontrola typów w trakcie wykonywania kodu spowoduje zgłoszenie błędu.

Poniższy przykład ilustruje funkcję o nazwie typeTest() , która oczekuje argumentu typu Array, a do której przekazano wartość 3. W trybie standardowym spowoduje to błąd czasu wykonywania, ponieważ wartość 3 nie należy do zadeklarowanego typu danych parametru (Array).

function typeTest(xParam:Array) 
{ 
    trace(xParam); 
} 
var myNum:Number = 3; 
typeTest(myNum);  
// run-time error in ActionScript 3.0 standard mode

Mogą także wystąpić sytuacje, w których błąd w czasie wykonywania zostanie zgłoszony mimo przeprowadzenia kompilacji w trybie ścisłym. Jest to możliwe, jeśli kompilacja odbywa się w trybie ścisłym, ale zrezygnowano kontrolę typów w czasie kompilacji, ponieważ użyto zmiennej bez typu. Użycie zmiennej bez typu nie eliminuje kontroli typów, a jedynie odracza ją do czasu wykonywania. Na przykład, jeśli zmienna myNum z poprzedniego przykładu nie ma zadeklarowanego typu danych, kompilator nie może wykryć niezgodności typów, ale kod zgłosi błąd w czasie wykonywania, ponieważ porówna bieżącą wartość myNum , która w wyniku przypisania wynosi 3, z typem parametru xParam , czyli Array.

function typeTest(xParam:Array) 
{ 
    trace(xParam); 
} 
var myNum = 3; 
typeTest(myNum);  
// run-time error in ActionScript 3.0

Kontrola typów dopiero w trakcie wykonywania pozwala także na bardziej elastyczne korzystanie z mechanizmów dziedziczenia. Dzięki odroczeniu kontroli typów do momentu wykonania kodu tryb standardowy umożliwia odwoływanie się do właściwości podklasy nawet jeśli dokonano rzutowania rozszerzającego (ang. upcast). Rzutowanie rozszerzające ma miejsce, gdy instancja zostaje zadeklarowana przy użyciu klasy bazowej, ale jest tworzona przy użyciu podklasy. Możemy na przykład utworzyć klasę ClassBase, którą można rozszerzyć (klas z atrybutem final nie można rozszerzać):

class ClassBase 
{ 
}

Następnie możemy utworzyć podklasę klasy ClassBase o nazwie ClassExtender, która będzie miała jedną właściwość o nazwie someString :

class ClassExtender extends ClassBase 
{ 
    var someString:String; 
}

Używając obu klas, możemy utworzyć instancję zadeklarowaną przy użyciu typu danych ClassBase, ale utworzoną faktycznie przy użyciu konstruktora klasy ClassExtender. Rzutowanie rozszerzające jest uznawane za operację bezpieczną, ponieważ klasa bazowa nie zawiera żadnych właściwości ani metod nieistniejących w podklasie.

var myClass:ClassBase = new ClassExtender();

Podklasa natomiast zawiera właściwości lub metody, których brak w klasie bazowej. Na przykład klasa ClassExtender zawiera właściwość someString , która nie istnieje w klasie ClassBase. W trybie standardowym kompilatora ActionScript 3.0 dozwolone jest odwoływanie się do tej właściwości z instancji myClass — nie spowoduje to zgłoszenia błędu w czasie kompilacji:

var myClass:ClassBase = new ClassExtender(); 
myClass.someString = "hello"; 
// no error in ActionScript 3.0 standard mode

Operator is umożliwia przetestowanie, czy zmienna lub wyrażenie należy do określonego typu danych. W poprzednich wersjach języka ActionScript tę samą funkcjonalność realizował operator instanceof , ale w języku ActionScript 3.0 operatora instanceof nie należy stosować do testowania przynależności do typów danych. Do ręcznego sprawdzania typów należy używać operatora is , a nie operatora instanceof , ponieważ wyrażenie x instanceof y sprawdza tylko, czy w łańcuchu prototypów x istnieje y (a w języku ActionScript 3.0 łańcuch prototypów nie odzwierciedla w pełni hierarchii dziedziczenia).

Operator is analizuje właściwą hierarchię dziedziczenia i może być stosowany nie tylko do sprawdzania, czy obiekt jest instancją konkretnej klasy, lecz także czy obiekt jest instancją klasy implementującej konkretny interfejs. W poniższym przykładzie tworzona jest instancja klasy Sprite o nazwie mySprite , po czym operator is używany jest do sprawdzania, czy mySprite jest instancją klas Sprite i DisplayObject oraz czy implementuje interfejs IEventDispatcher:

var mySprite:Sprite = new Sprite(); 
trace(mySprite is Sprite); // true 
trace(mySprite is DisplayObject);// true 
trace(mySprite is IEventDispatcher); // true

Operator is sprawdza hierarchię dziedziczenia i prawidłowo informuje, że instancja mySprite jest zgodna z klasami Sprite oraz DisplayObject (klasa Sprite jest podklasą klasy DisplayObject). Operator is sprawdza także, czy mySprite dziedziczy z jakichkolwiek klas, które implementują interfejs IEventDispatcher. Ponieważ klasa Sprite dziedziczy z klasy EventDispatcher, która implementuje interfejs IEventDispatcher, operator is prawidłowo informuje, że mySprite implementuje ten interfejs.

Poniższy przykład ilustruje te same testy, co poprzednio, ale wykonywane za pomocą operatora instanceof , a nie is . Operator instanceof prawidłowo rozpoznaje mySprite jako instancję klasy Sprite lub DisplayObject, ale zwraca false , gdy próbujemy sprawdzić, czy mySprite implementuje interfejs IEventDispatcher.

trace(mySprite instanceof Sprite); // true 
trace(mySprite instanceof DisplayObject);// true 
trace(mySprite instanceof IEventDispatcher); // false

Operator as również umożliwia sprawdzenie, czy wyrażenie należy do określonego typu danych. Jednak w przeciwieństwie do operatora is , operator as nie zwraca wartości typu Boolean. Operator as zwraca wartość wyrażenia zamiast true albo wartość null zamiast false . Poniższy przykład ilustruje wynik użycia operatora as zamiast operatora is w prostym przypadku sprawdzenia, czy instancja klasy Sprite należy do typów danych DisplayObject, IEventDispatcher i Number.

var mySprite:Sprite = new Sprite(); 
trace(mySprite as Sprite);                 // [object Sprite] 
trace(mySprite as DisplayObject);                 // [object Sprite] 
trace(mySprite as IEventDispatcher);                 // [object Sprite] 
trace(mySprite as Number);                                       // null

Operand po prawej stronie operatora as musi być typem danych. Próba użycia jako prawego operandu wyrażenia innego niż typ danych spowoduje zgłoszenie błędu.

Typ danych Boolean zawiera dwie wartości: true oraz false . Zmienne typu Boolean nie mogą przyjmować żadnych innych wartości. Domyślna wartość zadeklarowanej, ale niezainicjowanej zmiennej typu Boolean to false .

Wartości typu danych int są przechowywane wewnętrznie jako 32-bitowe liczby całkowite; typ ten obejmuje zbiór liczb całkowitych od

-2 147 483 648 (-2 ³¹ ) do 2 147 483 647 (2 ³¹ - 1) włącznie. We wcześniejszych wersjach języka ActionScript istniał tylko typ danych Number używany zarówno do liczb całkowitych, jak i zmiennopozycyjnych. W języki ActionScript 3.0 programista ma dostęp do niskopoziomowych typów maszynowych reprezentujących 32-bitowe liczby całkowite ze znakiem i bez znaku. Jeśli zmienna nie potrzebuje wartości ułamkowych lub bardzo dużych/małych, użycie typu int zamiast typu Number powinno zapewnić większą szybkość wykonywania programu i bardziej oszczędne wykorzystanie pamięci.

Do reprezentowania wartości całkowitych spoza zakresu typu int należy stosować typ danych Number, który uwzględnia wartości z zakresu od plus do minus 9 007 199 254 740 992 (53-bitowe liczby całkowite). Domyślna wartość zmiennych typu int to 0.

Typ danych Null zawiera tylko jedną wartość, null . Jest to domyślna wartość danych typu String oraz wszystkich klas definiujących złożone typy danych, w tym klasy Object. Żadne inne typy pierwotne, w tym Boolean, Number, int oraz uint, nie zawierają wartości null . W czasie wykonywania wartość null jest przekształcana na odpowiednią wartość domyślną, jeśli podjęto próbę przypisania null do wartości typu Boolean, Number, int lub uint. Tego typu danych nie można używać we wskazaniach typu.

W języku ActionScript 3.0 typ danych Number może reprezentować liczby całkowite ze znakiem, liczby całkowite bez znaku i liczby zmiennopozycyjne. Jednak ze względów wydajnościowych należy używać typu danych Number wyłącznie do reprezentacji liczb całkowitych niemieszczących się w zakresie 32-bitowych typów int i uint oraz liczb zmiennopozycyjnych. Aby liczba była przechowywana jako zmiennopozycyjna, należy zapisać ją z kropką dziesiętną. Pominięcie kropki dziesiętnej spowoduje, że liczba będzie przechowywana jako wartość całkowita

Dane typu Number są zapisywane w formacie 64-bitowym o podwójnej precyzji zgodnie ze specyfikacją IEEE Standard for Binary Floating-Point Arithmetic (IEEE-754). Standard ten reguluje zasady zapisywania liczb zmiennopozycyjnych w słowach 64-bitowych. Jeden bit określa, czy liczba jest dodatnia, czy ujemna. Jedenaście bitów zajmuje wykładnik dla podstawy 2. Pozostałe 52 bity zawierają mantysę (ang. significand lub mantissa ), czyli liczbę podnoszoną do potęgi określonej przez wykładnik.

Dzięki wykorzystaniu części bitów do przechowywania wykładnika, typ danych Number umożliwia przechowywanie liczb zmiennopozycyjnych znacznie większych niż wówczas, gdyby wszystkie bity były zajęte przez mantysę. Na przykład, gdyby w danych typu Number wszystkie 64 bity były zajęte przez mantysę, możliwe byłoby zapisywanie liczb nie większych niż 2 ⁶⁵ - 1. Wykorzystanie 11 bitów na wykładnik sprawia, że w danych typu Number mantysa może być podniesiona do potęgi 2 ¹⁰²³ .

Maksymalna i minimalna wartość danych typu Number przechowywane są we właściwościach statycznych klasy Number o nazwach Number.MAX_VALUE i Number.MIN_VALUE .

Number.MAX_VALUE == 1.79769313486231e+308 
Number.MIN_VALUE == 4.940656458412467e-324

Ceną, jaką trzeba zapłacić za bardzo szeroki zakres wartości typu Number, jest precyzja reprezentacji liczb. W danych typu Number mantysa jest zapisana na 52 bitach, przez co wartości, których nie da się dokładnie zapisać w tej liczbie bitów (np. ułamek 1/3) są tylko przybliżeniami. Jeśli w aplikacji wymagana jest bezwzględna precyzja zapisu liczb dziesiętnych, konieczne będzie użycie oprogramowania, które implementuje dziesiętną arytmetykę zmiennopozycyjną (a nie omawianą tutaj binarną arytmetykę zmiennopozycyjną).

Wartości całkowite typu Number zapisane są tylko na 52 bitach mantysy. Przy użyciu tych 52 bitów i specjalnego bitu ukrytego można zapisać liczby z zakresu od -9 007 199 254 740 992 (-2 ⁵³ ) do 9 007 199 254 740 992 (2 ⁵³ ).

Wartość NaN jest używana nie tylko jako wartość domyślna zmiennych typu Number , lecz również jako wynik wszelkich operacji, które powinny zwracać liczbę, ale jej nie zwracają Na przykład próba obliczenia pierwiastka kwadratowego z liczby ujemnej da w wyniku NaN . Inne specjalne wartości typu Number to dodatnia nieskończoność oraz ujemna nieskończoność .

Typ danych String reprezentuje ciąg znaków 16-bitowych. Ciągi znaków są przechowywane wewnętrznie w formacie Unicode UTF-16. Ciągi znaków są wartościami niezmiennymi, podobnie jak w języku oprogramowania Java. Każda operacja na wartości typu String zwraca nową instancję ciągu. Wartość domyślna zmiennej z zadeklarowanym typem String jest null . Wartość null nie jest tym samym, co pusty łańcuch ( "" ). Wartość null oznacza, że w zmiennej nie jest zapisana wartość, a pusty łańcuch oznacza, że ma wartość typu String, która nie zawiera znaków.

Wartości typu danych uint są przechowywane wewnętrznie jako 32-bitowe liczby całkowite bez znaku; typ ten obejmuje zbiór liczb całkowitych od 0 do 4 294 967 295 (2 ³² - 1) włącznie. Typ uint jest przeznaczony do stosowania w okolicznościach, w których wymagane jest użycie nieujemnych liczb całkowitych. Na przykład dane typu uint muszą być używane do zapisu wartości kolorów pikseli, ponieważ dane typu int zawierają bit znaku, który zakłóca interpretację wartości kolorów. Do przechowywania wartości całkowitych większych niż maksymalna wartość typu uint należy stosować typ danych Number, który pozwala na zapis 53-bitowych liczb całkowitych. Domyślna wartość zmiennych typu uint to 0.

Typ danych void zawiera tylko jedną wartość, undefined . We wcześniejszych wersjach języka ActionScript wartość undefined była domyślną wartością instancji klasy Object. W języku ActionScript 3.0 domyślna wartość instancji klasy Object to null . Próba przypisania wartości undefined instancji klasy Object spowoduje przekonwertowanie wartości na null . Wartość undefined można przypisywać tylko zmiennym bez typu. Zmienne bez typu są to zmienne, w których deklaracji pominięto wskazanie typu lub użyto wskazania typu w postaci gwiazdki ( * ). Słowa void można użyć tylko jako wskazania typu wartości zwracanej.

Typ danych Object jest zdefiniowany przez klasę Object. Klasa Object pełni rolę klasy bazowej dla wszystkich innych definicji klas w języku ActionScript. Wersja typu danych Object w języku ActionScript 3.0 różni się od poprzednich wersji pod trzema względami. Po pierwsze, typ danych Object nie jest już domyślnym typem danych przypisywanym zmiennym bez wskazanego typu. Po drugie typ danych Object nie zawiera już wartości undefined , która była domyślną wartością instancji klasy Object. Po trzecie w języku ActionScript 3.0 wartość domyślna instancji klasy Object to null .

W poprzednich wersjach języka ActionScript zmiennej bez wskazanego typu automatycznie przypisywany był typ danych Object. Ta zasada nie obowiązuje w języku ActionScript 3.0, w którym wprowadzono koncepcję zmiennej rzeczywiście pozbawionej typu. Zmienne bez wskazanego typu są teraz uznawane za zmienne bez typu. Aby w sposób jednoznaczny zaznaczyć w kodzie, że zmienna jest celowo pozostawiana bez typu, można użyć wskazania typu w postaci symbolu gwiazdki ( * ), który jest równoważny pominięciu typu. Poniżej przedstawiono dwie równoważne instrukcje. Obie one deklarują zmienną x bez typu.

var x 
var x:*

Tylko zmienne bez typu mogą przyjmować wartość undefined . Próba przypisania wartości undefined zmiennej o określonym typie danych spowoduje, że środowisko wykonawcze przekonwertuje wartość undefined na wartość domyślną tego typu. W przypadku danych typu Object wartością domyślną jest null , co oznacza, że w przy próbie przypisania undefined do instancji Object wartość zostanie przekształcona na null .