Методы в JavaScript

упс...

function Test(){}

Test.prototype = {

    x: 5,

    y: 3,

    sum: function(){

        return this.x + this.y;

    }

};

Может стоит с ним по ласковее и не будет сопротивляться? Если натягивать классориентированный подход на прототипоориентированный язык, понятно, что ему это не понравится.

кстати. наследование штатными средствами делается тоже не очень сложно

TestChild.prototype = new Test();

можно еще почитать тут - http://dklab.ru/chicken/nablas/40.html

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

Если вы про эмуляцию классов, то, имхо, мотоцикл, это как раз прототипы. Только, конечно, с велосипеда на мотоцикл так просто не пересесть, придется долго тренироваться. А эмуляция классов, это вообще даже не велосипед, а самые что ни на есть костыли.

Вы знаете, когда отлаживаешь проект с большим количеством javascript под популярными браузерами, складывается ощущение, что "разработчики js-движков" не только ламеры, но и вообще безответственные лентяи. В примитивных случаях все ок, но как только кода становится много - память начинает течь, причем под разными браузерами в разных местах. И для борьбы с этим приходится выдумывать разные идиотские хаки. Так что не стоит рассчитывать на всякую "оптимизацию" - ее там почти что нет.

Прошу прощения, ctrl-c не сработал. Цитата следующая:

Так, уже многое написано о проблеме наследования (котого в JS нет).

да, я тоже очень порадовался первой фразе статьи : )

Красиво, факт... но недопустимо. Потому что на каждый объект создаётся свой набор методов. См. демонстрирующий пример.

http://javascript.crockford.com/private.…
И вот эта, конечно же.

Зато уж точно создастся 100 лишних ссылок.

Вообще, автор статьи не до конца разобрался в теме.
Основная ошибка и "затык" начинающих — попытка обращаться с прототипами объектов, а не их конструкторов. Ибо прототипов у самих объектов нет.

// конструктор
var MyObj = function(){ this.x = 10; };
MyObj.prototype = { x:0, y:0, move:function(x,y){this.x=x; this.y=y;} };
// создание объекта
var myObj = new MyObj();
for(var i in myObj){ if myObj.hasOwnProperty(i) alert(i); } // -> «x»
alert(myObj.x); // -> 10
alert(myObj.y); // -> 0
alert(myObj.move); // -> «function», т.е. метод присутствует.

Как это работает:
«MyObj» — обычная функция. Ещё раз: обычная функция.
При вызове (любой) функции с оператором new происходят три вещи:
1. Создаётся новый, «чистый» объект в памяти.
2. Ссылка на него передаётся вызываемой функции как «this». Всё, что функция назначит этому «this» внутри себя, соответственно будет назначено новому объекту.
3. По окончании работы ссылка на объект возвращается переменной по оператору присваивания. В нашем примере – «myObj». Также мы можем вернуть ссылку явно – оператором «return».

Если проверить все «собственные» свойства свежесозданного «myObj» при помощи метода hasOwnProperty() выяснится, что он имеет лишь свойство «x», назначенное ему конструктором.

for(var i in myObj){ if myObj.hasOwnProperty(i) alert(i); } // -> «x»

Тогда откуда берётся «y»? Не найдя этого свойства в самом объекте, машинка обращается к создавшей его функции. Ссылка на неё хранится в каждом объекте, в свойстве «constructor» (мы даже можем проверять принадлежность объекта: myObj.constructor == MyObj // -> true). Затем машинка обращается с свойству «prototype» конструктора и – о чудо – находит там «y». Полный путь: «myObj.constructor.prototype.y». Надеюсь, не нужно объяснять, почему это свойство получается общим для всех объектов, созданных через MyObj().
Вообще, все «общие» свойства, такие как методы или «статические» переменные нужно оставлять в прототипах. Делать на них лишние ссылки из объектов не нужно – машинка сама найдёт свойство по цепочке наследования. Другое дело, что можно переопределить свойство (как это сделано с «x» в примере) – тогда его значение будет уникальным, принадлежащим только этому объекту, а машинка доберётся до него раньше, не углубляясь в прототипы.

Подробнее о самом «прототипе». Это обычный объект, с обычными свойствами, создается обычным путём (запись в примере «someObj = {}» является лишь сокращением от «someObj = new Object()», как и «someObj = []» является «someObj = new Array()»). Т.е. можно создавать объект-прототип любого класса. Так реализуется наследование.

// новый конструктор
var myObj2 = function(){};
MyObj2.prototype = new MyObj(); // ога, вот отсюда возьмём всё что не найдем в самих объектах
// его объект
var myObj2 = new MyObj2();
for(var i in myObj2){ if myObj2.hasOwnProperty(i) alert(i); } // а ничего нет – кунструктор-то ничего не назначил, объект пустой

(продолжение)

alert(myObj2.x) // ->10, ибо myObj2.constructor.prototype = объект, созданный MyObj, и при создании ему был назначен x = «10».

Ещё раз: у самого объекта prototype нет. Только у конструктора. Но каждый объект своего конструктора «знает».
ИМХО, больше в этой статье писать ни о чём не нужно.

p.s.
На закуску — пример «упаковки классов».

Object.extend = function(_class, properties)
{
if(!_class) _class = function(){};
_class.extend = this.extend;
_class.prototype = new this();
if(properties)
for(property in properties)
if(properties.hasOwnProperty(property)) _class.prototype[property] = properties[property];
return _class;
}

Пример:

var Point = Object.extend(null, {x:10, y:10});
var p1 = new Point();
alert(p1.x); // -> 10

var Circle = Point.extend(null, {r:20});
var c1 = new Circle();
log(c1.x); // -> 10

p.p.s. блин, глядя на ситуацию не мог промолчать. Надеюсь, поможет кому.

(Опечатка, имена конструкторов — с заглавной.)

var myObj2 = function(){};

должно быть

var MyObj2 = function(){};

Строго говоря, начиная с третьего варианта, программист может выбирать любой на свой вкус. Мой личный вкус тяготеет к последнему.

Прочёл «YUI Blog: with Statement Considered Harmful».

If you can’t read a program and be confident that you know what it is going to do, you can’t have confidence that it is going to work correctly. For this reason, the with statement should be avoided.

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

P.S. Разве что про "функциональное программирование" - исправьте, глупо же смотрится.

Для начинающих необходимо именно категорично выставлять некоторые вещи неграмотными или недопустимыми, даже если это спорное утверждение в данном случае. Это нужно для того, чтобы начинающие не начали делать ляпы в начале. Когда они дорастут до того уровня, чтобы самостоятельно определять, что грамотно или допустимо, а что — нет, они составят свою точку зрения. А до тех пор лучше сразу одёрнуть.

К слову:

Мне мама говорила всегда: "Не ешь тесто - кишки слипнутся, придётся операцию делать!" Я верил до... 20 лет. Потом, когда подумал, сказал: «Мама, так ты меня всю жизнь обманывала?» — «Конечно, зато ты у меня никогда тесто не ел».

Напишите, пожалуйста, почему нельзя использовать with.

тэги <pre> и <strong>. Поддержка вставок кода на Хабре несколько хромает, сам накалывался