关于引用对象拷贝

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

引用类型有：对象、数组、函数、正则
非引用类型有：数字、字符串、boolean、undefined、null

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

var obj1 = {a:1, b:2};
var obj2 = {a:1, b:2};
console.log(obj1 == obj2); //false
console.log(obj1 = obj2);
console.log(obj1 == obj2); //true

因为obj1和obj2是对象，属于引用类型。
所以变量obj1和obj2只是储存着内存的地址指针。

第一次比较的时候obj1和obj2的指向不同的地址，输出false

然后 obj2的地址指针赋值给了obj1，覆盖了obj1原本的地址指针

第二次比较时，obj1和obj2的地址指针已经一样了，所以输出true

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

var a = 1
var b = 2
var c = { name: '饥人谷', age: 2 }
var d = [a, b, c]

var aa = a
var bb = b
var cc = c
var dd = d

a = 11
b = 22
c.name = 'hello'
d[2]['age'] = 3

console.log(aa) 
console.log(bb) 
console.log(cc)
console.log(dd)

执行后：

a = 11
b = 22
c = { name: 'hello', age: 3 }
d = [1, 2, c]

aa = 1
bb = 2
cc = c
dd = d

console.log(aa) //输出 1   非引用类型直接赋值
console.log(bb) //输出 2   非引用类型直接赋值
console.log(cc) //输出 { name: 'hello', age: 3 }  引用类型赋值指向相同位置
console.log(dd) //输出 [1, 2, { name: 'hello', age: 3 } ]   引用类型赋值指向相同位置

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

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)

f1(a)相当于
function f1(n){
  var n = a;
  ++n;
}
因为 非引用类型 a = 1，所以 n = 2

f2(c)相当于
function f2(obj){
  var obj = c; //赋值的内容是c的指针地址
  ++obj.age //等于++c.age
}
此时 c = { name: 'jirengu', age: 3 }

f1(c.age)
funciton f1(n){
  var n = c.age; //c.age是非引用类型，n = 3
  ++n;  //n = 3
}
console.log(a) // 1 
console.log(c) // { name: 'jirengu', age: 3 }
 

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

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

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

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

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

方法1：

function deepCopyFn(obj){
  var newObj = {};
  for(var key in obj){
    if(obj.hasOwnProperty(key)){
      if(typeof obj[key] === "string" || typeof obj[key] === "number" ||
      typeof obj[key] === "boolean" || typeof obj[key] === undefined || typeof obj[key] === null ){
        newObj[key] = obj[key];
      } else {
        newObj[key] = deepCopyFn(obj[key]);
      }
   }
  }
  return newObj;
}

//通过递归的方式取到所有基本类型的值和所有引用类型中每一个基本类型的值，
//再逐一赋值给一个新的空对象，实现深拷贝

方法2：

function deepCopyFn2(obj){
  var newObj = {};
  var objString = JSON.stringify(obj);
  var newObj = JSON.parse(objString);
  return newObj;
}
//把对象的所有值转为字符串，
//再把字符串转为对象赋值给一个新的空对象，实现深拷贝
//缺点：用JSON.stringify方法来在将对象转字符串时会省略值为undefined的键