JS的引用类型和对象拷贝

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

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

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

var obj1 = {a:1, b:2};
var obj2 = {a:1, b:2};
console.log(obj1 == obj2);//false，obj1与obj2指向的是两个不同的堆内存
console.log(obj1 = obj2);//Object {a: 1, b: 2}，将obj2指向的堆内存赋值给了obj1
console.log(obj1 == obj2);//true，obj2与obj1指向的堆内存是相同的

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) //1，aa的内存中的值并没有改变，改变的只是a的内存中的值
console.log(bb) //2，bb的内存中的值并没有改变，改变的只是b的内存中的值
console.log(cc)//Object {name: 'hello', age: 3}，
/*c与cc指向的都是同一个堆内存，即为同一个对象，当这个地址中的内容有所变动时，
所有指向这个堆内存的对象都会变动*/
console.log(dd)//[1,2,Object], Object{age: 3, name: 'hello'}
/*数组也是引用类型，当执行var d = [a,b,c]时，已经开辟了一个新的堆内存，并将a，b的值和c指向的
堆内存复制进去，外面的a，b发生改变时，对d新开辟空间里的a，b不会造成影响，由于c指向的堆内存与d中
的c指向的堆内存相同，所以在对c进行操作是数组d的值也会改变。*/

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) 
/*单独拿出c.age，相当于是var n=c.age，是数值的传递，当操作n时并不会对c.age造成影响*/

console.log(a) //1，
/*f1函数中，n相当于var n=a，是数值的传递，当操作n时并不会对a造成影响*/
console.log(c)//Object{name:'jirengu', age:3}
/*f2函数中，相当于var obj=c，是地址的传递，操作的对象是同一块堆内存，所以在操作完后会改变c对象里的值*/

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 -=i;
    }
  }
}
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 in arr){
    newArr[i] = arr[i];
  }
  for(var i = 0; i < newArr.length; i++){
    if(newArr[i] <= 0){
      newArr.splice(i,1);
      i -=i;
    }
  }
  return newArr;
}
var arr2 = filter(arr)
console.log(arr2) // [3,1,2]
console.log(arr)  // [3,1,0,-1,-3,2,-5]

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

方法一：

function deepCopy1(obj){
  var newObj = {}
  
    for(var i in obj){
      if(obj.hasOwnProperty(i)){
        if(typeof obj[i] == 'number'||typeof obj[i] == 'boolean'||
           typeof obj[i] == 'string'||obj[i] == undefined||obj[i] == null){
        newObj[i] = obj[i];
        }else{
        newObj[i] = deepCopy1(obj[i]);
        }
      }
      
    }
  
return newObj;
}
var obj1={
  phone:undefined,
  work:null,
  name: 'oyrc',
  family: {
    b: 'ss',
    g: 'bb'
  }
}
var obj2=deepCopy1(obj1);
console.log(obj2)//Object {phone: undefined, work: null, name: "oyrc", family: {b: 'ss',g: 'bb'}}

方法二：

var obj1={
  phone:undefined,
  work:null,
  name: 'oyrc',
  family: {
    b: 'ss',
    g: 'bb'
  }
}
function deepCopy2(obj){
  var oldObj=JSON.stringify(obj);
  var newObj=JSON.parse(oldObj);
  return newObj;
}

var obj3=deepCopy2(obj1);
console.log(obj3)//Object {work: null, name: "oyrc", family: {b: 'ss',g: 'bb'}}

使用JSON时，当对象中有undefined时，该值不会拷贝到新对象中。