xt-ems-front/src/utils/validator.js

/*
* rule
* {"trigger":"change","max":10,"min":20,"field":"telegrpNo","fullField":"telegrpNo","type":"string", ...}
*  可自定义属性
*/
// 定义默认中文所占字符长度，由个项目使用的数据库决定
// 正常 utf-8以三个字节存储中文；gbk以二个字节存储中文。
const _chineseLength = 3;

/*
  数字效验
*/
export const zCheckNumber1 = (rule, value, callback) => {
  if (value) {
    if (typeof value === 'number') {
      value = value.toString().trim()
    }
    let str = /^[+-]{0,1}(([1-9][0-9]*)|0)\.{0,1}[0-9]*$/
    if (!str.test(value)) {
      return callback(new Error('请输入正确的数字格式'))
    }
  }
  callback();
}

/*
  数字效验，只允许非负整数
*/
export const zCheckNumber2 = (rule, value, callback) => {
  if (value) {
    if (typeof value === 'number') {
      value = value.toString().trim()
    }
    let str = /^[0-9]+$/
    if (!str.test(value)) {
      return callback(new Error('只允许输入自然数'))
    }
  }
  callback();
}

/*
  常用的id效验(大小写字母、数组与下划线)
*/
export const zCheckId = (rule, value, callback) => {
  if (value) {
    let str = /^[a-zA-Z0-9_]+$/
    if (!str.test(value)) {
      return callback(new Error('只允许输入英文字母、数字和下划线的组合'))
    }
  }
  callback();
}

/*
  常用的id效验(大小写字母、数组与下划线)
*/
export const zCheckIds = (rule, value, callback) => {
  if (value) {
    let str = /^[a-zA-Z0-9_]+$/
    if (!str.test(value)) {
      return callback(new Error('只允许输入英文字母、数字、下划线和逗号'))
    }
  }
  callback();
}

// number校验
/*
 处理属性:
 length tip isPositive: 是否为正数
 */
export const checkNumber = (rule, value, callback) => {
  if (typeof value === 'number') {
    value = value.toString().trim()
  }
  if (value) {
    if (isNaN(value) || value.toString().trim() === '') {
      return callback(new Error('请输入数字'));
    }
    if (typeof rule.length === 'undefined') {
      if (typeof rule.isPositive !== 'undefined') {
        if (value < 0) {
          return callback(new Error('请输入正数'))
        }
      }
      return callback()
    }
    let arry = rule.length.toString().split('.')
    let integer = arry[0]
    let decimal = arry[1]
    let str = null, reg = null
    if (typeof decimal === 'undefined') {
      str = '\\d{0,' + integer + '}'
      if (rule.negative) {
        str = '-?\\d{0,' + integer + '}'
      }
      reg = new RegExp('^' + str + '$', 'g');
      if (!reg.test(value)) {
        return callback(new Error(integer + ' 位整数'));
      }
    } else {
      integer = integer - decimal;
      str = '(([1-9]{1}\\d{0,' + (integer - 1) + '}(\\.\\d{1,' + decimal + '})?)|(0(\\.\\d{1,' + decimal + '})?))'
      if (rule.negative) {
        str = '-?(([1-9]{1}\\d{0,' + (integer - 1) + '}(\\.\\d{1,' + decimal + '})?)|(0(\\.\\d{1,' + decimal + '})?))'
      }
      reg = new RegExp('^' + str + '$', 'g');
      if (!reg.test(value)) {
        return callback(new Error(integer + ' 位整数,小数点后' + decimal + '位'));
      }
    }
  } else {
    if (rule.required) {
      return callback(new Error('不能为空'));
    }
  }
  callback();
};

export const checkcntNumber = (rule, value, callback) => {
  if (typeof value === 'number') {
    value = value.toString().trim()
  }
  if (value) {
    if (isNaN(value) || value.toString().trim() === '') {
      return callback(new Error('请输入数字'));
    }
    if (typeof rule.length === 'undefined') {
      if (typeof rule.isPositive !== 'undefined') {
        if (value < 0) {
          return callback(new Error('请输入正数'))
        }
      }
      return callback()
    }
    let arry = rule.length.toString().split('.')
    let integer = arry[0]
    let decimal = arry[1]
    let str = null, reg = null
    if (typeof decimal === 'undefined') {
      str = '\\d{0,' + integer + '}'
      if (rule.negative) {
        str = '-?\\d{0,' + integer + '}'
      }
      reg = new RegExp('^' + str + '$', 'g');
      if (!reg.test(value)) {
        return callback(new Error(integer + ' 位整数'));
      }
    } else {
      integer = integer - decimal;
      str = '(([1-9]{1}\\d{0,' + (integer - 1) + '}(\\.\\d{1,' + decimal + '})?)|(0(\\.\\d{1,' + decimal + '})?))'
      if (rule.negative) {
        str = '-?(([1-9]{1}\\d{0,' + (integer - 1) + '}(\\.\\d{1,' + decimal + '})?)|(0(\\.\\d{1,' + decimal + '})?))'
      }
      reg = new RegExp('^' + str + '$', 'g');
      if (!reg.test(value)) {
        return callback(new Error(integer + ' 位整数,小数点后' + decimal + '位'));
      }
    }
  } else {
    if (rule.required) {
      return callback(new Error('请输入件数'));
    }
  }
  callback();
};

export const checkPercent = (rule, value, callback) => {
  if (value) {
    if (value) {
      if (isNaN(value)) {
        return callback(new Error('请输入数字'));
      }
      let exact = rule.exact
      let item = '100'
      let max = '100|'
      if (exact) {
        item += '.'
      }
      for (let i = 0; i < exact; i++) {
        item += '0'
        max += item + '|'
      }
      let str = '((100(\\.0{1,' + exact + '})?)|(0(\\.\\d{1,' + exact + '})?)|([1-9]?\\d{0,1}(\\.\\d{1,' + exact + '})?))'
      let reg = new RegExp('^' + str + '$', 'g');
      if (!reg.test(value)) {
        return callback(new Error('0~100,可保留' + exact + '位小数'))
      }
    }
  } else {
    if (rule.required) {
      return callback(new Error('请输入'));
    }
  }
  callback();
}

export const checkPercent2 = (rule, value, callback) => {
  if (value) {
    if (value) {
      if (isNaN(value)) {
        return callback(new Error('请输入数字'));
      }
      let exact = rule.exact
      let item = '1000'
      let max = '1000|'
      if (exact) {
        item += '.'
      }
      for (let i = 0; i < exact; i++) {
        item += '0'
        max += item + '|'
      }
      let str = '((1000(\\.0{1,' + exact + '})?)|(0(\\.\\d{1,' + exact + '})?)|([1-9]?\\d{0,2}(\\.\\d{1,' + exact + '})?))'
      let reg = new RegExp('^' + str + '$', 'g');
      if (!reg.test(value)) {
        return callback(new Error('0~1000,可保留' + exact + '位小数'))
      }
    }
  } else {
    if (rule.required) {
      return callback(new Error('请输入'));
    }
  }
  callback();
}
// 是否为整数包含0
export const checkInteger = (rule, value, callback) => {
  if (value) {
    if (isNaN(value)) {
      return callback(new Error('请输入数字'));
    }
    let str = /^([1-9][0-9]*)$|^0$/
    if (!str.test(value)) {
      return callback(new Error('请输入自然数'))
    }
  }
  callback();
}

// 电话手机号码验证
export const checkTel = (rule, value, callback) => {
  if (value) {
    let reg = /^1[34578]\d{9}$/
    let reg1 = /^0\d{2,3}-?\d{7,8}$/

    let result = false, result1 = false
    if (reg.test(value)) {
      result = true
    }
    if (reg1.test(value)) {
      result1 = true
    }
    if (result || result1) {
      callback()
    } else {
      return callback(new Error('手机(固定电话)格式有误...'))
    }
  } else {
    if (rule.required) {
      return callback(new Error('请输入'));
    }
  }
  callback()
}

// 传真验证
export const checkFax = (rule, value, callback) => {
  if (value) {
    let reg1 = /^(\d{3,4}|\d{3,4}-)?\d{7,8}$/
    let result1 = false
    if (reg1.test(value)) {
      result1 = true
    }
    if (result1) {
      return callback()
    } else {
      return callback(new Error('格式验证有误...'))
    }
  }
  callback()
}

export const chekPercent = (rule, value, callback) => {
  if (value) {
    let reg = new RegExp('^(\\d|[1-9]\\d|100)$');
    if (!reg.test(value)) {
      return callback(new Error('数值在0~100之间'))
    }
  }
  callback()
}

// 校验只能输入英文 和 数字
export const checkEnglish = (rule, value, callback) => {
  if (value) {
    let reg = /^[A-Za-z0-9\s]+$/
    if (!reg.test(value)) {
      return callback(new Error('请输入英文和数字'));
    }
    if (rule.max < value.length) {
      return callback(new Error('最多输入' + rule.max + '个字符'));
    }
  } else {
    if (rule.required) {
      return callback(new Error('请输入'));
    }
  }
  callback();
};

// 价格校验(大于0)
export const checkPositiveNumber = (rule, value, callback) => {
  if (value) {
    if (isNaN(value)) {
      return callback(new Error('请输入数字'));
    } else if (!(value > 0)) {
      return callback(new Error('请输入正数'));
    }
  }
  callback();
};
// 文本校验（综合）
/*
* 处理属性：
* required max min fieldName chineseLength
*/
export const checkText = (rule, value, callback) => {
  if (value) {
    let reg = /^[-_a-zA-Z0-9\u4e00-\u9fa5]+$/;
    if (!reg.test(value)) {
      return callback(new Error('请输入中文、英文字母、数字、下划线（_）或横线（-）的组合'));
    }
    let chineseLen = _chineseLength;
    if (rule.chineseLength && rule.chineseLength > 0) {
      chineseLen = rule.chineseLength;
    }
    let iLen = chineseLen > 1 ? _charLength(value, chineseLen) : value.length;
    if (rule.min && rule.min > 0 && iLen < rule.min) {
      return callback(new Error('最少输入' + rule.min + '个字符（一个中文占' + chineseLen + '个字符）'));
    }
    if (rule.max && rule.max > 0 && iLen > rule.max) {
      return callback(new Error('最多输入' + rule.max + '个字符（一个中文占' + chineseLen + '个字符）'));
    }
  } else {
    if (rule.required) {
      let sfield = rule.fieldName ? rule.fieldName : '';
      return callback(new Error('请输入' + sfield));
    }
  }
  callback();
};

/*
 * 处理属性：
 * required max min fieldName chineseLength
 */
export const checkComplexText = (rule, value, callback) => {
  if (value) {
    let chineseLen = _chineseLength;
    if (rule.chineseLength && rule.chineseLength > 0) {
      chineseLen = rule.chineseLength;
    }
    let iLen = chineseLen > 1 ? _charLength(value, chineseLen) : value.length;
    if (rule.min && rule.min > 0 && iLen < rule.min) {
      return callback(new Error('最少输入' + rule.min + '个字符（一个中文占' + chineseLen + '个字符）'));
    }
    if (rule.max && rule.max > 0 && iLen > rule.max) {
      return callback(new Error('最多输入' + rule.max + '个字符（一个中文占' + chineseLen + '个字符）'));
    }
  } else {
    if (rule.required) {
      let sfield = rule.fieldName ? rule.fieldName : '';
      return callback(new Error('请输入' + sfield));
    }
  }
  callback();
};
// 中文校验
export const checkChinese = (rule, value, callback) => {
  let reg = /^[\u4e00-\u9fa5./?#:'"_=+-]+$/;
  if (!reg.test(value)) {
    return callback(new Error('请输入中文'));
  }
  callback();
};
// 字符校验（含中文）
export const checkChar = (rule, value, callback) => {
  let reg = /^[-_a-zA-Z0-9\u4e00-\u9fa5]+$/;
  if (!reg.test(value) && value) {
    return callback(new Error('请输入中文、英文字母、数字、下划线（_）或横线（-）的组合'));
  }
  callback();
};
// 字符校验（含中文）
export const checkChar2 = (rule, value, callback) => {
  let reg = /^[#-_a-zA-Z0-9\u4e00-\u9fa5]+$/;
  if (!reg.test(value) && value) {
    return callback(new Error('请输入中文、英文字母、数字、井号(#)、下划线（_）或横线（-）的组合'));
  }
  callback();
};
// 字符校验（不含中文）
export const checkCharNoChinese = (rule, value, callback) => {
  let reg = /^[-_a-zA-Z0-9]+$/;
  if (value && !reg.test(value)) {
    return callback(new Error('请输入英文字母、数字、下划线（_）或横线（-）的组合'));
  }
  callback();
};
export const checkCharNoChinese2 = (rule, value, callback) => {
    let reg = /^[\w-./#:]+$/;
    if (value && !reg.test(value)) {
        return callback(new Error('请输入英文字母、数字、下划线（_）或横线（-）的组合'));
    }
    callback();
};
export const checkCharNoChinese3 = (rule, value, callback) => {
    let reg = /^[-a-zA-Z0-9]+$/;
    if (value && !reg.test(value)) {
        return callback(new Error('请输入英文字母、数字、- 的组合'));
    }
    callback();
};
export const checkCharNoChinese4 = (rule, value, callback) => {
    let reg = /^[-_a-z0-9]+$/;
    if (value && !reg.test(value)) {
        return callback(new Error('请输入小写英文字母、数字、- 、_ 的组合'));
    }
    callback();
};
export const checkCharNoChinese5 = (rule, value, callback) => {
    let reg = /^[-_a-z0-9${}.]+$/;
    if (value && !reg.test(value)) {
        return callback(new Error('请输入英文字母、数字、- 、_ 、$、{}、. 的组合'));
    }
    callback();
};
export const checkCode = (rule, value, callback) => {
    let reg = /^[-a-z0-9]+$/;
    if (value && !reg.test(value)) {
        return callback(new Error('请输入英文字母、数字 - 的组合'));
    }
    callback();
};
export const checkVersion = (rule, value, callback) => {
    let reg = /^[-_0-9.]+$/;
    if (value && !reg.test(value)) {
        return callback(new Error('请输入数字、- _的组合'));
    }
    callback();
};

// 字符长度校验（包含对中文的处理）rule需至少有 min 或 max
export const checkCharLength = (rule, value, callback) => {
  if (value) {
    let chineseLen = _chineseLength;
    if (rule.chineseLength && rule.chineseLength > 0) {
      chineseLen = rule.chineseLength;
    }
    let iLen = chineseLen > 1 ? _charLength(value, chineseLen) : value.length;
    if (rule.min && rule.min > 0 && iLen < rule.min) {
      return callback(new Error('最少输入' + rule.min + '个字符（一个中文占' + chineseLen + '个字符）'));
    }
    if (rule.max && rule.max > 0 && iLen > rule.max) {
      return callback(new Error('最多输入' + rule.max + '个字符（一个中文占' + chineseLen + '个字符）'));
    }
  } else {
    if (rule.required) {
      return callback(new Error('请输入'));
    }
  }
  callback();
};

export const checkCharLength2 = (rule, value, callback) => {
  if (value) {
    let chineseLen = _chineseLength;
    if (rule.chineseLength && rule.chineseLength > 0) {
      chineseLen = rule.chineseLength;
    }
    let iLen = chineseLen > 1 ? _charLength(value, chineseLen) : value.length;
    if (rule.min && rule.min > 0 && iLen < rule.min) {
      return callback(new Error('最少输入' + rule.min + '个字符'));
    }
    if (rule.max && rule.max > 0 && iLen > rule.max) {
      return callback(new Error('最多输入' + rule.max + '个字符'));
    }
  } else {
    if (rule.required) {
      return callback(new Error('请输入'));
    }
  }
  callback();
};
// 校验邮编
export const checkZIP = (rule, value, callback) => {
  if (value) {
    let reg = /^\d{6}$/;
    if (reg.test(value)) {
      callback();
    } else {
      return callback(new Error('请输入邮编（6位数字）'));
    }
  }
  callback();
}
// 校验internet URL
export const checkURL = (rule, value, callback) => {
  if (value) {
    let reg = /(((^https?:(?:\/\/)?)(?:[-;:&=+$,\w]+@)?[A-Za-z0-9.-]+|(?:www.|[-;:&=+$,\w]+@)[A-Za-z0-9.-]+)((?:\/[+~%/.\w-_]*)?\??(?:[-+=&;%@.\w_]*)#?(?:[\w]*))?)$/g
    if (reg.test(value)) {
      callback();
    } else {
      return callback(new Error('请输入网址'));
    }
  }
  callback()
}
// 校验邮箱
export const checkEmail = (rule, value, callback) => {
  var re = /^[A-Za-z\d]+([-_.][A-Za-z\d]+)*@([A-Za-z\d]+[-.])+[A-Za-z\d]{2,4}$/;
  if (value) {
    if (re.test(value)) {
      callback();
    } else {
      return callback(new Error('请输入正确的邮箱'));
    }
  } else {
    if (rule.required) {
      return callback(new Error('请输入'));
    }
  }
  callback();
}

/**
 * 字符长度，处理中文
 * utf-8以三个字节存储中文；gbk以二个字节存储中文。
 */
export function _charLength (str, chineseLen) {
  if (!str || str.length <= 0) { return 0; };
  // str = mytrim(str);
  let chineseLength = 3; // utf-8编码，中文长度
  if (chineseLen && chineseLen > 0) {
    chineseLength = chineseLen
  }
  let objValue = str;
  let objLength = 0;
  let compareChar = '';
  let regExp = new RegExp("^[A-Za-z0-9 -_`~!@#$%^&*()-+=|,<.>/?;:'\\\"]$");
  for (let count = 0; count < objValue.length; count++) {
    compareChar = objValue.substring(count, count + 1);
    if (regExp.test(compareChar)) {
      objLength += 1;
    } else if (compareChar === '\\') {
      objLength += 1;
    } else {
      objLength += chineseLength;
    }
  }
  return objLength;
}

// 外部引用
export const checkCNLen = (str, chineseLen) => {
  if (!str || str.length <= 0) { return 0; };
  // str = mytrim(str);
  let chineseLength = 3; // utf-8编码，中文长度
  if (chineseLen && chineseLen > 0) {
    chineseLength = chineseLen
  }
  let objValue = str;
  let objLength = 0;
  let compareChar = '';
  let regExp = new RegExp("^[A-Za-z0-9 -_`~!@#$%^&*()-+=|,<.>/?;:'\\\"]$");
  for (let count = 0; count < objValue.length; count++) {
    compareChar = objValue.substring(count, count + 1);
    if (regExp.test(compareChar)) {
      objLength += 1;
    } else if (compareChar === '\\') {
      objLength += 1;
    } else {
      objLength += chineseLength;
    }
  }
  return objLength;
}

/**
 * 判断不能为数字
 */
export const checkDigital = (rule, value, callback) => {
  var re = /^[0-9]+.?[0-9]*/; // 判断字符串是否为数字//判断正整数/[1−9]+[0−9]∗]∗/
  if (re.test(value)) {
    return callback(new Error('不能全部输入数字'));
  }
  callback();
}
// 检验数据
export const checkNumber1 = (rule, value, callback) => {
  if (typeof value === 'number') {
    value = value.toString().trim()
  }
  if (value) {
    if (isNaN(value) || value.toString().trim() === '') {
      return callback(new Error('请输入数字'));
    }
    if (typeof rule.length === 'undefined') {
      if (typeof rule.isPositive !== 'undefined') {
        if (value < 0) {
          return callback(new Error('请输入正数'))
        }
      }
      return callback()
    }
    let arry = rule.length.toString().split('.')
    let integer = arry[0]
    let decimal = arry[1]
    let str = null, reg = null
    if (typeof decimal === 'undefined') {
      str = '\\d{0,' + integer + '}'
      if (rule.negative) {
        str = '-?\\d{0,' + integer + '}'
      }
      reg = new RegExp('^' + str + '$', 'g');
      if (!reg.test(value)) {
        return callback(new Error('最多 ' + integer + ' 位整数'));
      }
    } else {
      integer = integer - decimal;
      str = '(([1-9]{1}\\d{0,' + (integer - 1) + '}(\\.\\d{1,' + decimal + '})?)|(0(\\.\\d{1,' + decimal + '})?))'
      if (rule.negative) {
        str = '-?(([1-9]{1}\\d{0,' + (integer - 1) + '}(\\.\\d{1,' + decimal + '})?)|(0(\\.\\d{1,' + decimal + '})?))'
      }
      reg = new RegExp('^' + str + '$', 'g');
      if (!reg.test(value)) {
        return callback(new Error('最多' + integer + '位整数，' + decimal + '位小数'));
      }
    }
  } else {
    if (rule.required) {
      return callback(new Error('不能为空'));
    }
  }
  callback();
};

/**
 * @summary 设置cookie
 * @param {string} name cookie名称
 * @param {string} value cookie值
 * @param {int} expires 保存时间(单位:小时)
 * @param {string} path
 * @param {string} domain
 * @param {string} secure
 */
export const setCookie = (name, value, expires, path, domain, secure) => {
  let str = name + '=' + encodeURIComponent(value);
  if (expires > 0) {
    let date = new Date();
    date.setTime(date.getTime() + expires * 3600 * 1000);
    str += ';expires=' + date.toGMTString();
  }
  if (path) { str += ';path=' + path; }
  if (domain) { str += ';domain=' + domain; }
  if (secure) { str += ';secure=' + secure; }
  document.cookie = str;
};
/**
 * @summary 读取cookie
 * @param {string} name cookie名称
 * @retrun {string} value cookie值
 * @example
 */
export const getCookie = (name) => {
  let start = document.cookie.indexOf(name + '=');
  if ((!start) && (name !== document.cookie.substring(0, name.length))) { return ''; }
  if (start === -1) { return ''; }
  let len = start + name.length + 1;
  let end = document.cookie.indexOf(';', len);
  if (end === -1) { end = document.cookie.length; }
  return decodeURIComponent(document.cookie.substring(len, end));
};
/**
 * 存储localStorage
 * @param {string} sName
 * @param {string} sCntent
 * @example setLocalStore('name', '测试');
 */
export const setLocalStore = (sName, sCntent) => {
  if (!sName) return;
  window.localStorage.setItem(sName, sCntent);
};
/**
 * @summary 根据时间及格式获取时间的字符串
 * @param {int} iDate 时间
 * @param {string} sFormat 格式，默认：yyyy-MM-dd HH:mm:ss
 * @return {string} 格式化后的日期字符串
 * @example
 *    formatDate(new Date(),'yyyy-MM-dd HH:mm:ss SSS');// 2017-6-6 11:11:11
 */
export const formatDate = (iDate, sFormat = 'yyyy-MM-dd HH:mm:ss') => {
  if (!iDate) { return ''; }
  let dDate = new Date(iDate);
  let year = dDate.getFullYear();// 年
  let month = dDate.getMonth() + 1;// 月
  if (month < 10) { month = '0' + month; }
  let date = dDate.getDate();// 日
  if (date < 10) { date = '0' + date; }
  let hour = dDate.getHours();// 时
  if (hour < 10) { hour = '0' + hour; }
  let minute = dDate.getMinutes();// 分
  if (minute < 10) { minute = '0' + minute; }
  let second = dDate.getSeconds();// 秒
  if (second < 10) { second = '0' + second; }
  let millisecond = dDate.getMilliseconds();// 毫秒
  if (sFormat.indexOf('yyyy') >= 0) { sFormat = sFormat.replace('yyyy', year + ''); }
  if (sFormat.indexOf('MM') >= 0) { sFormat = sFormat.replace('MM', month + ''); }
  if (sFormat.indexOf('dd') >= 0) { sFormat = sFormat.replace('dd', date + ''); }
  if (sFormat.indexOf('HH') >= 0) { sFormat = sFormat.replace('HH', hour + ''); }
  if (sFormat.indexOf('mm') >= 0) { sFormat = sFormat.replace('mm', minute + ''); }
  if (sFormat.indexOf('ss') >= 0) { sFormat = sFormat.replace('ss', second + ''); }
  if (sFormat.indexOf('SSS') >= 0) { sFormat = sFormat.replace('SSS', millisecond + ''); }
  return sFormat;
};

/**
 * 格式化时间
 * @param {String} str
 * @returns 格式化后的时间
 */
export const formatDate1 = (iDate = new Date().getTime(), sFormat = 'yyyy-MM-dd HH:mm:ss') => {
  let dDate = new Date(iDate);
  let year = dDate.getFullYear();// 年
  let month = dDate.getMonth() + 1;// 月
  if (month < 10) { month = '0' + month; }
  let date = dDate.getDate();// 日
  if (date < 10) { date = '0' + date; }
  let hour = dDate.getHours();// 时
  if (hour < 10) { hour = '0' + hour; }
  let minute = dDate.getMinutes();// 分
  if (minute < 10) { minute = '0' + minute; }
  let second = dDate.getSeconds();// 秒
  if (second < 10) { second = '0' + second; }
  let millisecond = dDate.getMilliseconds();// 毫秒
  if (sFormat.indexOf('yyyy') >= 0) {
    sFormat = sFormat.replace('yyyy', year + '');
  }
  if (sFormat.indexOf('MM') >= 0) {
    sFormat = sFormat.replace('MM', month + '');
  }
  if (sFormat.indexOf('dd') >= 0) {
    sFormat = sFormat.replace('dd', date + '');
  }
  if (sFormat.indexOf('HH') >= 0) {
    sFormat = sFormat.replace('HH', hour + '');
  }
  if (sFormat.indexOf('mm') >= 0) {
    sFormat = sFormat.replace('mm', minute + '');
  }
  if (sFormat.indexOf('ss') >= 0) {
    sFormat = sFormat.replace('ss', second + '');
  }
  if (sFormat.indexOf('SSS') >= 0) {
    sFormat = sFormat.replace('SSS', millisecond + '');
  }
  return sFormat;
};

export const formatTime = (data) => {
    let {H, M, S} = 0;
    let second = parseInt(data / 1000);
    S = second % 60;
    if (second / 60 > 60) {
        M = parseInt(second / 60) % 60;
        H = parseInt(M / 60);
    } else {
        M = parseInt(second / 60);
    }
    let str = '';
    if (H || M) {
        str = H ? M + '小时' + M + '分钟' + S + '秒' : M + '分钟' + S + '秒';
    } else {
        if (S === 0) {
            str = '-'
        } else {
            str = S + '秒'
        }
    }
    return str
}

/**
 * @summary 删除数组对象的某个成员（或添加成员）
 * @param {array} arrayObj 数组对象
 * @param {object} obj 需要删除的对象
 * @param {string} attrName 比对的参数名（如ID）
 * @return {array} 新的数组对象
 */
export const removeOrAddEleFormArrayObj = (arrayObj = [], obj, attrName) => {
  let iIndex = -1;
  for (let i = 0; i < arrayObj.length; i++) {
    if (arrayObj[i][attrName] && arrayObj[i][attrName] === obj[attrName]) {
      iIndex = i;
      break;
    }
  }
  if (iIndex >= 0) {
    arrayObj.splice(iIndex, 1);
  } else {
    // arrayObj.splice(0, 0, obj);
    arrayObj.push(obj);
  }
  return arrayObj;
};

/**
 *  @summary 获取B数组中存在A数组值的自身索引
 * @param {array} A 已存在数组对象
 * @param {array} B 待比较数组对象
 * @param {array} str 待比较数组的id
 * **/
export const compareArray = (A, B, str) => {
  let indexs = []; // 获取比较后的索引数组
  for (let i = 0; i < A.length; i++) {
    for (let j = 0; j < B.length; j++) {
      // console.log(A[i][str], B[j][str], A[i][str] === B[j][str]);
      if (A[i][str] === B[j][str]) {
        indexs.push(j);
        break;
      }
    }
  }
  return indexs
};

/**
 * @summary 内控模块使用，校验上、下限值的正确性
 * @param: min: 下限值
 * @param: max: 上限值
 * @param: len: 字符限制长度
 * @param: decimal: 小数位数
 * @return: Object 0：不弹出错误信息，1：只能填写正实数，最多保留四位小数！，2：数字的长度不能大于' + len + '位，3：下限值不能大于上限值
 * 如果只传了min没有传max，则为单个数字的校验
 * */
export const validOrder = (len, min, max, decimal) => {
  let obj = {
    state: '',
    msg: ''
  };
  let reg = /^(0|[1-9][0-9]*)(\.[0-9]{1,4})?$/;
  if (decimal) {
    let str = '^(0|[1-9][0-9]*)(\\.[0-9]{1,' + decimal + '})?$';
    reg = new RegExp(str);
  }
  if (len && min) {
    if (reg.test(min)) {
      // 判断数字的长度
      if (min.length > len) {
        obj.state = '2';
        obj.msg = '数字的长度不能大于' + len + '位';
        return obj;
      } else {
        if (max) {
          if (reg.test(max)) {
            // 上下限都有值，则比较大小
            if (max.length <= len) {
              // 长度符合要求，比较大小
              if (parseFloat(min) > parseFloat(max)) {
                // 下限值大于上限值，报错
                obj.state = '3';
                obj.msg = '下限值不能大于上限值';
                return obj;
              } else {
                // 两个数字都校验通过
                obj.state = '0';
                obj.msg = '';
                return obj;
              }
            } else {
              obj.state = '2';
              obj.msg = '数字的长度不能大于' + len + '位';
              return obj;
            }
          } else {
            obj.state = '1';
            obj.msg = '只能填写正实数，最多保留四位小数！';
            return obj;
          }
        } else {
          // 没有传第二个数字，则为单个数字的校验，这个时候已经证明参数min是一个正实数且长度不大于len，校验通过
          obj.state = '0';
          obj.msg = '';
          return obj;
        }
      }
    } else {
      obj.state = '1';
      obj.msg = '只能填写正实数，最多保留四位小数！';
      return obj;
    }
  }
};

export const isStartEndDate = (startDate, endDate) => {
  let start = new Date(startDate);
  let end = new Date(endDate);
  if (start > end) {
    return true;
  }
  return false;
};

/*
 *解析cookie值
 */
export const getUserName = function (str) {
  let arr = str.split(';');
  let arr1 = [];
  let obj = {};
  for (let item of arr) {
    arr1 = item.split('=');
    obj[arr1[0].trim()] = arr1[1].trim();
  }
  return obj;
};

/**
 * @summary 比较一个对象前后的属性值是否相同
 * @param: before: 未改变的对象（备份）
 * @param: after: 可能改变了的对象
 * @return: Boolean true: 相同（未改变），false: 对象的属性值已经改变了
 * */
export const compareObj = (before, after) => {
  let flag = true;
  // 首先获取对象的所有属性
  let propList = Object.keys(before);
  for (let item of propList) {
    if (before[item] !== after[item]) {
      flag = false;
      break;
    }
  }
  return flag;
};

/*
 * 千分表达式转换
 * num 要格式化的数字 n 保留小数位
 */
export const formatNum = function (num, n) {
  if (!n) {
    n = 2;
  }
  if (num === null || num === 'null' || num === undefined || num === 'undefined') { return ''; }
  if (isNaN(num)) { return num; }
  let data = (num + '').split('.');
  num = data[0];
  if (n) {
    num = Number(num);
    num.toFixed(n);
  }
  num = String(num);
  var re = /(-?\d+)(\d{3})/;
  while (re.test(num)) {
    num = num.replace(re, '$1,$2');
    console.log('num: ', num);
  }
  if (data[1] !== '' && data[1] !== null && data[1] !== undefined) {
    num = num + '.' + data[1];
  }
  return num;
};
// 正整数校验 max:最大值   min: 最小值
export const checkPositiveInteger = (rule, value, callback) => {
  if (value) {
    console.log(rule)
    let st = /^[1-9][0-9]*$/;
    if (!st.test(value)) {
      return callback(new Error('请输入正整数'));
    }
    if (rule.max && value > rule.max) {
      return callback(new Error('最大值' + rule.max));
    }
    if (rule.min && value < rule.min) {
      return callback(new Error('最小值' + rule.min));
    }
  }
  callback();
};

export const checkObjectNo = (rule, value, callback) => {
  let str = /^([A-Z][0-9]{2})-([0-9a-zA-Z]{5})\.([1-9][0-9]{0,5})\.([1-9][0-9]{0,2})$/;
  if (!str.test(value)) {
    callback(new Error('块序号格式错误'));
  }
  callback();
};

// ip地址校验

export const checkIpAddress = (rule, value, callback) => {
  let reg = /^(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9])$/;
  if (!reg.test(value) && value) {
    callback(new Error('IP地址格式错误'))
  }
  callback()
}