http://livedocs.adobe.com/flex/3/html/help.html?content=03_Language_and_Syntax_08.html

“…ActionScript stores primitive values internally as immutable objects. The fact that they are stored as immutable objects means that passing by reference is effectively the same as passing by value.”

“In ActionScript 3.0, primitive values and their wrapper objects are, for practical purposes, indistinguishable. All values, even primitive values, are objects. Flash Player and Adobe AIR treat these primitive types as special cases that behave like objects but that don’t require the normal overhead associated with creating objects. This means that the following two lines of code are equivalent:

var someInt:int = 3;
var someInt:int = new int(3);”

int x = 5 is not equivalent to int x = new Number(5) (is that what you were arguing?).

At least in AVM2 it isn’t…

A way you can see is by
trace(System.totalMemory);
for (var i:int = 0; i < 100; i++)
{
int x = 5;
}
trace(System.totalMemory);

Since garbage collection occurs over a few frames, the instances of 5 would still be in memory if 5 referred to a new object.
Again, I’m not sure if this is what you were arguing…

I’m pretty sure x is referencing the memory location of value 5, rather than a new object with that value.

Also, I’m VERY skeptical that 74345.4 in your example isn’t casted before runtime. I’m not saying I’m 100% sure I’m right; I could be wrong about this and you could be right, but I need some evidence.

The primitives in AS3 are treated very different than objects programmers can make.

Here’s some documentation I believe supports my claim:
http://www.nusphere.com/kb/jscoreref/number.html
“The Number object is an object wrapper for primitive numeric values.”

http://livedocs.adobe.com/flash/9.0/ActionScriptLangRefV3/Number.html

“You can manipulate primitive numeric values by using the methods and properties associated with the Number class. This class is identical to the JavaScript Number class.”

Your proof of them being passed by value is wrong and confuses variables for the values they contain.

In the example “x” is a variable. It is not the object. The variable references an object, in this case the number 9. Assigning a new value to “x” makes the variable point to another object, the number 90. This was created by multiplying a reference to the earlier 9 with a literal object with the value 10, this returned a new object with the value 90.

The example has nothing to do with the actual object being passed by value or by reference or not. Since Number and int are immutable there is no way of proving that they are passed by value or by reference in the way you do, because you only change the variable. The variable is not the same as the object it references.

“5 is Object” and “74345.4.toExponential(4)” has absolutely nothing to do with the compiler. ActionScript has late binding, which means that the method toExponential isn’t resolved until runtime. Other languages bind early and resolve these things at compile time, but ActionScript does not. The compiler does not cast, and the runtime doesn’t cast either. The literal 5 is an object. It is just treated a bit different by the runtime in some cases.

“Primitive data include integers and floating-point numbers encoded in various ways.”

So I assume I’m using the correct term.

Also, I’m confused why you say that they are not passed by reference.

var x:int = 9;
func(x);
trace(x); // still 9
x = func(x);
trace(x); // now 90

func = function(x:int)
{
x = x*10;
return x;
}

The actually value is immutable because they are primitives.

5 is Object works because of the compiler. That’s why 7345.4.toExponential works. The compiler casts the number as a Number object.

7345.4.toExponential(2) is equivalent to Number(7345.4).toExponential(2);

Except that they are not. Everything is an object in ActionScript. Java has real primitives, but they are a completely different thing from the Number, Boolean, int and uint types in ActionScript. Just consider this:

trace(5 is Object) // this prints “true”

The reason that it looks like Number and the others are primitives is that the compiler and the runtime does some optimization tricks on variables that are typed as Number, int and uint, and the fact that these types are immutable. That is not the same thing as them being primitives. You can’t do this with a primitive:

trace(7345.4.toExponential(2))

Number, int, uint and Boolean, are not passed by value, but by reference. Not that it makes any difference, because they are immutable and you can’t change them anyway. The same goes for String.