2019-5-24 函数式调用封装；入门

(function () {

    // 根据不同的模块环境变量，决定root的值
  var root = typeof self == 'object' && self.self === self && self ||
       typeof global =='object' && global.global ===global && global ||
       this || {};


  var _ = function () {
    if(!(this instanceof _)) {return new _()}
  };


  _.hi = function(){
    console.log('_hi',arguments)
  }


  _.test = function(){
    console.log('_test',arguments)
  }

  /**
   * 为了实现_.test()与_().test()调用都是同一个方法，所以采用下面这个方法封装；
   * 而_.mixin就是动态批量完成方法注入
   */
  _.prototype.test= function(){
    //_.test(...arguments)
    _.test.apply(this,arguments)
    console.log('prototype_test',...arguments)
  }

  //为了实现_,_();这样两种调用方式;把对象的方法，都设置到原型链上；
  _.mixin = function (obj) {
    Object.keys(obj).forEach((method)=>{
          var func = obj[method];
          _.prototype[method] = function(...arg){
            func.apply(this,arg);
          }
        });

  }

   _.mixin(_);
    //导出通用的AMD,CMD，ES6类
  if(typeof exports !='undefined' && !exports.nodeType){
   if(typeof module != 'undefined' && !module.nodeType&&module.exports){
     exports = module.exports = _;
   }
   exports._ = _;
}else{
    root._ = _;
}

})();

测试：

console.log( _().test(2,3,4))//1对象调用
console.log( _.test(1,2,3))//2函数调用

总结：

1.无new 函数化封装，为了解决有些人不愿意使用new 的方式调用方法；

2.调用方法时，需要把方法都映射到函数原型对象上面去；

3.头部尾部封装了通用的模块写法，避免了变量污染；