运行时参数数据类型校验工具类

工作所需进行工具封装，在此记录

import {
  isObject,
  isFunction,
  isString,
  isNumber,
  isArray,
  isBoolean,
} from '../xxx';
/**
 * 运行时参数数据类型校验工具类
 * @param {Object} data 源数据
 * @param {Object} rules 校验规则
 * @example
 * const data = { // 数据源
 *  phone: 1591231234,
 * };
 * const rules = { // 校验规则
 *  userInfo: {
 *    type: 'Object', // Any, Function, Object, Array, Boolean, Number, String
 *    require: true, // Boolean
 *    childNodes: { // 子节点 Object
 *      phone: {
 *        type: 'String',
 *        reg: /^1(?:3\d|4[4-9]|5[0-35-9]|6[67]|7[013-8]|8\d|9\d)\d{8}$/, reg/string
 *      },
 *    },
 *  },
 * };
 * const validator = new Validator(data, rules) // 实例化校验器
 * validator.autoValidate(); // 自动根据rules校验data
 * validate.autoValidate(data, rules).validateString('tifa').validateArray(['', 1]); // 自定义链式调用
 */
class Validator {
  /**
   * validator
   * @param {Object} data 源数据
   * @param {Object} rules 校验规则
   */
  constructor(data, rules) {
    this._rules = rules;
    this.data = data;
  }

  _typeMap = {
    'Any': 'Any',
    '[object Function]': 'Function',
    '[object Object]': 'Object',
    '[object Array]': 'Array',
    '[object Boolean]': 'Boolean',
    '[object Number]': 'Number',
    '[object String]': 'String',
  }

  /**
   * js原生类型_typeMap映射
   * @param {any} data 原始数据
   * @returns {String} _typeMap
   */
  getType(data = this.data) {
    const acceptOriginType = Object.prototype.toString.call(data)
    return this._typeMap[acceptOriginType];
  }

  /**
   * 
   * @param {Object} data 校验目标对象
   * @param {Object} rules 校验规则
   * @returns {validator} 校验器实例
   */
  normalValidate(data = this.data, rules = this._rules) {
    const dataType = this.getType(data);
    if (dataType !== 'Object') {
      this._errorHandler(`应为Object，但接收到${dataType}`)
    }

    const source = {
      keyList: Object.keys(data),
      valueList: Object.values,
    };

    Object.entries(rules).map(([filedName, filedRule]) => {
      const {
        type = 'Any',
        require = false,
        range,
        childNodes,
        reg,
      } = filedRule;

      // 必传字段
      if (require && !source.keyList.includes(filedName)) {
        this._errorHandler(`${filedName}为必传参数，当前参数${source.keyList}`)
      }

      // 当前规则校验的字段
      const sourceValue = data[filedName];
      const sourceValueType = this.getType(sourceValue);
      if (sourceValue !== undefined && sourceValue !== 'undefined') {
        // 类型校验
        if (type !== sourceValueType && type !== 'Any') {
          this._errorHandler(`${filedName}参数应为${type}，但接收到${sourceValue}=> ${sourceValueType}`)
        }

        const r = new RegExp(reg);
        if (reg && !r.test(`${sourceValue}`)) {
          this._errorHandler(`${filedName}参数应符合${reg}规则，但接收到${sourceValue}=> ${sourceValueType}`)
        }

        // 入参取值范围限制
        if (range && range.length) {
          const rangeLimit = range.some(item => !['String', 'Number'].includes(this.getType(item)))
          if (rangeLimit) this._errorHandler('range只接受String/Number')
          if (!range.includes(sourceValue)) this._errorHandler(`${filedName}的值只能在${range}中选择`)
        }

        const childNodesType = this.getType(childNodes);

        // 节点校验器limit
        if (childNodes && childNodesType !== 'Object') {
          this._errorHandler(`childNodes应为Object，但接收到${childNodesType}`)
        }

        // 子节点校验器存在，递归校验子节点
        if (childNodes) {
          this.normalValidate(sourceValue, childNodes)
        }
      }
    })
    return this;
  }

  /**
   * 校验对象类型
   * @returns {validator} 校验器实例
   */
  validateObject(data = this.data) {
    const result = isObject(data);
    if (!result) this._errorHandler(`参数错误，应为Object，但接收到${this.getType(data)}`);
    return this;
  }

  /**
   * 校验函数类型
   * @returns {validator} 校验器实例
   */
  validateFunction(data = this.data) {
    const result = isFunction(data);
    if (!result) this._errorHandler(`参数错误，应为Function，但接收到${this.getType(data)}`);
    return this;
  }

  /**
   * 校验字符串类型
   * @param {Any} data 原始数据
   * @returns {validator} 校验器实例
   */
  validateString(data = this.data) {
    const result = isString(data);
    if (!result) this._errorHandler(`参数错误，应为String，但接收到${this.getType(data)}`);
    return this;
  }

  /**
   * 校验数字类型
   * @param {Any} data 原始数据
   * @returns {validator} 校验器实例
   */
  validateNumber(data = this.data) {
    const result = isNumber(data)
    if (!result) this._errorHandler(`参数错误，应为Number，但接收到${this.getType(data)}`);
    return this;
  }

  /**
   * 校验数组类型
   * @param {Any} data 原始数据
   * @returns {validator} 校验器实例
   */
  validateArray(data = this.data) {
    const result = isArray(data);
    if (!result) this._errorHandler(`参数错误，应为Array，但接收到${this.getType(data)}`);
    return this;
  }

  /**
   * 校验布尔类型
   * @param {Any} data 原始数据
   * @returns {validator} 校验器实例
   */
  validateBoolean(data = this.data) {
    const result = isBoolean(data);
    if (!result) this._errorHandler(`参数错误，应为Boolean，但接收到${this.getType(data)}`);
    return this;
  }

  /**
   * 兼容function转string，仅用于提示性转换
   * @param {any} data 原始数据
   * @returns {String} 返回字符串
   */
  _dataToString(data) {
    const type = this.getType(data)
    return type === 'Function' ? data : JSON.stringify(data)
  }

  _errorHandler(msg) {
    throw new Error(`参数错误！${msg}`)
  }
}

export default Validator;