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<arr.length; i++){
              if(arr[i]<=0){
                    arr.splice(i,1)   //i=2，此時數組是第2個對象“0”被刪除
                    i -= 1    //i-- 同理，由于0已經被刪掉，還是得從第2個對象開始遍歷，要不就漏掉-1了，所以需要-1
              }
      }
}
filter(arr)
console.log(arr) // [3,1,2]

6.過濾如下數組，只保留正數，原數組不變，生成新數組

var arr = [3,1,0,-1,-3,2,-5]
function filter(arr){
     var result = []    //聲明一個新數組
     for(var i=0;i<arr.length;i++){
            if(arr[i]>0){    
                   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
}