Object and Function are quite confusing

Question

Object instanceof Object
true
Object instanceof Function
true
Function instanceof Object
true
Function instanceof Function
true

so if Function is an Object and the Object is a Function how come

Function === Object and Function == Object are false?

I do understand that checking the instance of an object is not the same as comparison. So the question here is the fuzziness in the case where if two objects (which are actually types) are instances of each other, shouldn't the types be the same?

Note: Object is not an instance of a Number or an Array just an instance of Function.

score 17 · Accepted Answer · edited Sep 08 '14 at 05:53

17

From JavaScript Prototypal Inheritance:

Quite everything, in JavaScript, inherits from Object. We could say that Object is the super class, or better, the super constructor, of every variable and that everything is an instanceof Object. The Object constructor is a Function, but a Function is an instanceof Object. This means that these assertions are always true:

(Object instanceof Function) === (Function instanceof Object)

Above example is true because Object is a constructor, and a constructor in JavaScript is always a Function. At the same time, every Function has its own prototype, and a prototype always starts its inheritance from Object.prototype. The Function constructor, is a Function itself, and the function prototype is a function(){};

(Function.prototype instanceof Object) === (function(){} instanceof Object)

edited Sep 08 '14 at 05:53

user123444555621

148,182
27
114
126

answered Jan 05 '10 at 00:19

Annie

6,621
22
27

1

+1 for saying the same thing I said but in a much more concise and easy-to-understand way. xD – Sasha Chedygov Jan 05 '10 at 00:23
`Quite everything, in JavaScript, inherits from Object` and then ES5 came: `var notObject = Object.create(null); notObject instanceof Object; //false` – Derek 朕會功夫 Sep 07 '14 at 23:48
1

That is the most confusing explanation I have ever seen. – user123444555621 Sep 08 '14 at 04:44
@Derek朕會功夫 True. And of course, even before ES5 the assertion was wrong. Clearly, every prototype chain is finite, thus `Object.prototype instanceof Object === false` – user123444555621 Sep 08 '14 at 04:56

Sasha Chedygov · Answer 2 · 2010-01-05T00:21:18.560

5

Everything is an Object in JavaScript because JavaScript is an object-oriented language. Function is an instance of Object because everything is an instance of Object. Simple enough. However, objects that initialize other objects (constructors) are also Functions in JavaScript, so it would make sense for Object to also be a Function.

Think about this:

var obj = new Object();

Object in this case is used as a Function, is it not? So while, in theory, Object should be the lowest-level object in the language, JavaScript cannot function without Functions (pun!), so you need both to be at the same level. Object needs to be an instance of Function because it's a constructor and it needs to create more instances of itself.

function FooBar() {}

The FooBar class above is an instance of both Object and Function, because it's both. The same logic applies to the built-in Object and Function objects; they're instances of both.

Phew, confusing. Did that make any sense?

edited Jan 05 '10 at 00:21

answered Jan 05 '10 at 00:15

Sasha Chedygov

127,549
26
102
115

Makes sense to me, but as you can probably see I had just as much trouble (unsuccessfully) trying to explain the same thing :-P – Graza Jan 05 '10 at 00:18
Haha yeah, it's not easy to explain! – Sasha Chedygov Jan 05 '10 at 00:20
It certainly makes sense given that it is Javascript, in no other language that I know of do you instantiate a function (of type Function), you only invoke it. Appreciate your effort in trying to answer the right question. – Murali Jan 05 '10 at 00:21
there are many Functional Programming languages that can have functions that generate functions LISP, LOGO, ... even BASIC! (the technique involves creating a string and embedding it in the BASIC program as a line - the embedded string would define a function) – Ekim Aug 18 '11 at 02:48

score 4 · Answer 3 · edited Jan 05 '10 at 00:38

4

I think this is more due to the unique way in which objects are defined. You don't define a type in javascript, you define a constructor. But you also do not define the constructor as a constructor, it's simply a function.

You can then refer to the types by the name of their constructor....which is just a function.

function Tiger(){ //function, or object?
}

function Apple(){ //function, or object?
}

Both could be objects, or perhaps just functions. Only the way you use them will determine that. So it kind of makes sense that at a low level, objects are functions and functions are objects, but there is still a difference, right?

edited Jan 05 '10 at 00:38

Sasha Chedygov

127,549
26
102
115

answered Jan 05 '10 at 00:13

Graza

5,010
6
32
37

Regarding your comment method or object, it is definitely not a method unless it is called with some scope. – Murali Jan 05 '10 at 00:26
Ah, yes, is this a terminology clash here - would "//FUNCTION, or Object?" be a better comment? – Graza Jan 05 '10 at 00:30

score 1 · Answer 4 · answered Sep 08 '14 at 04:59

1

There is no such thing as classes in Javascript. The instanceof operator is called on functions.

Object is a constructor function for "Object objects" (yes, this is the official term), and Function is the constructor function for "Function objects".

So, when you call Function instanceof Object, it returns true because Function is a function, and thus an object, etc. This does not mean that the types are the same, because Object and Function have different prototypes:

Object.prototype
   ^
   | inherits from
   |                instance
Function.prototype  <-------  Object, Function

answered Sep 08 '14 at 04:59

user123444555621

148,182
27
114
126

Nice copy and pasting from your last answer. – Derek 朕會功夫 Sep 08 '14 at 05:22
...since the question was closed as a duplicate – user123444555621 Sep 08 '14 at 05:42
1

I deleted the other answer, to avoid duplicate content :) – user123444555621 Sep 08 '14 at 05:47
But what is not shown in diagram is Object.prototype.constructor === Object but Object instance of Function.prototype. This whole thing has no logic no matter how any one tries to explain. – Number945 Jan 24 '17 at 20:23

score 0 · Answer 5 · answered Dec 10 '15 at 12:17

Suppose:

<---- : links to (via .__proto__)

<-- : has inherited property of (via .)

Then:

Function.prototype <---- {Object, Function}

Object <---- Function.prototype

Object.prototype <-- Object

console.log(Object.prototype.constructor === Object); // true!

Object.prototype does not link to anything; it doesn't have __proto__ property.

score 0 · Answer 6 · edited May 23 '17 at 10:27

0

 javascript:alert([ window.navigator.userAgent, Object ].join("\n\n") )

displays

Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.3) Gecko/20100423 
    Ubuntu/10.04 (lucid) Firefox/3.6.3

function Object() {
    [native code]
}

reference: Is every JavaScript Object a function?

edited May 23 '17 at 10:27

Community

1
1

answered Aug 18 '11 at 02:50

Ekim

949
1
8
9

`javascript:alert(Function)` displays `function Function() { [native code] }` – Ekim Aug 18 '11 at 02:57

score -2 · Answer 7 · answered Jan 04 '10 at 23:56

-2

instanceof operator indicates if the first argument is of the given type. That is saying

 A instanceof B

returns true if A is an instance of the type B.

The == and === operators are comparison operators on the other hand. They compare values for equality.

For instance, you can say jack instanceof Boy is true but would you say that jack == boy? No.

answered Jan 04 '10 at 23:56

Vincent Ramdhanie

102,349
23
137
192

The OP's question is more about how `Object` and `Function` can be instances of each other and not be the same thing. – Sasha Chedygov Jan 05 '10 at 00:18

Object and Function are quite confusing

7 Answers7

Linked

Related