If we create a function like:
function Rabbit() {}
We see that it inherits from the same object that Function inherits from i.e.
Rabbit.__proto__ === Function.__proto__
What is this higher object? If we try to log it it looks like : ƒ () { [native code] }. Shouldn't Rabbit be inheriting from Function object because it's a function? Can somebody explain where i'm wrong?
What is this higher object?
It's the object referenced by Function.prototype, which is also a function. It's where functions get their properties and methods from (call, apply, bind, name, and length).
That object's prototype is the object referenced by Object.prototype, which is responsible for basic object properties and methods such as hasOwnProperty and toString and, since you used it in your example, __proto__ (which is a web-only feature for backward compatibility; don't use it, use Object.getPrototypeOf instead).
Shouldn't
Rabbitbe inheriting fromFunctionobject because it's a function?
No, that's what Function.prototype is for.
Let's put Function, specifically, aside for a moment. Suppose you have:
function Thingy() {
}
and
let t = new Thingy();
Object.getPrototypeof(t) === Thingy.prototype will be true, because when you use new Thingy, the resulting object gets the object that Thingy.prototype points to as its prototype. This is how constructor functions and prototypes work in JavaScript.
Function is a constructor that creates functions. So the equivalent would be:
let Rabbit = new Function();
Object.getPrototypeOf(Rabbit) === Function.prototype is true. It's also true for functions that, like your Rabbit, aren't created via new Function.
Function and Function.prototype separately? Couldn't this be done using one object?
__proto__ of a future instance.
Function is a constructor function: When you call it via new Function, it creates a new function. Like all constructor functions when you use new X, the prototype of the new object is taken from X.prototype, so that's why Function has a prototype property with the various features functions typically have on it. Function (the function) supplies the initialization of the new object (a function), Function.prototype provides the prototype for the object (which, again, is just like other constructor functions).Shouldn't Rabbit be inheriting from Function object because it's a function?
No, because it is a regular function. Every function you create this way is actually a Function object instance. See mdn.
In order to make a Function be a prototype of your object you need to explicitly specify it as a prototype of your object and create an instance using new keyword.
function Rabbit() {} basically does Rabbit = new Function() for us?Date, Map, Set, WeakMap, WeakSet, Int32Array and related, Promise, Proxy... But several (RegExp, Object, Array, and Function) are better avoided (barring a really good reason) in favor of using the literal syntax provided for those types of objects.