引用类型对象拷贝

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，把obj2中的内容赋值给了obj1
console.log(obj1 == obj2);    //true，两者指向的是同一个内存

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

var a = 1  
var b = 2  
var c = { name: 'lala', 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    a值改变对aa没有影响
console.log(bb)    //2    b值改变对bb没有影响
console.log(cc)    //{ name: 'hello', age: 3}    c把堆地址赋值给了cc，指向的是同一个栈地址，c栈地址信息变更，随之cc也变更；d同理
console.log(dd)   // [1, 2, Object] 

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

var a = 1    //--1--
var c = { name: 'lala', age: 2 }    

function f1(n){
  //var n = a =1
  ++n  // n=2
}
function f2(obj){
  //var obj = c
  ++obj.age
}

f1(a)    
f2(c) 
f1(c.age) 
console.log(a)    //1，a是原始类型，改变n的值对a没有影响     
console.log(c)    //3，f2(c)改变了c的age为3，而f1(c.age) 只是传入了一个值并没有改变它

5.过滤如下数组，只保留正数，直接在原数组上操作(array.splice(start, deleteCount)

var arr = [3,1,0,-1,-3,2,-5]
function filter(arr){
      for(var i=0; i

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

var arr = [3,1,0,-1,-3,2,-5]
function filter(arr){
     var result = []    //声明一个新数组
     for(var i=0;i0){    
                   result.push(arr[i])    //把数组中大于0的正数都放到新数组result中
            } 
     }
     return result
}
var arr2 = filter(arr)
console.log(arr2) // [3,1,2]
console.log(arr)  // [3,1,0,-1,-2,2,-5]

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

浅复制：浅复制是复制引用，复制后的引用都是指向同一个对象的实例，彼此之间的操作会互相影响。

var clone = { name:"clone" }     //复制一份src对象的应用
var clone1 = clone;
clone1.name = "clone1"; 
console.log(clone.name);     //输出clone1。两个使用的是同一个地址，其中一个改变，影响两个

深复制：深复制不是简单的复制引用，而是在堆中重新分配内存，并且把源对象实例的所有属性都进行新建复制，以保证深复制的对象的引用图不包含任何原有对象或对象图上的任何对象，复制后的对象与原来的对象是完全隔离的

//方法一
function deepCopy(oldObj) {
    var newObj = {};
    for(var key in oldObj) {
        if(typeof oldObj[key] === 'object' && oldObj[key] !== null ) {
            newObj[key] = deepCopy(oldObj[key]);
        }else{
            newObj[key] = oldObj[key];
        }
    }
    return newObj;
}

//方法二
//优点：简单方便，大多数时候可以满足需求
//缺点：1.无法复制函数 2.原型链没了，对象就是object，所属的类没了。
function deepCopy2(oldObj) {
    var newObj = {}
    newObj = JSON.parse( JSON.stringify(oldObj) )
    return newObj
}