lodash.js--辅助函数的世界

_isPrototype.js 文件解读

判断是否是一个原型，而不是一个对象

原型有构造器，并且构造器是个fn，最后构造器指向自己。

a.prototype
a.prototype.contructor === a.prototype
function isPrototype(value) {
  var Ctor = value && value.constructor, // 获取原型对象的构造器，这是一个fn类型
      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
  // proto是构造器的原型，其指向原型对象本身
  return value === proto;
}
// 构造器是原型的一个引用。

_freeGlobal.js

node.js全局global对象判断

var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

_root.js

var freeGlobal = require('./_freeGlobal'); // 引入node环境global
var freeSelf = typeof self == 'object' && self && self.Object === Object && self; // window环境self
// 如果没有global或者self，则调用一个匿名函数返回this。间接获取顶级this指向。
var root = freeGlobal || freeSelf || Function('return this')();

_promise.js

从root里面获取promise参数。

调用getNative()->getValue()->baseIsNative()

function getNative(object, key) {
  var value = getValue(object, key); // 是否有值
  return baseIsNative(value) ? value : undefined; // 是否是自然的值
}

_getValue.js

function getValue(object, key) {
  return object == null ? undefined : object[key];
}

_baseIsNative

function baseIsNative(value) {
  if (!isObject(value) || isMasked(value)) {
    return false;
  }
  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
  return pattern.test(toSource(value));
}
// Used to match `RegExp`
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;

/** Used to detect if a method is native. */
var reIsNative = RegExp('^' +
  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
);
/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;

_isFunction.js

function isFunction(value) {
  if (!isObject(value)) {
    return false;
  }
  // The use of `Object#toString` avoids issues with the `typeof` operator
  // in Safari 9 which returns 'object' for typed arrays and other constructors.
  var tag = baseGetTag(value);
  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
}
var asyncTag = '[object AsyncFunction]',
    funcTag = '[object Function]',
    genTag = '[object GeneratorFunction]',
    proxyTag = '[object Proxy]';

_baseGetTag.js 读取对象的字符串描述

function baseGetTag(value) {
  if (value == null) { // 是null或者undefine 对象
    return value === undefined ? undefinedTag : nullTag;
  }
  // Symbol 对象
  // Object(Symbol(x))的[[primitiveValue]]（原始值）指向Symbol,运行时会被转化为symbol对象。可以输入Object(11), Object('11')查看其原始值。
  // Object(Symbol(x)).__proto__ 指向Symbol,可以浏览器查看一下。
  // 查找有没有Symbol.toStringTag 这样的属性，有的话则为symbol类型。Symbol.toStringTag 为symbol所专有的属性，可以Symbol.prototype 在原型中查找到该属性名，其值为“Symbol”。
  return (symToStringTag && symToStringTag in Object(value))
    ? getRawTag(value)
    : objectToString(value);
}
var nullTag = '[object Null]',
    undefinedTag = '[object Undefined]';
var symToStringTag = Symbol ? Symbol.toStringTag : undefined; // Symbol(Symbol.toStringTag)
// 如果是symbol对象，则循环它的值，否则为undefined

_objectToString.js 常用操作，调用原型对象的toString将对象的类型字符串打印出来。打印结果如[‘object object’]

function objectToString(value) {  return nativeObjectToString.call(value);}var objectProto = Object.prototype;var nativeObjectToString = objectProto.toString;// 一般写为 Object.prototype.toString.call(object)

_getRawTag.js 忽略symbol.toStringTag类型的获取对象描述字符串的函数

var objectProto = Object.prototype;var hasOwnProperty = objectProto.hasOwnProperty;var nativeObjectToString = objectProto.toString;var symToStringTag = Symbol ? Symbol.toStringTag : undefined;function getRawTag(value) {  var isOwn = hasOwnProperty.call(value, symToStringTag), // 自身属性是否包含symbol属性      tag = value[symToStringTag]; // 复制一份 symToStringTag 值  try {    value[symToStringTag] = undefined; // 尝试重置    var unmasked = true;  } catch (e) {}  var result = nativeObjectToString.call(value); // 返回对象字符串描述。如：[object Symbol]  if (unmasked) {    if (isOwn) { // 如果是本身拥有的，则还原。      value[symToStringTag] = tag;    } else {      delete value[symToStringTag]; // 删除该值    }  }  return result;}

_Symbol.js

// symbol 不能转换为字符串，也不能转换为数字类型，否则报错。function toKey(value) {  if (typeof value == 'string' || isSymbol(value)) {    return value;  }  var result = (value + '');  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;}var INFINITY = 1 / 0;

isSymbol.js

var symbolTag = '[object Symbol]';function isSymbol(value) {  return typeof value == 'symbol' ||    (isObjectLike(value) && baseGetTag(value) == symbolTag);}// 直接判断类型为symbol,或者是一个对象，并且里面的值是symbol类型。// let a = Symbol(111)// typeof a == 'symbol'

_isObjectLike.js 是否是类对象，判断对象是否是对象即可, undefined属于对象和数组类型，不是类对象。

function isObjectLike(value) {  return value != null && typeof value == 'object';}