lodash的工具方法(二)

_.isError(value)

检查 value is an Error, EvalError, RangeError, ReferenceError,SyntaxError, TypeError, or URIError object.

function isError(value) {
  if (!isObjectLike(value)) {
    return false;
  }
  return (objectToString.call(value) == errorTag) ||
    (typeof value.message == 'string' && typeof value.name == 'string');
}

判断value是否是一个对象
objectToString以后是一个'[object Error]'
value.message和value.name都应该是字符串

_.isFinite(value)

检查value是否是一个有限数值


/** 检测node中的自由变量global. global在nodejs中的全局变量，有点类似在浏览器中的windows */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

/**检测self变量*/
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** 用作保存全局对象的引用 */
var root = freeGlobal || freeSelf || Function('return this')();

var nativeIsFinite = root.isFinite;


function isFinite(value) {
  return typeof value == 'number' && nativeIsFinite(value);
}

传入的value必须是number类型
nativeIsFinite实际上调用的是window.isFinite来判断是否是有限制。

window在代码中没看到， Function('return this')();在浏览器里运行返回的是window

_.toNumber(value)

link

_.toFinite(value)

https://segmentfault.com/a/11...

_.toInteger(value)

将value转换位一个数字。
https://segmentfault.com/a/11...

_.isInteger(value)

检查value是否是一个整数

function isInteger(value) {
  return typeof value == 'number' && value == toInteger(value);
}

当然用到了一个工具方法

/**将value转换成一个整数*/
function toInteger(value) {
  var result = toFinite(value),
      remainder = result % 1;

  return result === result ? (remainder ? result - remainder : result) : 0;
}

_.isMap(value)

判断是不是map类型。

var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;

var nodeUtil = (function() {
  try {
    return freeProcess && freeProcess.binding('util');
  } catch (e) {}
}()); // 如果是node环境，保存了util的引用
var nodeIsMap = nodeUtil && nodeUtil.isMap; // util.isMap ，nodejs 判断map类型的方法


function baseIsMap(value) {
  return isObjectLike(value) && getTag(value) == mapTag;
}// 是对象，在判断toString返回的字符串符合mapTag

_.isNaN(value)

判断是否是NaN

在js中，NaN是唯一个一个不等于自己的值。

function isNaN(value) {
  // An `NaN` primitive is the only value that is not equal to itself. NaN是唯一一个自己不等于自己的value
 
  return isNumber(value) && value != +value;
}

该方法其实是基于Number.isNaN.而不是(window || global).isNaN方法，window.isNaN(undefined)返回true。

_.isNative(value)

检查 value 是否是一个原生函数。

注意：这种方法不能可靠地检测在core-js包中存在的本地函数，因为 core-js 规避这种检测。尽管有多个请求，core-js 维护者已经明确表态：任何试图修复检测将受阻。这样一来，我们别无选择，只能抛出一个错误。不幸的是，这也影响其他的包，比如依赖于 core-js的babel-polyfill。

_.isNil(value)

检查 value 是否是 null 或者 undefined。

function isNil(){
    return value == null
}

_.isNull(value)

判断value是否等于null

    function isNull(value){
        return  value === null
    }

_.isNumber(value)

判断value是Number类型

考虑到其它几种判断类型的方法，此处判断Numberl类型的时候仍然要考虑到new Numnber()这种类型

function isNumber(value){
    return typeof value == 'number' || (isObjectLike(value)) && objectToString.call(value) == numberTag)
}

_.isRegExp(value)

判断value是RegExp类型

var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;

baseUnary其实是个很简单的方法,接收一个函数，只让它接收一个参数。

function baseUnary(func) {
  return function(value) {
    return func(value);
  };
}
/** 也就是说，对于baseUnary返回的方法，不论传入多少个参数，它只接收第一个参数*/

function consoleArgs(){
    console.log(...args)
}
var testFn  = baseUnary(consoleArgs);
testFn(1,2,3,4,5,6) // => [1]

至于说到的nodeIsRegExp便是util.isRegExp，是nodejs中的方法。
继续说baseIsRegExp便没有任何神秘感了。

function baseIsRegExp(value) {
  return isObject(value) && objectToString.call(value) == regexpTag;
}

_.isSafeInteger(value)

Checks if value is a safe integer. An integer is safe if it's an IEEE-754 double precision number which isn't the result of a rounded unsafe integer.

value是否是一个安全整数。一个安全整数应该符合IEEE-754的非双精度浮点数

Note: This method is based on
Number.isSafeInteger.

var MAX_SAFE_INTEGER = 9007199254740991,

function isSafeInteger(value) {
  return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
}

value是一个整数类型，并且在正负-MAX_SAFE_INTEGER之间

_.isSet(value)

value是否是一个set对象。

var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;

var nodeIsSet = nodeUtil && nodeUtil.isSet;判断node环境中的isSet方法存在。

浏览器的环境中，执行的是baseIsSet.

function baseIsSet(value) {
  return isObjectLike(value) && getTag(value) == setTag;
}

走到这，getTag的方法便是返回对应的value的tag.可是为什么不用Object.prototype.toString了呢

是因为，IE11等特殊情况做了兼容处理。

IE11中的date views,maps,sets,weak maps
Edge14版本一以下的data views
Nodejs中的promise

// Fallback for data views, maps, sets, and weak maps in IE 11,
// for data views in Edge < 14, and promises in Node.js.
if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
    (Map && getTag(new Map) != mapTag) ||
    (Promise && getTag(Promise.resolve()) != promiseTag) ||
    (Set && getTag(new Set) != setTag) ||
    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
  getTag = function(value) {
    var result = objectToString.call(value),
        Ctor = result == objectTag ? value.constructor : undefined,
        ctorString = Ctor ? toSource(Ctor) : undefined;

    if (ctorString) {
      switch (ctorString) {
        case dataViewCtorString: return dataViewTag;
        case mapCtorString: return mapTag;
        case promiseCtorString: return promiseTag;
        case setCtorString: return setTag;
        case weakMapCtorString: return weakMapTag;
      }
    }
    return result;
  };
}

   Ctor = result == objectTag ? value.constructor : undefined,
        ctorString = Ctor ? toSource(Ctor) : undefined;

// -
var funcToString = Function.prototype.toString

function toSource(func) {
  if (func != null) {
    try {
      return funcToString.call(func);
    } catch (e) {}
    try {
      return (func + '');
    } catch (e) {}
  }
  return '';
}

如果是个Map类型的value，通过toSource处理后，在chrome中返回"function Map() { [native code] }"。在上边的几种情况下，不能直接用Object.prototype.toString.call调用。才有了针对几种特殊情况，toSource处理后，返回修正后的tag。

_.isString(value)

检查value是否是字符串

function isString(value) {
  return typeof value == 'string' ||
    (!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag);
}

_.isSymbol(value)

检查是否是Symbol类型

function isSymbol(value) {
  return typeof value == 'symbol' ||
    (isObjectLike(value) && objectToString.call(value) == symbolTag);
}

_.isTypedArray(value)

判断是否是typedArray

var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;

function baseIsTypedArray(value) {
  return isObjectLike(value) &&
    isLength(value.length) && !!typedArrayTags[objectToString.call(value)];
}

判断是对象
且有length
toString是对应集合的属性之一

下边为typedArrayTabs的类型集合。

var arrayBufferTag = '[object ArrayBuffer]',
    dataViewTag = '[object DataView]',
    float32Tag = '[object Float32Array]',
    float64Tag = '[object Float64Array]',
    int8Tag = '[object Int8Array]',
    int16Tag = '[object Int16Array]',
    int32Tag = '[object Int32Array]',
    uint8Tag = '[object Uint8Array]',
    uint8ClampedTag = '[object Uint8ClampedArray]',
    uint16Tag = '[object Uint16Array]',
    uint32Tag = '[object Uint32Array]';

/** Used to identify `toStringTag` values of typed arrays. */
var typedArrayTags = {};
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
typedArrayTags[uint32Tag] = true;
//- 之上的tag都为true，其它为false
typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
typedArrayTags[errorTag] = typedArrayTags[funcTag] =
typedArrayTags[mapTag] = typedArrayTags[numberTag] =
typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
typedArrayTags[setTag] = typedArrayTags[stringTag] =
typedArrayTags[weakMapTag] = false;

_.isUndefined(value)

检查是否是undefined

function isUndefined(value) {
  return value === undefined;
}

_.isWeakMap(value)

检查 value 是否是 WeakMap 对象。

function isWeakMap(value) {
  return isObjectLike(value) && getTag(value) == weakMapTag;
}

参照isSet

_.isWeakSet(value)

检查 value 是否是 WeakSet 对象。

function isWeakSet(value) {
  return isObjectLike(value) && objectToString.call(value) == weakSetTag;
}

参照isSet

lodash的工具方法(二)