Почему * не * "наследовать" /расширяться от Object в JavaScript?

Хорошо известно, что объявление объектов с нотной JSON делает их "наследуемыми" (или, точнее, похожими на) базовыми Object:

myobj={a:1, b:2};

что почти эквивалентно myobj = Object.create(Object); myobj.a=1; myobj.b=2;

и чем:

Object.getPrototypeOf(myobj)

печатает следующее:

Object
    __defineGetter__: function __defineGetter__() { [native code] }
    __defineSetter__: function __defineSetter__() { [native code] }
    __lookupGetter__: function __lookupGetter__() { [native code] }
    __lookupSetter__: function __lookupSetter__() { [native code] }
    constructor: function Object() { [native code] }
    hasOwnProperty: function hasOwnProperty() { [native code] }
    isPrototypeOf: function isPrototypeOf() { [native code] }
    propertyIsEnumerable: function propertyIsEnumerable() { [native code] }
    toLocaleString: function toLocaleString() { [native code] }
    toString: function toString() { [native code] }
    valueOf: function valueOf() { [native code] }

Однако можно вызвать Object.create(), поставив null в качестве аргумента:

myobj2 = Object.create(null);

В этом случае будет возвращен пустой прототип:

Object
    No Properties

И вот вопрос: в каких случаях и почему я должен разорвать цепочку прототипов на оригинал Object? Где это может быть полезно?

Обновление:, как уже исправлено ниже, я имею в виду Object.create(Object.prototype), а не Object.create(Object), который вернет объект Function (действительно, Object() является конструкторной функцией для прототипов Object)..

Ответы

Ответ 1

Вместо этого:

myobj = Object.create(Object);

... Я думаю, вы имеете в виду, что это эквивалент:

myobj = Object.create(Object.prototype);

... потому что:

Object.getPrototypeOf( {a:1, b:2} ) === Object.prototype;  // true

Что касается того, почему раньше использовать null, если ваш объект не нуждается в каких-либо свойствах Object.prototype, то окончание цепи раньше было бы технически (хотя и незначительно) ускорять поиск свойств, когда свойство не существует для объекта, о котором идет речь.

Обратите внимание, что я говорю "раньше", потому что цепочка всегда заканчивается на null.

Object.getPrototypeOf( Object.prototype );  // null


             obj ----------> proto -------> Object.proto -----> null
         +---------+      +---------+      +-------------+     
         |         |      |         |      |             |
         |  foo:1  |      |  bar:1  |      | toString:fn |      null
         |         |      |         |      |             |
         +---------+      +---------+      +-------------+ 
              ^                ^                  ^               X
              |                |                  |               |
obj.foo ------+                |                  |               |
              ^                |                  |               |
obj.bar-------+----------------+                  |               |
              ^                ^                  |               |
obj.toString--+----------------+------------------+               |
              ^                ^                  ^               |
obj.baz-------+----------------+------------------+---------------+

   ^---property lookups

Обратите внимание, что свойство baz не существует в цепочке прототипов.

Из-за этого ему необходимо последовательно искать каждый объект, пока он не достигнет null, прежде чем он поймет, что baz не существует нигде.

Если вы удалите Object.prototype из цепочки, он немного ускорится null.