Primitives and Objects

Question

Definitive JavaScript by David Flanagan makes a distinction between Objects and Primitives.

He defines the primitives as Number, String, Boolean, Null, and Undefined, as does the standard.

However, would it be more accurate to define a primitive, as subset of object, i.e. to call them Primitive Objects.

Because they have their own methods and are complex entities.

Actual Question

Would Primitive Object be more accurate than Object when defining String, Boolean, and Number?

Answer 1

Objects and primitives are distinct:

typeof 42 === "number"             
typeof new Number(42) === "object"
new Number(42) !== 42

However, when necessary, primitives are automatically wrapped by temporary objects, which can be automatically converted back into primitives:

(42).toString() === "42"
new Number(42) == 42
new Number(42) + 1 === 43

Especially in the context of the Java and C# programming languages, this sort of behavior is called autoboxing. As wrapper objects have some confusing characteristics, for example:

Boolean(new Boolean(false)) === true

it is good practice to avoid intentionally storing them in variables and instead use primitives whenever possible.

Answer 2

It's not about semantics, look:

var threePrimitive = 3;
var threeObject = new Number(3);

threePrimitive.toFixed(2); // 3.00
threeObject.toFixed(2); // 3.00

threePrimitive.foo = true
threeObject.foo = true;
threePrimitive.foo; // undefined
threeObject.foo; // true

Primitives are wrapped in objects when you try to call a method on them, but after initial use the object is thrown away.

---

As for how this is stated in the specification, I'm not 100% sure, but here is what I think (based on the tips left by Bergi in one of his answers. Section 11.2.1 states that the accessor properties should be evaluated as follows:

1. Let baseReference be the result of evaluating MemberExpression.
2. Let baseValue be GetValue(baseReference).

(...)

Then in 8.7.1 we see the following:

The following [[Get]] internal method is used by GetValue when V is a property reference with a primitive base value. It is called using base as its this value and with property P as its argument. The following steps are taken:

1. Let O be ToObject(base).
2. Let desc be the result of calling the [[GetProperty]] internal method of O with property name P.
3. If desc is undefined, return undefined.
4. If IsDataDescriptor(desc) is true, return desc.[[Value]].
5. Otherwise, IsAccessorDescriptor(desc) must be true so,
6. let getter be desc.[[Get]]. If getter is undefined, return undefined.
7. Return the result calling the [[Call]] internal method of getter providing base as the this value and providing no arguments.

NOTE The object that may be created in step 1 is not accessible outside of the above method. An implementation might choose to avoid the actual creation of the object. The only situation where such an actual property access that uses this internal method can have visible effect is when it invokes an accessor function.

Answer 3

Would Primitive Object be more accurate then Object when defining String, Boolean, and Number?

Please note that I'm not saying that numbers are not objects here, I'm pointing out that it appears ambiguous. This is the kind of thing that confuses JavaScript newcomers.

The distinction is mostly academic, but there is one case where it seems ambiguous: literals represent primitive objects except when the literal appears to represent a number. You can't apply a method directly to a literal integer* symbol:

1.toString();
SyntaxError: identifier starts immediately after numeric literal

…but you can apply methods of Numbers:

Number(1).toString();
'1'

…and a name that contains a number is a Number:

x = 4;
x.toString();
'4'

I think this is actually a parsing problem, but I don't really know why the parser can't tell that 1 is a Number as easily as it can tell that "abc" is a String. I suppose it has to do with the semantic ambiguity of the . symbol. (Is it a decimal point or a method operator?)

*JavaScript doesn't actually have integers. I just mean a symbol that consists entirely of [0-9]+.