(function (global, factory) {

}(this, function () {}))

// commomjs 规范
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
// amd 规范
typeof define === 'function' && define.amd ? define('underscore', factory) :
// 如果都不是则 直接挂在this上
(global = global || self, (function () {
  var current = global._;
  var exports = global._ = factory();
  //防止多次引入冲突
  exports.noConflict = function () {
    global._ = current;
    return exports;
  };
}()));

// 建立根节点对象，self 在浏览器端， global 在服务端， this 在一些虚拟机中，使用self 代替 window 提供对 Webworker 的支持
var root = typeof self == 'object' && self.self === self && self ||
          typeof global == 'object' && global.global === global && global ||
          Function('return this')() ||
          {};

function optimizeCb(func, context, argCount) {

  // 没有传入执行上下文， 直接返回函数
  if (context === void 0) return func;
  switch (argCount == null ? 3 : argCount) {
    case 1:
      return function (value) {
        return func.call(context, value);
      };
      // The 2-argument case is omitted because we’re not using it.
    case 3:
      return function (value, index, collection) {
        return func.call(context, value, index, collection);
      };
    case 4:
      return function (accumulator, value, index, collection) {
        return func.call(context, accumulator, value, index, collection);
      };
  }
  return function () {
    return func.apply(context, arguments);
  };
}

var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;


// 简单获取属性值
function shallowProperty(key) {
  return function (obj) {
    return obj == null ? void 0 : obj[key];
  };
}

var getLength = shallowProperty('length');

// 属性检查 数字格式，且不能超过数组最大值
function createSizePropertyCheck(getSizeProperty) {
  return function (collection) {
    var sizeProperty = getSizeProperty(collection);
    return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= MAX_ARRAY_INDEX;
  }
}

var isArrayLike = createSizePropertyCheck(getLength);

function each(obj, iteratee, context) {
  iteratee = optimizeCb(iteratee, context);
  var i, length;
  if (isArrayLike(obj)) {
    for (i = 0, length = obj.length; i < length; i++) {
      iteratee(obj[i], i, obj);
    }
  } else {
    var _keys = keys(obj);
    for (i = 0, length = _keys.length; i < length; i++) {
      iteratee(obj[_keys[i]], _keys[i], obj);
    }
  }
  return obj;
}

//内部方法，创建一个toString 基础测试器
  function tagTester(name) {
    var tag = '[object ' + name + ']';
    return function (obj) {
      return toString.call(obj) === tag;
    };
  }
  var isFunction = tagTester('Function');
  var isFunction$1 = isFunction;

  //返回一个排序的 所有工具函数名的数组
  function functions(obj) {
    var names = [];
    for (var key in obj) {
      if (isFunction$1(obj[key])) names.push(key);
    }
    return names.sort();
  }

function _(obj) {
  if (obj instanceof _) return obj;
  if (!(this instanceof _)) return new _(obj);
  this._wrapped = obj;
}

function mixin(obj) {

  // 循环所有导出方法的名称
  each(functions(obj), function (name) {
    // 每个名称对应的方法
    var func = _[name] = obj[name];
    //  在原型上挂载同样的方法
    _.prototype[name] = function () {
      //拿到上面挂载的 传入的对象
      var args = [this._wrapped];
      // 拼接为整个数组 
      Array.prototype.push.apply(args, arguments);
      //直接用定义的内置方法执行
      return chainResult(this, func.apply(_, args));
    };
  });
  return _;
}

var allExports = {
  each:each
}

var _$1 = mixin(allExports);
// Legacy Node.js API.
_$1._ = _$1;

return _$1;

_([1,2,3]).each(function(item){console.log(item)});

yarn init -y

var add = function(a){
  return 1 + a
}

describe('测试基本api',function(){
  it('add',function(){
    except(add(1)).toBe(2)
  })
})

yarn add -D karma

{
  // 测试框架名称
  frameworks: ['jasmine'],

  //测试文件目录
  files: [
    "./test/unit/**/*.js",
    "./test/unit/**/*.spec.js"
  ],

  singleRun:true
}

 "scripts": {
  "karma-init": "karma init",
  "karma-start": "karma start"
}

yarn add -D karma-jasmine karma-phantomjs-launcher phantomjs

function add(a) {
  if (a == 1) {
    return a + 1;
  } else {
    return a + 2;
  }
}

describe('单元测试',function(){
  it("contains spec with an expectation", function() {
    expect(add(1)).toBe(2);
  })
})

{
  preprocessors: {
    "./test/unit/**/*.js":"coverage"
  },

  reporters: ['progress','coverage'],

  coverageReporter: {
    dir: 'doc/coverage',
    reporters: [
      // reporters not supporting the `file` property
      { type: 'html', subdir: 'report-html' },
    ]
  }
}

{
  "scripts": {
    "backstop-init": "backstop init",
    "backstop-start": "backstop test"
  }
}

{
  "id": "baidu",

  // 设计图分辨率设置
  "viewports": [
    {
      "label": "phone",
      "width": 375,
      "height": 667
    },
    {
      "label": "tablet",
      "width": 1024,
      "height": 768
    }
  ],

  //调用 puppeteer 库的脚本
  "onBeforeScript": "puppet/onBefore.js",
  "onReadyScript": "puppet/onReady.js",
  "scenarios": [
    {
      "label": "baidu home",
      "cookiePath": "backstop_data/engine_scripts/cookies.json",
      "url": "https://garris.github.io/BackstopJS/",
      "referenceUrl": "",
      "readyEvent": "",
      "readySelector": "",
      "delay": 0,
      "hideSelectors": [],
      "removeSelectors": [],
      "hoverSelector": "",
      "clickSelector": "",
      "postInteractionWait": 0,
      "selectors": [],
      "selectorExpansion": true,
      "expect": 0,
      "misMatchThreshold" : 0.1,
      "requireSameDimensions": true
    }
  ],
  "paths": {
    "bitmaps_reference": "backstop_data/bitmaps_reference",
    "bitmaps_test": "backstop_data/bitmaps_test",
    "engine_scripts": "backstop_data/engine_scripts",
    "html_report": "doc/backstop_data/html_report",
    "ci_report": "backstop_data/ci_report"
  },
  "report": ["browser"],
  "engine": "puppeteer",
  "engineOptions": {
    "args": ["--no-sandbox"]
  },
  "asyncCaptureLimit": 5,
  "asyncCompareLimit": 50,
  "debug": false,
  "debugWindow": false
}

var assert = require('assert'),
    factorial = require('../index');
 
suite('Test', function (){
    setup(function (){
        // Create any objects that we might need
    });
 
    suite('#factorial()', function (){
        test('equals 1 for sets of zero length', function (){
            assert.equal(1, factorial(0));
        });
 
        test('equals 1 for sets of length one', function (){
            assert.equal(1, factorial(1));
        });
 
        test('equals 2 for sets of length two', function (){
            assert.equal(2, factorial(2));
        });
 
        test('equals 6 for sets of length three', function (){
            assert.equal(6, factorial(3));
        });
    });
});

module.exports = function (n) {
    if (n < 0) return NaN;
    if (n === 0) return 1;
 
    return n * factorial(n - 1);

var assert = require('assert'),
    factorial = require('../index');
 
describe('Test', function (){
    before(function(){
        // Stuff to do before the tests, like imports, what not
    });
 
    describe('#factorial()', function (){
        it('should return 1 when given 0', function (){
            factorial(0).should.equal(1);
        });
 
        it('should return 1 when given 1', function (){
            factorial(1).should.equal(1);
        });
 
        it('should return 2 when given 2', function (){
            factorial(2).should.equal(2);
        });
 
        it('should return 6 when given 3', function (){
            factorial(3).should.equal(6);
        });
    });
 
    after(function () {
        // Anything after the tests have finished
    });
});

const partial = (fn, ...args) => {
  return (...args2) =>  fn.call(this, ...args, ...args2)
}

console.log(partial(function (a, b, c, d) {
  return a + b + c + d
}, 1, 2)(3, 4))

Function.prototype.bind = function (ctx) {
  if (typeof this !== 'function') throw new Error();
  var args = Array.prototype.slice.call(arguments, 1);
  var toBind = this;
  var fn = function _fn() {
    args = args.concat(Array.prototype.slice.call(arguments, 0))
    toBind.apply(this instanceof _fn ? this : ctx, args)
  }
  if (toBind.prototype) {
    fn.prototype = Object.create(toBind.prototype)
  }
  return fn;
}

Function.prototype.bind = function (ctx) {
  if (typeof this !== 'function') throw new Error();
  var args = Array.prototype.slice.call(arguments, 1);
  var toBind = this;
  var noop = function(){}
  var fn = function _fn() {
    args = args.concat(Array.prototype.slice.call(arguments, 0))
    toBind.apply(noop.prototype.isPrototypeOf(this) ? this : ctx, args)
  }
  if (toBind.prototype) {
    noop.prototype = toBind.prototype;
  }
  fn.prototype = new noop()
  return fn;
}

const curry = (fn, args = []) =>
  fn.length === args.length ? fn(...args) : (...args2) => curry(fn, [...args, ...args2])

const uncurry = (fn) => (...args) => fn.apply(this, args)

Function.prototype.uncurring = function () {
  var self = this;
  return function () {
    return self.apply(this, arguments);
  };
};