возьми свой пример и в конце кода напиши:

alert( q.__private ); // увидишь 'text'

а нужно видеть undefined

deleted

Это большой недостаток прототипного наследования, который не создает новый экземпляр а юзает старый, просто с иным контекстом... Конечно это облегчает язык в целом, как в обучении так и построении быстрых решений. Так же как отметили выше не жрет память, но с таким подходом сложно писать что-то реально крупное и полноценное. Я не говорю что JavaScript плох, мне он конечно не особо привычен, но жить можно. Я привык к ООП и там все предсказуемо, но тут увы не предскажешь чей ты контекст получишь.
что бы другой прогер их не задел или не перекрыл. Или я сам же, забыв о том что где-то что-то подобное объявил.

ну когда я вызываю я вкурсе какой я передаю контекст, но я не буду в курсе когда вызывать буду не я... то-есть я пишу библу а юзает кто-то другой.. тут уж я не всевидящий что бы узнать что передает тот кто вызывал функцию/метод тот что я писал. В этом плане в ООП я точно могу указать каков объект(ы) я кочу видеть в качестве экземпляра.
Ну я рад за тех кто это ввел себе в голову общепринятым.. но опять же повторюсь... есть один прогер, написал некий класс, создал в ней приватную переменную __blah. Все хорошо все гуд, но тут я беру его библу и юзаю его классы, потом расширяю его классы своими, и тоже создаю переменную с таким же именем __blah, что в результате произойдет перекрытие его переменной и вызовет конфликт.

вот пример:
кто-то написал библу.. допустим ты написал библиотеку, очень удобную и т.д. вот типо часть ее кода:

function YouMethod() {
    this.__private = [];
    this.blah = function() {
        this.__private.join( "\n" );
    }
}

В итоге я беру твою либу, допустим минифицированую, понятно дело что в коде я без пива не пойму. Ну тоесть код то сжат. Ну подумаю все чики и начну дописывать свое к ней:

function YouMethod(){this.__private = [];this.blah=function(){this.__private.join( "\n" );}}

function MyMethod() {
    this.__private = {}; // я решил назвать так приватную, но не знал что у теб она тоже так называется. И имеет другой тип.
    this.tata = function(){}
}
MyMethod.prototype = new YouMethod();
var lala = new MyMethod();
lala.blah(); // вызовет ошибку

В итоге происходит конфликт, твоя функция думает что там в качестве приватной лежит массив, но так как я назвал свою переменную тоже так же как и ты, то теперь эта переменная имеет тип объекта и твоя функция вызовет ошибку обратившись к приватной переменной. Это и называется перекрытие, конфликт.

запили книжку на юкозе, попутно запилив красивый responsive дизайн с нуля.

Maxmaxmахimus,
что то ты многовато написал, какой то чуши... без обид, но не нужно мне объяснять что такое прототипы, что такое классы а что такое ООП. Поверь я знаю что это такое.. Вся речь лишь началась с того что прототипы в отличии от классов полный порожняк.

И не надо мне рассказывать где тут моя/твоя переменная... ты даже вникнуть не можешь в то, о чем я тебе говорю, и начинаешь потом писать непонятно что. Тебе нужно поучить программирование на классах, то-есть ООП и тогда ты поймешь о чем я говорю и что я имею вииду.

А зная лишь один JavaScript ты никогда не поймешь того в чем различается ООП от того что умеет JS.

Maxmaxmахimus,
ну вот видишь, ты снова меня не понял.. я не кричу о том что в JS это невозможно, речь идет о прототипах а не о языке в целом. Я в курсе что на JS можно хорошо писать при желании. Снова повторюсь, речь идет о прототипах. Тоесть сравнение классового наследования с прототипным наследованием. А не о языках и ООП в целом.

Maxmaxmахimus,
ладно я устал с тобой спорить и пытаться объяснить в чем различие настоящего полноценного ООП от Прототипного Программирования, который лишь пытается сделать вид что он полноценный ООП язык, потому как имеет возможность работать с сущностями объектов и имеет наследование. Но это не говорит о его полноценности, умение наследовать не дает языку понятия ООП. Умение работать с объектами как с сущностями не дает языку понятие ООП. Я не говорю что ООП это классы, ООП это умение делать все то и в полной мере что я описал выше, а основное отличие и важность уметь инкапсулировать. И помимо этого другие вещи. Прототипное программирование это лишь некий подтип объектного программирования. Но не полноценный, о чем я и пытаюсь втолковать.

Все на этом разговор считаю дальше нет смысла продолжать.