function A(){
    this.a = {};
}

function B(){}
B.prototype = new A;

var b1= new B();
var b2= new B();
b1.a.x = 1;
b2.a.x = 2;
log(b1.a.x == 1);//false
log(b2.a.x == 2);//true

Хотелось бы понять сокральный смысл, для чего так сделано.

Здравствуйте, dotneter, Вы писали:

D>Хотелось бы понять сокральный смысл, для чего так сделано.

Прототипное программирование.

Здравствуйте, anonymous, Вы писали:

Вы уверены что там описано почему в javascript поля объекты и поля примитивных типов видут себя по разному?

Здравствуйте, dotneter, Вы писали:

D>Вы уверены что там описано почему в javascript поля объекты и поля примитивных типов видут себя по разному?

Там описано, почему

b1.a == b2.a; // true

со всеми вытекающими последствиями.

Здравствуйте, anonymous, Вы писали:

Меня смутило что если тип поля а заменить на int.

function A(){
    this.a = 0;
}

function B(){}
B.prototype = new A;

var b1= new B();
var b2= new B();
b1.a = 1;
b2.a = 2;
log(b1.a == 1);//true
log(b2.a == 2);//true

То все работает как и предполагалось. Но в общем у меня в голове таки родилось более менее
логичное объяснение.

Здравствуйте, dotneter, Вы писали:

D>Здравствуйте, anonymous, Вы писали:

D>Меня смутило что если тип поля а заменить на int.

D>

D>function A(){
D>    this.a = 0;
D>}

D>function B(){}
D>B.prototype = new A;

D>var b1= new B();
D>var b2= new B();
D>b1.a = 1;
D>b2.a = 2;
D>log(b1.a == 1);//true
D>log(b2.a == 2);//true

D>

D>То все работает как и предполагалось. Но в общем у меня в голове таки родилось более менее
D>логичное объяснение.
Дело вовсе не в примитивности целого типа. Вот так тот же результат:

function A(){
    this.a = {};
}

function B(){}
B.prototype = new A;

var b1= new B();
var b2= new B();
b1.a.x = 1;
b2.a = {};
b2.a.x = 2;
log(b1.a.x == 1);//true
log(b2.a.x == 2);//true

Т.е. в последнем вашем примере вы просто оверайдите в наследниках родительский филд.

Здравствуйте, dotneter, Вы писали:

D>

D>function A(){
D>    this.a = {};
D>}

D>function B(){}
D>B.prototype = new A;

D>var b1= new B();
D>var b2= new B();
D>b1.a.x = 1;
D>b2.a.x = 2;
D>log(b1.a.x == 1);//false
D>log(b2.a.x == 2);//true

D>

D>Хотелось бы понять сокральный смысл, для чего так сделано.

Попробую объяснить, возможно сам ошибаюсь.

В вашем примере вы не используете наследование. Вы просто говорите, что у объектов B, прототипом является объект A.
Дальше вы создаете два объекта типа B.
Дальше происходит чтение свойства "a" в объектах b1, b2, т.к. у них общий протип, то вы получаете в обоих случаях одинаковый объект.
Дальше вы пишите в подсвойство "x" общего объекта "a" для обоих объектов b1, b2.
Поэтому x сначала становится равным 1, потом 2.

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

function A(){
    this.a = {};
}

function B(){
    A.prototype.constructor.call(this);
}
B.prototype = new A;
B.prototype.constructor = B;

var b1= new B();
var b2= new B();
b1.a.x = 1;
b2.a.x = 2;
alert((b1.a.x == 1));//true
alert((b2.a.x == 2));//true

Здесь, при создании B, создается и объект базового класса, т.е. A
Свойство "a" — становится уникальным и свойством объектов b1, b2. Соотвественно и запись в x у них не перезатирает друг друга.

Возможны опечатки. Синтаксис наследования вспомнил по памяти, но идея в этом.