Javascript原型继承中的数组和数字数据类型之间有区别吗？

我是javascript原型继承的书呆子。我能理解下面代码中发生的事情

function Hamster() {  }
Hamster.prototype = {
  food: [],
  found: function(something) {
    this.food.push(something)
  }
}

// Create two speedy and lazy hamsters, then feed the first one
speedy = new Hamster()
lazy = new Hamster()

speedy.found("apple")
speedy.found("orange")

alert(speedy.food.length) // 2

下面的一行也是警报

2

b'z，因为这两个对象正在共享

仓鼠的原型中的
食物
数组

alert(lazy.food.length) // 2

但如果我将数组的数据类型更改为number，
food
key在两个实例之间不共享

function Hamster() {  }
Hamster.prototype = {
  food: 0,
  found: function(something) {
    this.food = something
  }
}

// Create two speedy and lazy hamsters, then feed the first one
speedy = new Hamster()
lazy = new Hamster()

speedy.found(123)


alert(speedy.food) // 123

但是下面的行提醒
0
，您能告诉我为什么这不提醒
123

alert(lazy.food) // 0

在JavaScript中，属性查找遵循原型链，但不遵循属性分配

所以，当你说

this.food = something;

食物
属性是在对象上创建的。因此，它覆盖了
原型
中的
食品
。但是，当您访问
lazy
时，由于它是属性查找，因此首先搜索当前对象，然后搜索原型，在原型中定义它并将其赋值为0。这就是它警告0的原因。
在JavaScript中，属性查找遵循原型链，但不遵循属性分配

所以，当你说

this.food = something;

食物
属性是在对象上创建的。因此，它覆盖了
原型
中的
食品
。但是，当您访问
lazy
时，由于它是属性查找，因此首先搜索当前对象，然后搜索原型，在原型中定义它并将其赋值为0。这就是它向0发出警报的原因。
每个
仓鼠的
实例都有自己的
食物
属性。但在第一个版本中，它们都指向同一个数组，您正在使用
push
就地修改该数组。在第二个版本中，它们指向整数，不能就地修改；
found
函数重新分配该实例的属性，这对其他实例没有影响

要为每个实例提供自己的
food
array属性，需要使用一个构造函数来分配它

您可以在下面看到类似的行为，它只使用普通变量，而不是对象和继承

arr1 = [];
arr2 = arr1;
arr1.push(1);
console.log(arr2); // prints [1]

int1 = 0;
int2 = int1;
int1 = 1;
console.log(int2); // prints 0

赋值运算符“=”将从变量中删除指针

arr1 = [];
arr2 = arr1;
arr2 = ['Appple'];
console.log(arr1); // prints []

每个
仓鼠
实例都有自己的
食物
属性。但在第一个版本中，它们都指向同一个数组，您正在使用
push
就地修改该数组。在第二个版本中，它们指向整数，不能就地修改；
found
函数重新分配该实例的属性，这对其他实例没有影响

要为每个实例提供自己的
food
array属性，需要使用一个构造函数来分配它

您可以在下面看到类似的行为，它只使用普通变量，而不是对象和继承

arr1 = [];
arr2 = arr1;
arr1.push(1);
console.log(arr2); // prints [1]

int1 = 0;
int2 = int1;
int1 = 1;
console.log(int2); // prints 0

赋值运算符“=”将从变量中删除指针

arr1 = [];
arr2 = arr1;
arr2 = ['Appple'];
console.log(arr1); // prints []

需要理解的是，在第一种情况下，两个对象对食物仍然有自己的价值；只是在每种情况下，它们的值都是对内存中同一对象的引用，因此将项推入该属性引用的数组会更改相同的数组

@Barmar的答案（我投了更高的票）已经说明了所有这些，但这里有另一个例子可以帮助证明这一点：

function Hamster() {}

Hamster.prototype = {
    food: [],
    found: function(something) {
        this.food = something;
    }
}

// Create two speedy and lazy hamsters, then feed the first one
speedy = new Hamster()
lazy = new Hamster()

speedy.found(["apple"])
speedy.found(["orange"])

alert(speedy.food) // orange
alert(lazy.food) // <empty>

函数仓鼠（）{}
仓鼠。原型={
食物：[]，
发现：功能（某物）{
食物=某物；
}
}
//创建两个快速和懒惰的仓鼠，然后喂养第一个
斯皮蒂=新仓鼠（）
懒惰=新仓鼠（）
speedy.found（[“apple”]）
speedy.found（[“橙色”]）
警惕（快速。食物）//橙色
警惕（懒惰。食物）//

在本例中，每个
food
属性都会获得对不同数组的引用，因此很明显，每个属性都是独立的

要带走的关键是：

保存对象的变量的值是对该对象的引用。包含一个原语（如数字）的变量的值就是原语本身的值。
要理解的是，在第一种情况下，两个对象对食物仍然有自己的值；只是在每种情况下，它们的值都是对内存中同一对象的引用，因此将项推入该属性引用的数组会更改相同的数组

@Barmar的答案（我投了更高的票）已经说明了所有这些，但这里有另一个例子可以帮助证明这一点：

function Hamster() {}

Hamster.prototype = {
    food: [],
    found: function(something) {
        this.food = something;
    }
}

// Create two speedy and lazy hamsters, then feed the first one
speedy = new Hamster()
lazy = new Hamster()

speedy.found(["apple"])
speedy.found(["orange"])

alert(speedy.food) // orange
alert(lazy.food) // <empty>

函数仓鼠（）{}
仓鼠。原型={
食物：[]，
发现：功能（某物）{
食物=某物；
}
}
//创建两个快速和懒惰的仓鼠，然后喂养第一个
斯皮蒂=新仓鼠（）
懒惰=新仓鼠（）
speedy.found（[“apple”]）
speedy.found（[“橙色”]）
警惕（快速。食物）//橙色
警惕（懒惰。食物）//

在本例中，每个
food
属性都会获得对不同数组的引用，因此很明显，每个属性都是独立的

要带走的关键是：

保存对象的变量的值是对该对象的引用。包含基元（如数字）的变量的值是基元本身的值。
但在第二个版本中它没有共享，这是他的问题。但在第二个版本中它没有共享，这是他的问题。我刚刚修改了
found
函数
found:function（something）{this.food+=某物}
我没有重新分配它，而是得到了
0
对于
lazy
的实例，这没有什么区别，
this.food+=
只是
this.food=this.food+
的简写。数字不能就地修改，它们不是数组和对象之类的复合对象。需要理解的是，在第一种情况下，两个对象对于
食物仍然有自己的值；只是它们在每种情况下的值都是对内存中相同对象的引用。对，@Vimalraj.s，因为每个对象都有自己的值<