Gegevenstypen

Type controleren bij compilatie geniet vaak de voorkeur bij grotere projecten. Flexibiliteit in de gegevenstypen is bij grotere projecten immers vaak van minder belang dan het zo vroeg mogelijk afvangen van typefouten. Daarom wordt de ActionScript-compiler in Flash Professional en Flash Builder standaard uitgevoerd in de strikte modus.

Voor het controleren van het type bij compilatie moet in de compiler de informatie over gegevenstypen bekend zijn voor de variabelen of expressies in de code. U kunt een gegevenstype expliciet declareren voor een variabele door de operator dubbelepunt ( : ) toe te voegen, gevolgd door het gegevenstype als achtervoegsel van de variabelenaam. U kunt een gegevenstype aan een parameter koppelen door de operator dubbelepunt te gebruiken, gevolgd door het gegevenstype. Met de volgende code wordt bijvoorbeeld informatie over het gegevenstype toegevoegd aan de parameter xParam en wordt een variabele myParam gedeclareerd met een expliciet gegevenstype:

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

In de strikte modus rapporteert de ActionScript-compiler niet-overeenkomende typen als compilatiefouten. Met de volgende code wordt bijvoorbeeld een functieparameter xParam gedeclareerd van het type Object. Verderop wordt geprobeerd waarden van het type String en Number toe te voegen aan die parameter. Dit resulteert in een compilatiefout in de strikte modus.

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); 
    } 
}

Zelfs in de strikte modus kunt u controle van het type bij compilatie selectief omzeilen door de rechterkant van een toewijzingsinstructie zonder type te laten. U kunt een variabele of expressie zonder type markeren door een typeannotatie weg te laten of door de speciale asterisk ( * ) te gebruiken als typeannotatie. Als de parameter xParam in het vorige voorbeeld geen typeannotatie krijgt, wordt de code als volgt in de strikte modus gecompileerd:

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");

Type controleren bij uitvoering vindt altijd plaats in ActionScript 3.0, of u nu compileert in de strikte modus of in de standaardmodus. Neem bijvoorbeeld een situatie waarin de waarde 3 als argument wordt doorgegeven aan een functie die een array verwacht. In de strikte modus wordt een compilatiefout gegenereerd, omdat de waarde 3 niet compatibel is met het gegevenstype Array. Als u de strikte modus uitschakelt en in de standaardmodus werkt, worden bij compilatie de niet-overeenkomende typen niet als fout gemeld. Bij controle van het type bij uitvoering treedt echter wel een uitvoeringsfout op.

In het volgende voorbeeld wordt een functie getoond met de naam typeTest() die een argument van het type Array verwacht, maar de waarde 3 krijgt doorgegeven. Dit resulteert in een uitvoeringsfout in de standaardmodus, omdat de waarde 3 geen lid is van het gedeclareerde gegevenstype voor de parameter (Array).

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

Er kunnen zich ook situaties voordoen waarin een uitvoeringsfout optreedt zelfs terwijl u in de strikte modus werkt. Dit is mogelijk wanneer u de strikte modus gebruikt, maar controle van het type bij compilatie omzeilt door een variabele zonder type te gebruiken. Wanneer u een variabele zonder type gebruikt, wordt het controleren van het type niet uitgeschakeld, maar uitgesteld tot uitvoering plaatsvindt. Als bijvoorbeeld de variabele myNum in het vorige voorbeeld geen gedeclareerd gegevenstype heeft, worden de niet-overeenkomende typen niet gedetecteerd in de compiler. De code genereert echter een uitvoeringsfout, omdat de uitvoeringswaarde van myNum , die op 3 is ingesteld door de toewijzingsinstructie, wordt vergeleken met het type van xParam , die is ingesteld op het gegevenstype Array.

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

Controle van het type bij uitvoering biedt tevens meer flexibiliteit voor het gebruik van overerving dan controle bij compilatie. Door de controle van het type uit te stellen tot de uitvoering, kunt u in de standaardmodus naar eigenschappen van een subklasse verwijzen zelfs wanneer er sprake is van upcasting . Een upcast treedt op wanneer u een basisklasse gebruikt om het type van een klasseninstantie te declareren, maar een subklasse om deze te instantiëren. U kunt bijvoorbeeld een klasse maken met de naam ClassBase die kan worden uitgebreid (klassen met het attribuut final kunnen niet worden uitgebreid):

class ClassBase 
{ 
}

Vervolgens kunt u als volgt een subklasse van ClassBase maken met de naam ClassExtender, die één eigenschap heeft met de naam someString :

class ClassExtender extends ClassBase 
{ 
    var someString:String; 
}

Met behulp van beide klassen kunt u een klasseninstantie maken die is gedeclareerd met het gegevenstype ClassBase, maar geïnstantieerd met de constructor ClassExtender. Een upcast wordt als een veilige bewerking beschouwd, omdat de basisklasse geen eigenschappen of methoden bevat die zich niet in de subklasse bevinden.

var myClass:ClassBase = new ClassExtender();

Een subklasse bevat echter eigenschappen of methoden die de basisklasse niet heeft. De klasse ClassExtender bevat bijvoorbeeld de eigenschap someString , die niet bestaat in de klasse ClassBase. In de standaardmodus van ActionScript 3.0 kunt u naar deze eigenschap verwijzen met de instantie myClass zonder een compilatiefout te genereren, zoals in het volgende voorbeeld wordt getoond:

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

Met de operator is kunt u testen of een variabele of expressie lid is van een bepaald gegevenstype. In eerdere versies van ActionScript vervulde de operator instanceof deze rol. In ActionScript 3.0 moet u de operator instanceof echter niet gebruiken om lidmaatschap van gegevenstypen te testen. U gebruikt de operator is in plaats van de operator instanceof om het type handmatig te controleren, omdat de expressie x instanceof y alleen maar de prototypeketen van x controleert op het bestaan van y (en in ActionScript 3.0 geeft de prototypeketen geen volledig beeld van de overervingshiërarchie).

De operator is controleert de juiste overervingshiërarchie. U kunt daarmee niet alleen controleren of een object een instantie is van een bepaalde klasse, maar ook of een object een instantie is van een klasse die een bepaalde interface implementeert. In het volgende voorbeeld wordt een instantie gemaakt van de klasse Sprite met de naam mySprite en wordt met de operator is getest of mySprite een instantie is van de klassen Sprite en DisplayObject en of implementatie van de interface IEventDispatcher plaatsvindt:

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

De operator is controleert de overervingshiërarchie en rapporteert correct dat mySprite compatibel is met de klassen Sprite en DisplayObject (de klasse Sprite is een subklasse van de klasse DisplayObject). De operator is controleert ook of mySprite overerft van enige andere klassen die de interface IEventDispatcher implementeren. Omdat de klasse Sprite overerft van de klasse EventDispatcher, die de interface IEventDispatcher implementeert, rapporteert de operator is correct dat mySprite dezelfde interface implementeert.

In het volgende voorbeeld worden dezelfde tests als in het vorige voorbeeld getoond, maar nu met de operator instanceof in plaats van is . De operator instanceof stelt correct vast dat mySprite een instantie is van Sprite of DisplayObject, maar retourneert false bij het testen of mySprite de interface IEventDispatcher implementeert.

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

Met de operator as kunt u ook controleren of een expressie lid is van een bepaald gegevenstype. Anders dan bij de operator is , retourneert de operator as echter geen Booleaanse waarde. De operator as retourneert de waarde van de expressie in plaats van true en null in plaats van false . In het volgende voorbeeld worden de resultaten getoond van het gebruik van de operator as in plaats van de operator is . Het betreft een eenvoudige controle of een instantie van Sprite lid is van de gegevenstypen DisplayObject, IEventDispatcher en 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

Wanneer u de operator as gebruikt, moet de operand aan de rechterkant een gegevenstype zijn. Een poging om aan de rechterkant een andere expressie dan een gegevenstype te gebruiken als operand, resulteert in een fout.

Het gegevenstype Boolean bestaat uit twee waarden: true en false . Voor variabelen van het type Boolean zijn geen andere waarden geldig. De standaardwaarde van een Booleaanse variabele die is gedeclareerd maar niet is geïnitialiseerd, is false .

Het gegevenstype int wordt intern opgeslagen als een 32-bits geheel getal en bestaat uit de set gehele getallen van

-2,147,483,648 (-2 ³¹ ) tot en met 2.147.483.647 (2 ³¹ - 1). Eerdere versies van ActionScript kenden alleen het gegevenstype Number, voor zowel gehele getallen als getallen met drijvende komma. In ActionScript 3.0 hebt u nu toegang tot machinetypen op laag niveau voor 32-bits gehele getallen met en zonder teken. Als de variabele geen getallen met drijvende komma nodig heeft, is het gebruik van het gegevenstype int in plaats van het gegevenstype Number sneller en efficiënter.

Voor waarden van gehele getallen buiten het bereik van de minimale en maximale waarde voor int gebruikt u het gegevenstype Number. Daarmee zijn waarden mogelijk tussen positief en negatief 9.007.199.254.740.992 (53-bits gehele getallen). De standaardwaarde voor variabelen van het gegevenstype int is 0.

Het gegevenstype Null bevat maar één waarde: null . Dit is de standaardwaarde voor het gegevenstype String en alle klassen die complexe gegevenstypen definiëren, waaronder de klasse Object. Geen van de andere primitieve gegevenstypen, zoals Boolean, Number, int en uint, bevat de waarde null . Tijdens de uitvoering wordt de waarde null omgezet in de toepasselijke standaardwaarde wanneer u null probeert toe te wijzen aan variabelen van het type Boolean, Nummer, int of uint. U kunt dit gegevenstype niet als typeannotatie gebruiken.

In ActionScript 3.0 kan het gegevenstype Number gehele getallen, gehele getallen zonder teken en getallen met drijvende komma vertegenwoordigen. Voor maximale prestaties dient u het gegevenstype Number echter alleen te gebruiken voor gehele getallen met waarden groter dan de 32-bits typen int en uint kunnen opslaan, of voor getallen met drijvende komma. Als u een getal met drijvende komma wilt opslaan, moet u een decimaal teken opnemen in het getal. Als u het decimale teken weglaat, wordt het getal opgeslagen als een geheel getal.

Het gegevenstype Number gebruikt de 64-bits indeling met dubbele precisie zoals is gespecificeerd in de standaard IEEE-754 (voor berekeningen met binaire getallen met drijvende komma). Deze standaard schrijft voor hoe getallen met drijvende komma worden opgeslagen met behulp van de 64 beschikbare bits. Eén bit wordt gebruikt om aan te duiden of het getal positief of negatief is. Elf bits worden gebruikt voor de exponent, die wordt opgeslagen als grondtal 2. De resterende 52 bits worden gebruikt voor de opslag van de significant (ook wel mantisse genoemd). Dit is het getal dat tot de macht wordt verheven die de exponent aangeeft.

Door sommige bits voor de opslag van een exponent te gebruiken kan het gegevenstype Number getallen met drijvende komma opslaan die aanzienlijk hoger zijn dan wanneer alle bits voor de significant zouden worden gebruikt. Als het gegevenstype Number bijvoorbeeld alle 64 bits zou gebruiken voor de opslag van de significant, kan het een getal opslaan van maximaal 2 ⁶⁵ - 1. Door 11 bits te gebruiken voor de opslag van een exponent, kan het gegevenstype Number de significant verheffen tot de macht 2 ¹⁰²³ .

De maximale en minimale waarde die het gegevenstype Number kan vertegenwoordigen, wordt opgeslagen in statische eigenschappen van de klasse Number met de naam Number.MAX_VALUE en Number.MIN_VALUE .

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

Hoewel dit bereik van getallen enorm is, gaat dit ten koste van de precisie. Het gegevenstype Number gebruikt 52 bits voor de opslag van de significant. Dit heeft tot gevolg dat getallen waarvoor meer dan 52 bits nodig zijn voor een exacte representatie, zoals de breuk 1/3, slechts benaderingen zijn. Als voor uw toepassing absolute precisie is vereist voor decimale getallen, moet u software gebruiken die berekeningen met decimale getallen met drijvende komma implementeert in tegenstelling tot berekeningen met binaire getallen met drijvende komma.

Wanneer u waarden van gehele getallen opslaat met het gegevenstype Number, worden alleen de 52 bits van de significant gebruikt. Het gegevenstype Number gebruikt deze 52 bits en een speciale verborgen bit om gehele getallen te vertegenwoordigen van -9.007.199.254.740.992 (-2 ⁵³ ) tot 9.007.199.254.740.992 (2 ⁵³ ).

De waarde NaN wordt niet alleen gebruikt als de standaardwaarde voor variabelen van het type Number , maar ook als het resultaat van een bewerking die een getal moet retourneren maar dat niet doet. Als u bijvoorbeeld probeert de vierkantswortel van een negatief getal te berekenen, is het resultaat NaN . Andere speciale waarden voor Number zijn positief oneindig en negatief oneindig .

Het gegevenstype String vertegenwoordigt een reeks van 16-bits tekens. Tekenreeksen worden intern opgeslagen als Unicode-tekens in de UTF-16-indeling. Tekenreeksen zijn, net als in de programmeertaal Java, onveranderlijk. Een bewerking op een tekenreekswaarde retourneert een nieuwe instantie van de tekenreeks. De standaardwaarde voor een variabele die met het gegevenstype String wordt gedeclareerd, is null . De waarde null is niet hetzelfde als de lege string ( "" ). De waarde null betekent dat er in de variabele geen waarde is opgeslagen, terwijl de lege string betekent dat de variabele een waarde bevat, die bestaat uit een String zonder tekens.

Het gegevenstype uint wordt intern opgeslagen als een 32-bits geheel getal zonder teken en bestaat uit de set gehele getallen van 0 tot en met 4.294.967.295 (2 ³² - 1). Gebruik het gegevenstype uint in speciale situaties waarbij niet-negatieve gehele getallen nodig zijn. U moet het gegevenstype uint bijvoorbeeld gebruiken om pixelkleurwaarden te vertegenwoordigen. Het gegevenstype int heeft namelijk een interne tekenbit die niet geschikt is voor de verwerking van kleurwaarden. Voor waarden van gehele getallen boven de maximale waarde voor uint gebruikt u het gegevenstype Number. Daarmee zijn waarden mogelijk van 53-bits gehele getallen. De standaardwaarde voor variabelen van het gegevenstype uint is 0.

Het gegevenstype void bevat maar één waarde: undefined . In eerdere versies van ActionScript was undefined de standaardwaarde voor instanties van de klasse Object. In ActionScript 3.0 is de standaardwaarde voor instanties van Object null . Wanneer u probeert de waarde undefined toe te wijzen aan een instantie van de klasse Object, wordt de waarde omgezet in null . U kunt alleen een waarde undefined toewijzen aan variabelen zonder type. Variabelen zonder type zijn variabelen zonder typeannotatie of met het asterisksymbool ( * ) als typeannotatie. U kunt void alleen gebruiken als retourneringstypeannotatie.

Het gegevenstype Object wordt gedefinieerd door de klasse Object. De klasse Object dient als basisklasse voor alle klassendefinities in ActionScript. De versie van het gegevenstype Object in ActionScript 3.0 verschilt op drie manieren van eerdere versies. Ten eerste is het gegevenstype Object niet meer het standaardgegevenstype dat wordt toegewezen aan variabelen zonder typeannotatie. Ten tweede omvat het gegevenstype Object niet meer de waarde undefined , die de standaardwaarde was voor instanties van Object. Ten derde is in ActionScript 3.0 de standaardwaarde voor instanties van de klasse Object null .

In eerdere versies van ActionScript werd aan een variabele zonder typeannotatie automatisch het gegevenstype Object toegewezen. Dit is niet meer het geval in ActionScript 3.0, waarin nu werkelijk variabelen zonder type voorkomen. Variabelen zonder typeannotatie worden nu als variabelen zonder type beschouwd. Als u aan lezers van de code duidelijk wilt maken dat u een variabele opzettelijk zonder type hebt gelaten, kunt u het asterisksymbool ( * ) gebruiken als typeannotatie. Dit staat gelijk aan het weglaten van een typeannotatie. In het volgende voorbeeld worden twee gelijkwaardige instructies getoond, waarbij in beide gevallen een variabele zonder type x wordt gedeclareerd:

var x 
var x:*

Alleen variabelen zonder type kunnen de waarde undefined bevatten. Wanneer u probeert de waarde undefined toe te wijzen aan een variabele met een gegevenstype, wordt tijdens de uitvoering de waarde undefined omgezet in de standaardwaarde voor dat gegevenstype. Voor instanties van het gegevenstype Object, is de standaardwaarde null , wat betekent dat als u probeert om undefined aan een Objectinstantie toe te wijzen, de waarde wordt omgezet in null .