ActionScript: ¿Hay alguna vez una buena razón para usar 'como' casting?

Question

Por lo que entiendo de ActionScript, hay dos tipos de moldes:

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

También, y por favor, corríjanme si me equivoco aquí, as de fundición o bien devolver una instancia de la clase o null, mientras El casting de "nombre de clase" devolverá una instancia de la clase o generará una excepción si el reparto es imposible; además de esto, son idénticos.

Teniendo en cuenta esto, as fundición parece ser una violación masiva del principio fail-fast-fail-early ... Y estoy teniendo problemas para imaginar una situación en la que sería preferible usar un molde as en lugar que un molde de nombre de clase (con, posiblemente, un instanceof arrojado allí).

Entonces, mi pregunta es: ¿bajo qué circunstancias sería preferible usar as de fundición?

Answer 1

Debe usar as para emitir en dos escenarios: fundición a Date, y fundición a Array.

Para las fechas, una llamada a Date(xxx) se comporta igual que la nueva Date().toString().

Para las matrices, una llamada a Array(xxx) creará un Array con un elemento: xxx.

El método de fundición Class() ha demostrado ser más rápido que as de fundición, por lo que puede ser preferible as cuando los asuntos de eficiencia (y cuando no está trabajando con las fechas y matrices).

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 2

Utilice 'como' con arreglos.

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

Producirá una matriz de longitud uno con la matriz original en el primer elemento. Si usa 'como' de la siguiente manera, obtiene el resultado de exptected.

var goodArray:Array; 
goodArray = obj as Array; 

Generalmente, 'como' es preferible 'Clase()' en ActionScript como se comporta más como fundición en otros idiomas.

Answer 3

Hay un par de puntos en esta discusión digno de mención.

Hay una gran diferencia en la forma en que los dos trabajan, Class() intentará convertir el objeto a la clase especificada, pero si no lo hace (a veces, depende del tipo de datos) arrojará un error de tiempo de ejecución. Por otro lado, usar object como Class preformará una verificación de tipo primero, y si el objeto especificado no se puede convertir a la clase indicada, se devolverá un valor nulo.

Esta es una diferencia muy importante, y es una herramienta útil en el desarrollo. Nos permite hacer lo siguiente:

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

if(o) 
{ 
    //do stuff 
} 

Creo que la utilidad de eso es bastante obvia.

"as" también es más consistente con el resto del lenguaje (es decir: "myObject es MyClass").

El método MiClase() tiene beneficios adicionales cuando se trabaja con tipos simples de datos (int, número, los uint, String) Algunos ejemplos de esto son:

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 

Este es un tema bueno e importante, como una regla general uso "como" cuando trabajo con Objetos y Cast() cuando uso tipos de datos más simples, pero así es como me gusta estructurar mi código.

Answer 4

Lo uso cuando tengo un ArrayCollection de objetos y necesito enumerarlos a través de ellos, o usar una función de selector.

p. Ej.

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

Answer 5

En realidad, hacen cosas diferentes ... cuando dices

myvar as ClassName 

Usted está realmente sólo dejar que el compilador sabe que este objeto es o bien un nombre de clase o una subclase de NombredeClase

cuando dice:

ClassName(myvar) 

Realmente intenta convertirlo a ese tipo de objeto.

así que si su objeto es una o un descenso de la clase y no es necesario para convertirlo usaría como

ejemplos:

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