Array vraagstukje om het weekend mee door te komen

[Laiverd]

var plop = new Array(9);
trace(plop.length); // output: 9

var plop = new Array(99999);
trace(plop.length); // output: 99999

Maar dan:
var plop = new Array(9999999999);
trace(plop.length); // output: 1410065407

Bug of feature?

John

[Roenes]

Ik denk dat die laatste output waarde gewoon de maximale capaciteit van een array is. Of dit ook werkelijk zo is, weet ik niet maar dat lijkt me het meest logische :)

[Laiverd]

Dat is het dus niet:
var plop = new Array(1410065409)
trace(plop.length) // output: 1410065409

[Roenes]

idd jah, kheb er ff mee zitten spelen maar kan er geen zinnige verklaring voor verzinnen :)

[SaphuA]

n = Math.pow(2, 31)-1;
var a = new Array(n)
trace(n + "," + a.length));
output: 2147483647,2147483647

n = Math.pow(2, 31);
var a = new Array(n)
trace(n + "," + a.length));
output: 2147483648,-2147483648

n = Math.pow(2, 31)+1;
var a = new Array(n)
trace(n + "," + a.length));
output: 2147483649,-2147483647

So it looks like Flash is using a signed long (4 byte) value internally to represent the array index and anything bigger than pow(2,31)-1 causes it to interpret that value as a negative number.

It should be throwing an array bound error of some kind, but I suspect this is suppressed because Flash also allows associative indexing which means just about any value can be a valid array index. Implicit type conversion will probably cause bad index values to be converted to strings so associative indexing takes over.

Short answer, stay away from boundary conditions if you can and know what you're doing when you use arrays in Flash or you may get bitten by any number of odd "bugs".

Heb je hier iets aan?

[Roenes]

aan dat signed bitje dacht ik vandaag tijdens de les. Dat hadden we kunnen weten dat het daaraan zou liggen. Aan het 2e gedeelte van die associatieve indexes had ik niet aan gedacht. Maar leerzaam stukje tekst :)

[TheDutch]

----

[TheDutch]

2.147.483.647 is de maximale waarde die een integer(32) kan bevatten. Wanneer je een grotere waarde meegeeft aan de array, wrapped hij eromheen. Dus hij begint eigenlijk opnieuw te tellen. 2.147.483.647 past 4.657 maal in 9.999.999.999. Als je dit gaat berekenen zul je zien dat de teller uiteindelijk op 1.410.065.409 uitkomt :).

De array bevat wel 9.999.999.999 elementen en je kunt ook dingen opslaan en ophalen met zo'n hoog getal. Ik denk dus dat de length property alleen een integer terug kan geven en daardoor gaat wrappen. Dit heeft dus eigenlijk niets met Arrays te maken en alles met de length property in ActionScript.

Ik zie dit als een tekortkoming in een feature en zou geclassificeerd mogen worden als bug ;).

[SaphuA]

Maarja, welke idioot gaat een array maken met zo'n lengte? :D
Denk niet dat je dit als een bug moet zien, MM moet ergens zijn grenzen trekken lijkt me?

[TheDutch]

Is ook wel zo SaphuA, echter heeft Macromedia wel de array zo gemaakt dat het maximaal 9.223.372.036.854.775.296 elementen kan bevatten wat ongeveer gelijk staat aan int64. Wanneer ze dan een property maken om het aantal elementen van een array uit te lezen, moeten ze het wel zo maken dat de integer types overeenkomen. Momenteel kan de length property van de array maar maximaal int32 terug geven :).

Kortom ze zouden de length property van de array moeten verhogen van int32 naar de int64 die ook gebruikt wordt voor de Array index.

2.147.483.647 = int32 //length property
9.223.372.036.854.775.296 = int64 //Array index