js 資料型別

1. 六種 基本資料型別:

• Boolean. 布林值，true 和 false.
• null. 一個表明 null 值的特殊關鍵字。 JavaScript 是大小寫敏感的，因此 null 與 Null、NULL或其他變數完全不同。
• undefined. 變數未定義時的屬性。
• Number. 表示數字，例如： 42 或者 3.14159。
• String. 表示字串，例如："Howdy"
• Symbol ( 在 ECMAScript 6 中新新增的型別).。一種資料型別，它的例項是唯一且不可改變的。

1. 以及 Object 物件引用資料型別

大多數情況下，我們可以通過typeof屬性來判斷。只不過有一些例外，比如:

var fn = new Function ('a', 'b', 'return a + b')

typeof fn // function

基本型別 和 引用資料型別 的相關區別

基本資料型別

我們來看一下 MDN 中對基本資料型別的一些定義：

除 Object 以外的所有型別都是不可變的（值本身無法被改變）。例如，與 C 語言不同，JavaScript 中字串是不可變的（譯註：如，JavaScript 中對字串的操作一定返回了一個新字串，原始字串並沒有被改變）。我們稱這些型別的值為“原始值”。

var a = 'string'
a[0] = 'a'
console.log(a)  // string

我們通常情況下都是對一個變數重新賦值，而不是改變基本資料型別的值。在 js 中是沒有方法是可以改變布林值和數字的。倒是有很多操作字串的方法，但是這些方法都是返回一個新的字串，並沒有改變其原有的資料。比如:

• 獲取一個字串的子串可通過選擇個別字母或者使用 String.substr().
• 兩個字串的連線使用連線操作符 (+) 或者 String.concat().

引用資料型別

引用型別（object）是存放在堆記憶體中的，變數實際上是一個存放在棧記憶體的指標，這個指標指向堆記憶體中的地址。每個空間大小不一樣，要根據情況開進行特定的分配，例如。

var person1 = {name:'jozo'};
var person2 = {name:'xiaom'};
var person3 = {name:'xiaoq'};

引用型別的值是可變的：

person1['name'] = 'muwoo'

console
 
.log(person1) // {name: 'muwoo'}

傳值與傳址

瞭解了基本資料型別與引用型別的區別之後，我們就應該能明白傳值與傳址的區別了。
在我們進行賦值操作的時候，基本資料型別的賦值（=）是在記憶體中新開闢一段棧記憶體，然後再把再將值賦值到新的棧中。例如:

var a = 10;
var b = a;

a ++ ;
console.log(a); // 11
console.log(b); // 10

所以說，基本型別的賦值的兩個變數是兩個獨立相互不影響的變數。

但是引用型別的賦值是傳址。只是改變指標的指向，例如，也就是說引用型別的賦值是物件儲存在棧中的地址的賦值，這樣的話兩個變數就指向同一個物件，因此兩者之間操作互相有影響。例如：

var a = {}; // a儲存了一個空物件的例項
var b = a;  // a和b都指向了這個空物件

a.name = 'jozo';
console.log(a.name); // 'jozo'
console.log(b.name); // 'jozo'

b.age = 22;
console.log(b.age);// 22
console.log(a.age);// 22

console.log(a == b);// true

淺拷貝

先來看一段程式碼的執行：

var obj = {a: 1, b: {c: 2}}
var obj1 = obj
var obj2 = shallowCopy(obj);
functionshallowCopy(src) {
    var dst = {};
     for (var prop in src) {
         if (src.hasOwnProperty(prop)) {
             dst[prop] = src[prop];
          }
      }
     return dst;
}

var obj3 = Object.assign({}, obj)

obj.a = 2
obj.b.c = 3

console.log(obj) // {a: 2, b: {c: 3}}
console.log(obj1) // {a: 2, b: {c: 3}}
console.log(obj2) // {a: 1, b: {c: 3}}
console.log(obj3) // {a: 1, b: {c: 3}}

這段程式碼可以說明賦值得到的物件 obj1 只是將指標改變，其引用的仍然是同一個物件，而淺拷貝得到的的 obj2 則是重新建立了新物件。但是，如果原物件obj中存在另一個物件，則不會對物件做另一次拷貝，而是隻複製其變數物件的地址。這是因為淺拷貝只複製一層物件的屬性，並不包括物件裡面的為引用型別的資料。
對於陣列，更長見的淺拷貝方法便是slice(0)和 concat()
ES6 比較常見的淺拷貝方法便是 Object.assign

深拷貝

通過上面的這些說明，相信你對深拷貝大致瞭解了是怎樣一個東西了：深拷貝是對物件以及物件的所有子物件進行拷貝。那麼如何實現這樣一個深拷貝呢？

1. JSON.parse(JSON.stringify(obj))

對於常規的物件，我們可以通過JSON.stringify來講物件轉成一個字串，然後在用JSON.parse來為其分配另一個儲存地址，這樣可以解決記憶體地址指向同一個的問題：

var obj = {a: {b: 1}}
var copy = JSON.parse(JSON.stringify(obj))

obj.a.b = 2
console.log(obj) // {a: {b: 2}}
console.log(copy) // {a: {b: 1}}

但是 JSON.parse()、JSON.stringify也存在一個問題，JSON.parse()和J SON.stringify()能正確處理的物件只有Number、String、Array等能夠被 json 表示的資料結構，因此函式這種不能被 json 表示的型別將不能被正確處理。

var target = {
    a: 1,
    b: 2,
    hello: function() { 
            console.log("Hello, world!");
    }
};
var copy = JSON.parse(JSON.stringify(target));
console.log(copy);   // {a: 1, b: 2}
console.log(JSON.stringify(target)); // "{"a":1,"b":2}"

2. 遍歷實現屬性複製

既然淺拷貝只能實現非object第一層屬性的複製，那麼遇到object只需要通過遞迴實現淺拷貝其中內部的屬性即可：

functionextend (source) {
  var target
  if (typeof source === 'object') {
    target = Array.isArray(source) ? [] : {}
    for (var key in source) {
      if (source.hasOwnProperty(key)) {
        if (typeof source[key] !== 'object') {
          target[key] = source[key]
        } else {
          target[key] = extend(source[key])
        }
      }
    }
  } else {
    target = source
  }
  return target
}

var obj1 = {a: {b: 1}}
var cpObj1 = extend(obj1)
obj1.a.b = 2
console.log(cpObj1) // {a: {b: 1}}

var obj2 = [[1]]
var cpObj2 = extend(obj2) 
obj2[0][0] = 2
console.log(cpObj2) // [[1]]

我們再來看一下 Zepto 中深拷貝的程式碼:

    // 內部方法：使用者合併一個或多個物件到第一個物件
    // 引數：
    // target 目標物件  物件都合併到target裡
    // source 合併物件
    // deep 是否執行深度合併
    functionextend(target, source, deep) {
        for (key in source)
            if (deep && (isPlainObject(source[key]) || isArray(source[key]))) {
                // source[key] 是物件，而 target[key] 不是物件， 則 target[key] = {} 初始化一下，否則遞迴會出錯的
                if (isPlainObject(source[key]) && !isPlainObject(target[key]))
                    target[key] = {}

                // source[key] 是陣列，而 target[key] 不是陣列，則 target[key] = [] 初始化一下，否則遞迴會出錯的
                if (isArray(source[key]) && !isArray(target[key]))
                    target[key] = []
                // 執行遞迴
                extend(target[key], source[key], deep)
            }
            // 不滿足以上條件，說明 source[key] 是一般的值型別，直接賦值給 target 就是了
            else if (source[key] !== undefined) target[key] = source[key]
    }

內部實現其實也是差不多。

http://www.vxjezfv.cn/
http://news.vxjezfv.cn/
http://www.xibiyo.com.cn/
http://news.xibiyo.com.cn/
http://www.9208361.org.cn/
http://news.9208361.org.cn/
http://www.9111316.cn/
http://news.9111316.cn/
http://www.bluelf.com.cn/
http://news.bluelf.com.cn/
http://www.qqq136com.cn/
http://news.qqq136com.cn/
http://www.2819w.cn/
http://news.2819w.cn/
http://www.9019758.org.cn/
http://news.9019758.org.cn/
http://www.wydaogou.cn/
http://news.wydaogou.cn/
http://www.ralhys.cn/
http://news.ralhys.cn/