var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {

  if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);

  var self = baseCreate(sourceFunc.prototype);

  var result = sourceFunc.apply(self, args);

  if (_.isObject(result)) return result;

  return self;

};

_.bind = restArguments(function(func, context, args) {

  if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');

  var bound = restArguments(function(callArgs) {

    return executeBound(func, bound, context, this, args.concat(callArgs));

  });

  return bound;

});

function foo() {}

var bindFoo = _.bind(foo, context/*没写定义，随便什么东西*/);

var bindFooInstance = new bindFoo();

_.partial = restArguments(function(func, boundArgs) {

  var placeholder = _.partial.placeholder;

  var bound = function() {

    var position = 0, length = boundArgs.length;

    var args = Array(length);

    for (var i = 0; i < length; i++) {

      args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];

    }

    while (position < arguments.length) args.push(arguments[position++]);

    return executeBound(func, bound, this, this, args);

  };

  return bound;

});

_.partial.placeholder = _;

// e.g.

function add(a, b) { return a + b; }

var addOne = _.partial(add, 1, _);

addOne(3); //

_.bindAll = restArguments(function(obj, keys) {

  keys = flatten(keys, false, false);

  var index = keys.length;

  if (index < 1) throw new Error('bindAll must be passed function names');

  while (index--) {

    var key = keys[index];

    obj[key] = _.bind(obj[key], obj);

  }

});

// e.g.

var obj = {

  name: 'xiaoming',

  age: '25',

  getName() {

    return this.name;

  },

  getAge() {

    return this.age;

  },

  sayHello() {

    return 'hello, I am ' + this.name + ' and i am ' + this.age + ' years old.';

  }

}

name = 'global name';

_.bindAll(obj, 'getName', 'getAge');

var getName = obj.getName, getAge = obj.getAge, sayHello = obj.sayHello;

getName();  // xiaoming

getAge();   //

sayHello(); // hello, I am global name and i am undefined years old.

_.memoize = function(func, hasher) {

  var memoize = function(key) {

    var cache = memoize.cache;

    var address = '' + (hasher ? hasher.apply(this, arguments) : key);

    if (!has(cache, address)) cache[address] = func.apply(this, arguments);

    return cache[address];

  };

  memoize.cache = {};

  return memoize;

};

_.delay = restArguments(function(func, wait, args) {

  return setTimeout(function() {

    return func.apply(null, args);

  }, wait);

});

_.defer = _.partial(_.delay, _, 1);

// 在指定时间间隔 wait 内只会被执行一次

// 在某一时间点 函数被执行 那么之后 wait 时间内的调用都不会被立即执行 而是设置一个定时器等到间隔等于 wait 再执行

// 如果在计时器等待的时间又被调用了 那么定时器将执行在等待时间内的最后一次调用

// options 有两个字段可填  { leading: false } 或 { trailing: false }

// { leading: false } 表示调用时不会立即执行 而是等待 wait 毫秒之后执行

// { trailing: false } 表示执行之后的 wait 时间内的调用都忽略掉

// 不要同时设置这两个字段

_.throttle = function(func, wait, options) {

  var timeout, context, args, result;

  var previous = 0;

  if (!options) options = {};

  // later 函数是定时器指定执行的函数 context, args 不是设置定时器时指定的 而是执行 later 时决定的

  var later = function() {

    // 如果 options.leading = false 的话就将 previous 设置为 0 作为标记 下一次执行 func 时就不会被立即执行了

    previous = options.leading === false ? 0 : _.now();

    timeout = null;

    result = func.apply(context, args);

    // 这里判断 !timeout 真的好迷啊...

    if (!timeout) context = args = null;

  };

  var throttled = function() {

    var now = _.now();

    // 如果没有上一次调用 或者 之前的调用已经结束 且 leading = false 会设置 previous = 0

    // previous = 0 且 options.leading = false 说明上一次 func 执行完成 此次的 fun 不需要立即执行 等 wait ms 再执行

    if (!previous && options.leading === false) previous = now;

    // 根据当前时间和上一次调用的时间间隔与 wait 比较判断

    var remaining = wait - (now - previous);

    context = this; // 注意每一次调用都会更新 context 和 args 而执行 later 用到的是这两个参数

    args = arguments; // 也就是说设置定时器时对应的参数 不一定是执行对应的参数~

    // remaining <= 0 则证明距离上次调用间隔大于 wait 了 可以被执行

    // 理论上 remaining > wait 不会存在 除非 now < previous 也就是系统时间出错了（被修改了

    if (remaining <= 0 || remaining > wait) {

      // 当设置了 leading 是不会进入这个分支的= =

      // 删除定时器 重置 previous 为当前时间 并执行 func

      if (timeout) {

        clearTimeout(timeout);

        timeout = null;

      }

      previous = now;

      result = func.apply(context, args);

      if (!timeout) context = args = null;

    }

    // 否则如果有 timeout 证明隔一段已经设置一段时间后执行 不再设置定时器

    // 间隔小于 wait 而且没有 timeout 的话 就设置一个定时器 到指定时间间隔后再执行

    // 如果 options.trailing = false 则忽略这次调用 因为时间间隔在 timeout 之内

    else if (!timeout && options.trailing !== false) {

      // 设置了 trailing 不会进入这个分支

      timeout = setTimeout(later, remaining);

    }

    return result;

  };

  // 重置 throttled 的状态 同时取消还没有执行的定时器

  throttled.cancel = function() {

    clearTimeout(timeout);

    previous = 0;

    timeout = context = args = null;

  };

  return throttled;

};

// e.g.

function log(sth) {

  console.log('===> ' + sth + '  ' + new Date().toLocaleTimeString());

}

var tLog = _.throttle(log, 1000);

// === start === 20:29:54

// ===> 1  20:29:54

// ===> 4  20:29:55

var tLog = _.throttle(log, 1000, { leading: false });

// === start === 20:30:15

// ===> 4  20:30:16

var tLog = _.throttle(log, 1000, { trailing: false });

// === start === 20:30:39

// ===> 1  20:30:39

// 不要同时设置 leading 和 trailing ~ 否则永远都不会被执行

// var tLog = _.throttle(log, 1000, { leading: false, trailing: false });

console.log('=== start === ' + new Date().toLocaleTimeString());

tLog(1);

tLog(2);

tLog(3);

tLog(4);

_.debounce = function(func, wait, immediate) {

  var timeout, result;

  var later = function(context, args) {

    timeout = null;

    if (args) result = func.apply(context, args);

  };

  var debounced = restArguments(function(args) {

    if (timeout) clearTimeout(timeout);

    if (immediate) {

      var callNow = !timeout;

      // 虽然有 timeout 但是这里的 later 没有传参所以不会执行 func

      // 只是为了标记之后的 wait 时间内都不会再执行函数

      // 如果等待的过程中又被调用 那么就从那个时间点开始再进行 wait 时间的不执行

      timeout = setTimeout(later, wait);

      if (callNow) result = func.apply(this, args);

    } else {

      timeout = _.delay(later, wait, this, args);

    }

    return result;

  });

  debounced.cancel = function() {

    clearTimeout(timeout);

    timeout = null;

  };

  return debounced;

};

// _.partial(wrapper, func) 是预先给 wrapper 传入参数 func

// 所以 _.wrap(func, wrapper) 就是 返回 wrapper 先传入 func 后返回的函数

_.wrap = function(func, wrapper) {

  return _.partial(wrapper, func);

};

// e.g.

function func(name) {

  return 'hi ' + name;

}

function wrapper(func, ...args) {

  return func(args).toUpperCase();

}

var sayHi = _.wrap(func, wrapper);

sayHi('saber', 'kido'); // HI SABER,KIDO

_.compose = function() {

  var args = arguments;

  var start = args.length - 1;

  return function() {

    var i = start;

    // 从最后一个函数开始执行

    var result = args[start].apply(this, arguments);

    // 每一个函数的入参是上一个函数的出参

    while (i--) result = args[i].call(this, result);

    return result;

  };

};

// e.g.

function getName(firstname, lastname) { return firstname + ' ' + lastname; }

function toUpperCase(str) { return str.toUpperCase(); }

function sayHi(str) { return 'Hi ' + str; }

_.compose(sayHi, toUpperCase, getName)('wenruo', 'duan'); // Hi WENRUO DUAN

_.after = function(times, func) {

  return function() {

    if (--times < 1) {

      return func.apply(this, arguments);

    }

  };

};

// e.g.

function ajax(url, fn) {

  console.log(`获取 ${url} 资源...`);

  setTimeout(() => {

    console.log(`获取 ${url} 资源完成`);

    fn();

  }, Math.random() * 1000);

}

function finish() {

  console.log('资源全部获取完成 可以进行下一步操作...');

}

var urls = ['urla', 'urlb', 'urlc'];

var finishWithAfter = _.after(urls.length, finish);

for (var i = 0; i < urls.length; i++) {

  ajax(urls[i], finishWithAfter);

}

// 获取 urla 资源...

// 获取 urlb 资源...

// 获取 urlc 资源...

// 获取 urla 资源完成

// 获取 urlc 资源完成

// 获取 urlb 资源完成

// 资源全部获取完成 可以进行下一步操作...

_.before = function(times, func) {

  var memo;

  return function() {

    if (--times > 0) {

      memo = func.apply(this, arguments);

    }

    if (times <= 1) func = null;

    return memo;

  };

};

// 调用前 times-1 次执行 之后每一次都返回之前的运行的值

var foo = _.before(3, _.identity);

console.log(foo(1)) //

console.log(foo(2)) //

console.log(foo(3)) // 2 (第 n 次开始调用不再执行 func 直接返回上一次的结果

console.log(foo(4)) //

_.once = _.partial(_.before, 2);

_.restArguments = restArguments;

// Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.

var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');

var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',

  'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];

var collectNonEnumProps = function(obj, keys) {

  var nonEnumIdx = nonEnumerableProps.length;

  var constructor = obj.constructor;

  var proto = _.isFunction(constructor) && constructor.prototype || ObjProto;

  // Constructor is a special case.

  var prop = 'constructor';

  if (has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);

  while (nonEnumIdx--) {

    prop = nonEnumerableProps[nonEnumIdx];

    if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {

      keys.push(prop);

    }

  }

};

_.keys = function(obj) {

  if (!_.isObject(obj)) return [];

  if (nativeKeys) return nativeKeys(obj);

  var keys = [];

  for (var key in obj) if (has(obj, key)) keys.push(key);

  // Ahem, IE < 9.

  if (hasEnumBug) collectNonEnumProps(obj, keys);

  return keys;

};

_.allKeys = function(obj) {

  if (!_.isObject(obj)) return [];

  var keys = [];

  for (var key in obj) keys.push(key);

  // Ahem, IE < 9.

  if (hasEnumBug) collectNonEnumProps(obj, keys);

  return keys;

};

_.values = function(obj) {

  var keys = _.keys(obj);

  var length = keys.length;

  var values = Array(length);

  for (var i = 0; i < length; i++) {

    values[i] = obj[keys[i]];

  }

  return values;

};

_.mapObject = function(obj, iteratee, context) {

  iteratee = cb(iteratee, context);

  var keys = _.keys(obj),

      length = keys.length,

      results = {};

  for (var index = 0; index < length; index++) {

    var currentKey = keys[index];

    results[currentKey] = iteratee(obj[currentKey], currentKey, obj);

  }

  return results;

};

// e.g.

var _2camel = str => str.replace(/_(\w)/g, (item, letter) => letter.toUpperCase());

var obj = { first: 'mo_li_xiang_pian', second: 'yong_ren_zi_rao' };

_.mapObject(obj, _2camel); // { first: 'moLiXiangPian', second: 'yongRenZiRao' }

_.pairs = function(obj) {

  var keys = _.keys(obj);

  var length = keys.length;

  var pairs = Array(length);

  for (var i = 0; i < length; i++) {

    pairs[i] = [keys[i], obj[keys[i]]];

  }

  return pairs;

};

_.invert = function(obj) {

  var result = {};

  var keys = _.keys(obj);

  for (var i = 0, length = keys.length; i < length; i++) {

    result[obj[keys[i]]] = keys[i];

  }

  return result;

};

_.functions = _.methods = function(obj) {

  var names = [];

  for (var key in obj) {

    if (_.isFunction(obj[key])) names.push(key);

  }

  return names.sort();

};

var createAssigner = function(keysFunc, defaults) { // [defaults] {Boolean}

  return function(obj) {

    var length = arguments.length;

    if (defaults) obj = Object(obj); //  把 obj 转成对象

    if (length < 2 || obj == null) return obj;

    for (var index = 1; index < length; index++) {

      var source = arguments[index],

          keys = keysFunc(source), // keysFunc 是获取对象指定的 key 集合的函数

          l = keys.length;

      for (var i = 0; i < l; i++) {

        var key = keys[i];

        // 如果设置 defaults 则只有在在当前对象没有 key 属性的时候 才添加 key 属性

        // 否则就为 obj 添加 key 属性 存在就替换

        if (!defaults || obj[key] === void 0) obj[key] = source[key];

      }

    }

    return obj;

  };

};

_.extend = createAssigner(_.allKeys);

// _.extend(obj, ...otherObjs)

// 把 otherObjs 上面的所有的属性都添加到 obj 上 相同属性后面会覆盖前面的

_.extendOwn = _.assign = createAssigner(_.keys);

// _.extendOwn(obj, ...otherObjs)

// 把 otherObjs 上面的所有的自有属性都添加到 obj 上 相同属性后面会覆盖前面的

_.defaults = createAssigner(_.allKeys, true);

// _.extend(obj, ...otherObjs)

// 对 otherObjs 上面的所有的属性 如果 obj 不存在相同属性名的话 就添加到 obj 上 相同属性后面被忽略

var keyInObj = function(value, key, obj) {

  return key in obj;

};

_.pick = restArguments(function(obj, keys) {

  // 通过 restArguments 传入的参数除了第一个都被合成了一个数组 keys

  var result = {}, iteratee = keys[0];

  if (obj == null) return result;

  if (_.isFunction(iteratee)) {

    // 如果 iteratee (keys[0]) 是一个函数

    // 可以看做是 _.pick(obj, iteratee, context)

    // obj 中符合 iteratee(value, key, obj) 的键值对被返回

    if (keys.length > 1) iteratee = optimizeCb(iteratee, keys[1]);

    keys = _.allKeys(obj);

  } else {

    // 如果 iteratee (keys[0]) 不是函数

    // 将 keys 数组递归压平 成为一个新数组 keys

    // 对于 obj 中的属性在 keys 中的键值对被返回

    iteratee = keyInObj;

    keys = flatten(keys, false, false);

    obj = Object(obj);

  }

  for (var i = 0, length = keys.length; i < length; i++) {

    var key = keys[i];

    var value = obj[key];

    if (iteratee(value, key, obj)) result[key] = value;

  }

  return result;

});

_.omit = restArguments(function(obj, keys) {

  var iteratee = keys[0], context;

  if (_.isFunction(iteratee)) {

    iteratee = _.negate(iteratee);

    if (keys.length > 1) context = keys[1];

  } else {

    keys = _.map(flatten(keys, false, false), String);

    iteratee = function(value, key) {

      return !_.contains(keys, key);

    };

  }

  return _.pick(obj, iteratee, context);

});

_.create = function(prototype, props) {

  var result = baseCreate(prototype);

  if (props) _.extendOwn(result, props);

  return result;

};

_.clone = function(obj) {

  if (!_.isObject(obj)) return obj;

  return _.isArray(obj) ? obj.slice() : _.extend({}, obj);

};

// chain 是一个函数 传入一个对象 obj 返回一个下划线的实例，该实例有一个 _wrapped 属性为 obj 同时有 _chain 属性为 true 标记此对象用于链式调用

_.chain = function(obj) {

  var instance = _(obj);

  instance._chain = true;

  return instance;

};

// 返回链式结果 如果当前实例就有 _chain 则将结果包装成链式对象返回 否则就直接返回对象本身

var chainResult = function(instance, obj) {

  return instance._chain ? _(obj).chain() : obj;

};

// 将对象 obj 中的函数添加到 _.prototype

_.mixin = function(obj) {

  // 对于 obj 中每一为函数的属性

  _.each(_.functions(obj), function(name) {

    // 都将该属性赋值给下划线

    var func = _[name] = obj[name];

    // 同时在下划线的原型链上挂这个函数 同时这个函数可以支持链式调用

    _.prototype[name] = function() {

      var args = [this._wrapped];

      push.apply(args, arguments);

      // 将 this._wrapped 添加到 arguments 最前面传入 func

      // 因为 this._wrapped 就是生成的一个下划线实例的原始的值

      // func 运行的 this 是 _ 把 this._wrapped 也就是上一个链式函数的运行结果 传入 func

      // 将 this 和 func 的返回值传入 chainResult

      // 如果 this 是一个链式对象（有 _chain 属性）就继续返回链式对象

      // 否则直接返回 obj

      return chainResult(this, func.apply(_, args));

    };

  });

  return _;

};

// Add all of the Underscore functions to the wrapper object.

// 将 _ 传入 mixin

// 下划线上每一个函数都会被绑定到 _.prototype 这样这些函数才能被实例访问

_.mixin(_);

// Add all mutator Array functions to the wrapper.

// 把一些数组相关的函数也加到 _.prototype

_.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {

  var method = ArrayProto[name];

  _.prototype[name] = function() {

    var obj = this._wrapped;

    method.apply(obj, arguments);

    if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];

    return chainResult(this, obj);

  };

});

// Add all accessor Array functions to the wrapper.

_.each(['concat', 'join', 'slice'], function(name) {

  var method = ArrayProto[name];

  _.prototype[name] = function() {

    return chainResult(this, method.apply(this._wrapped, arguments));

  };

});

// 从一个含有链式的 _ 实例中获取本来的值

_.prototype.value = function() {

  return this._wrapped;

};

_.tap = function(obj, interceptor) {

  interceptor(obj);

  return obj;

};

// e.g.

let obj = [1, 2, 3];

let interceptor = (x) => { console.log('中间值是：', x) }

let result = _(obj).chain().map(x => x * x).tap(interceptor).filter(x => x < 5).max().value();

//              [1,2,3]      [1,4,9]        打印中间值         [1,4]            取最大值 4

//  .value() 就是从 _ 实例 这里是 { [Number: 4] _wrapped: 4, _chain: true } 获取本来的数据

console.log(result);

// 中间值是： [ 1, 4, 9 ]

//

// Internal recursive comparison function for `isEqual`.

var eq, deepEq;

eq = function(a, b, aStack, bStack) {

  // Identical objects are equal. `0 === -0`, but they aren't identical.

  // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).

  if (a === b) return a !== 0 || 1 / a === 1 / b;

  // `null` or `undefined` only equal to itself (strict comparison).

  if (a == null || b == null) return false;

  // `NaN`s are equivalent, but non-reflexive.

  if (a !== a) return b !== b;

  // Exhaust primitive checks

  var type = typeof a;

  if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;

  return deepEq(a, b, aStack, bStack);

};

// Internal recursive comparison function for `isEqual`.

deepEq = function(a, b, aStack, bStack) {

  // Unwrap any wrapped objects.

  if (a instanceof _) a = a._wrapped;

  if (b instanceof _) b = b._wrapped;

  // Compare `[[Class]]` names.

  var className = toString.call(a);

  if (className !== toString.call(b)) return false;

  switch (className) {

    // Strings, numbers, regular expressions, dates, and booleans are compared by value.

    case '[object RegExp]':

    // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')

    case '[object String]':

      // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is

      // equivalent to `new String("5")`.

      return '' + a === '' + b;

    case '[object Number]':

      // `NaN`s are equivalent, but non-reflexive.

      // Object(NaN) is equivalent to NaN.

      if (+a !== +a) return +b !== +b;

      // An `egal` comparison is performed for other numeric values.

      return +a === 0 ? 1 / +a === 1 / b : +a === +b;

    case '[object Date]':

    case '[object Boolean]':

      // Coerce dates and booleans to numeric primitive values. Dates are compared by their

      // millisecond representations. Note that invalid dates with millisecond representations

      // of `NaN` are not equivalent.

      return +a === +b;

    case '[object Symbol]':

      return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);

  }

  var areArrays = className === '[object Array]';

  if (!areArrays) {

    // 如果不是数组也不是对象的话 其他情况都已经比较完了 所以一定是 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.

    // 如果都是自定义类型的实例 都有 constructor 的话 那么构造函数一定要相等

    var aCtor = a.constructor, bCtor = b.constructor;

    if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&

                             _.isFunction(bCtor) && bCtor instanceof bCtor)

                        && ('constructor' in a && 'constructor' in b)) {

      return false;

    }

  }

  // Assume equality for cyclic structures. The algorithm for detecting cyclic

  // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.

  // Initializing stack of traversed objects.

  // It's done here since we only need them for objects and arrays comparison.

  // 比较 stack 是为了防止对象的一个属性是对象本身这种情况

  // let obj = {}; obj.prop = obj;

  // 这种情况下比较对象再比较对象的每一个属性 就会发生死循环

  // 所以比较到每一个属性的时候都要判断和之前的对象有没有相等的

  // 如果相等的话 就判断另一个对象是不是也这样 来判断两个对象是否相等

  // 而不需要继续比较下去了~ 是不是很巧妙~

  aStack = aStack || [];

  bStack = bStack || [];

  var length = aStack.length;

  while (length--) {

    // Linear search. Performance is inversely proportional to the number of

    // unique nested structures.

    if (aStack[length] === a) return bStack[length] === b;

  }

  // Add the first object to the stack of traversed objects.

  aStack.push(a);

  bStack.push(b);

  // Recursively compare objects and arrays.

  if (areArrays) {

    // 如果是数组的话 需要比较其每一项都相等

    // Compare array lengths to determine if a deep comparison is necessary.

    length = a.length;

    if (length !== b.length) return false;

    // Deep compare the contents, ignoring non-numeric properties.

    while (length--) {

      if (!eq(a[length], b[length], aStack, bStack)) return false;

    }

  } else {

    // 如果是对象的话 需要比较其每一个键都相等 对应的值再深度比较

    // Deep compare objects.

    var keys = _.keys(a), key;

    length = keys.length;

    // Ensure that both objects contain the same number of properties before comparing deep equality.

    if (_.keys(b).length !== length) return false;

    while (length--) {

      // Deep compare each member

      key = keys[length];

      if (!(has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;

    }

  }

  // Remove the first object from the stack of traversed objects.

  // 讨论一个为什么要出栈 这个有点像 dfs 哈

  // obj = { a: { a1: ... }, b: { b1: ... } }

  // 判断属性 a 的时候栈里是 [obj] 然后判断 a != obj

  // 接下来会递归判断 a1 以及其下属性

  // 到 a1 的时候 栈中元素为 [obj, a]

  // 当属性 a 被判断完全相等后 需要继续比较 b 属性

  // 当比较到 b 的时候 栈中应该是 [obj] 而不是 [obj, a]

  // a == b 不会造成死循环 我们不需要对不是父子（或祖先）关系的属性进行比较

  // 综上 这里需要出栈（大概没讲明白...反正我明白了...

  aStack.pop();

  bStack.pop();

  return true;

};

// Perform a deep comparison to check if two objects are equal.

_.isEqual = function(a, b) {

  return eq(a, b);

};

_.isEmpty = function(obj) {

  if (obj == null) return true;

  if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;

  return _.keys(obj).length === 0;

};

_.isElement = function(obj) {

  return !!(obj && obj.nodeType === 1);

};

_.isArray = nativeIsArray || function(obj) {

  return toString.call(obj) === '[object Array]';

};

// Is a given variable an object?

_.isObject = function(obj) {

  var type = typeof obj;

  return type === 'function' || type === 'object' && !!obj;

};

_.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error', 'Symbol', 'Map', 'WeakMap', 'Set', 'WeakSet'], function(name) {

  _['is' + name] = function(obj) {

    return toString.call(obj) === '[object ' + name + ']';

  };

});

if (!_.isArguments(arguments)) {

  _.isArguments = function(obj) {

    return has(obj, 'callee');

  };

}

Object.prototype.toString.apply(arguments) === '[object Arguments]'

// Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,

// IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).

var nodelist = root.document && root.document.childNodes;

if (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') {

  _.isFunction = function(obj) {

    return typeof obj == 'function' || false;

  };

}

// Is a given object a finite number?

_.isFinite = function(obj) {

  return !_.isSymbol(obj) && isFinite(obj) && !isNaN(parseFloat(obj));

};

// Is the given value `NaN`?

_.isNaN = function(obj) {

  return _.isNumber(obj) && isNaN(obj);

};

// Is a given value a boolean?

_.isBoolean = function(obj) {

  return obj === true || obj === false || toString.call(obj) === '[object Boolean]';

};

// Is a given value equal to null?

_.isNull = function(obj) {

  return obj === null;

};

// Is a given variable undefined?

_.isUndefined = function(obj) {

  return obj === void 0;

};

_.has = function(obj, path) {

  if (!_.isArray(path)) {

    return has(obj, path);

  }

  var length = path.length;

  for (var i = 0; i < length; i++) {

    var key = path[i];

    if (obj == null || !hasOwnProperty.call(obj, key)) {

      return false;

    }

    obj = obj[key];

  }

  return !!length;

};

// e.g.

let obj = { a: { b: { c: 1 } } };

_.has(obj, ['a', 'b', 'c']); // true

_.has(obj, ['a', 'b', 'd']); // false

_.has(obj, []); // false

_.noConflict = function() {

  root._ = previousUnderscore;

  return this;

};

_.identity = function(value) {

  return value;

};

var a = [null, null, [1,2,3], null, [10, 12], null];

a.filter(_.identity)

_.constant = function(value) {

  return function() {

    return value;

  };

};

// e.g.

// api: image.fill( function(x, y) { return color })

image.fill( _.constant( black ) );

_.noop = function(){};

_.propertyOf = function(obj) {

  if (obj == null) {

    return function(){};

  }

  return function(path) {

    return !_.isArray(path) ? obj[path] : deepGet(obj, path);

  };

};

_.times = function(n, iteratee, context) {

  var accum = Array(Math.max(0, n)); // n 不能小于 0

  iteratee = optimizeCb(iteratee, context, 1);

  for (var i = 0; i < n; i++) accum[i] = iteratee(i);

  return accum;

};

// e.g.

_.times(6, i => i * i); // [ 0, 1, 4, 9, 16, 25 ]

_.times(6, _.identity); // [ 0, 1, 2, 3, 4, 5 ]

_.now = Date.now || function() {

  return new Date().getTime();

};

// 一些 HTML 的转义字符

var escapeMap = {

  '&': '&',

  '<': '&lt;',

  '>': '&gt;',

  '"': '&quot;',

  "'": ''',

  '`': '`'

};

var unescapeMap = _.invert(escapeMap);

// Functions for escaping and unescaping strings to/from HTML interpolation.

var createEscaper = function(map) {

  // 以传入 escapeMap 举例

  var escaper = function(match) {

    // 返回对应的转义后的字符串

    return map[match];

  };

  // 生成一个正则表达式用来匹配所有的需要转义的字符 (?:&|<|>|"|'|`)

  // 正则表达式有两种创建方式 通过 /.../ 字面量直接创建 或者通过 new RegExp(regStr) 创建

  // 这里的 ?: 表示正则表达不捕获分组 如果不添加这个的话 在 replace 中可使用 $i 代替捕获的分组

  // 比如

  // '2015-12-25'.replace(/(\d{4})-(\d{2})-(\d{2})/g,'$2/$3/$1'); --> "12/25/2015"

  // '2015-12-25'.replace(/(?:\d{4})-(\d{2})-(\d{2})/g,'$2/$3/$1'); -->  "25/$3/12"

  // 为了防止 $1 变成捕获的字符串这里使用了 ?: （其实好像也用不到吧= =

  var source = '(?:' + _.keys(map).join('|') + ')';

  var testRegexp = RegExp(source); // 生成的正则表达式 /(?:&|<|>|"|'|`)/

  var replaceRegexp = RegExp(source, 'g'); // 生成的正则表达式 /(?:&|<|>|"|'|`)/g

  return function(string) {

    string = string == null ? '' : '' + string;

    return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;

  };

};

_.escape = createEscaper(escapeMap);

_.unescape = createEscaper(unescapeMap);

// e.g.

_.escape('<html></html>') // &lt;html&gt;&lt;/html&gt;

_.unescape('&lt;html&gt;&lt;/html&gt;') // <html></html>

_.result = function(obj, path, fallback) {

  if (!_.isArray(path)) path = [path];

  var length = path.length;

  if (!length) {

    return _.isFunction(fallback) ? fallback.call(obj) : fallback;

  }

  for (var i = 0; i < length; i++) {

    var prop = obj == null ? void 0 : obj[path[i]];

    if (prop === void 0) {

      prop = fallback;

      i = length; // Ensure we don't continue iterating.

    }

    obj = _.isFunction(prop) ? prop.call(obj) : prop;

  }

  return obj;

};

// e.g.

_.result({ a: { b: 2 } }, ['a','d'], () => 'failed');   // failed

_.result({ a: { b: 2 } }, ['a','b'], () => 'failed');   //

_.result({ a: () => ({ b: 2 }) }, ['a','b'], 'failed'); //

_.result({ a: () => ({ b: 2 }) }, ['a','d'], 'failed'); // failed

var idCounter = 0;

_.uniqueId = function(prefix) {

  var id = ++idCounter + '';

  return prefix ? prefix + id : id;

};

// e.g.

_.uniqueId('DWR'); // DWR1

_.uniqueId('DWR'); // DWR2

_.uniqueId('XIA');   // XIA3

let template = `

<lable>用户ID：</lable><span><%= userId %></span>

<lable>用户名：</lable><span><%= username %></span>

<lable>用户密码：</lable><span><%- password %></span>

<%

if (userId === 1) { console.log('管理员登录...') }

else { console.log('普通用户登录...') }

%>

`

let render = _.template(template);

render({userId: 1, username: '管理员', password: '<pwd>'});

/* render 返回:

<lable>用户ID：</lable><span>1</span>

<lable>用户名：</lable><span>管理员</span>

<lable>用户密码：</lable><span>&lt;pwd&gt;</span>

*/

// 同时控制台打印: 管理员登录...

_.templateSettings = {

evaluate: /<%([\s\S]+?)%>/g, // <% %> js脚本

interpolate: /<%=([\s\S]+?)%>/g, // <%= %> 表达式

escape: /<%-([\s\S]+?)%>/g // <%- %> 表达式 生成后对 html 字符进行转义 如 < 转义为 &lt; 防止 XSS 攻击

};

let settings = { interpolate: /{{([\s\S]+?)}}/ }

let template = `

<div>欢迎{{ data }}登录</div>

`;

let render = _.template(template, { interpolate: /{{([\s\S]+?)}}/, variable: 'data' });

render('OvO'); // <div>欢迎OvO登录</div>

// \s  匹配一个空白字符，包括空格、制表符、换页符和换行符。

// \S  匹配一个非空白字符。

// 所以 \s\S 就是匹配所有字符 和 . 比起来它多匹配了换行

_.templateSettings = {

  evaluate: /<%([\s\S]+?)%>/g,      // <%  %>

  interpolate: /<%=([\s\S]+?)%>/g,  // <%= %>

  escape: /<%-([\s\S]+?)%>/g        // <%- %>

};

// 这是一个一定不会匹配的正则表达式

var noMatch = /(.)^/;

// 因为后面要拼接一个函数体 有些字符放到字符串需要被转义 这里定义了需要转义的字符

// \u2028 和 \u2029 不知道是啥 不想查了= =

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) { // oldSettings 为了向下兼容 可以无视

  if (!settings && oldSettings) settings = oldSettings;

  // 可以传入 settings 要和 _.templateSettings 中属性名相同来覆盖 templateSettings

  settings = _.defaults({}, settings, _.templateSettings);

  // reg.source 返回正则表达式两个斜杠之间的字符串 /\d+/g --> "\d+"

  // matcher 就是把三个正则连起来 /<%-([\s\S]+?)%>|<%=([\s\S]+?)%>|<%([\s\S]+?)%>|$/g

  // 加了一个 $ 表示匹配字符串结尾

  var matcher = RegExp([

    (settings.escape || noMatch).source,

    (settings.interpolate || noMatch).source,

    (settings.evaluate || noMatch).source

  ].join('|') + '|$', 'g');

  var index = 0;

  var source = "__p+='";

  // 假设传入的 text 是 '<p><%=x+1%></p>'

  text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {

    // 函数的参数分别是：

    // 匹配的字符串

    // 匹配的分组（有三个括号，所以有三个分组，分别表示 escape, interpolate, evaluate 匹配的表达式）

    // 匹配字符串的下标

    // 第一次匹配： "<p><%=x+1%></p>" 会和 interpolate: /<%=([\s\S]+?)%>/g 匹配 interpolate 的值为 "x+1"

    // index = 0, offset 匹配的起始下标 就是截取字符串最前面未匹配的那一段

    // text.slice(index, offset) 就是 "<p>" 此时的 source 就是 "__p+='<p>"

    // replace(escapeRegExp, escapeChar) 的作用是：

    // source 拼接的是一个 '' 包裹的字符串 有些字符放到 ' ' 里需要被转义

    // 第二次匹配：匹配字符串（"<p><%=x+1%></p>"）结尾

    // text.slice(index, offset) 此时获取的是 "</p>"

    // 拼接后 source 为 "__p+='<p>'+\n((__t=(x+1))==null?'':__t)+\n'</p>"

    source += text.slice(index, offset).replace(escapeRegExp, escapeChar);

    index = offset + match.length; // 匹配的起始下标+匹配字符串长度 就是匹配字符串末尾的下标

    if (escape) {

      // ((__t = (_.escape(escape))) == null ? '' : __t)

      // _.escape 是将生成的表达式中的 html 字符进行转义

      source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";

    } else if (interpolate) {

      // ((__t = (interpolate)) == null ? '' : __t)

      source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";

    } else if (evaluate) {

      // 前面的字符串加分号 同时执行该脚本

      source += "';\n" + evaluate + "\n__p+='";

    }

    // 第一次匹配后 interpolate 为 "x+1"

    // 此时 source 是 "__p+='<p>'+\n((__t=(x+1))==null?'':__t)+\n'"

    // 第二次匹配 escape、interpolate、evaluate 都不存在 不会改变 source

    // Adobe VMs need the match returned to produce the correct offset.

    // 返回 match 只是为了获取正确的 offset 而替换后的 text 并没有改变

    return match;

  });

  source += "';\n";

  // 如果没有指定 settings.variable 就添加 with 指定作用域

  // 添加 with 之后 source 为 "with(obj||{}){\n__p+='<p>'+\n((__t=(x+1))==null?'':__t)+\n'</p>\';\n}\n"

  if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';

  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,'');};

  // with(obj||{}){

  // __p+='<p>'+

  // ((__t=(x+1))==null?'':__t)+

  // '</p>';\n}\nreturn __p;

  // "

  var render;

  try {

    // 传入的参数1： settings.variable || obj

    // 传入的参数2： _ 使用于可以在插值中使用 _ 里的函数

    // 函数体 source

    render = new Function(settings.variable || 'obj', '_', source);

    /* 生成函数 render

      function anonymous(obj, _) {

        var __t, __p = '',

          __j = Array.prototype.join,

          print = function() {

            __p += __j.call(arguments, '');

          };

        with(obj || {}) {

          __p += '<p>' +

            ((__t = (x + 1)) == null ? '' : __t) +

            '</p>';

        }

        return __p;

      }

    */

  } catch (e) {

    e.source = source;

    throw e;

  }

  var template = function(data) {

    return render.call(this, data, _);

  };

  // Provide the compiled source as a convenience for precompilation.

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

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

  return template;

};

var template = _.template("<p><%=x+1%></p>");

template({x: 'void'}) // <p>void1</p>

_.prototype.value = function() {

  return this._wrapped;

};

_.prototype.valueOf = _.prototype.toJSON = _.prototype.value;

_.prototype.toString = function() {

  return String(this._wrapped);

};

if (typeof define == 'function' && define.amd) {

  define('underscore', [], function() {

    return _;

  });

}