进阶4 引用类型对象拷贝

1. 引用类型有哪些？非引用类型有哪些？

引用类型值（对象、数组、函数、正则）：指的是那些保存在堆内存中的对象，变量中保存的实际上只是一个指针，这个指针执行内存中的另一个位置，由该位置保存对象；
基本类型值（number、boolean、string、null和undefined）：指的是保存在栈内存中的简单数据段。

2. 如下代码输出什么？为什么

2.代码输出什么？.png

输出结果：
false //obj1和obj2 指向不同的内存地址
{a:1,b:2} //将obj2赋值给obj1
true //执行上面的赋值语句后，obj1和obj2的指针或路径指向同样一个堆内存空间.

3. 如下代码输出什么? 为什么

3.代码输出什么？.png

输出结果：
1 //a和aa都是数值，为非引用类型，a数值的变化对aa无影响，传值传递 aa=1
2 //b和bb都是数值，为非引用类型，b数值的变化对bb无影响，传值传递 bb=1
{name: "hello", age: 3}
 //c是对象，即引用类型值。将c指向对象的指针赋给cc，c和cc指向的其实是同一个对象，
   对c的修改就是对其指向的对象的修改，因此cc会保持一致的变化
[1, 2, {name: "hello", age: 3}]
 // d[0]和d[1]是将a和b的数值拷贝过来，
    d[2]和c指向的也是同一个对象，d[2]中存储的只是指向对象的指针

4. 如下代码输出什么? 为什么

4.代码输出什么？.png

var a = 1
var c = { name: 'jirengu', age: 2 }

function f1(n){
  ++n
}
function f2(obj){
  ++obj.age
}

f1(a)  //相当于把a的值赋给n，即n==1，function f1(n) {++n}后，n===2,a===1
f2(c) //object { name: 'jirengu', age: 3 }
f1(c.age) //var n = c.age, n = 3，执行function f1(n) {++n}后，n===4,c.age===3

console.log(a) 
console.log(c)
输出结果：
1 //a是基本类型值，++n不会影响a的值
{name: "jirengu", age: 3} //c为引用类型，共用同一内存地址，所以++obj.age使得age：3

5. 过滤如下数组，只保留正数，直接在原数组上操作

var arr = [3,1,0,-1,-3,2,-5]
function filter(arr){
    var j=0;
    for(var i=0;i0){
            arr[j]=arr[i];
            j++;
        }
    }
    arr.length=j;
}
filter(arr)
console.log(arr) // [3,1,2]

6. 过滤如下数组，只保留正数，原数组不变，生成新数组

var arr = [3,1,0,-1,-3,2,-5]
function filter(arr){
    var newArr=[];
    var j=0;
    for(var i=0;i0){
            newArr[j]=arr[i];
            j++;
        }
    }
    return newArr;
}
var arr2 = filter(arr)
console.log(arr2) // [3,1,2]
console.log(arr)  // [3,1,0,-1,-2,2,-5]

7. 写一个深拷贝函数，用两种方式实现

• 递归法

var obj1= {
  name: '小明',
  age:9,
  hobby: ['唱歌','篮球','读书']
}
function deepCopy(obj) {
  var newObj = {}; //开辟新空间
  for( var key in obj) {
  //判断有个对象是否有属性或对象
      if (obj.hasOwnProperty(key)) {
          if (typeof obj[key] === 'number' || 
              typeof obj[key] === 'string' || 
              typeof obj[key] === 'boolean'||
              obj[key] === undefined || obj[key] === null) {
              newObj[key] = obj[key];
          }else {
              newObj[key] = deepCopy(obj[key]);
             //若对象中有嵌套，再递归嵌套对象的属性
          }
      }
  }
  return newObj;
}
var obj2 = deepCopy(obj1);
console.log(obj2);

• JSON法

//利用json.stringify()将对象转换为字符串，然后再利用json.parse()将字符串转换为对象
function deepCopy1(obj) {
    return newObj = JSON.parse(JSON.stringify(obj));
}