И вы, похоже, как и я любите Ruby

Точно Да и вообще я люблю языки (Erlang, Python, CoffeeScript, Lua и другие).

Возможно, вместо написания своей, лучше использовать вашу, не изобретать велосипед, — с теорией знаком да и ладно

Ну, написание своего “велосипеда” в академических целях несомненно повышает скилл — так что в любом случае будет полезно. Но, если же Вы уже используете какой-то фреймворк в проекте, где реализованы “классы”, то есть смысл сразу их использовать. Хотя, все зависит от ситуации — может Ваша “обертка” будет намного эффективней или еще что-то.

(Только хотел бы заметить, что у вас меню в правом верхнем углу спозиционировано абсолютно и при этом не помещается в обычный экран браузера на моём 13″ макбуке, поэтому приходится хитрить — менять в Веб-инспекторе позиционирование, либо уменьшать масштаб страницы. Надо, очевидно, что-то сделать с этим.)

Да, мне уже говорили об этом. Этот блок меню писал не я. Если есть какие-нибудь предложения, как это можно лучше реализовать, пришлите мне на почту, я с удовольствием рассмотрю и встрою.

(Только хотел бы заметить, что у вас меню в правом верхнем углу спозиционировано абсолютно и при этом не помещается в обычный экран браузера на моём 13″ макбуке, поэтому приходится хитрить — менять в Веб-инспекторе позиционирование, либо уменьшать масштаб страницы. Надо, очевидно, что-то сделать с этим.)

Спасибо; приятно видеть программистов, интересующихся глубоким JS.

Во-первых, не очень понятно, когда у создаваемого объекта появляется свойство constructor: в момент присвоения A.prototype = new A()?

Свойство constructor у объектов является не родным, а унаследованным. Это свойство лежит в прототипе:

function A() {}

var a = new A();

console.log(a.constructor); // A

Но — отчетливо видно, что это неродное свойство:

console.log(a.hasOwnProperty("constructor")); // false
console.log(a.__proto__.hasOwnProperty("constructor")); // true

console.log(A.prototype.hasOwnProperty("constructor")); // true

console.log(a.__proto__ === A.prototype); // true

А в A.prototype свойство constructor появляется при создании функции. И это есть рекурсивная ссылка функции на себя:

console.log(A.prototype.constructor === A); // true

Во-вторых, по поводу ООП-обёртки. Можно ли использовать ваш код для написания своей ? Какие ещё обёртки вы бы посоветовали, в чём их преимущество?

Конечно используйте К тому же, это довольно распространенный на сегодня вариант для ES3. В ES5 появилась уже стандартная обертка — Object.create, которая делает почти то же самое внутри.

Оберток много, реализации есть во многих библиотеках. Наиболее интересны обертки с удобным super-вызовами, т.е. вызовы методов родительских классов без “хардкода” имен классов. Вот несколько из моих наработок.

Собственно, у меня к вам пара вопросов по данной статье. Во-первых, не очень понятно, когда у создаваемого объекта появляется свойство constructor: в момент присвоения A.prototype = new A()? Было бы здорово, если бы вы подробнее описали это место. Во-вторых, по поводу ООП-обёртки. Можно ли использовать ваш код для написания своей ? Какие ещё обёртки вы бы посоветовали, в чём их преимущество?

Насколько я понимаю преобразуется в:

var x = (typeof x !== 'undefined') ? x : {};

(Опечатка с {}? Дефолтное значение 10 у Вас в примере). Здесь используется преобразование ToBoolean:

var x = (Boolean(x) === true) ? x : 10;

Несколько запутанная нотация, код несомненно короче, но первая мысль которая приходит на ум, когда ее видишь – это возвращение true/false из x||10

Это может быть вызвано привычкой, выработанной изначально в языке с другой семантикой (например, Си). Здесь же, JS возвращает сам операнд, а не boolean значение всей операции (хоть и использует boolean-преобразование для теста). Такая же семантика, например, в Python.

Насколько я понимаю преобразуется в:

var x = (typeof x !== 'undefined') ? x : {};

Несколько запутанная нотация, код несомненно короче, но первая мысль которая приходит на ум, когда ее видишь – это возвращение true/false из x||10.

Собственно, если речь идет лишь о конструкторе Object, то инициализатор объекта (или литеральная нотация объекта) — всего лишь синтаксический сахар для new Object:

var foo = {x: 10, y: 20};

то же самое, что:

var foo = new Object;
foo.x = 10;
foo.y = 20;

Очевидно, что когда имена свойств и структура объекта заранее известны, удобней использовать инициализатор объекта (хотя, может быть и дело вкуса).

С другой стороны, метод с конструктором позволяет создавать свойства, имена которых определяются в рантайме, т.е. не известны на этапе компиляции:

var foo = new Object;

for (var k = 3; k--;) {
  foo["slot" + k] = k;
}

console.log(foo); // {slot3: 3, slot2: 2, ...}

Прототипом в обоих случаях — и с {}, и с new Object, будет Object.prototype.

Ну и, опять же, как было отмечено в разделе про литеральные нотации, имя Object можно переопределить, и тогда new Object будет возвращать другой объект, тогда как {} продолжит (но не во всех реализациях) создавать нативные объекты.

1. Конструктор;
2. Literal notation;

Спасибо!

но я пока не знаю на сколько он корректен

Вполне себе корректен. Реализация — дело десятое. Просто помните, что JS позволяет вызывать метод объекта сразу же, без промежуточных результатов (именно это преимущество цепочек). А что там вернет предыдущий метод — это уже Ваша реализация.

Т.е. не обязательно даже возвращать объект того же типа. Например, создаем одиночный объект, вызываем его метод foo, который возвращает строку, и сразу же вызываем метод строки:

({foo: function () {
  return "foo";
}})
  .foo() // "foo"
  .toUpperCase(); // "FOO"