ActionScript 3 Casting

• Not consistent with other languages - Both Java and C# use the syntax (Type) expression.
• Ambiguous syntax - Because the cast looks like the call to a constructor, the code isn't as clear as it could be. Did you simply forget the new keyword, or did you actually want to perform a cast?
• Conversion operator precedence - ActionScript includes conversion functions such as Array(), Number(), and Boolean() that take precedence over a cast and usually yield unexpected results. It's impossible to cast to an Array because the conversion function is called instead.

To address these issues, ActionScript 3 introduces the as operator which behaves very similar to a cast. The syntax is expression as datatype, and is exactly the same syntax that C# uses, which should aid developers in migrating to ActionScript 3 in the future.

Using the as operator is simple:

// The getChildAt method returns a DisplayObject, but
// we want to cast it to a Sprite, so we use the as operator
var s:Sprite = getChildAt(0) as Sprite;

A key difference between casting and the as operator is the behavior on failure. When a cast fails in ActionScript 2, null is returned. When a cast fails in ActionScript 3, a TypeError is thrown. With the as operator in ActionScript 3, whenever a cast fails the default value for the datatype is returned. See the documentation for more information.

var o:Object = "test";

trace( o as MovieClip ); // displays: null
trace ( MovieClip ( o ) ); // generates a TypeError

One of the nice benefits of using as over a cast is that you can successfully cast to the Array datatype now:

// Create a generic Object but initialize it with 
// an Array for demonstration purposes
var o:Object = [1, 2, 3];

// Attempt to cast o as an Array - unexpected results
// because the Array conversion function is called instead
var a:Array = Array( o );
// The Array conversion function creates an array with a single
// element containg the value of o
trace( a.length ); // displays: 1
// Demonstrate that a contains a single element (an array of length 3)
trace( a[0].length ); // displays: 3
// Access the first element from o
trace( a[0][0] ); // displays: 1

// Cast o to an Array via the as keyword - this works like
// we expect it to
var b:Array = o as Array;
trace( b.length ); // displays: 3
// Access the first element from o
trace( b[0] ); // displays: 1

Positive changes like this really make ActionScript 3 enjoyable to work with. I don't think I'll ever understand why casts were originally defined as Type( expression ) when ( Type ) expression seems superior, but at least the as operator makes casting tolerable again.