Datatyper

En datatyp definierar en serie värden. Datatypen Boolean är en serie av exakt två värden: true och false . Förutom datatypen Boolean definieras flera vanligare datatyper i ActionScript 3.0, däribland String, Number och Array. Du kan definiera egna datatyper genom att använda klasser eller gränssnitt för att definiera en egen uppsättning värden. Alla värden i ActionScript 3.0 är objekt, vare sig de är primitiva eller komplexa , .

Ett primitivt värde är ett värde som hör till någon av följande datatyper: Boolean, int, Number, String och uint. Det går oftast snabbare att arbeta med primitiva värden än att arbeta med komplexa värden, eftersom primitiva värden lagras i ActionScript på ett speciellt sätt som gör minnes- och hastighetsoptimering möjlig.

Obs! I ActionScript lagras primitiva värden internt som oföränderliga objekt, vilket kan vara intressant att veta. Det faktum att de lagras som oföränderliga objekt betyder att överföring med referens är detsamma som överföring med värde. Detta minskar minnesanvändningen och ökar körningshastigheten eftersom referenserna vanligtvis är mycket mindre än själva värdena.

Ett komplext värde är ett värde som inte är primitivt. Datatyper som definierar uppsättningar av komplexa värden är bland annat Array, Date, Error, Function, RegExp, XML och XMLList.

I många programmeringsspråk skiljer man mellan primitiva värden och deras wrapper-objekt. Java har till exempel det primitiva värdet int och klassen java.lang.Integer som omsluter värdet. Primitiva värden i Java är inte objekt, men deras wrapprar är det, vilket gör att primitiva värden är bra för vissa åtgärder och wrapper-objekt är bättre för andra åtgärder. I ActionScript 3.0 är primitiva värden och deras wrapper-objekt omöjliga att särskilja. Alla värden, även primitiva, är objekt. I körningsmiljön behandlas dessa primitiva typer som specialfall som beter sig som objekt, men som inte kräver den kapacitet som normalt associeras med att skapa objekt. Det betyder att följande två kodrader är likvärdiga:

var someInt:int = 3; 
var someInt:int = new int(3);

Alla ovanstående primitiva och komplexa datatyper definieras av huvudklasserna i ActionScript 3.0. Med huvudklasserna kan du skapa objekt med hjälp av litterala värden i stället för att använda operatorn new . Du kan till exempel skapa en array med ett litteralt värde eller klasskonstruktorn Array så här:

var someArray:Array = [1, 2, 3]; // literal value 
var someArray:Array = new Array(1,2,3); // Array constructor

Typkontroll

Typkontroll utförs antingen vid kompilering eller vid körning. Språk med statiska typer, som C++ och Java, utför typkontroll vid kompileringen. Språk med dynamiska typer, som Smalltalk och Python, hanterar typkontroll vid körningen. ActionScript 3.0, som är ett språk med dynamiska typer, har en typkontroll som utförs vid körningen, men kan även använda en typkontroll som utförs vid kompileringen tack vare ett speciellt kompileringsläge som kallas strikt läge . I strikt läge utförs typkontrollen både vid kompilering och vid körning, men i standardläge utförs typkontroll bara vid körning.

Språk som har dynamiska typer är otroligt flexibla när du strukturerar kod men genererar typfel vid körningen. Språk med statiska typer rapporterar typfel vid kompileringen och typinformation krävs vid kompileringen.

Typkontroll vid kompilering

Typkontroll vid kompilering föredras ofta i större projekt. Detta beror på, att när man arbetar med stora projekt blir det viktigare att hitta typfel så tidigt som möjligt än att man använder en flexibel datatyp. Det är därför som ActionScript-kompilatorn i Flash Professional och Flash Builder som standard är inställd på att köras i strikt läge.

Adobe Flash Builder

Du kan inaktivera det strikta läget i Flash Builder via inställningarna för ActionScript-kompilatorn i dialogrutan Project Properties.

För att kompilatorn ska kunna utföra typkontroll vid kompilering måste koden innehålla datatypsinformation om variabler och uttryck. Om du vill deklarera en datatyp för en variabel lägger du till kolonoperatorn ( : ) följt av datatypen som suffix i variabelnamnet. Om du vill associera en datatyp med en parameter använder du kolonoperatorn följt av datatypen. I följande kod läggs datatypsinformation till i parametern xParam och deklareras variabeln myParam med en explicit datatyp:

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

I strikt läge rapporterar ActionScript-kompilatorn felaktig matchning av typer som kompileringsfel. I följande kod deklareras funktionsparametern xParam , för typen Object, men försök görs senare att tilldela värden av typen String och Number till den parametern. Detta skapar ett kompileringsfel i strikt läge.

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

Du kan emellertid även i strikt läge selektivt välja bort typkontroll vid kompilering genom att låta höger sida av en tilldelningsprogramsats vara typlös. Du kan markera en variabel eller ett uttryck som typlöst genom att antingen utesluta en typanteckning eller använda den speciella asterisktypanteckningen ( * ). Om parametern xParam i föregående exempel ändras så att den inte längre har en typanteckning kompileras koden i strikt läge:

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

Typkontroll vid körning

Typkontroll vid körning utförs i ActionScript 3.0 vare sig du kompilerar i strikt läge eller i standardläge. Anta att värdet 3 skickas som ett argument till en funktion som förväntar sig en array. I strikt läge genereras ett fel eftersom värdet 3 inte är kompatibelt med datatypen Array. Om du inaktiverar strikt läge och kör i standardläge reagerar kompilatorn inte över typmatchningsfelet, men typkontrollen vid körning resulterar i ett körningsfel.

I följande exempel visas funktionen typeTest() som förväntar sig ett Array-argument men som tar emot värdet 3. Detta förorsakar ett körningsfel i standardläge eftersom värdet 3 inte ingår i parameterns deklarerade datatyp (Array).

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

Du kan också i vissa situationer få ett körningsfel även när du arbetar i strikt läge. Detta kan hända om du använder strikt läge men väljer bort typkontroll vid kompilering genom att använda en typlös variabel. När du använder en typlös variabel väljer du inte bort typkontrollen, utan fördröjer den till körningen. Om till exempel variabeln myNum i föregående exempel inte har en deklarerad datatyp kan kompilatorn inte identifiera typmatchningsfelet. Koden genererar då ett körningsfel, eftersom körningsvärdet för myNum , som har värdet 3 som ett resultat av tilldelningsprogramsatsen, jämförs med typen för xParam , som är inställd på datatypen Array.

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

Typkontroll vid körning tillåter flexiblare användning av arv än typkontroll vid kompilering. Genom att fördröja typkontrollen till körningen kan du i standardläge referera egenskaper av en underklass även om du använder upcast . En upcast inträffar när du använder en basklass för att deklarera typ av klassinstans men en underklass för att instansiera den. Du kan alltså skapa en klass med namnet ClassBase som kan utökas (klasser med attributet final kan inte utökas):

class ClassBase 
{ 
}

Du kan därefter skapa en underklass för ClassBase som heter ClassExtender som har en egenskap som heter someString enligt följande:

class ClassExtender extends ClassBase 
{ 
    var someString:String; 
}

Om du använder båda klasserna kan du skapa en klassinstans som deklareras med datatypen ClassBase men som instansieras med konstruktorn ClassExtender. En upcast är en säker åtgärd eftersom basklassen bara innehåller egenskaper och metoder som finns i underklassen.

var myClass:ClassBase = new ClassExtender();

En underklass innehåller däremot egenskaper och metoder som basklassen inte innehåller. Klassen ClassExtender innehåller till exempel egenskapen someString som inte finns i klassen ClassBase. I standardläge i ActionScript 3.0 kan du referera den här egenskapen med instansen myClass utan att generera ett kompileringsfel, vilket visas i följande exempel:

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

Operatorn is

Med operatorn is kan du testa om en variabel eller ett uttryck är medlem i en viss datatyp. I tidigare versioner av ActionScript hade operatorn instanceof den här funktionaliteten, men i ActionScript 3.0 ska operatorn instanceof inte användas för att testa datatypsmedlemskap. Använd operatorn is i stället för operatorn instanceof för manuell typkontroll eftersom uttrycket x instanceof y snarare kontrollerar om prototypkedjan för x innehåller y (och i ActionScript 3.0 ger prototypkedjan inte en fullständig bild av arvshierarkin).

Operatorn is kontrollerar arvshierarkin och kan användas för att kontrollera inte bara om ett objekt är en instans av en viss klass, utan även om objektet är en instans av en klass som implementerar ett visst gränssnitt. I följande exempel skapas en instans av klassen Sprite som heter mySprite och använder operatorn is för att testa om mySprite är en instans av klasserna Sprite och DisplayObject, och huruvida den implementerar gränssnittet IEventDispatcher:

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

Operatorn is kontrollerar arvshierarkin och rapporterar att mySprite är kompatibel med klasserna Sprite och DisplayObject (klassen Sprite är en underklass till klassen DisplayObject). Operatorn is kontrollerar också om mySprite ärver från några klasser som implementerar gränssnittet IEventDispatcher. Eftersom klassen Sprite ärver från klassen EventDispatcher, som implementerar gränssnittet IEventDispatcher, rapporterar operatorn is att mySprite implementerar samma gränssnitt.

I följande exempel visas samma tester från föregående exempel, men med instanceof i stället för operatorn is . Operatorn instanceof identifierar att mySprite är en instans av Sprite eller DisplayObject, men den returnerar false när den används för att testa om mySprite implementerar gränssnittet IEventDispatcher.

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

Operatorn as

Med operatorn as kan du testa om ett uttryck är medlem i en viss datatyp. l motsats till operatorn is returnerar operatorn as inte ett booleskt värde. I stället returnerar operatorn as värdet för uttrycket i stället för true , och null i stället för false . I följande exempel visas resultatet av att använda operatorn as i stället för operatorn is vid en enkel kontroll av om instansen Sprite är medlem i datatypen DisplayObject, IEventDispatcher och 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

När du använder operatorn as måste operanden till höger vara en datatyp. Om du försöker använda ett uttryck som inte är en datatyp som operand till höger genereras ett fel.

Dynamiska klasser

Med en dynamisk klass definieras ett objekt som du kan ändra vid körning genom att lägga till eller ändra egenskaper och metoder. En klass som inte är dynamisk, till exempel klassen String, är en fast klass. Du kan inte lägga till egenskaper och metoder i en fast klass vid körning.

Du kan skapa dynamiska klasser med attributet dynamic när du deklarerar en klass. Med följande kod skapas en dynamisk klass som heter Protean :

dynamic class Protean 
{ 
    private var privateGreeting:String = "hi"; 
    public var publicGreeting:String = "hello"; 
    function Protean() 
    { 
        trace("Protean instance created"); 
    } 
}

Om du senare instansierar en instans av klassen Protean kan du lägga till egenskaper och metoder i den utanför klassdefinitionen. Med följande kod skapas till exempel en instans av klassen Protean och läggs egenskapen aString och egenskapen aNumber till i instansen.

var myProtean:Protean = new Protean(); 
myProtean.aString = "testing"; 
myProtean.aNumber = 3; 
trace(myProtean.aString, myProtean.aNumber); // testing 3

Egenskaper som du lägger till i en instans av en dynamisk klass är körningsenheter, och all typkontroll utförs vid körning. Du kan inte lägga till en typanteckning i en egenskap som du lägger till på det här sättet.

Du kan också lägga till en metod i instansen myProtean genom att definiera en funktion och bifoga den till en egenskap för instansen myProtean . Följande kod flyttar programsatsen trace till metoden traceProtean() :

var myProtean:Protean = new Protean(); 
myProtean.aString = "testing"; 
myProtean.aNumber = 3; 
myProtean.traceProtean = function () 
{ 
    trace(this.aString, this.aNumber); 
}; 
myProtean.traceProtean(); // testing 3

Metoder som skapats på det här sättet kommer inte åt privata egenskaper eller metoder av klassen Protean. Referenser till allmänna egenskaper eller metoder för klassen Protean måste dessutom kvalificeras med antingen nyckelordet this eller med klassnamnet. I följande exempel visas hur metoden traceProtean() försöker komma åt privata och allmänna variabler för klassen Protean .

myProtean.traceProtean = function () 
{ 
    trace(myProtean.privateGreeting); // undefined 
    trace(myProtean.publicGreeting); // hello 
}; 
myProtean.traceProtean();

Beskrivning av datatyper

Primitiva datatyper kan vara Boolean, int, Null, Number, String, uint och void. Huvudklasserna i ActionScript definierar också följande komplexa datatyper: Object, Array, Date, Error, Function, RegExp, XML och XMLList.

Boolean, datatyp

Datatypen Boolean kan ha två värden: true och false . Inga andra värden är giltiga för den här datatypen. Standard för en boolesk variabel som är deklarerad, men inte initierad, är false .

int, datatyp

Datatypen int lagras internt som 32-bitars heltal och har en uppsättning heltal från

-2 147 483 648 (-2 31 ) till och med 2 147 483 647 (2 31 - 1). Tidigare versioner av ActionScript hade bara datatypen Number som användes för både heltal och flyttal. I ActionScript 3.0 kan du använda lågnivåmaskintyper för 32-bitars heltal med och utan tecken. Om din variabel inte använder flyttal går det snabbare och är effektivare om du använder datatypen int i stället för datatypen Number.

För heltalsvärden som ligger utanför minimi- och maximivärdena för int använder du datatypen Number, som kan hantera värden mellan positiva och negativa 9 007 199 254 740 992 (53-bitars heltalsvärden). Standardvärdet för variabler som är av datatypen int är 0.

Null, datatyp

Datatypen Null innehåller bara ett värde, null . Detta är standardvärdet för datatypen String och alla klasser som definierar komplexa datatyper, däribland klassen Object. Ingen av de primitiva datatyperna, till exempel Boolean, Number, int eller uint, innehåller värdet null . Vid körning konverteras värdet null till lämpligt standardvärde om du försöker tilldela null till variabler av typen Boolean, Number, int eller uint. Du kan inte använda den här datatypen som en typanteckning.

Number, datatyp

I ActionScript 3.0 kan den här datatypen representera heltal, heltal utan tecken och flyttal. Om du vill maximera prestanda bör du använda datatypen Number bara för heltal som är större än vad 32-bitarstyperna int och uint kan lagra eller för flyttal. Om du vill lagra flyttal måste du infoga ett decimalkomma i talet. Om du utesluter decimalkommat sparas talet som ett heltal.

Datatypen Number använder 64-bitars dubbelprecisionsformat som anges av IEEE:s standard för binär flyttalsaritmetik (IEEE-754). Denna standard anger hur flyttal lagras med 64 tillgängliga bitar. En bit används för att ange om talet är positivt eller negativt. Elva bitar används för exponenten som lagras som bas 2. De återstående 52 bitarna används för att lagra signifikanden (kallas också mantissa ), som är det tal som upphöjs till det som anges av exponenten.

Genom att använda vissa bitar för att lagra en exponent kan datatypen Number lagra flyttal som är mycket större än om den använde alla bitarna för signifikanden. Om datatypen Number till exempel använder alla 64 bitar för att lagra signifikanden, bör den lagra ett tal som är så stort som 2 65 - 1. Genom att använda elva bitar för att lagra en exponent kan datatypen Number upphöja signifikanden till 2 1023 .

Maximi- och minimivärdena som typen Number kan representera lagras i statiska egenskaper för klassen Number som kallas Number.MAX_VALUE respektive Number.MIN_VALUE .

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

Även om det här talintervallet är enormt är priset för intervallet precision. Datatypen Number använder 52 bitar för att lagra signifikanden, vilket resulterar i att tal som kräver mer än 52 bitar för att representeras exakt, till exempel bråket 1/3, bara blir approximationer. Om ditt program kräver absolut precision med decimaltal måste du använda program som implementerar decimalflyttalsaritmetik i motsats till binär flyttalsaritmetik.

När du lagrar heltalsvärden med datatypen Number används bara de 52 bitarna av signifikanden. Datatypen Number använder dessa 52 bitar och en speciell dold bit för att representera heltal från -9 007 199 254 740 992 (-2 53 ) till 9 007 199 254 740 992 (2 53 ).

Värdet NaN används inte bara som standardvärde för variabler av typen Number , utan också som resultatet av en beräkning som ska returnera ett tal men som inte gör det. Om du till exempel försöker beräkna kvadratroten av ett negativt tal blir resultatet NaN . Andra speciella Number-värden är positiv oändlighet och negativ oändlighet .

Obs! Resultatet av division med 0 är bara NaN om divisorn också är 0 . Division med 0 skapar infinity när dividenden är positiv eller -infinity när dividenden är negativ.

String, datatyp

Datatypen String representerar en sekvens av 16-bitarstecken. Strängar sparas internt som Unicode-tecken med UTF-16-formatet. Strängar är oföränderliga värden, på samma sätt som i programmeringsspråket Java. En operation på ett String-värde resulterar i en ny instans av strängen. Standardvärdet för en variabel som har deklarerats med datatypen String är null . Värdet null är inte samma sak som den tomma strängen ( "" ). Värdet null betyder att variabeln saknar ett sparat värde, medans en tom sträng betyder att variabeln har ett värde som är en sträng utan några tecken.

uint, datatyp

Datatypen uint lagras internt som ett 32-bitars heltal utan tecken och innehåller en serie heltal från 0 till och med 4 294 967 295 (2 32 - 1). Använd datatypen uint vid speciella tillfällen som anropar icke-negativa heltal. Du måste till exempel använda datatypen uint för att representera pixelvärden i färg eftersom datatypen int har en intern bit med tecken som inte är lämplig för hantering av färgvärden. Om det gäller heltal som är större än maximivärdet för uint använder du datatypen Number som kan hantera 53-bitars heltal. Standardvärdet för variabler som är av datatypen uint är 0.

void, datatyp

Datatypen void innehåller bara ett värde, undefined . I tidigare versioner av ActionScript var undefined standardvärde för instanser av klassen Object. I ActionScript 3.0 är standardvärdet för Object-instanser null . Om du försöker tilldela en instans av klassen Object värdet undefined konverteras värdet till null . Du kan bara tilldela variabler som är typlösa värdet undefined . Typlösa variabler är variabler som antingen saknar typanteckning eller som använder symbolen asterisk ( * ) för typanteckning. Du kan använda void bara som returtypsanteckning.

Object, datatyp

Datatypen Object definieras av klassen Object. Klassen Object fungerar som basklass för alla klassdefinitioner i ActionScript. ActionScript 3.0-versionen av datatypen Object skiljer sig på tre sätt från datatypen i tidigare versioner. För det första är datatypen Object inte längre standarddatatyp som tilldelas variabler utan typanteckning. För det andra innehåller datatypen Object inte längre värdet undefined , som används som standardvärde för Object-instanser. För det tredje är standardvärdet för klassen Object null i ActionScript 3.0.

I tidigare versioner av ActionScript har en variabel utan typanteckning automatiskt tilldelats datatypen Object. Detta gäller inte längre i ActionScript 3.0 som nu innehåller en helt typlös variabel. Variabler utan typanteckning betraktas nu som typlösa. Om du vill visa läsarna av din kod att du avsiktligen har lämnat en variabel typlös kan du använda en asterisk ( * ) för typanteckningen, vilket motsvarar att utesluta en typanteckning. I följande exempel visas två likvärdiga programsatser som båda deklarerar den typlösa variabeln x :

var x 
var x:*

Endast typlösa variabler kan innehålla värdet undefined . Om du försöker tilldela en variabel som har en datatyp värdet undefined konverteras värdet undefined till standardvärdet för den datatypen vid körning. För instanser av datatypen Object är standardvärdet null , vilket betyder att om du försöker tilldela värdet undefined till en Object-instans konverteras värdet till null .

Typkonverteringar

En typkonvertering inträffar när ett värde transformeras till ett värde av en annan datatyp. Typkonverteringar kan antingen vara implicita eller explicita . Implicit konvertering, som även kallas tvång , utförs ibland vid körning. Om till exempel värdet 2 tilldelas en variabel med datatypen Boolean konverteras värdet 2 till det booleska värdet true innan variabeln tilldelas värdet. Explicit konvertering, som också kallas datatypsbyte , inträffar när koden instruerar kompilatorn att hantera en variabel av en viss datatyp som om den hör till en annan datatyp. När primitiva värden ingår konverteras värden från en datatyp till en annan datatyp med datatypsbytet. När du vill byta datatyp för ett objekt omsluter du objektnamnet med parentes och skriver namnet på den nya datatypen framför. I följande kod byts en boolesk variabel ut mot en heltalsvariabel:

var myBoolean:Boolean = true; 
var myINT:int = int(myBoolean); 
trace(myINT); // 1

Implicita konverteringar

Implicita konverteringar inträffar vid körning i olika sammanhang:

  • I tilldelningsprogramsatser

  • När värden skickas som funktionsargument

  • När värden returneras från funktioner

  • I uttryck som använder vissa operatorer, till exempel additionsoperatorn ( + )

    För användardefinierade typer lyckas implicita konverteringar när värdet som ska konverteras är en instans av destinationsklassen eller en klass som härstammar från destinationsklassen. Om en implicit konvertering misslyckas uppstår ett fel. Följande kod innehåller en lyckad och en misslyckad implicit konvertering:

    class A {} 
    class B extends A {} 
     
    var objA:A = new A(); 
    var objB:B = new B(); 
    var arr:Array = new Array(); 
     
    objA = objB; // Conversion succeeds. 
    objB = arr; // Conversion fails.

    Om det gäller primitiva typer hanteras implicita konverteringar genom anrop till samma interna konverteringsalgoritmer som anropas av de explicita konverteringsfunktionerna.

Explicita konverteringar

Du bör använda explicita konverteringar, eller datatypsbyte, när du kompilerar i strikt läge eftersom du kanske inte vill att ett typmatchningsfel ska generera ett kompileringsfel. Detta kan inträffa när du vet att tvång kommer att konvertera dina värden korrekt vid körning. När du till exempel arbetar med data som du fått från ett formulär, kanske du vill förlita dig på tvång för att konvertera vissa strängvärden till numeriska värden. I följande kod genereras ett kompileringsfel även om koden kan köras korrekt i standardläge:

var quantityField:String = "3"; 
var quantity:int = quantityField; // compile time error in strict mode

Om du vill fortsätta i strikt läge, men vill att strängen ska konverteras till ett heltal, kan du använda explicit konvertering enligt följande:

var quantityField:String = "3"; 
var quantity:int = int(quantityField); // Explicit conversion succeeds.

Datatypsbyte till int, uint och Number

Du kan byta ut en datatyp till någon av de tre taltyperna int, uint och Number. Om det av någon anledning inte går att konvertera talet tilldelas datatyperna int och uint standardvärdet 0, medan datatypen Number tilldelas standardvärdet NaN . Om du konverterar ett booleskt värde till ett tal blir true värdet 1 och false blir värdet 0.

var myBoolean:Boolean = true; 
var myUINT:uint = uint(myBoolean); 
var myINT:int = int(myBoolean); 
var myNum:Number = Number(myBoolean); 
trace(myUINT, myINT, myNum); // 1 1 1 
myBoolean = false; 
myUINT = uint(myBoolean); 
myINT = int(myBoolean); 
myNum = Number(myBoolean); 
trace(myUINT, myINT, myNum); // 0 0 0

Strängvärden som innehåller bara siffror kan konverteras till någon av taltyperna. Taltyperna kan också konvertera strängar som ser ut som negativa tal eller strängar som representerar ett hexadecimalt värde (till exempel 0x1A ). Vid konverteringen ignoreras inledande och avslutande tomrum i strängvärdet. Du kan också byta strängar som ser ut som flyttal med Number() . Inkluderingen av ett decimaltecken gör att uint() och int() returnerar ett heltal och decimaltecknet och de tecken som kommer efter trunkeras. Följande strängvärden kan till exempel bytas till tal:

trace(uint("5")); // 5 
trace(uint("-5")); // 4294967291. It wraps around from MAX_VALUE 
trace(uint(" 27 ")); // 27 
trace(uint("3.7")); // 3 
trace(int("3.7")); // 3 
trace(int("0x1A")); // 26 
trace(Number("3.7")); // 3.7

Strängvärden som innehåller icke-numeriska tecken returnerar 0 när de byts med int() eller uint() och NaN när de byts med Number() . Vid konverteringen ignoreras inledande och avslutande tomrum, men 0 eller NaN returneras om en sträng har ett tomrum som avgränsar två tal.

trace(uint("5a")); // 0 
trace(uint("ten")); // 0 
trace(uint("17 63")); // 0

I ActionScript 3.0 stöder funktionen Number() inte längre oktala (eller bas-8) tal. Om du använder en sträng med en inledande nolla i funktionen Number() i ActionScript 2.0 tolkas talet som ett oktalt tal och konverteras till ett decimaltal. Detta gäller inte med funktionen Number() i ActionScript 3.0 där nollan ignoreras. Med följande kod genereras olika utdata vid kompilering med olika versioner av ActionScript:

trace(Number("044"));  
// ActionScript 3.0 44 
// ActionScript 2.0 36

Datatypsbyte är nödvändigt när ett värde av en viss numerisk typ tilldelas en variabel av en annan numerisk typ. Även i strikt läge konverteras de numeriska typerna implicit till andra numeriska typer. Detta betyder att man i vissa fall får oväntat resultat när intervallet för en typ överskrids. Följande exempel kompileras alla i strikt läge, men vissa av dem genererar oväntade värden:

var myUInt:uint = -3; // Assign int/Number value to uint variable 
trace(myUInt); // 4294967293 
 
var myNum:Number = sampleUINT; // Assign int/uint value to Number variable 
trace(myNum) // 4294967293 
 
var myInt:int = uint.MAX_VALUE + 1; // Assign Number value to uint variable 
trace(myInt); // 0 
 
myInt = int.MAX_VALUE + 1; // Assign uint/Number value to int variable 
trace(myInt); // -2147483648

I följande tabell sammanfattas resultatet av datatypsbyte till Number, int eller uint från andra datatyper.

Datatyp eller värde

Resultat av konvertering till Number, int eller uint

Boolean

Om värdet är true : 1, annars 0.

Date

Den interna beteckningen för objektet Date, som är antalet millisekunder som förflutit sedan midnatt den 1 januari 1970, universaltid.

null

0

Object

Om instansen är null och konverterat till Number NaN ; annars 0.

String

Ett tal om det går att konvertera strängen till ett tal; i annat fall NaN om det konverteras till Number eller 0 om det konverteras till int eller uint.

undefined

NaN om den konverteras till Number. 0 om den konverteras till int eller uint.

Datatypsbyte till Boolean

Datatypsbyte till Boolean från någon av de numeriska datatyperna (uint, int eller Number) resulterar i false om det numeriska värdet är 0, och i annat fall i true . Om du använder datatypen Number kan värdet NaN också resultera i false . I följande exempel visas resultatet av datatypsbyte av talen -1, 0 och 1:

var myNum:Number; 
for (myNum = -1; myNum<2; myNum++) 
{ 
    trace("Boolean(" + myNum +") is " + Boolean(myNum)); 
}

Utdata från exemplet visar att värdet false bara returneras av talet 0:

Boolean(-1) is true 
Boolean(0) is false 
Boolean(1) is true

Databyte till Boolean från ett strängvärde returnerar false om strängen är null eller en tom sträng ( "" ). I annat fall returneras true .

var str1:String; // Uninitialized string is null. 
trace(Boolean(str1)); // false 
 
var str2:String = ""; // empty string 
trace(Boolean(str2)); // false 
 
var str3:String = " "; // white space only 
trace(Boolean(str3)); // true

Databyte till Boolean från en instans av klassen Object returnerar false om instansen är null och returnerar annars true :

var myObj:Object; // Uninitialized object is null. 
trace(Boolean(myObj)); // false 
 
myObj = new Object(); // instantiate  
trace(Boolean(myObj)); // true

Booleska variabler får specialbehandling i strikt läge på det sättet att du kan tilldela ett booleskt värde värden av valfri datatyp utan att använda databyte. Implicit tvång från alla datatyper till datatypen Boolean inträffar även i strikt läge. Databyte till Boolean är inte nödvändigt för att undvika fel i strikt läge i motsats till byte till andra datatyper. I följande exempel kompileras allt i strikt läge och beteendet blir väntat vid körning:

var myObj:Object = new Object(); // instantiate  
var bool:Boolean = myObj; 
trace(bool); // true 
bool = "random string"; 
trace(bool); // true 
bool = new Array(); 
trace(bool); // true 
bool = NaN; 
trace(bool); // false

I följande tabell sammanfattas resultatet av datatypsbyte till Boolean från andra datatyper:

Datatyp eller värde

Resultat av konvertering till Boolean

String

false om värdet är null eller tom sträng ( "" ). Annars true .

null

false

Number, int eller uint

false om värdet är NaN eller 0; annars true .

Object

false om instansen är null ; annars true .

Databyte till String

Vid databyte till datatypen String från någon av de numeriska datatyperna returneras en strängbeteckning för talet. Vid databyte till datatypen String från ett booleskt värde returneras strängen "true" om värdet är true och strängen "false" om värdet är false .

Vid databyte till datatypen String från en instans av klassen Objekt returneras strängen "null" om instansen är null . I annat fall vid databyte till typen Sträng från klassen Object returneras strängen "[object Object]" .

Vid databyte till String från en instans av klassen Array returneras en sträng som innehåller en semikolonavgränsad lista på alla array-element. I följande databyte till datatypen String returneras en sträng som innehåller alla tre elementen av arrayen:

var myArray:Array = ["primary", "secondary", "tertiary"]; 
trace(String(myArray)); // primary,secondary,tertiary

Vid databyte till String från en instans av klassen Date returneras en strängbeteckning för det datum som instansen innehåller. I följande exempel returneras en strängbeteckning för klassinstansen Date (utdata ger resultatet för Pacific Daylight Time):

var myDate:Date = new Date(2005,6,1); 
trace(String(myDate)); // Fri Jul 1 00:00:00 GMT-0700 2005

I följande tabell sammanfattas resultatet av datatypsbyte till datatypen String från andra datatyper.

Datatyp eller värde

Resultat av konvertering till String

Array

En sträng som består av alla array-element.

Boolean

" true eller false "

Date

En strängbeteckning för objektet Date.

null

"null"

Number, int eller uint

En strängbeteckning för talet.

Object

Om instansen är null "null" . Annars "[object Object]".