例子: https://gitee.com/akff/ak-mini-program

实现效果

image.png

实现代码

    if (isTool
      .isHaveValue(value, "value不能为空")
      .isNumber(number, "number不能为空", "number不是数字类型")
      .isEmail(email, "email不能为空", "email不是邮箱格式")
      .isPhone(phone, "phone不能为空", "phone不是正确电话格式")
      .isPrice(price, "price不能为空", "price不是正确价格格式")
      .isResult === true) {
      // 通过校验
    } else {
      // 不通过校验
    }

核心代码

const regExpression = require('./AKRegExpression.js')


// 方法: 是否数字
function checkNumber(str, isHaveZero) {
  let regE = new RegExp('[0-9]', 'g')
  //是否已经有 点'.'
  let isHavePoint = false
  for (let index in str) {
    if (str[index] == '.') { //是否为'.'
      // 判断是否有重复逗号
      if (isHavePoint) {
        return false
      }
      isHavePoint = true
    } else if (regE.exec(str) == undefined) { //是否为数字
      //是否为'.'特殊符号
      return false
    } else if (isHaveZero != true && index == 0 && str[0] == "0") {
      //是否第一位为0
      return false
    }
  }
  //循环没有跳出,则返回true
  return true
}
// 结果(只要不是进入bundleFalse方法,就是true)
const isResult = true

// 判断方法
const tool = {
  //判断开始时间和结束时间范围
  isEnableTimeRange(startTime, endTime, splitSymbol, warnNote) {
    let start = startTime.split(splitSymbol).join("")
    let end = endTime.split(splitSymbol).join("")
    let note = ""
    if (Number(start) > Number(end)) { //年 开始日期 在结束日期前
      note = (warnNote || "开始时间不能大于结束时间")
    }

    if (note != "") {
      wx.showToast({
        title: note,
        icon: 'none'
      })
      return bundleFalse
    }
    return this
  },

  //非空判断(数组/对象/字符串)
  isHaveValue(data, note) {
    if (data === null) {
      data = undefined
    }
    let typeStr = typeof data
    let isHaveValue = true
    switch (typeStr) {
      case 'undefined': //空
        isHaveValue = false
        break
      case 'string': //字符串
        data == "" && (isHaveValue = false)
        break
      case 'object': //数组或对象
        Object.keys(data).length ||
          (isHaveValue = false)
      default:
        break
    }

    if (note && !isHaveValue) {
      wx.showToast({
        title: note || "",
        icon: 'none',
      })
    }

    return isHaveValue ? this : bundleFalse
  },

  //判断是否电话
  isPhone(data, nullNote = '手机号不能为空', notPhoneNote = '手机号格式不正确') {
    let isHave = this.isHaveValue.apply(this, [data, nullNote]).isResult
    let isPhoneNum = false
    if (isHave) {
      isPhoneNum = regExpression.phoneRegExp.test(data)
      isPhoneNum || wx.showToast({
        title: notPhoneNote,
        icon: 'none'
      })
    }
    return isPhoneNum ? this : bundleFalse
  },

  //判断是否数字
  isNumber(data, nullNote, notNumbernote, isHaveZero) {
    let isNumber = true
    let note = ""

    //判断是否为0 (解决 0 == "")
    let checkZero = data + ""
    if (checkZero == "") {
      isNumber = false
      note = nullNote
    } else if (!checkNumber(checkZero, isHaveZero)) {
      isNumber = false
      note = notNumbernote
    }
    isNumber == false && wx.showToast({
      title: note,
      icon: 'none'
    })
    return isNumber ? this : bundleFalse
  },

  // 是否价格
  isPrice(data, nullNote, notNumbernote, isCanNull) {
    // 判断是否为null
    if (isCanNull && !data) return this
    //正则
    var reg = regExpression.priceExp
    // 转为字符串
    let checkZero = data + ""
    let note = checkZero == "" ? nullNote : notNumbernote
    const isPrice = reg.test(checkZero)
    if (!isPrice) {
      wx.showToast({
        title: note,
        icon: 'none'
      })
    }
    return isPrice ? this : bundleFalse
  },



  // 检查是否是邮箱
  isEmail(value, nullNote, notPhoneNote) {
    if (!this.isHaveValue.apply(this, [value, nullNote]).isResult) {
      return bundleFalse
    }
    let expr = /^(\w-*\.*)+@(\w-?)+(\.\w{2,})+$/
    if (expr.test(value)) {
      return this
    } else {
      notPhoneNote && wx.showToast({
        title: notPhoneNote,
        icon: 'none'
      })
      return bundleFalse
    }

  },

  // 角标是否选中
  isPickerIndex(data, note) {
    let isHaveValue = data != null && data != -1
    if (note && !isHaveValue) {
      wx.showToast({
        title: note || "",
        icon: 'none',
      })
    }
    return isHaveValue ? this : bundleFalse
  },

}

// 创建过渡对象
let bundleFalse = {
  isResult: false
}
// 插入当校验false时的回调-空方法
const funcNames = Object.keys(tool)
for (let funcName of funcNames) {
  if (typeof tool[funcName] == "function") {
    bundleFalse[funcName] = function() {
      return this
    }
  }
}



module.exports = {
  // 结果
  isResult,
  //判断开始时间和结束时间范围
  isEnableTimeRange: tool.isEnableTimeRange,
  //是否有值判断(数组/对象/字符串)
  isHaveValue: tool.isHaveValue,
  //判断是否电话
  isPhone: tool.isPhone,
  //判断是否数字
  isNumber: tool.isNumber,
  // 是否价格
  isPrice: tool.isPrice,
  // 检查是否是邮箱
  isEmail: tool.isEmail,
  // 角标是否选中
  isPickerIndex: tool.isPickerIndex,
}