基本类型、引用类型
- 基本类型（字符串、数值、布尔值、null 和 undefined）：指的是保存在栈内存中的简单数据段
- 引用类型（对象、数组、函数、正则）：指的是那些保存在堆内存中的对象，变量中保存的实际上只是一个指针，这个指针执行内存中的另一个位置，由该位置保存对象
练习一
var obj1 = {a:1, b:2};
var obj2 = {a:1, b:2};
console.log(obj1 == obj2);
console.log(obj1 = obj2);
console.log(obj1 == obj2);
// -----------------------//
/*
得到的结果为
// false
// {a: 1, b: 2}
// true
分析如下：
声明了两个对象，属性和属性值皆相同，但 obj1 和 obj2 是两个不同的对象
var obj1 = {a: 1, b: 2} // 假设内存地址为 0x0000
var obj2 = {a: 1, b: 2} // 假设内存地址为 0x0088
console.log(obj1 == obj2) // 二者指向的不是同一个对象（地址），为 false
console.log(obj1 = obj2) // 赋值操作，使得 obj1 指针指向的地址变为 0x0088
console.log(obj1 == obj2) // 二者指向同一个对象（地址），为 true
*/
练习二
var a = 1
var b = 2
var c = {name: '饥人谷', age: 2}
var d = [a, b, c]
var aa = a // 1
var bb = b // 2
var cc = c // {name: '饥人谷', age: 2}
var dd = d // [1, 2, {name: '饥人谷', age: 2}]
a = 11
b = 22
c.name = 'hello'
d[2]['age'] = 3
console.log(aa)
console.log(bb)
console.log(cc)
console.log(dd)
//--------------//
/*
结果如下
// 1
// 2
// {name: 'hello', age: 3}
// [1, 2, {name: 'hello', age: 3}]
分析如下：
a、b 都为基本类型中的number，对 aa、bb 赋值之后，aa、bb 也为基本类型的 number，无论对 a、b 如何修改，都不会影响 aa、bb 的值，
而对象 c 是引用类型，标识符 c 的指针指向 {name: '饥人谷', age: 2} 在内存中所在的地址，对 cc 赋值操作，cc 也指向同一个地址，对 c 进行修改，实际上是对 {name: '饥人谷', age: 2} 进行修改，凡是引用了这一对象的标识符都会受其影响，所以 cc、dd 中的 name 和 age 分别变为 'hello' 和 3
*/
练习三
var a = 1
var c = {name: 'jirengu', age: 2}
function f1(n){
++n // 前增量
}
function f2(obj){
++obj.age
}
f1(a)
f2(c)
f1(c.age)
console.log(a)
console.log(c)
//----------------//
/*
结果如下：
// 1
// {name: 'jirengu', age: 3}
分析如下：
a 为基本类型的number，
执行 f1(a) 不会影响全局作用域下的 a，所以 a 仍然为 1
c 为引用类型的对象，
执行 f2(c) 时，c 作为参数传递进入 f2，实则 f2 的参数 obj = c，obj 指向对象 {name: 'jirengu', age: 2}，f2 内部对 obj.age自增1，会影响到所引用的对象，对象变为 {name: 'jiregu', age: 3}
执行 f1(c.age) 时，f1 内部的 n 实际上获得了 age 的属性值 2，之后同第一步，n 自增1，但 age 的属性值不受影响，仍为 3
*/
练习四 过滤数组，在原数组上操作
var arr = [3, 1, 0, -1, -3, 2, -5]
function filter(arr){
for(let i = 0; i < arr.length; i++){
if(arr[i]<0 || arr[i] == 0){
arr.splice(i, i); // 若不是正数，删除
i--; // 抵消 i++ 的自增1 效果，下一轮循环仍从该位开始
}
}
return arr;
}
filter(arr)
console.log(arr) // [3, 1, 2]
练习五 过滤数组，不在原数组上操作
var arr = [3, 1, 0, -1, -3, 2, -5]
function filter(arr){
if(Array.prototype.filter){
return Array.prototype.filter.call(arr, function(x){
return x > 0;
});
} else {
var result = [];
for (let i = 0; i < arr.length; i++) {
if (arr[i] > 0) {
result.push(arr[i])
}
}
return result;
}
}
var arr2 = filter(arr)
console.log(arr2) // [3, 1, 2]
console.log(arr) // [3, 1, 0, -1, -3, 2, -5]
对象拷贝
// 浅拷贝
function shallowCopy(oldObj) {
var newObj = {};
for (var i in oldObj) {
if (oldObj.hasOwnProperty(i)) {
newObj[i] = oldObj[i];
}
}
return newObj;
}
var x = {
a: 1,
b: {f: {g: 1}},
c: [1, 2, 3]
};
var y = shallowCopy(x);
console.log(y.b.f === x.b.f); // true
// Object.assign() 可以把任意多个的元对象自身的可枚举属性拷贝给目标对象
var x = {
a: 1,
b: { f: { g: 1 } },
c: [1, 2, 3]
};
var y = Object.assign({}, x);
console.log(y.b.f === x.b.f); // true
// 深拷贝
function deepcCopy(oldObj) {
var newObj = {};
for (var key in oldObj) {
if(oldObj.hasOwnProperty(key)) {
if (typeof oldObj[key] === 'number' || typeof oldObj[key] === 'boolean' || typeof oldObj[key] === 'string' || oldObj[key] === undefined || oldObj[key] === null) {
newObj[key] = oldObj[key];
} else {
newObj[key] = deepCopy(oldObj[key]); // 递归调用，层层遍历拷贝
}
}
}
return newObj;
}
// JSON.parse、JSON.stringify实现深拷贝
var source = { name: "source", child: { name: "child" } };
var target = JSON.parse(JSON.stringify(source));
target.name = "target"; // 改变 target 的 name 属性值
console.log(source.name); // source
console.log(target.name); // target
target.child.name = "target child"; // 改变 target 的 child
console.log(source.child.name); // child
console.log(target.child.name); // target child
记住，深拷贝的目的在于，拷贝完成时，就“切断”引用
