有人可以解释这两种情况之间的区别吗?也就是说,为什么b没有在第一次重新定义,但它在第二次重新定义?
a = [0,1,2,3,4]
b = a //b = [0,1,2,3,4]
a = 4
console.log(b) //b is still [0,1,2,3,4]
//redefining a AFTER saying b = a will NOT change b
/
a = [0,1,2,3,4]
b = a //b = [0,1,2,3,4]
for ( i = 0; i < a.length; i++){
a[a.length - (i + 1)] = b[i]
} //I though this loop would redefine a as b in reverse. But this happens:
console.log(a) //both a and b have changed to [0,1,2,1,0]
console.log(b) //I don't understand why b changed at all, since a is being redefined
//AFTER I saved b as [0,1,2,3,4] and the = sign is supposed to just
//assign the value on the right to the value on the left
答案 0 :(得分:3)
在第一种情况下,您已将单个数组的引用存储为两个变量 - a
和b
。然后,您更改了a
,删除了引用,现在包含4
。在此之后,您只有变量b
引用数组,您只能通过b
更改该数组的项目。
在第二种情况下,您再次对变量a
和b
中的单个数组进行了两次引用。但是当你做一些工作并改变一个项a[a.length - (i + 1)] = b[i]
时,这个语句就会通过引用并更改单个数组对象中的一个项,因为b
也指同一个数组,相同的变化是通过变量b
可见。
因此,此语句a[a.length - (i + 1)] = b[i]
获取b[i]
处的项目,并将其分配给a[a.length - (i + 1)]
,但这也与语句b[b.length - (i + 1)]
相同。
简明扼要地,您在a
和b
中有相同的引用,如果您通过a
更改数组,则b
也会更改,因为它们指的是相同的数组。
如果要更改第一个阵列而不影响第二个阵列,则需要创建两个单独的阵列。您可以通过slice
函数或数组扩展运算符([...a]
)或只需调用a.reverse
来返回反向数组。
const a = [0,1,2,3,4];
const b = a.slice(); // splice returns a new array
for(let i = b.length - 1; i >= 0; i--) {
a[a.length - i - 1] = b[i];
}
console.log(a);
console.log(b);
或者只是致电reverse
功能
let a = [0,1,2,3,4];
let b = [...a];
a.reverse();
console.log(a);
console.log(b);
答案 1 :(得分:1)
像这样理解
案例1
a = [0,1,2,3,4]
这相当于
Ref#1 = [0,1,2,3,4]
a = Ref#1
执行b = a
时,相当于
b = Ref#1
和a = 4
相当于
Ref#2 = 4
a = ValOfRef#2
现在b仍然保留Ref#1
,这就是为什么它仍然是[0,1,2,3,4]
。请注意,在您的情况下,Number
类型的基本数据类型为value
类型,Objects/Arrays
为引用类型。
案例2
在这种情况下,您正在循环Ref#1
并同时修改它,因为a
和b
都Ref#1
,这就是您出乎意料的原因结果。为了获得预期的结果,您必须打破a
和b
的引用。在您的情况下,最简单的方法是使用JSON.parse(JSON.strigify())
。见下文
a = [0, 1, 2, 3, 4]
b = JSON.parse(JSON.stringify(a));
for (i = 0; i < a.length; i++) {
a[a.length - (i + 1)] = b[i];
}
console.log(a);
console.log(b);
&#13;