const moduleA = {
  state: { ... },
  mutations: { ... },
  actions: { ... },
  getters: { ... }
}

const moduleB = {
  state: { ... },
  mutations: { ... },
  actions: { ... }
}

const store = new Vuex.Store({
  modules: {
    a: moduleA,
    b: moduleB
  }
})

store.state.a // -> moduleA 的状态
store.state.b // -> moduleB 的状态

store = {
  modules: {
    moduleA: {
      state: {},

      modules: {
        moduleC: {
          state: {},
          actions: {}
        }
      }

    },

    modulesB: {
      state: {},
      mutations: {
        // xxx
      }
    }

  }
}

register(path, rawModule, runtime = true) {
    if (process.env.NODE_ENV !== 'production') {
      assertRawModule(path, rawModule)
    }

    const newModule = new Module(rawModule, runtime)
    if (path.length === 0) {
      // 整个传入store 里的 option 为一个大的 module ,
      // 再对option 里的 modules 属性进行递归注册为 module
      this.root = newModule
    } else {
      const parent = this.get(path.slice(0, -1))
      parent.addChild(path[path.length - 1], newModule)
    }

    // register nested modules
    if (rawModule.modules) {
      forEachValue(rawModule.modules, (rawChildModule, key) => {
        // 这里的 concat 并不改变原来的数组，所以如果是同级的 module ,那么他还是有着相同的父级
        this.register(path.concat(key), rawChildModule, runtime)
      })
    }
  }

constructor (rawModule, runtime) {
    this.runtime = runtime
    // 存储子 modules
    this._children = Object.create(null)
    // Store the origin module object which passed by programmer
    // 存储原始的这个传进来的 module
    this._rawModule = rawModule
    const rawState = rawModule.state  // 获取模块的 state

    // Store the origin module's state
    this.state = (typeof rawState === 'function' ? rawState() : rawState) || {} // state 最终是一个对象
  }

// util.js
function forEachValue (obj, fn) {
    Object.keys(obj).forEach(key => fn(obj[key], key))
  }

else {
      const parent = this.get(path.slice(0, -1)) 
      parent.addChild(path[path.length - 1], newModule)
    }

// 作用：获取当前的模块的父模块
// 传入的 path 是从根模块到父模块的一条链路
get(path) {
    return path.reduce((module, key) => {
      return module.getChild(key)
    }, this.root)
  }

const state = this._modules.root.state  // 将 "根模块对象的 state" (即最外层store的state对象)赋予 state ,

function installModule(store, rootState, path, module, hot) {
// hot 当动态改变 modules 或者热更新的时候为 true.
  const isRoot = !path.length // 判断是否是根模块
  const namespace = store._modules.getNamespace(path)  // 获取s使用的命名空间

  // register in namespace map
  if (module.namespaced) { 
    // 如果命名空间存在，就在store 对象中建立 namespace 到模块的映射
    store._modulesNamespaceMap[namespace] = module
  }

  // set state
  if (!isRoot && !hot) { // 如果不是根模块以及 hot = false，这里我们是根模块，所以我们先放一放，跳到下一步
    const parentState = getNestedState(rootState, path.slice(0, -1))
    const moduleName = path[path.length - 1]
    store._withCommit(() => {
      Vue.set(parentState, moduleName, module.state)
    })
  }

  // 跳到下面先看看makeLocalContext，
  // 又跳！！！放心，，不用跳多远，也就是下一个 issue，，，抠鼻.gif
  const local = module.context = makeLocalContext(store, namespace, path)  
  
  // 注册各个模块的 mutaations 方法到 store._mutations 中，每个type对应一个数组
  module.forEachMutation((mutation, key) => {
    const namespacedType = namespace + key
    registerMutation(store, namespacedType, mutation, local)
  })

  // 注册各个模块的 actions 到store._actions
  module.forEachAction((action, key) => {
    const type = action.root ? key : namespace + key
    const handler = action.handler || action
    registerAction(store, type, handler, local)
  })

  // 注册各个模块的 getters 到store._wrappedGetters
  module.forEachGetter((getter, key) => {
    const namespacedType = namespace + key
    registerGetter(store, namespacedType, getter, local)
  })
 
  
  module.forEachChild((child, key) => { // 递归子模块
    installModule(store, rootState, path.concat(key), child, hot)
  })
}

commit(_type, _payload, _options) {
    // check object-style commit
    // 这里就是获取正确的 type / payload /options
    const {
      type,
      payload,
      options
    } = unifyObjectStyle(_type, _payload, _options)

    const mutation = {
      type,
      payload
    }

    // 获取触发的type  对应的 mutation
    const entry = this._mutations[type]
    if (!entry) {  // 如果不存在，给出警告
      if (process.env.NODE_ENV !== 'production') {
        console.error(`[vuex] unknown mutation type: ${type}`)
      }
      return
    }
    this._withCommit(() => {  // 由于entry是一个数组，所以逐个执行，并传入负载
      entry.forEach(function commitIterator(handler) {
        handler(payload)
      })
    })

    // 触发 订阅函数
    this._subscribers.forEach(sub => sub(mutation, this.state))

    if (
      process.env.NODE_ENV !== 'production' &&
      options && options.silent
    ) {
      console.warn(
        `[vuex] mutation type: ${type}. Silent option has been removed. ` +
        'Use the filter functionality in the vue-devtools'
      )
    }
  }

dispatch(_type, _payload) {  // 基本和commit 一样
// xxx
  }

function resetStoreVM(store, state, hot) {
  const oldVm = store._vm // 之前的 vue 实例

  // bind store public getters
  store.getters = {}  // 终于找到你 
  const wrappedGetters = store._wrappedGetters  // 前面说过的各个模块的 getters 集合
  const computed = {}
  forEachValue(wrappedGetters, (fn, key) => {
    // use computed to leverage its lazy-caching mechanism
    computed[key] = () => fn(store)    // 收集各个 getter，等会传入 computed ，以此做到响应式
    Object.defineProperty(store.getters, key, {
      get: () => store._vm[key],  // 因为利用了计算属性，所以各个 getter 就变成了 vue 实例的属性
      enumerable: true // for local getters
    })
  })

  // use a Vue instance to store the state tree
  // suppress warnings just in case the user has added
  // some funky global mixins
  const silent = Vue.config.silent //// 是否取消Vue 所有的日志与警告
  Vue.config.silent = true

  // 重新 new 
  store._vm = new Vue({
    data: {
      $$state: state  // 这里虽然是 $$state，但是利用store.state时获取的就是它
    },
    computed
  })

  /* get state() {
        return this._vm._data.$$state
  }*/

  Vue.config.silent = silent

  // enable strict mode for new vm
  if (store.strict) {
    enableStrictMode(store)
  }

  if (oldVm) {
    if (hot) {
     // 解除旧vm的state的引用，以及销毁旧的Vue对象
      // dispatch changes in all subscribed watchers
      // to force getter re-evaluation for hot reloading.
      store._withCommit(() => {
        oldVm._data.$$state = null
      })
    }
   
    Vue.nextTick(() => oldVm.$destroy())
  }
}

 if (!isRoot && !hot) { // 如果不是根模块以及 hot = false，这里我们是根模块，所以我们先放一放，跳到下一步
    const parentState = getNestedState(rootState, path.slice(0, -1))
    const moduleName = path[path.length - 1]
    store._withCommit(() => {
      Vue.set(parentState, moduleName, module.state)
    })
  }

    var Person = function(name){
        this.name = name;
    }

    Person.prototype.getName = function(){
        return this.name;
    }

   var Bob = new Person('Bob');    // 这里 new Person('Bob') 发生了什么？

  function New(func) {
    var res = {};
    if (func.prototype !== null) {
        res.__proto__ = func.prototype;
    }
    var ret = func.apply(res, Array.prototype.slice.call(arguments, 1));
    if ((typeof ret === "object" || typeof ret === "function") && ret !== null) {    // typeof null === 'object'
        return ret;
    }
    return res;
}

    // 原来的：
    /* function show(content) {
        window.document.getElementById('app').innerHTML = content
    };

    export default  */

    export function show(content) {
        window.document.getElementById('app').innerHTML = content
    };

    export function getAge(age) {
        console.log(age)
    }

    export var fileName = 'show'

(function (modules) {
    // 这一部分没有变化
})([
    // 数组的第一个元素也没有变
    (function (module, exports, __webpack_require__) {
        const show = __webpack_require__(1)
        show('webpack hello 77')
    }),

    
    (function (module, __webpack_exports__, __webpack_require__) {
        "use strict";
        
        Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
        /* harmony export (immutable) */ __webpack_exports__["show"] = show;
        /* harmony export (immutable) */ __webpack_exports__["getAge"] = getAge;
        /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fileName", function() { return fileName; });

        // 最终的 __webpack_exports__（也就是exports) 变为了如下：
        /* 
        __webpack_exports__={
            __esModule:true,
            show,
            getAge,
            fileName
        }
        */

        


        function show(content) {
            window.document.getElementById('app').innerHTML = content
        };

        function getAge() {
            console.log(age)
        }

        var fileName = 'show'
    })
])

// show.js 改为如下：
export function show(content) {
    window.document.getElementById('app').innerHTML = content
};

export function getAge() {
    console.log(age)
}

export var fileName = 'show1'

export var fileName = 'show2'

// show.js
export function show(content) {
    window.document.getElementById('app').innerHTML = content
};


function getAge(age) {
    console.log(age)
}

var fileName1 = 'show1'

export {
    fileName1 as f1,
    getAge as age
}

// show.js
function getAge(age) {
    console.log(age)
}


export default getAge

// show.js
function getAge(age) {
    console.log(age)
}

export function show() {
    console.log(55)
}

export var n = 'n'

export default {
    getAge
}

// show.js
function getAge(age) {
    console.log(age)
}

export function show() {
    console.log(55)
}

export var n = 'n'

export default {
    getAge,
    n
}

module.exports = function getAge(age) {
    console.log(age)
}

export function show() {
    console.log(55)
}

var n = 'n'
export default {
    n
}

// __webpack_require__(1)
function (module, __webpack_exports__, __webpack_require__) {

    "use strict";
    Object.defineProperty(__webpack_exports__, "__esModule", {
        value: true
    });
    /* WEBPACK VAR INJECTION */
    
    (function (module) { /* harmony export (immutable) */
        __webpack_exports__["show"] = show;
        module.exports = function getAge(age) {
            console.log(age)
        }

        function show() {
            console.log(55)
        }

        var n = 'n'
        __webpack_exports__["default"] = ({
            n
        });
    }.call(__webpack_exports__, __webpack_require__(2)(module)))
}

// __webpack_require__(2)
function (module, exports) {

    module.exports = function (originalModule) {
        if (!originalModule.webpackPolyfill) {
            // 以originalModule为原型创建一个新对象
            var module = Object.create(originalModule);
            // module.parent = undefined by default
            if (!module.children) module.children = [];
            Object.defineProperty(module, "loaded", {
                enumerable: true,
                get: function () {
                    return module.l; 这里是 originalModule 的 l
                }
            });
            Object.defineProperty(module, "id", {
                enumerable: true,
                get: function () {
                    return module.i;    // 这里是 originalModule 的 i
                }
            });
            Object.defineProperty(module, "exports", {
                enumerable: true,
            });
            module.webpackPolyfill = 1;
        }
        
        return module;
    };
}

function getAge(age) {
    console.log(age)
}

function show() {
    console.log(55)
}

var n = 'n'


module.exports = {
    show,
    getAge,
    n
}

Vue.use = function (plugin: Function | Object) {
        // 检测该插件是否已经被安装
        if (plugin.installed) {
            return
        }
        // use 支持传入一个选项对象，如
        // Vue.use(MyPlugin, { someOption: true })
        const args = toArray(arguments, 1)  //获取可选对象
        
        args.unshift(this)  // 将Vue 构造器传入，当插件的第一个参数
        if (typeof plugin.install === 'function') {
            // install执行插件安装
            plugin.install.apply(plugin, args)
        } else if (typeof plugin === 'function') {
            plugin.apply(null, args)
        }
        plugin.installed = true  // 防止再次安装
        return this
    }

function install(_Vue) {
  if (Vue && _Vue === Vue) {
    // 给出警告：说明重复安装
    return
  }
  Vue = _Vue
  applyMixin(Vue)
}

function vuexInit() {
        // this -> vm
        const options = this.$options
        // store injection
        if (options.store) { // 获取传入new Vue({store}) 里面的 store，并注册为 vm 的 $store 属性，这样我们就能在实例中使用 this.$store 访问 store 对象了
            this.$store = typeof options.store === 'function' ?
                options.store() :
                options.store
        } else if (options.parent && options.parent.$store) {
            // 子组件从其父组件引用 $store 属性
            this.$store = options.parent.$store
        }
    }

// 构造函数
    constructor(options = {}) {
        // .......
    }

// util.js
   function assert (condition, msg) {
    if (!condition) throw new Error(`[vuex] ${msg}`)
  }

// store internal state
    // 表示提交状态，作用是保证对 Vuex 中 state 的修改只能在 mutation 的回调函数中，而不能在外部随意修改state
    this._committing = false
    // 用户定义的 actions
    this._actions = Object.create(null)
    // action 订阅者
    this._actionSubscribers = []
    // // 用户定义的 mutations
    this._mutations = Object.create(null)
    // 用户定义的 getters
    this._wrappedGetters = Object.create(null)
    // 收集用户定义的 modules
    this._modules = new ModuleCollection(options)
    // 模块命名空间map
    this._modulesNamespaceMap = Object.create(null)
    // 存储所有对 mutation 变化的订阅者,当执行commit时会执行队列中的函数
    this._subscribers = []
    // 创建一个 Vue 实例, 利用 $watch 监测 store 数据的变化
    this._watcherVM = new Vue()

const store = this
    const {
      dispatch,
      commit
    } = this

    this.dispatch = function boundDispatch(type, payload) {
      return dispatch.call(store, type, payload)
    }
    this.commit = function boundCommit(type, payload, options) {
      return commit.call(store, type, payload, options)
    }

 computed: {
    // 计算属性的 getter
    reversedMessage: function () {
      // `this` 指向 vm 实例
      return this.message.split('').reverse().join('')
    }
  }

    this.strict = strict

    const state = this._modules.root.state

    // init root module.
    // this also recursively registers all sub-modules
    // and collects all module getters inside this._wrappedGetters
    installModule(this, state, [], this._modules.root)

    // initialize the store vm, which is responsible for the reactivity
    // (also registers _wrappedGetters as computed properties)
    resetStoreVM(this, state)

    // apply plugins
    plugins.forEach(plugin => plugin(this))

    if (Vue.config.devtools) {
      devtoolPlugin(this)
    }

// index.js
(function (window) {
    let createTag = (tag, attrOpts) => { // 创建标签
        let Tag = document.createElement(tag)
        forEachValue(attrOpts, (key) => {
            Tag[key] = attrOpts[key]
        })
        return Tag
    }

    let forEachValue = function (obj, fn) {
        Object.keys(obj).forEach(key => fn(key))
    }

    // 注意，使用document.querySelector()获取 body元素 时，要传入 'body'，而不是 document.body
    let appendChild = (parent, child) => {
        parent = document.querySelector(parent)
        parent.appendChild(child)

        return function () {
            parent.removeChild(child)
        }
    }

    let assert = (condition, msg) => { // 断言
        if (!condition) throw new Error(`${msg}`)
    }



    let jsonp = req => {
        let {
            url,
            data,
            callback
        } = req
        let script,
            removeChild,
            params = [],
            fnName = 'jsonpCb'

        data['callback'] = fnName

        assert(url, "url 不能为空")
        assert(callback, "url 不能为空")

        for (let key in data) {
            params.push(`${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
        }

        url = url.indexOf('?') > 0 ? `${url}&` : `${url}?`

        url += params.join('&')

        script = createTag('script', {
            src: url,
            type: "text/javascript"
        })

        removeChild = appendChild('body', script)

        window[fnName] = res => {
            callback(res)
            removeChild()
            delete window[fnName]
        }

        script.onerror = (error) => {
            callback({
                error
            })
            removeChild()
            delete window[fnName]
        }


    }


    jsonp({
        url: 'http://localhost:8080/login',
        data: {
            name: 'echo666'
        },
        callback: function (res) {
            console.log(JSON.stringify(res));
        }
    })

})(this);

var qs = require('querystring');
var http = require('http');
var server = http.createServer();

server.on('request', function (req, res) {
    var params = qs.parse(req.url.split('?')[1]);
    console.log(params)

    var fn = params.callback;

    // jsonp返回设置
    res.writeHead(200, {
        'Content-Type': 'text/javascript'
    });
    res.end(fn + '(' + JSON.stringify(params) + ')');

});

server.listen('8080');
console.log('Server is running at port 8080...');

 GET https://www.example.com/login.php?user=mickey&passwd=mini

let ary = [8, 5, 12, 2, 4, -6, 1, -3]

// 升序
let sortArrayByAscendingOrder1 = (ary) => {
    for (var j = 1, l = ary.length; j < l; j++) {
        let key = ary[j],
        i = j - 1;
        while (i > -1 && ary[i] > key) {
            ary[i + 1] = ary[i]
            --i;
        }
        ary[i + 1] = key;
    }
    return ary
}

let sortArrayByAscendingOrder2 = (ary)=>{
  var i,j;
   for(i = 1;i < ary.length; i++){
    for(j = 0;j<i;j++){
       if(ary[j]>ary[i]){
        ary.splice(j,0,ary[i]);
        ary.splice(i+1,1);
       }
     }
   }
   return ary;
 };

// 降序
let sortArrayByDescendingOrder = (ary) => {
    var l = ary.length,
  	j,
       temp;
      
  for(var i=1;i<l;i++){
  	if(ary[i]>ary[i-1]){
      	      temp = ary[i]
          
              for(j=i-1;j>-1&&ary[j]<temp;j--){
          		ary[j+1] = ary[j]
              }
          
              ary[j+1] = temp
      }
  }
    return ary
}

sortArrayByAscendingOrder1 (ary)     // [ -6, -3, 1, 2, 4, 5, 8, 12 ]
sortArrayByAscendingOrder2 (ary)     // [ -6, -3, 1, 2, 4, 5, 8, 12 ]
sortArrayByDescendingOrder (ary)   // [12, 8, 5, 4, 2, 1, -3, -6]

var arr = [func1, func2, func3];
function func1(ctx, next) {
    ctx.index++
    next();
}
function func2(ctx, next) {
    setTimeout(function () {
        ctx.index++;
        next();
    });
}
function func3(ctx, next) {
    console.log(ctx.index);
}

const compose = arr => arr.reverse().reduce((a, b) => obj => b(obj, () => a(obj)), () => { })
compose(arr)({ index: 0 }); // 输出：2

/*
function compose(arr) {
    return arr.reverse().reduce((a, b) => {
        return function (obj) {
            b(obj, function () {
                a(obj)
            })
        }
    }, () => { })
}
*/

// main.js
var {
    show
} = require('./show')
var {
    getName
} = require('./getName')
// console.log(show)
show()
getName(666)


// show.js
var {
    getName
} = require('./getName')

export function show() {
    console.log(55)
}

// getName.js
export function getName(name) {
    console.log(name)
}

// 立即执行函数体里面基本没变，只是最后return 的时候是从传进来的数组的第二个元素开始执行：
return __webpack_require__(__webpack_require__.s = 1);

// 传进来的参数为：
[
/* 0 */
(function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony export (immutable) */ __webpack_exports__["getName"] = getName;
function getName(name) {
    console.log(name)
}

 }),
/* 1 */
(function(module, exports, __webpack_require__) {

var {
    show
} = __webpack_require__(2)
var {
    getName
} = __webpack_require__(0)
// console.log(show)
show()
getName(666)

 }),
/* 2 */
 (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony export (immutable) */ __webpack_exports__["show"] = show;
var {
    getName
} = __webpack_require__(0)

function show() {
    console.log(55)
}

})
]

// main.js
var {
    show
} = require('./show')
var {
    getName
} = require('./getName')

import {
    getAge
} from './getAge'
// console.log(show)
show()
getName(666)
getAge(777888)

// show.js
import {
    getAge
} from './getAge'
export function show() {
    console.log(55)
    getAge(777888)
}

// getAge.js
export function getAge(age) {
    console.log(age)
}

// getName.js
var {
    show
} = require('./show')
import {
    getAge
} from './getAge'
export function getName(name) {
    console.log(name)
}

return __webpack_require__(__webpack_require__.s = 2);

[
/* 0 */
(function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = getAge;
function getAge(age) {
    console.log(age)
}

 }),

/* 1 */
(function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony export (immutable) */ __webpack_exports__["show"] = show;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__getAge__ = __webpack_require__(0);

function show() {
    console.log(55)
    Object(__WEBPACK_IMPORTED_MODULE_0__getAge__["a" /* getAge */])(777888)
}

 }),


/* 2 */
(function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__getAge__ = __webpack_require__(0);
var {
    show
} = __webpack_require__(1)
var {
    getName
} = __webpack_require__(3)


// console.log(show)
show()
getName(666)
Object(__WEBPACK_IMPORTED_MODULE_0__getAge__["a" /* getAge */])(777888)

}),


/* 3 */
 (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony export (immutable) */ __webpack_exports__["getName"] = getName;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__getAge__ = __webpack_require__(0);
var {
    show
} = __webpack_require__(1)

function getName(name) {
    console.log(name)
}

 })
 ]

let ary = [8, 5, 12, 2, 1, 4, -6, -3]

/**
 * 
 * @param {Array} ary   数组
 * @param {Number} l    排序的左边起始点
 * @param {Number} r     排序的右边终点
 */

let quickSort = (ary, l, r) => {
    if (l < r) {
        let pivot;   //枢轴元素
        let i, j;
        i = l;
        j = r;
        pivot = ary[i]  // 以排序序列的第一个元素为枢轴元素

        // 完成一趟排序
        while (i < j) {
            while (i < j && ary[j] > pivot) j--;    // 从右向左找第一个小于pivot的数 前面 i<j 保证了 i ,j 不会有寻找的重合
            if (i < j) {    // 要加上这里的判断，不然会出现下面图片显示得最后一步 2和1 位置错误的问题
                ary[i] = ary[j]
                i++
            }


            while (i < j && ary[i] < pivot) i++;
            if (i < j) {    // 要加上这里的判断，不然会出现下面图片显示得最后一步 2和1 位置错误的问题
                ary[j] = ary[i]
                j--
            }

        }

        ary[i] = pivot

        // 递归地将pivot两边的序列进行按照上面的过程进行排序
        quickSort(ary, l, i - 1)    // 对左边进行排序
        quickSort(ary, i + 1, r)    // 对右边进行排序

    }

    return ary
}

quickSort(ary, 0, 7)    // [ -6, -3, 1, 2, 4, 5, 8, 12 ]
// 不加判断的结果： [ -6, -3, 2, 1, 4, 5, 8, 12 ]

    var eq, deepEq

    eq = function (a, b, aStack, bStack) {
        // 因为 0=== -0 
        // 所以，先判断 a !== 0 保证了，a和b 是不为0 的，
        // 其次，判断，a 和b 与 0 和 -0 的关系 
        // 1/0 == Infinite
        // 1/-0 == -Infinite
        if (a === b) return a !== 0 || 1 / a === 1 / b


        // a和b 中只要有一个是 undefined 或者 null ,就判为 false ,严格模式下
        if (a == null || b == null) return false;

        // NaN 情况
        // 如果 a 是NaN ，则判断 b 是不是 NaN
        if (a !== a) return b !== b

        var type = typeof a
        // 经过上面的if 语句，如果是基本类型，如果相等，那么前面就已经有了结论，不会跳到这里，
        // 这里是排除 基本数据类型的判断，凡是数据基本类型，到了这一步，表明两者并不相等
        // 以便下面的对象的深度比较
        if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;

        // 接下来进行对象的深度比较
        return deepEq(a, b, aStack, bStack);

    }


    deepEq = function (a, b, aStack, bStack) {
        // 如果 a,b 是underscore 的子类，
        // 那么就比较 _wrapped 属性值
        // 也就是传进来的 obj
        if (a instanceof _) a = a._wrapped;
        if (b instanceof _) b = b._wrapped;

        var className = toString.call(a)
        // 先用Object.prototype.toString 方法判断是否属于同一类型
        if (className !== toString.call(b)) return false

        // 下面针对不同的情况进行讨论
        switch (className) {
            case '[object RegExp]':
            case '[object String]':
                // new String
                // 正则和字符串的则转换为字符串来比较
                return '' + a === '' + b;

            case '[object Number]':
                // 如果+a !== +a 那么a = NaN
                // 此时判断 b 是否是 NaN
                if (+a !== +a) return +b !== +b;
                // 将 a 转换为  基本类型
                // 如果 a 为 0，判断 1 / +a === 1 / b
                // 否则判断 +a === +b
                return +a === 0 ? 1 / +a === 1 / b : +a === +b;


                // 直接将 Date 和 Boolean  转化为 数字比较
            case '[object Date]':
            case '[object Boolean]':
                return +a === +b;

                /** 
                 * var a = Symbol(1)
                    var b  = Symbol(1)
                    a === b  -> false

                    所以此时比较 时应该就比较 传入 Symbol 的参数

                    var a = Symbol(1)
                    var b  = Symbol(1)      
                    Symbol.prototype.valueOf.call(b) === Symbol.prototype.valueOf.call(a)  // false
                    Symbol.prototype.toString.call(b) === Symbol.prototype.toString.call(a) // true

                    // 这里好像判断失误了？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？
                 */
            case '[object Symbol]':
                return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);
        }

        // 判断是否是数组
        var areArrays = className === '[object Array]';
        if (!areArrays) { // 如果不是数组
            // 此时 typeof a| b 是函数。。这样两个函数不管如何直接 false
            if (typeof a != 'object' || typeof b != 'object') return false;

            // Objects with different constructors are not equivalent, but `Object`s or `Array`s
            // from different frames are.
            // 如果 a 和 b 有着不同的构造函数不一定是不等，如 Object 和 Array 如果在不同的 iframes 的时候
            var aCtor = a.constructor,
                bCtor = b.constructor;
            // aCtor !== bCtor 说明 两者的构造函数不同
            // _.isFunction(aCtor) 保证 能使用 instanceof 来进行判断
            // ('constructor' in a && 'constructor' in b) 是防止如下情况：
            /* var attrs = Object.create(null);
            attrs.name = "Bob";
            eq(attrs, {
                name: "Bob"
            }); 
            // 这两个对象应该是相等的
            */
            if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&
                    _.isFunction(bCtor) && bCtor instanceof bCtor) &&
                ('constructor' in a && 'constructor' in b)) {
                return false;
            }
        }


        aStack = aStack || [];
        bStack = bStack || [];

        var length = aStack.length;
        while (length--) { // 逐个比较其值    第一次时 length = 0 这里不会执行
            if (aStack[length] === a) return bStack[length] === b
        }

        aStack.push(a)
        bStack.push(b)

        if (areArrays) { // 如果是数组
            length = a.length
            if (length !== b.length) return false // 数组长度不等，自然两者不相等

            while (length--) { // 递归比较a和b 的一个个子元素，层层剥茧,只要有一个不同，就是false
                if (!eq(a[length], b[length], aStack, bStack)) return false
            }
        } else { // 是纯对象情况
            var keys = _.keys(a),
                key // 获取a 的所有 键
            length = keys.length
            // 键值长度不等，自然不等
            if (_.keys(b).length !== length) return false;
            while (length--) {
                // Deep compare each member
                key = keys[length];
                // 先看 b 中是否有这个键，有的话，再将a 和 b 对应这个键的键值进行递归比较 
                if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;
            }
        }

        aStack.pop();
        bStack.pop();
        return true;

    }


    _.isEqual = function (a, b) {
        return eq(a, b);
    };

// 三种模板的定义，并且是全局
    // \s ： Unicode 任何空白符
    // \S : 任何非 Unicode 空白符之间外的字符
    // 非贪婪匹配
    _.templateSettings = {
        evaluate: /<%([\s\S]+?)%>/g,
        interpolate: /<%=([\s\S]+?)%>/g,
        escape: /<%-([\s\S]+?)%>/g
    };

    // . ：除换行符和其他Unicode 行终止符之外的任意字符
    var noMatch = /(.)^/;

    var escapes = {
        "'": "'",
        '\\': '\\',
        '\r': 'r', // 回车
        '\n': 'n', // 换行
        '\u2028': 'u2028', // 行分隔符
        '\u2029': 'u2029' // 段落分隔符
    };

    var escapeRegExp = /\\|'|\r|\n|\u2028|\u2029/g;

    var escapeChar = function (match) {
        return '\\' + escapes[match];
    };


    _.template = function (text, settings, oldSettings) {
        // 如果没有新的 setting ,就将老的 setting  设置为 settings
        if (!settings && oldSettings) settings = oldSettings
        // 合并 setting 和 _.templateSettings，但不进行覆盖
        settings = _.defaults({}, settings, _.templateSettings);

        // 正则的属性：
        //  var  escape = /<%-([\s\S]+?)%>/g
        // escape.source ="d(b+)d"   -> string
        // escape.lastIndex :下一个匹配的索引值

        var matcher = RegExp([
            (settings.escape || noMatch).source,
            (settings.interpolate || noMatch).source,
            (settings.evaluate || noMatch).source
        ].join('|') + '|$', 'g'); // -> /<%-([\s\S]+?)%>|<%=([\s\S]+?)%>|<%([\s\S]+?)%>|$/g


        var index = 0
        var source = "__p+="

        /**
        * _.template("Using 'with': <%= data.answer %>", {variable: 'data'})({answer: 'no'});

            以上述例子为例讲解


        */
        text.replace(matcher, function (match, escape, interceptor, evaluate, offset) {
            // \n ->\\n    \->\\ 
            // 此时 source ="__p+=Using \'with\': "
            // match =  <%= data.answer %>
            // escape = '  data.answer  '
            source = += text.slice(index, offset).replace(escapeRegExp, escapeChar)
            // 便于下次 slice 
            index = offset + match.length

            if (escape) {
                // 需要对变量进行编码
                // source ="__p+=Using \'with\': '+\n((__t=(  data.answer  ))==null?'':_.escape(__t))+\n'"
                source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
            } else if (interpolate) {
                // 单纯地插入变量
                source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
            } else if (evaluate) {
                // 可以直接执行的 JavaScript 语句
                // 注意 "__p+="，__p 为渲染返回的字符串
                source += "';\n" + evaluate + "\n__p+='";
            }
            // 将匹配到的内容原样返回（Adobe VMs 需要返回 match 来使得 offset 值正常）
            return match;
        })

        // source ="__p+=Using \'with\': '+\n((__t=('  data.answer  '))==null?'':_.escape(__t))+\n'';\n"
        source += "';\n"

        // 如果没有指定  settings.variable 直接用 with 指定作用域
        // 关于 with
        // https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/with
        if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';

        // 增设 print 函数，返回 所有参数 link 在一起的 字符串
        source = "var __t,__p='',__j=Array.prototype.join," +
            "print=function(){__p+=__j.call(arguments,'');};\n" +
            source + 'return __p;\n';
        /** 
         * source = (
         *      var __t,__p = '',__j = Array.prototype.join,
         *          print = function(){
         *              __p+=__j.call(arguments,"");
         *          }
         * 
         *          __p+=(Using \'with\': 
         *                  ((__t=('  data.answer  '))==null?'':_.escape(__t))
         *              )
         * 
         *          return __p
         * )
         */


        var render;
        try {
            // obj 为传入的 JSON 对象，传入 _ 参数使得函数内部能用 Underscore 的函数
            // source: 一个含有包括函数定义的JavaScript语句的字符串。

            // {variable: 'data'}

            /** 
             * render = function(data=obj,_){
             *      // 函数执行实体
             *   var __t,__p = '',__j = Array.prototype.join,
             *          print = function(){
             *              __p+=__j.call(arguments,"");
             *          }
             * 
             *          __p+=(Using \'with\': 
             *                  ((__t=('  data.answer  '))==null?'':_.escape(__t))
             *              )
             * 
             *          return __p
             * }
             */
            render = new Function(settings.variable || 'obj', '_', source);
        } catch (e) {
            e.source = source;
            throw e;
        }

        var template = function (data) {
            // data = {answer: 'no'}
            // 执行render 
            /** 
             * render = function(data=obj,_){
             *      // 函数执行实体
             *   var __t,
             *      __p = '',
             *      __j = Array.prototype.join,
             *      print = function(){
             *          __p+=__j.call(arguments,"");
             *      }
             * 
             *      __p+=(Using \'with\': 
             *              // data.answer = 'no'
             *              ((__t=('  data.answer  '))==null?'':_.escape(__t))
             *          )
             *      // __p = "Using \'with\':no"
             *      return __p
             * }
             */
            return render.call(this, data, _);
        };

        var argument = settings.variable || 'obj';

        /* 预编译模板对调试不可重现的错误很有帮助. 这是因为预编译的模板可以提供错误的代码行号和堆栈跟踪, 
        有些模板在客户端(浏览器)上是不能通过编译的 在编译好的模板函数上, 有 source 属性可以提供简单的预编译功能. */

        template.source = 'function(' + argument + '){\n' + source + '}';

        return template
    }

let _isPlainObj = (obj) => {
    if (typeof obj !== 'object' || obj === null) return false
    let proto = obj
    while (Object.getPrototypeOf(proto) !== null) {
        proto = Object.getPrototypeOf(proto)
    }

    return Object.getPrototypeOf(obj) === proto
}

let _execFn = function (fn) {
    if (typeof fn === 'function') {
        return fn()
    }

    return fn
}

let pickTrue = (isToStr, ...args) => {
    let trueCollections = []
    let len = args.length

    for (let i = 0; i < len; i++) {
        let arg = args[i]
        if (!arg)
            continue;
        let type = typeof arg

        if (type === 'string' || type === 'number') {
            trueCollections.push(arg)
        } else if (Array.isArray(arg) && arg.length) {
            let arrayReturn = pickTrue.apply(null, [false, ...arg])   // 使用apply 保证了pickTrue 里面为一系列的参数
            trueCollections.push(...arrayReturn)
        } else if (_isPlainObj(arg)) {
            for (let k in arg) {
                if (arg.hasOwnProperty(k) && _execFn(arg[k])) {
                    trueCollections.push(k)
                }
            }
        } else if (type == 'function') {
            let fnReturn = arg()
            let fnResult = pickTrue.apply(null, [true, fnReturn])
            trueCollections.push(fnResult)
        }
    }

    return isToStr ? trueCollections.join(' ') : trueCollections
}


module.exports = pickTrue

let assert = require('assert')
let pickTrue = require('../index')

describe('单输入基本类型', function () {
    it('保留基本类型->字符串', function () {
        assert.equal(pickTrue(
            true,
            1,
            2,
            's1',
            's2'
        ), '1 2 s1 s2')
    })


    it('保留基本类型->数组', function () {

        let p = pickTrue(
            false,
            1,
            2,
            's1',
            's2'
        )
        let expect = [1, 2, 's1', 's2']

        p.map((v, i) => {
            assert.equal(v, expect[i])
        })
    })
})

describe('对象和基本类型', function () {
    it('对象->字符串', function () {
        assert.equal(pickTrue(true,
            {
                a: 1,
                b: false,
                c: true,
                d: null
            }
        ), 'a c')
    })

    it('对象->数组', function () {
        let p = pickTrue(false,
            {
                a: 1,
                b: false,
                c: true,
                d: null
            }
        )
        let expect = ['a', 'c']

        p.map((v, i) => {
            assert.equal(v, expect[i])
        })

    })

    it('数组、对象、函数、以及基本类型--> 字符串', function () {

        assert.equal(pickTrue(true,
            1,
            's2',
            undefined,
            {
                a: true,
                b: null,
                c: undefined
            },
            [
                function () {
                    return 'fn'
                },
                [
                    2, {
                        d: true,
                        e: false,
                        f: function () {
                            return false
                        },
                        g: function () {
                            return true
                        }
                    }
                ]
            ]
        ), '1 s2 a fn 2 d g')
    })


    it('数组、对象、函数、以及基本类型--> 数组', function () {
        let p = pickTrue(false,
            1,
            's2',
            undefined,
            {
                a: true,
                b: null,
                c: undefined
            },
            [
                function () {
                    return 'fn'
                },
                [
                    2, {
                        d: true,
                        e: false,
                        f: function () {
                            return false
                        },
                        g: function () {
                            return true
                        }
                    }
                ]
            ]
        )
        let expect = [1, 's2', 'a', 'fn', 2, 'd', 'g']

        p.map((v, i) => {
            assert.equal(v, expect[i])
        })

    })
})