Prototype Chain

Com a vinda do ES6 as classes chegaram ao Javascript, porém são apenas syntax sugar para prototypes

const human = { walk: () => console.log('walking')
const person = {}

person.__proto__ = human
person.walk() // Output: walking

Herança com Prototypes

function Phone() {
	this.on = function() {}
}

const galaxy = new Phone()
galaxy.on()

Visualizando os Prototypes

const obj = {}
Object.getPrototypeOf(obj) // Object

const first = { a: 1 }
const second = { b: 2 }
Object.setPrototypeOf(second, first)

second.a // 1

Um Enígma

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

O operador instanceof testa se a função construtora aparece em qualquer lugar na prototype chain de um objeto.

objeto instanceof construtor 

The abstract operation InstanceofOperator(O, C) implements the generic algorithm for determining if an object O inherits from the inheritance path defined by constructor C. This abstract operation performs the following steps: 1. If Type(C) is not Object, throw a TypeError exception. 2. Let instOfHandler be GetMethod(C,@@hasInstance). 3. ReturnIfAbrupt(instOfHandler). 4. If instOfHandler is not undefined, then a. Return ToBoolean(Call(instOfHandler, C, «O»)). 5. If IsCallable(C) is false, throw a TypeError exception. 6. Return OrdinaryHasInstance(C, O).

Function instanceof 'string'
// Uncaught TypeError: Right-hand side of 'instanceof' is not an object

Function instanceof {}
// Uncaught TypeError: Right-hand side of 'instanceof' is not callable

const obj = {
	[Symbol.hasInstance]: 1,
}

Function instanceof obj
// Uncaught TypeError: number 1 is not a function

The abstract operation OrdinaryHasInstance implements the default algorithm for determining if an object O inherits from the instance object inheritance path provided by constructor C. This abstract operation performs the following steps: 1. If IsCallable(C) is false, return false. a. If C has a [[BoundTargetFunction]] internal slot, then b. Let BC be the value of C’s [[BoundTargetFunction]] internal slot. 2. Return InstanceofOperator(OBC) (see 12.9.4). 3. If Type(O) is not Object, return false. 4. Let P be Get(C, "prototype"). 5. ReturnIfAbrupt(P). 6. If Type(P) is not Object, throw a TypeError exception. 7. Repeat a. Let O be O.[[GetPrototypeOf]](). b. ReturnIfAbrupt(O). c. If O is null, return false. d. If SameValue(P, O) is true, return true.

Object instanceof Function // true

Function.prototype // ƒ () { [native code] }
Object.getPrototypeOf(Object) // ƒ () { [native code] }
Object.getPrototypeOf(Object) === Function.prototype // true

Function instanceof Object // true

Object.prototype // {}
Object.getPrototypeOf(Function) // ƒ () { [native code] }
Object.getPrototypeOf(Function) === Object.prototype // false
Object.getPrototypeOf(Object.getPrototypeOf(Function)) // {} - Object.prototype 
Object.getPrototypeOf(Object.getPrototypeOf(Function)) === Object.prototype // true

1. Obtém a propriedade prototype do construtor Object

2. Obtém o prototype do objeto Function

3. Compara o prototype do objeto com a propriedade prototype do construtor
1. O resultado é false pois Object.prototype é um objeto de onde derivam todos os outros objetos, enquanto que o prototype de Function é Function.prototype, uma função.

4. Aqui entram os passos de repetição, onde o prototype do prototype do objeto é obtido de forma recursiva até que seja null, ou igual a propriedade prototype do construtor:
1. O prototype de Function é Function.prototype,
2. O prototype de Function.prototype é Object.prototype, pois, novamente, funções também são objetos.
3. Logo, o resultado dessa comparação é true, pois Object.prototype (do construtor) é igual a Object.prototype (o prototype do prototype, do objeto Function)

Referências