Lodash中有哪些类型检查方法？请举例说明它们的用法 - 面试题

Lodash提供了丰富的类型检查方法，以下是关于Lodash类型检查的详细解答：

Lodash类型检查方法概述

Lodash提供了许多类型检查方法，用于判断值的类型。这些方法比原生的typeof和instanceof更准确、更可靠。

1. 基本类型检查

`_.isBoolean(value)`

检查值是否是布尔类型。

javascript
_.isBoolean(false);
// => true

_.isBoolean(null);
// => false

// 实际应用：验证布尔参数
function processFlag(flag) {
  if (!_.isBoolean(flag)) {
    throw new Error('Flag must be a boolean');
  }
  return flag ? 'enabled' : 'disabled';
}

`_.isNumber(value)`

检查值是否是数字。

javascript
_.isNumber(3);
// => true

_.isNumber(Number.MIN_VALUE);
// => true

_.isNumber(Infinity);
// => true

_.isNumber('3');
// => false

// 实际应用：验证数字输入
function calculateDiscount(price, discount) {
  if (!_.isNumber(price) || !_.isNumber(discount)) {
    throw new Error('Price and discount must be numbers');
  }
  return price * (1 - discount);
}

`_.isString(value)`

检查值是否是字符串。

javascript
_.isString('abc');
// => true

_.isString(1);
// => false

// 实际应用：验证字符串输入
function sanitizeInput(input) {
  if (!_.isString(input)) {
    return String(input);
  }
  return _.trim(input);
}

`_.isFunction(value)`

检查值是否是函数。

javascript
_.isFunction(_);
// => true

_.isFunction(/abc/);
// => false

// 实际应用：验证回调函数
function executeCallback(callback) {
  if (!_.isFunction(callback)) {
    console.warn('Callback is not a function');
    return;
  }
  callback();
}

2. 对象类型检查

`_.isObject(value)`

检查值是否是对象类型（包括数组、函数、对象等）。

javascript
_.isObject({});
// => true

_.isObject([1, 2, 3]);
// => true

_.isObject(_.noop);
// => true

_.isObject(null);
// => false

// 实际应用：检查是否为对象类型
function processValue(value) {
  if (_.isObject(value)) {
    return _.cloneDeep(value);
  }
  return value;
}

`_.isPlainObject(value)`

检查值是否是普通对象（通过Object构造函数创建的对象）。

javascript
function Foo() {
  this.a = 1;
}

_.isPlainObject(new Foo());
// => false

_.isPlainObject([1, 2, 3]);
// => false

_.isPlainObject({ 'x': 0, 'y': 0 });
// => true

_.isPlainObject(Object.create(null));
// => true

// 实际应用：验证配置对象
function validateConfig(config) {
  if (!_.isPlainObject(config)) {
    throw new Error('Config must be a plain object');
  }
  return config;
}

`_.isObjectLike(value)`

检查值是否是类对象（非null且typeof为'object'）。

javascript
_.isObjectLike({});
// => true

_.isObjectLike([1, 2, 3]);
// => true

_.isObjectLike(_.noop);
// => false

_.isObjectLike(null);
// => false

3. 数组类型检查

`_.isArray(value)`

检查值是否是数组。

javascript
_.isArray([1, 2, 3]);
// => true

_.isArray(document.body.children);
// => false

_.isArray('abc');
// => false

_.isArray(_.noop);
// => false

// 实际应用：验证数组输入
function processItems(items) {
  if (!_.isArray(items)) {
    items = [items];
  }
  return _.map(items, item => transform(item));
}

`_.isArrayLike(value)`

检查值是否是类数组（有length属性且为非负整数）。

javascript
_.isArrayLike([1, 2, 3]);
// => true

_.isArrayLike(document.body.children);
// => true

_.isArrayLike('abc');
// => true

_.isArrayLike(_.noop);
// => false

4. 空值检查

`_.isEmpty(value)`

检查值是否为空。

javascript
_.isEmpty(null);
// => true

_.isEmpty(true);
// => true

_.isEmpty(1);
// => true

_.isEmpty([1, 2, 3]);
// => false

_.isEmpty({ 'a': 1 });
// => false

_.isEmpty('');
// => true

_.isEmpty(' ');
// => false

// 实际应用：验证必填字段
function validateRequired(value, fieldName) {
  if (_.isEmpty(value)) {
    throw new Error(`${fieldName} is required`);
  }
  return value;
}

`_.isNil(value)`

检查值是否为null或undefined。

javascript
_.isNil(null);
// => true

_.isNil(void 0);
// => true

_.isNil(NaN);
// => false

// 实际应用：安全访问属性
function safeGet(obj, path) {
  const value = _.get(obj, path);
  return _.isNil(value) ? null : value;
}

5. 数字类型检查

`_.isInteger(value)`

检查值是否是整数。

javascript
_.isInteger(3);
// => true

_.isInteger(Number.MIN_VALUE);
// => false

_.isInteger(Infinity);
// => false

_.isInteger('3');
// => false

// 实际应用：验证整数输入
function validateCount(count) {
  if (!_.isInteger(count) || count < 0) {
    throw new Error('Count must be a positive integer');
  }
  return count;
}

`_.isFinite(value)`

检查值是否是有限数字。

javascript
_.isFinite(3);
// => true

_.isFinite(Number.MIN_VALUE);
// => true

_.isFinite(Infinity);
// => false

_.isFinite('3');
// => false

// 实际应用：验证有限数字
function calculate(value) {
  if (!_.isFinite(value)) {
    throw new Error('Value must be a finite number');
  }
  return Math.sqrt(value);
}

`_.isNaN(value)`

检查值是否是NaN（比原生isNaN更准确）。

javascript
_.isNaN(NaN);
// => true

_.isNaN(new Number(NaN));
// => true

isNaN(undefined);
// => true

_.isNaN(undefined);
// => false

// 实际应用：验证数字计算结果
function divide(a, b) {
  const result = a / b;
  if (_.isNaN(result)) {
    throw new Error('Invalid calculation result');
  }
  return result;
}

6. 日期和正则表达式检查

`_.isDate(value)`

检查值是否是日期对象。

javascript
_.isDate(new Date());
// => true

_.isDate('Mon April 23 2012');
// => false

// 实际应用：验证日期输入
function formatDate(date) {
  if (!_.isDate(date)) {
    date = new Date(date);
  }
  return date.toISOString();
}

`_.isRegExp(value)`

检查值是否是正则表达式。

javascript
_.isRegExp(/abc/);
// => true

_.isRegExp('/abc/');
// => false

// 实际应用：验证正则表达式
function compilePattern(pattern) {
  if (_.isRegExp(pattern)) {
    return pattern;
  }
  return new RegExp(pattern);
}

7. 元素检查

`_.isElement(value)`

检查值是否是DOM元素。

javascript
_.isElement(document.body);
// => true

_.isElement('<body>');
// => false

// 实际应用：验证DOM元素
function attachListener(element, event, handler) {
  if (!_.isElement(element)) {
    throw new Error('Element must be a DOM element');
  }
  element.addEventListener(event, handler);
}

`_.isArguments(value)`

检查值是否是arguments对象。

javascript
_.isArguments(function() { return arguments; }());
// => true

_.isArguments([1, 2, 3]);
// => false

8. 其他类型检查

`_.isError(value)`

检查值是否是Error对象。

javascript
_.isError(new Error());
// => true

_.isError(Error);
// => false

// 实际应用：错误处理
function handleError(error) {
  if (_.isError(error)) {
    console.error(error.message);
    return;
  }
  console.error('Unknown error:', error);
}

`_.isSymbol(value)`

检查值是否是Symbol。

javascript
_.isSymbol(Symbol.iterator);
// => true

_.isSymbol('abc');
// => false

// 实际应用：检查Symbol属性
function hasSymbolProperty(obj, sym) {
  return _.isSymbol(sym) && sym in obj;
}

`_.isTypedArray(value)`

检查值是否是类型化数组。

javascript
_.isTypedArray(new Uint8Array());
// => true

_.isTypedArray([]);
// => false

// 实际应用：处理二进制数据
function processData(data) {
  if (_.isTypedArray(data)) {
    return processBinaryData(data);
  }
  return processRegularData(data);
}

`_.isWeakMap(value)`

检查值是否是WeakMap。

javascript
_.isWeakMap(new WeakMap());
// => true

_.isWeakMap(new Map());
// => false

`_.isWeakSet(value)`

检查值是否是WeakSet。

javascript
_.isWeakSet(new WeakSet());
// => true

_.isWeakSet(new Set());
// => false

`_.isMap(value)`

检查值是否是Map。

javascript
_.isMap(new Map());
// => true

_.isMap(new WeakMap());
// => false

`_.isSet(value)`

检查值是否是Set。

javascript
_.isSet(new Set());
// => true

_.isSet(new WeakSet());
// => false

实际应用示例

类型验证器

javascript
class TypeValidator {
  static validate(value, type) {
    const validators = {
      'string': _.isString,
      'number': _.isNumber,
      'boolean': _.isBoolean,
      'array': _.isArray,
      'object': _.isPlainObject,
      'function': _.isFunction,
      'date': _.isDate,
      'regexp': _.isRegExp
    };

    const validator = validators[type];
    if (!validator) {
      throw new Error(`Unknown type: ${type}`);
    }

    return validator(value);
  }

  static validateSchema(data, schema) {
    const errors = [];

    _.forOwn(schema, (type, field) => {
      const value = data[field];
      if (!_.isNil(value) && !this.validate(value, type)) {
        errors.push(`${field} must be ${type}`);
      }
    });

    return {
      valid: errors.length === 0,
      errors
    };
  }
}

const schema = {
  name: 'string',
  age: 'number',
  active: 'boolean',
  tags: 'array'
};

const data = {
  name: 'John',
  age: 30,
  active: true,
  tags: ['developer', 'javascript']
};

const result = TypeValidator.validateSchema(data, schema);
// => { valid: true, errors: [] }

安全的数据访问

javascript
class SafeAccessor {
  static get(obj, path, defaultValue = null) {
    const value = _.get(obj, path);
    return _.isNil(value) ? defaultValue : value;
  }

  static getNumber(obj, path, defaultValue = 0) {
    const value = _.get(obj, path);
    return _.isNumber(value) ? value : defaultValue;
  }

  static getString(obj, path, defaultValue = '') {
    const value = _.get(obj, path);
    return _.isString(value) ? value : defaultValue;
  }

  static getArray(obj, path, defaultValue = []) {
    const value = _.get(obj, path);
    return _.isArray(value) ? value : defaultValue;
  }

  static getObject(obj, path, defaultValue = {}) {
    const value = _.get(obj, path);
    return _.isPlainObject(value) ? value : defaultValue;
  }
}

const data = {
  user: {
    name: 'John',
    age: 30,
    tags: ['developer']
  }
};

console.log(SafeAccessor.getString(data, 'user.name'));
// => 'John'

console.log(SafeAccessor.getNumber(data, 'user.age'));
// => 30

console.log(SafeAccessor.getArray(data, 'user.tags'));
// => ['developer']

console.log(SafeAccessor.getObject(data, 'user.profile'));
// => {}

类型转换器

javascript
class TypeConverter {
  static toString(value) {
    if (_.isString(value)) return value;
    if (_.isNil(value)) return '';
    if (_.isDate(value)) return value.toISOString();
    return String(value);
  }

  static toNumber(value) {
    if (_.isNumber(value)) return value;
    if (_.isString(value)) {
      const num = Number(value);
      return _.isNaN(num) ? 0 : num;
    }
    if (_.isBoolean(value)) return value ? 1 : 0;
    return 0;
  }

  static toArray(value) {
    if (_.isArray(value)) return value;
    if (_.isNil(value)) return [];
    if (_.isString(value)) return _.split(value, '');
    return [value];
  }

  static toObject(value) {
    if (_.isPlainObject(value)) return value;
    if (_.isArray(value)) return _.fromPairs(value));
    return {};
  }
}

console.log(TypeConverter.toString(123));
// => '123'

console.log(TypeConverter.toNumber('123'));
// => 123

console.log(TypeConverter.toArray('abc'));
// => ['a', 'b', 'c']

console.log(TypeConverter.toObject([['a', 1], ['b', 2]]));
// => { a: 1, b: 2 }

总结

Lodash提供了丰富的类型检查方法，包括：

基本类型检查：_.isBoolean、_.isNumber、_.isString、_.isFunction
对象类型检查：_.isObject、_.isPlainObject、_.isObjectLike
数组类型检查：_.isArray、_.isArrayLike
空值检查：_.isEmpty、_.isNil
数字类型检查：_.isInteger、_.isFinite、_.isNaN
日期和正则表达式检查：_.isDate、_.isRegExp
元素检查：_.isElement、_.isArguments
其他类型检查：_.isError、_.isSymbol、_.isTypedArray等

这些类型检查方法比原生的typeof和instanceof更准确、更可靠。在实际开发中，建议使用这些方法来进行类型验证，以提高代码的健壮性和可维护性。