Я должен кросс-скомпилировать в Linux или Windows?

Семь Коанов прототипа

Когда Чиро Сан спустился с Горы Огненной Лисы после глубокой медитации, его разум был чист и спокоен.

Однако его рука была беспокойной, и он сам схватил кисть и записал следующие заметки.

---

0) Две разные вещи можно назвать «прототипом»:

• свойство прототипа, как в obj.prototype

• внутреннее свойство прототипа, обозначаемое как [[Prototype]] в ES5 .

  Его можно получить через ES5 Object.getPrototypeOf().

  Firefox делает его доступным через свойство __proto__ как расширение. ES6 теперь упоминает некоторые необязательные требования для __proto__.

---

1) Эти концепции существуют для ответа на вопрос:

Когда я делаю obj.property, где JS ищет .property?

Интуитивно понятно, что классическое наследование должно влиять на поиск свойств.

---

2)

• __proto__ используется для поиска свойства точки ., как в obj.property.
• .prototype не не используется для поиска напрямую, только косвенно, поскольку это определяет __proto__ при создании объекта с помощью new.

Порядок поиска:

• obj свойства добавлены со свойствами obj.p = ... или Object.defineProperty(obj, ...)
• свойств obj.__proto__
• из obj.__proto__.__proto__ и т. д.
• , если для некоторого __proto__ задано null, вернуть undefined.

Это так называемая прототипная цепь .

Вы можете избежать поиска . с помощью obj.hasOwnProperty('key') и Object.getOwnPropertyNames(f)

---

3) Есть два основных способа установить obj.__proto__:

• new:

  var F = function() {}
  var f = new F()
  

  , затем new установил:

  f.__proto__ === F.prototype
  

  Это , где .prototype получает используется.

• Object.create:

   f = Object.create(proto)
  

  устанавливает:

  f.__proto__ === proto
  

4) Код:

var F = function() {}
var f = new F()

Соответствует следующей диаграмме:

(Function)       (  F  )                                      (f)
 |  ^             | | ^                                        |
 |  |             | | |                                        |
 |  |             | | +-------------------------+              |
 |  |constructor  | |                           |              |
 |  |             | +--------------+            |              |
 |  |             |                |            |              |
 |  |             |                |            |              |
 |[[Prototype]]   |[[Prototype]]   |prototype   |constructor   |[[Prototype]]
 |  |             |                |            |              |
 |  |             |                |            |              |
 |  |             |                | +----------+              |
 |  |             |                | |                         |
 |  |             |                | | +-----------------------+
 |  |             |                | | |
 v  |             v                v | v
(Function.prototype)              (F.prototype)
 |                                 |
 |                                 |
 |[[Prototype]]                    |[[Prototype]]
 |                                 |
 |                                 |
 | +-------------------------------+
 | |
 v v
(Object.prototype)
 | | ^
 | | |
 | | +---------------------------+
 | |                             |
 | +--------------+              |
 |                |              |
 |                |              |
 |[[Prototype]]   |constructor   |prototype
 |                |              |
 |                |              |
 |                | -------------+
 |                | |
 v                v |
(null)           (Object)

Эта диаграмма показывает множество предопределенных языковых узлов объектов: null, Object, Object.prototype, Function и Function.prototype. Наши две строки кода созданы только f, F и F.prototype.

---

5) .constructor обычно приходит из F.prototype посредством поиска .:

f.constructor === F
!f.hasOwnProperty('constructor')
Object.getPrototypeOf(f) === F.prototype
F.prototype.hasOwnProperty('constructor')
F.prototype.constructor === f.constructor

Когда мы пишем f.constructor, JavaScript выполняет . выглядит так:

• f не имеет .constructor
• f.__proto__ === F.prototype имеет .constructor === F, поэтому возьмите его

результат f.constructor == F интуитивно корректен, поскольку F используется для построения f, например установить поля, очень как в классических языках ООП.

---

6) Классический синтаксис наследования может быть достигнут путем манипулирования цепочками прототипов.

ES6 добавляет ключевые слова class и extends, которые являются просто синтаксическим сахаром для ранее возможного безумия манипулирования прототипом.

class C {
    constructor(i) {
        this.i = i
    }
    inc() {
        return this.i + 1
    }
}

class D extends C {
    constructor(i) {
        super(i)
    }
    inc2() {
        return this.i + 2
    }
}

// Inheritance syntax works as expected.
(new C(1)).inc() === 2
(new D(1)).inc() === 2
(new D(1)).inc2() === 3

// "Classes" are just function objects.
C.constructor === Function
C.__proto__ === Function.prototype
D.constructor === Function
// D is a function "indirectly" through the chain.
D.__proto__ === C
D.__proto__.__proto__ === Function.prototype

// "extends" sets up the prototype chain so that base class
// lookups will work as expected
var d = new D(1)
d.__proto__ === D.prototype
D.prototype.__proto__ === C.prototype
// This is what `d.inc` actually does.
d.__proto__.__proto__.inc === C.prototype.inc

// Class variables
// No ES6 syntax sugar apparently:
// http://stackoverflow.com/questions/22528967/es6-class-variable-alternatives
C.c = 1
C.c === 1
// Because `D.__proto__ === C`.
D.c === 1
// Nothing makes this work.
d.c === undefined

Упрощенная диаграмма без всех предопределенных объектов:

      __proto__
(C)<---------------(D)         (d)
| |                |           |
| |                |           |
| |prototype       |prototype  |__proto__
| |                |           |
| |                |           |
| |                | +---------+
| |                | |
| |                | |
| |                v v
|__proto__        (D.prototype)
| |                |
| |                |
| |                |__proto__
| |                |
| |                |
| | +--------------+
| | |
| | |
| v v
| (C.prototype)--->(inc)
|
v
Function.prototype