¬¬ mmmmmm, pues, si quieres que jale rápido (rendimiento) pues el más
rápido.





-----Mensaje original-----
De: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED] En
nombre de Hari Seldon
Enviado el: jueves, 14 de julio de 2005 1:50
Para: [email protected]
Asunto: RE: [ASNativos] Una tontería

        Lo de los tiempos es interesante... (Y lógico, por otro lado)

        El problema es, claro está, que de cara a rendimiento, que es
más
óptimo, ¿utilizar los constructores de clases, o bien utilizar
primitivas
directamente?
        
        Creo que es uno de los grandes problemas de todo lenguaje sin
tipado
fuerte.... ;)

        Saludos :)

> -----Mensaje original-----
> De: [EMAIL PROTECTED] 
> [mailto:[EMAIL PROTECTED] En nombre de Andrés 
> González Aragón
> Enviado el: miércoles, 13 de julio de 2005 9:37
> Para: [email protected]
> Asunto: RE: [ASNativos] Una tontería
> 
> Órale Joseba, que interesante lo que comentas de los tiempos, no sabía
> eso. Aunque estuve haciendo algunos experimentos, con la 
> clase(y el tipo
> primitivo) Number igual se tarda el doble; pero con Array es 
> diferente,
> miremos este ejemplo:
> 
> <code>
> trace("\nARRAY");
> var primitiv_array:Array = ["mnnn", 4, "Q", 5, new Object(), "mock"];
> var t:Number = getTimer();
> for (var i = 0; i < 100000; ++i) {
>       primitiv_array.toString()
> }
> trace("Tiempo con la primitiva: " + (getTimer() - t) + " ms.");
> var objet_array:Array = new Array("mnnn", 4, "Q", 5, new Object(),
> "mock");
> t = getTimer();
> for (var i = 0; i < 100000; ++i) {
>       objet_array.toString()
> }
> trace("Tiempo con el objeto: " + (getTimer() - t) + " ms.");
> </code>
> 
> -----Mensaje original-----
> De: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED] En
> nombre de Joseba Alonso
> Enviado el: martes, 12 de julio de 2005 13:07
> Para: [email protected]
> Asunto: RE: [ASNativos] Una tontería
> 
> Es un poco de lo mismo de antes, el operador typeof devuelve el tipo
> primitivo del *valor* que contiene la variable. El problema es que en
> realidad para Flash una clase *no* es un tipo. Recuerda que aunque con
> el
> AS2 nos parezca lo contrario, Flash sigue siendo un lenguaje basado en
> prototypes, no un lenguaje "real" OOP basado en clases. 
> Cualquier valor
> con
> una clase asociada nos devolvera "object" como tipo primitivo:
> 
> <script>
> var mistring = "hola";
> trace(typeof mistring); // "string"
> 
> var mistring2 = new String("hola");
> trace(typeof mistring2); // "object"
> 
> var mifuncion = function(){};
> trace(typeof mifuncion); // "function";
> 
> var mifuncion2 = new Function();
> trace(typeof mifuncion2); // "object";
> 
> var miclip = _root.createEmptyMovieClip("clip",1);
> trace(typeof miclip); // "movieclip"
> 
> var miclip2 = new MovieClip();
> trace(typeof miclip2); // "object"
> 
> </script>
> 
> Para comprobar si un objeto pertenece a una clase se utiliza el
> instanceof,
> para obtener la clase asociada a un valor se utiliza __proto__.
> 
> Un ejemplo mas o menos claro:
> 
> <script>
> var s1:String = "hola";
> trace(s1 instanceof String); // false
> trace(typeof s1); // "string"
> </script>
> 
> Con los literales generamos valores primitivos, y no se asocia ninguna
> clase. Por eso el instanceof nos devuelve 'false' y el type 
> es 'string'.
> Si
> queremos un objeto "real" de la clase String tenemos que hacer:
> 
> <script>
> var s2:String = new String("hola");
> trace(s2 instanceof String); // true
> trace(typeof s2); // "object"
> </script>
> 
> Lo que ocurre es que para que no nos volvamos locos (más) Flash nos
> permite
> llamar a metodos y propiedades sobre los valores primitivos aunque no
> pertenezcan a ninguna "Clase" esto lo hace generando el objeto y
> aplicando
> el metodo/propiedad de manera transparente para nosotros. 
> Esto se puede
> demostrar con el siguiente script:
> 
> <script>
> var primitiva:String = "un literal";
> var t:Number = getTimer();
> for(var i:Number = 0;i<100000;i++){
>       primitiva.indexOf("l");
> }
> trace("Tiempo con la primitiva: "+(getTimer()-t)+" ms.");
> var objeto:String = new String("un objeto");
> 
> t = getTimer();
> for(var i:Number = 0;i<100000;i++){
>       objeto.indexOf("l");
> }
> trace("Tiempo con el objeto: "+(getTimer()-t)+" ms.");
> </script>
> 
> Si lo ejecutas te dáras cuenta que con la primitiva tarda el triple de
> tiempo el llamar a los metodos, es el tiempo que tarda en generar el
> objeto
> por detrás y aplicar el metodo, mientras que con el objeto ya 
> creado el
> llamar al metodo es mas rapido porque ya esta generado.
> 
> Pfff, vaya chapa xDD, a ver si ha quedado claro ;)
> 
> Un saludo,
> 
> 
> Joseba Alonso
> www.5dms.com
> www.sidedev.net  
> 
> 
> ----------------------------------
> Lista ASNativos:[email protected]
> http://www.5dms.com/listas
> ----------------------------------
> ----------------------------------
> Lista ASNativos:[email protected]
> http://www.5dms.com/listas
> ----------------------------------


----------------------------------
Lista ASNativos:[email protected]
http://www.5dms.com/listas
----------------------------------
----------------------------------
Lista ASNativos:[email protected]
http://www.5dms.com/listas
----------------------------------

Responder a