就面試筆試題的一些筆記：

• 閉包（ 實現add(2)(5) ）
• 深複製和淺複製
• 原生js實現Promise

△ –>閉包知識：

實現add(2)(5)

function add (x) {
return function(y) { return x + y; };
}

△ –>深複製和淺複製：

深拷貝 與 淺拷貝： 迴圈引用和函式是不能通過 stringify 進行深拷貝的

• 對於迴圈引用和函式是無法通過stringify和parse的方法進行深拷貝的，關於迴圈引用，可以通過查詢迴圈點來斷掉這個迴圈，再進行深拷貝。

遇到的問題 ：
* 解決陣列淺拷貝的問題：
直接等於 = arr1=arr2;
slice和concat方法可以進行簡單素組的深拷貝
由於陣列內部屬性值為引用物件，因此使用slice和concat對物件陣列的拷貝，整個拷貝還是淺拷貝，拷貝之後陣列各個值的指標還是指向相同的儲存地址。
因此，slice和concat這兩個方法，僅適用於對不包含引用物件的一維陣列的深拷貝

• 解決陣列深拷貝的問題：
  也是通過 stringify 和 parse 的方法進行深拷貝，

• 解決深拷貝的問題：
  先把資料進行stringify轉換 ，再進行一次parse轉換。
  JSON.stringify() 方法是將一個JavaScript值(物件或者陣列)轉換為一個 JSON字串
  JSON.parse() 方法解析JSON格式資料並構造一個由字串描述的JavaScript物件/值

• 總結：

  1. 淺拷貝相當於引用地址的複製，兩個變數指標是共享（引用）同一個物件。obj1 === obj2
  2. 深拷貝相當於為另外一個物件開闢記憶體空間，並進行遞迴複製內部屬性。兩個物件的引用地址是不一樣的（即不是引用同一個物件）。obj1 !== obj2
  3. 可以通過”賦值操作符”、Object.assign()、陣列遍歷賦值等實現淺拷貝。
  4. 可以通過自定義程式碼、JSON物件的方法（JSON.parse和JSON.stringify）、JQuery.extend()等實現深拷貝。
  5. 目前來說，並沒有統一的標準方法來解決”迴圈引用”，從而實現真正的深拷貝。

• 比如 react 裡面有大量的物件複製，用 immutable 就很好。
  對付 deep clone, 最好的辦法是拋棄需要 deep clone 的程式碼

• 實際開發中 除了通過 stringify 和 parse 的方法進行深拷貝，
  eg:
  let item = JSON.parse(JSON.stringify(temp));
  item[‘recharge_principal’] = FormatMoneyByM(temp[‘recharge_principal’]);
  為此還採用了其他方式對資料做了處理，
  為了避免改變資料的值，直接將通過格式化函式後，加入陣列中。不採用中間變數來傳遞值。
  eg:
  let temp = data.list [ key ] || { } ;
  principal_arr.push ( CalculateMoneyByMm ( temp[ ’ principa l’ ] || 0 ) );

△ –> 用原生js實現promise：

ES6中Promise可以說很大情況下改善了非同步回撥的巢狀問題

第一：Promise建構函式接受一個函式作為引數，函式裡面有兩個引數resolve和reject分別作為執行成功或者執行失敗的函式
var promise=new Promsie(function(resolve,rejec){
    if(/*非同步執行成功*/){
        resolve(value);
    }else{
        reject(error);
    }
})
第二：可以通過then設定操作成功之後的操作，接受兩個函式作為引數
.then(function(){
    //回撥執行成功之後的操作
},function(){
    //回撥執行失敗之後的操作，可以沒有
});

Promise物件的狀態改變，只有兩種可能：從Pending變為Resolved和從Pending變為Rejected

function Promise(){
    this.status='pending'; //待定
    this.msg='';
    var process=arguments[0];
    var that=this;
    process(function(){
        that.status='resolve';
        that.msg=arguments[0];
    },function(){
        that.status='reject';     
        that.msg=arguments[0];           
    });
    return this;
}

Promise.prototype.then=function(){
    if(this.status=='resolve'){
        arguments[0](this.msg);
    }
    if(this.status=='reject '&& arguments[1]){
        arguments[1](this.msg);
    }
}

//測試
var promise =new Promise(function(resolve,reject){
    resolve('success!!!');
});
promise.then(function(success){
    console.log('success');
},function(){
    console.log('failed');
});

以上只是最基本的實現，在程式碼結構結構和容錯方面沒有進行考慮。
Promise物件的缺點：
1、無法取消Promise，一旦新建它就會立即執行，無法中途取消。
2、如果不設定回撥函式，Promise內部丟擲的錯誤，不會反應到外部。
3、當處於Pending狀態時，無法得知目前進展到哪一個階段（剛剛開始還是即將完成）。

/* 我們要滿足狀態只能三種狀態：PENDING,FULFILLED,REJECTED三種狀態，
且狀態只能由PENDING=>FULFILLED,或者PENDING=>REJECTED */
            var PENDING = 0;
            var FULFILLED = 1;
            var REJECTED = 2;
/* value狀態為執行成功事件的入參，deferreds儲存著狀態改變之後的需要處理的函式以及promise子節點，
建構函式裡面應該包含這三個屬性的初始化 */
            function Promise(callback) {
                this.status = PENDING;
                this.value = null;
                this.defferd = [];
                setTimeout(callback.bind(this, this.resolve.bind(this), this.reject.bind(this)), 0);
            }

            Promise.prototype = {
                constructor: Promise,
                //觸發改變promise狀態到FULFILLED
                resolve: function (result) {
                    this.status = FULFILLED;
                    this.value = result;
                    this.done();
                },
                //觸發改變promise狀態到REJECTED
                reject: function (error) {
                    this.status = REJECTED;
                    this.value = error;
                },
                //處理defferd
                handle: function (fn) {
                    if (!fn) {
                        return;
                    }
                    var value = this.value;
                    var t = this.status;
                    var p;
                    if (t == PENDING) {
                         this.defferd.push(fn);
                    } else {
                        if (t == FULFILLED && typeof fn.onfulfiled == 'function') {
                            p = fn.onfulfiled(value);
                        }
                        if (t == REJECTED && typeof fn.onrejected == 'function') {
                            p = fn.onrejected(value);
                        }
                    var promise = fn.promise;
                    if (promise) {
                        if (p && p.constructor == Promise) {
                            p.defferd = promise.defferd;
                        } else {
                            p = this;
                            p.defferd = promise.defferd;
                            this.done();
                        }
                    }
                    }
                },
                //觸發promise defferd裡面需要執行的函式
                done: function () {
                    var status = this.status;
                    if (status == PENDING) {
                        return;
                    }
                    var defferd = this.defferd;
                    for (var i = 0; i < defferd.length; i++) {
                        this.handle(defferd[i]);
                    }
                },
                /*儲存then函式裡面的事件
                返回promise物件
                defferd函式當前promise物件裡面
                */
                then: function (success, fail) {
                   var o = {
                        onfulfiled: success,
                        onrejected: fail
                    };
                    var status = this.status;
                    o.promise = new this.constructor(function () {

                    });
                    if (status == PENDING) {
                        this.defferd.push(o);
                    } else if (status == FULFILLED || status == REJECTED) {
                        this.handle(o);
                    }
                    return o.promise;
                }
            };