primitive Datentypen und Methoden

[k7c4]

Ich weiss nicht, ob es allen sobekannt ist, aber wenn man sich folgendes mal anschaut

Number.prototype.r = function(r)
{void 1;}
trace(1)
 
x=1
var remC = getTimer()
for (var i=0; i< 1000; i++)
{
    x.r()
}
trace(getTimer()-remC)
 
x= Number(1)
var remC = getTimer()
for (var i=0; i< 1000; i++)
{
    x.r()
}
trace(getTimer()-remC)
x=new Number(1)
var remC = getTimer()
for (var i=0; i< 1000; i++)
{
    x.r()
}
trace(getTimer()-remC) 

dann wird klar, dass jeder Aufruf von Methoden, die zu primitiven Datentypen gehören zu einer impliziten Umwandlung in ein Objekt des Primitiven Datentypes führt, es sei denn, das Ding wurde über new erzeugt

[borisp]

Ich weiss nicht, mir schwanken die Zahlen zu sehr... 3 Testläufe:

1
182
190
153

1
158
192
156

1
155
183
185

Das unterste zeigt, das auch x=new Number(1) langsamer sein kann. Trotzdem interessanter ansatz.

[k7c4]

Dann mach mal aus der 1000 in der for-Schleife eine 10000

[bokel]

Yup,
bei Strings sieht man es auch sehr deutlich:

t = getTimer();
s = "Hallo";
for(i=0; i<1000; i++){
    x = s.charAt(3);    
}
trace(getTimer()-t);
 
t = getTimer();
s = new String("Hallo");
for(i=0; i<1000; i++){
    x = s.charAt(3);    
}
trace(getTimer()-t); 

Ausgabe
101
63

mfg r.

[borisp]

Hm, joa - so langsam wird das interessant und sogleich auch logisch.


Wenn ich new String("Foo") mache braucht Flash kein eigenes Type-Casting zu machen um den Typ der Variable zu bestimmen - was auf jedenfall Zeit beansprucht. Dann noch die zuweisung von Methoden an ein String "Objekt".

Interessant bei größeren Sachen, die viele Variablen zuweisungen in schneller Abfolge machen müssen.

[borisp]

Folgendes Script allerdings

t = getTimer();
for(i=0; i<10000; i++){
    s = "Hallo";
}
trace(getTimer()-t);
 
t = getTimer();
for(i=0; i<10000; i++){
    s = new String("Hallo");
}
trace(getTimer()-t); 

484
1110

Also ist ein new String bei der zuweisung schon derb langsamer. Es macht nur der Methodenaufruf einen Unterschied - schön wäre zu wissen warum.

[k7c4]

String.prototype.test = function()
{
trace("--->" + [typeof this , this])
}
x = "hallo"
trace([typeof x,x])
x.test()
trace([typeof x,x])
 
 
x = new String()
trace([typeof x,x])
x.test()
trace([typeof x,x]) 

wenn x ein primitiver Datentyp String ist, wird bei jedem Aufruf von einer String-Methode eine Kopie von x in ein String-Objekt verwandelt. Wenn x ansich schon ein String-Objekt ist, fällt das natürlich flach. Das muss man sich so vorstellen.

// wenn ich mache
x = "wurst";
x.test()
 
//wird intern so etwa wie dieses gemacht
x = "wurst"
if(typeof x != "object")
{
temp = new String(x)
}
else
{
temp = x
}
temp.test()