Why in Javascript, 7 (a number) is not an instance of Number?

Question

When we do the following test below, it is returned false.

console.log(7 instanceof Number); // FALSE

However, in the second test, it is returned true.

var number = new Number('3');

console.log(number instanceof Number) // TRUE

In a second scenario, we also have a variation when we use typeof:

typeof 1 // "number"

typeof new Number(1) // "object"

I do not understand why this, since, in the examples below, both the object like the number shall have the method established in Number through the prototype!

Behold:

Number.prototype.square = function ()
{
   return Math.pow(this, 2);
}

var x = 3;

x.square(); // 9

new Number(3).square() // 9

(3).square() // 9

Does anyone know why this happens craziness variation?

Answer 1

In Javascript, there are primitive types for String, Number and Boolean (besides Object and of the types Null and Undefined, which only have one instance each). So, primitive values like the ones in the example below are not objects:

var texto = "Texto";
var numero = 7;
var booleano = true;

texto instanceof String;     // false
numero instanceof Number;    // false
booleano instanceof Boolean; // false

The operator instanceof does not say the type of value. If the value is an object, the instanceof says if what’s on the right side is one of the prototype chain of this object - and so new Number(7) instanceof Number === true, since the number was created with the constructor Number.

What gives the type of value is the operator typeof, with which you get the kind of primitives:

typeof texto;     // "string"
typeof numero;    // "number"
typeof booleano;  // "boolean"

When you try to access a property, the engine knows how "wrap" the value in an object of the corresponding type (String, Number or Boolean), to then return the property. This is similar to autoboxing java. The created object is temporary, it does not exist as a variable after obtaining the value of the property (although Engines can perform optimizations and keep it in memory if they deem it necessary). That’s how expressions like:

"foo".length;
(7).toFixed();
7..toFixed(); // o primeiro ponto é o separador de casas decimais
true.valueOf();

Answer 2

Strings and Numbers are primitive values, not objects, and therefore do not have a [[Prototype]], so it will only work if you instantiate them as objects.

The same problem would occur in the case:

console.log("Texto" instanceof String); -> false

var texto = new String('3');
console.log(texto instanceof String) -> true

It has a very explanatory and good reference here in the OR

Answer 3

Simply because he "is not" a object instance.

Objection instances are declared using the keyword new.

The reported problem also occurs for the following situations:

"string" instanceof String;      // false
true     instanceof Boolean;     // false

The curious thing is that it doesn’t happen the same for the types array and Object:

({foo: "bar"}) instanceof Object;  // true
[1,2,3] instanceof Array;          // true

This is because objects really are objects in javascript, already the case of array is even more peculiar, because in Javascript arrays are objects, so much so that the following expression is true:

[1,2,3] instanceof Object; // true
typeof [1,2,3];            // object

Javascript is not (was) an object-oriented language, but rather a language oriented to prototypes (or prototypes of objects). MDN reads as follows::

In Javascript, inheritance occurs through prototype objects⁴ and defines a relation of type "is one" ("is a" Relationship). Each object inherits properties and methods of its prototype object which is referenced by the prototype property. MDN: Javascript object oriented

I mean, in your example:

Number.prototype.square = function ()
{
   return Math.pow(this, 2);
}

You are adding a method to the prototype of the object Number, that is, not just the objects Number's will inherit this method, as well as any "object" (typages and etc) that also inherits the prototype Number.

Some links about:

• https://stackoverflow.com/questions/15505405/javascript-creating-new-instance-of-objects
• http://www.w3schools.com/js/js_arrays.asp
• https://developer.mozilla.org/pt-PT/docs/Javascript_orientado_a_objetos