Large Numbers as keys in Dictionaries (ActionScript 3) - actionscript-3

Question

I am using a Dictionary where the keys are Number objects, but I run into unexpected problems if the keys are large integers.
Here is some example code that inserts two key-value pairs in a Dictionary, one with a small key and one with a large one:
var dictionary:Dictionary = new Dictionary();
var smallNumberKey:Number = 1;
dictionary[smallNumberKey] = "some value";
var largeNumberKey:Number = 0x10000000;
dictionary[largeNumberKey] = "some value";
for (var key:Object in dictionary) {
trace("Key: " + key);
trace("Key type: " + flash.utils.getQualifiedClassName(key));
trace("Key as Number: " + (key as Number));
}
This gives the following output:
Key: 1
Key type: int
Key as Number: 1
Key: 268435456
Key type: String
Key as Number: null
None of the keys seems to be stored as a Number. Why is that? The first one is stored as an int, which can be converted to a Number. The second one however seems to be stored as a String, which makes no sense to me. What is going on here?

Answer 1

You can't use a Number as a key, because binary floating-point numbers do not lend themselves well to exact comparison, which is exactly what the Dictionary class does. (is "uses strict equality (===) for key comparison"). Read up on floating point numbers to understand why.
So when you assign a Number as a key to a Dictionary, the Flash engine must convert it to some other thing which can be represented exactly. String and int values can both be represented exactly by their contents, so Flash picks one to convert the supplied Number to. Doing some experimenting, it seems flash always converts an whole number value (even if supplied as a string) to an int if less than or equal to 0xFFFFFFF, and always converts to a String any whole number greater than that, probably due to some internal optimization in the fastest way to compare keys:
import flash.utils.Dictionary;
import flash.utils.getQualifiedClassName;
var dictionary:Dictionary = new Dictionary();
var stringKey:String = "123456789";
var intKey:int = 0xFFFFFFF;
var intKey2:int = intKey + 1;
dictionary[stringKey] = "Value 1";
dictionary[intKey] = "Value 2";
dictionary[intKey2] = "Value 3";
for (var key:Object in dictionary) {
trace( key + " [" + getQualifiedClassName(key) + "] = " + dictionary[key]);
}
Prints:
123456789 [int] = Value 1
268435455 [int] = Value 2
268435456 [String] = Value 3

Answer 2

From the Adobe doc:
The Dictionary class lets you create a dynamic collection of properties, which uses strict equality (===) for key comparison. When an object is used as a key, the object's identity is used to look up the object, and not the value returned from calling toString() on it.
"Using the object's identity" means using a reference to the object, a pointer to the place in memory where the actual object is stored. The problem when using primitive values as dictionary keys is that they are never passed by reference, and thus the values are not stored in the actual dictionary (i.e. they are not references to an object), but rather treated as "regular" dynamic properties, just like the ones you would expect from an Object. When you set
object[key] = "some value";
the key values are automatically converted either to int(just like the index of an Array) or String.
You can get around this, and use the actual performance benefits of Dictionary, by using a simple NumberKey wrapper class:
package
{
import flash.display.Sprite;
import flash.utils.Dictionary;
public class SimpleTest extends Sprite
{
var dictionary:Dictionary = new Dictionary();
public function SimpleTest() {
var smallNumberKey:NumberKey = new NumberKey(1);
dictionary[smallNumberKey] = "some value";
var largeNumberKey:NumberKey = new NumberKey(0x10000000);
dictionary[largeNumberKey] = "some value";
for(var key:Object in dictionary) {
trace( "Key: "+key );
trace( "Key type: "+flash.utils.getQualifiedClassName( key ) );
trace( "Key as Number: "+(key.numberValue) );
}
}
}
}
package {
public class NumberKey {
public var numberValue : Number;
public function NumberKey( n:Number ) {
numberValue = n;
}
}
}