關於引用物件拷貝

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的鍵