.AS File Format – Data types

All the types

Assigning null to a Boolean, int, uint or Number stores that type’s default instead, and assigning undefined to an Object stores null. Only * and untyped variables can hold undefined.

Numbers

Three numeric types share the arithmetic operators. int and uint are exact 32-bit integers, quicker than Number for counters and indexes; uint suits colours and bit masks. Number holds integers exactly up to 2⁵³ and every fraction to about 15 significant digits.

• Division always gives a Number: 7 / 2 is 3.5 even when both values are int. Use int(7 / 2) for 3.
• Dividing by zero gives Infinity or -Infinity, and 0 / 0 gives NaN; it is not an error.
• Storing a result in an int or uint wraps it to 32 bits: int(int.MAX_VALUE + 1) is −2147483648, and a uint given −3 holds 4294967293.
• The bitwise operators work on 32-bit integers and give int, except >>>, which gives uint.
• Math holds the functions and constants: Math.floor, Math.round, Math.sqrt, Math.random, Math.PI and the rest.

String

A String is a sequence of UTF-16 code units; length counts the units, so a character outside the Basic Multilingual Plane counts as 2. Strings cannot be changed: every method returns a new string. A String variable can be null, which is different from the empty string "". + joins strings and turns the other operand into a string when one side is a string. The methods are charAt, charCodeAt, concat, indexOf, lastIndexOf, localeCompare, match, replace, search, slice, split, substr, substring, toLowerCase, toUpperCase, the toLocale… versions and the static String.fromCharCode.

Object, *, void, null and undefined

• Object – the base of every class. A plain Object is dynamic, so it doubles as a hash map with string keys: o["name"] = "Ann". It cannot hold undefined.
• * – the untyped annotation. var x:* and var x mean the same, except that leaving the annotation out draws a warning in strict mode. The compiler does not check untyped values; the runtime still does.
• void – a return type for functions that return nothing: function reset():void.
• null – no object. The default of String, Object and every class type.
• undefined – no value. Read from a missing dynamic property, an untyped variable that was never set, or a missing argument with no default.

null == undefined is true, but null === undefined is false.

Array

An Array is a list indexed from 0 whose elements can be of any type and whose length grows as elements are added. It can be sparse: setting a[100] on an empty array makes length 101, with the elements in between undefined. Arrays are dynamic, so named properties can be added, but those are not elements and do not count in length.

The sort options are bit flags: Array.CASEINSENSITIVE (1), Array.DESCENDING (2), Array.UNIQUESORT (4), Array.RETURNINDEXEDARRAY (8) and Array.NUMERIC (16), so a.sort(Array.NUMERIC | Array.DESCENDING) sorts numbers from the largest.

Vector

Vector.<T> (Flash Player 10 and AIR 1.5 onwards) is an array whose elements all have the base type T, which the compiler and the runtime check. It is dense: there are no gaps, and reading or writing beyond the end (other than adding at index length) is a RangeError. The fixed property, or the second argument of the constructor, stops the length from changing. It has most of the methods of Array, but not sortOn, and its sort is given a compare function.

var names:Vector.<String> = new Vector.<String>();
names.push("Ann", "Bob");

var grid:Vector.<Vector.<int>> = new Vector.<Vector.<int>>(10, true);
var primes:Vector.<int> = new <int>[2, 3, 5, 7];
var fromArray:Vector.<Number> = Vector.<Number>([1.5, 2.5]);

A vector type is fixed to its base type: a Vector.<Sprite> is not a Vector.<DisplayObject>, though Vector.<*> and Vector.<Object> accept any element. Vector is the only class with a type parameter; ActionScript 3.0 has no general generics.

Dictionary

flash.utils.Dictionary is a dynamic object whose keys are compared by identity, so an object can be a key without being turned into a string. Created with new Dictionary(true), its keys are weak references: an entry disappears when nothing else refers to its key object. for … in visits the keys, for each … in the values, and delete d[key] removes an entry.

import flash.utils.Dictionary;

var speeds:Dictionary = new Dictionary();
speeds[playerSprite] = 4.5;
speeds[enemySprite] = 2;
for (var key:Object in speeds) {
    trace(key, speeds[key]);
}

Other built-in types

How values change from one type to another, and how strict mode checks them, is on Type checking and conversion.