Question

有人可以解释一下这里发生了什么吗？感谢。

var o = {a:1};
var p = o;
o === p; // true;
o = Object.create(o);
p === o; // false
o.b = 2;
o.a; // 1
b.a; // 1
o.b; // 2
p.b; // undefined

发生了什么事？特别是在L4。我将当前范围中的o分配给赋值的RHS的值，其中o仍然指向在L1上创建的原始对象。那么Object.create是否锁定到对象本身，与变量完全无关？

Answer 1

var o = {a:1};
var p = o;

到目前为止，您有1个对象和2个指向它的变量。

o = Object.create(o);

此行将变量o重新分配给由o原型化的新（空）对象。

上一个对象（目前是o的原型）仍由p引用。

字段读取如下：

o.a; // 1 - found in o's prototype (p)
b.a; // 1 - you probably meant p.a? found in p directly
o.b; // 2 - found in o directly
p.b; // not found in p or anywhere in p's prototype chain

Answer 2

// create a new object and assign it to o
var o = {a:1};

// assign the value of o to the variable p
var p = o;

// o equals p because both variables refer to the same object
o === p; // true;

// create a new object which uses the existing object o as prototype
// overwriting the current value of o with the new object
// It's essentially the same as
// var tmp = {};
// tmp.__proto__ = o;
// o = tmp
o = Object.create(o);

// o and p refer to two different objects now
p === o; // false

// A new property is added to the object o
o.b = 2;

// inherited from the object that o originally referred to
o.a; // 1

// b is not defined anywhere (you probably meant p)
// p still refers to the object created in the first step
b.a; // 1

// the property b was assigned to the new object through o.b = 2
o.b; // 2

// the original object doesn't have a property b
p.b; // undefined

Answer 3

这是一个显示DeepCopy和ShallowCopy

之间差异的示例

Object是引用类型。意味着当我创建对象x时，x只指向对象实际存在的内存（如0x0003f3）

默认情况下，引用的类型对象赋值（例如Object x = a）是浅的这意味着我有2个引用的类型对象，如o和p 当我执行赋值p == 0：两个值都引用同一个对象！ assingment只复制内存偏移而不是真实对象

表示您对“p”所做的每项更改都会反映为“o”。 o == p为True，因为两者都保持相同的指针。

在第4行：o指向另一个对象，其余只显示对“o”的更改不会反映为“p”，因为它们不再指向内存中的同一对象

Answer 4

我可以想象有人在重新分配时为什么p不会随o变化而感到困惑。

你将p分配给o并且你认为p是对o的引用，因为mutating o会改变p但重新分配o不会重新分配p（所以不能通过引用？）。

var o = {one:1};
p = o;
o.one="uno";//mutating o
o = {two:2};//re assigning o
console.log(p);//Object { one="uno"}

我认为这是因为JS分配并传递了引用的值。有些人通过引用告诉你在JS中是不可能的，JS总是按值传递。如果这是真的，那么你将无法改变传递/赋值。我认为Python的行为方式相同。

这些变量引用如何工作？

4 个答案: