ActionScript: Is there ever a good reason to use 'as' casting?

Question

From what I understand of ActionScript, there are two kinds of casts:

var bar0:Bar = someObj as Bar;  // "as" casting
var bar1:Bar = Bar(someObj); // "class name" casting (for want of a better name)

Also, and please correct me if I'm wrong here, as casting will either return an instance of the class or null, while "class name" casting will either return an instance of the class or raise an exception if the cast is impossible – other than this, they are identical.

Given this, though, as casting seems to be a massive violation of the fail-fast-fail-early principle... And I'm having trouble imagining a situation where it would be preferable to use an as cast rather than a class name cast (with, possibly, an instanceof thrown in there).

So, my question is: under what circumstances would it be preferable to use as casting?

Answer 1

Use 'as' with arrays.

var badArray:Array;
badArray = Array(obj);

Will yield an array of length one with the original array in the first element. If you use 'as' as follows, you get the exptected result.

var goodArray:Array;
goodArray = obj as Array;

Generally, 'as' is preferable to 'Class()' in ActionScript as it behaves more like casting in other languages.

Answer 2

You need to use as to cast in two scenarios: casting to a Date, and casting to an Array.

For dates, a call to Date(xxx) behaves the same as new Date().toString().

For arrays, a call to Array(xxx) will create an Array with one element: xxx.

The Class() casting method has been shown to be faster than as casting, so it may be preferable to as when efficiency matters (and when not working with Dates and Arrays).

import flash.utils.*;

var d = Date( 1 );

trace( "'" + d, "'is type of: ",getQualifiedClassName( d ) );

var a:Array = Array( d );

trace( "'" + a, "' is type of: ", getQualifiedClassName( a ) );

    //OUTPUT
        //'Mon Jun 15 12:12:14 GMT-0400 2009 'is type of:  String
        //'Mon Jun 15 12:12:14 GMT-0400 2009 ' is type of:  Array

    //COMPILER ERRORS/WARNINGS:
        //Warning: 3575: Date(x) behaves the same as new Date().toString(). 
        //To cast a value to type Date use "x as Date" instead of Date(x).
        //Warning: 1112: Array(x) behaves the same as new Array(x).
        //To cast a value to type Array use the expression x as Array instead of Array(x).

`

Answer 3

There are a couple of points in this discussion worth noting.

There is a major difference in how the two work, Class() will attempt to cast the object to the specified Class, but on failure to do so will (sometimes, depends on datatype) throw a runtime error. On the other hand using object as Class will preform a type check first, and if the specified object cannot be cast to the indicated Class a null value is returned instead.

This is a very important difference, and is a useful tool in development. It allows us to do the following:

var o:MyClass = myArray[i] as MyClass;

if(o)
{
    //do stuff
}

I think the usefulness of that is pretty obvious.

"as" is also more consistent with the rest of the language (ie: "myObject is MyClass").

The MyClass() method has additional benefits when working with simple data types (int, Number, uint, string) Some examples of this are:

var s:String = "89567";
var s2:String = "89 cat";
var n:Number = 1.9897;

var i:int = int(s); // i is = 89567, cast works
var i2:int = int(s2); //Can't convert so i2 is set to 0
var i3:int = int(n); // i = 1
var n2:Number = Number(s2); // fails, n2 = NaN

//when used in equations you'll get very different results
var result:int = int(n) * 10; //result is 10
var result:int = n * 10; //result is 19.89700
var result:int = int(s2) * 10; //result is 0

trace(s2 as Number); //outputs null
trace(s2 as int); //outputs null
trace(Number(s2)); //outputs NaN

This is a good and important topic, as a general rule I use "as" when working with Objects and Cast() when using simpler data types, but that's just how I like to structure my code.

Answer 4

I use it when I have an ArrayCollection of objects and need to enumerate through them, or use a selector function.

e.g.

var abc:mytype = mycollection.getItemAt(i) as mytype

Answer 5

They actually do different things...when you say

myvar as ClassName

You are really just letting the compiler know that this object is either a ClassName or a subclass of ClassName

when you say:

ClassName(myvar)

It actually tries to convert it to that type of object.

so if your object is a or a descent of the class and you do not need to convert it you would use as

examples:

var myvar:String = '<data/>';
var othervar:XML = XML(myvar); //right

var myvar:String = '<data/>';
var othervar:XML = (myvar as XML); //wrong

var myvar:XML = <data/>;
var othervar:XML = myvar as XML; // right