公共方法~~

公共方法

一.控制输入几位小数，并进行比较

1.需求描述

新增积分单位配置，系统默认的积分单位为1，支持手动修改配置，最小可为0.01

如果返回1时积分为整数，如果返回0.01时支持两位小数

2.前端B端 封装的全局判断积分的校验规则方法及使用：

rules 需要传入的参数：
requiredInfo： 此值默认不传：表示字段是必传字段校验，若传值为true,表示字段是非必传字段
pointzero： 是否可以输入0；true 则可以输入0；false:不可以输入0—

// 下面的参数是2个输入进行大小比较的时候
isNeedCompare：是否是2个输入框，用于校验积分的最小值 及 最大值 （有2个比较积分大小的输入框才需要传参）
min：若是2个输入框，则传入此值，积分最小值的字段 （有2个比较积分大小的输入框才需要传参）
max：若是2个输入框，则传入此值，积分最大值的字段 （有2个比较积分大小的输入框才需要传参）
dataFormCommons：若是2个输入框，此值为el-form 绑定的 ref的值 （有2个比较积分大小的输入框才需要传参）
twoValue：若是2个输入框，则传入此值，此值为 与当前输入框 比较的另一个输入框 prop字段的值 （有2个比较积分大小的输入框才需要传参）

pointOffsetFlag（此值存储在本地的）：
若 当膨胀系数为1时 && 不允许输入小数，可以输入1-9999999；
若 当膨胀系数为1时 && 允许输入小数，可以输入0-9999999；
若 当膨胀系数为100时 && 不允许输入小数，可以输入0-9999999.99
若 当膨胀系数为100时 && 允许输入小数，可以输入0.01-9999999.99

    // 自定义校验规则 - 积分
    validatePointCheckWay(rule, value, callback) {
      const {requiredInfo, isNeedCompare, pointzero, min, max, dataFormCommons, field, twoValue} = rule
      const pointOffsetFlag = localStorage.getItem('pointOffsetFlag')
      console.log(rule, value, '这里不行吗', requiredInfo, isNeedCompare, pointzero, min, max, dataFormCommons, field, twoValue)
      /*
        rules需要传入的参数：
        requiredInfo： 此值默认不传：表示字段是必传字段校验，若传值为true,表示字段是非必传字段
        pointzero： 是否可以输入0；true  则可以输入0；false:不可以输入0
        // 下面的参数是2个输入进行大小比较的时候
        isNeedCompare：是否是2个输入框，用于校验积分的最小值 及 最大值
        min：若是2个输入框，则传入此值，积分最小值的字段
        max：若是2个输入框，则传入此值，积分最大值的字段
        dataFormCommons：若是2个输入框，此值为el-form 绑定的 ref的值
        twoValue：若是2个输入框，则传入此值，此值为 与当前输入框 比较的另一个输入框 prop字段的值

        pointOffsetFlag（此值存储在本地的）：
        若 当膨胀系数为1时 && 不允许输入小数，可以输入1-9999999；
        若 当膨胀系数为1时 && 允许输入小数，可以输入0-9999999；
        若 当膨胀系数为100时 && 不允许输入小数，可以输入0-9999999.99
        若 当膨胀系数为100时 && 允许输入小数，可以输入0.01-9999999.99
      */
      const integer = pointzero ? /(^[1-9]\d{0,6}$)|(^0$\b)/ : /(^[1-9]\d{0,6}$)/
      const decimal = pointzero ? /(^([1-9]{1}\d{0,6})(\.\d{1,2})?$)|(^0[.][0-9][1-9]$)|(^0[.][1-9][0-9]?$)|(^0$\b)/ : /(^([1-9]{1}\d{0,6})(\.\d{1,2})?$)|(^0[.][0-9][1-9]$)|(^0[.][1-9][0-9]?$)/
      const regNumber = (pointOffsetFlag == 1) ? /^(0|[1-9][0-9]*|-[1-9][0-9]*)$/ : /(^[0-9]*$)|(^[0-9]*[\.]{1}[0-9]{1,2}$)/ //  const regNumber = /^(0|[1-9][0-9]*|-[1-9][0-9]*)$/ // 只允许输入数字的校验
      if (pointOffsetFlag == '1') { // 整数
        if (!requiredInfo) { // 默认 必传字段
          if (!pointzero) { // 不允许输入0
            if (value === '0' || value === '0') { // 输入0
              return callback(new Error('不允许输入0'))
            } else { // 未输入0
              if (!integer.test(value)) {
                return callback(new Error(pointzero ? '积分范围为0-9,999,999' : '积分范围为1-9,999,999'))
              }
            }
          } else {
            if (!integer.test(value)) {
              return callback(new Error(pointzero ? '积分范围为0-9,999,999' : '积分范围为1-9,999,999'))
            }
          }
        } else { // 不必传
          /*
            非必传字段：
            1. value有值 && 不为0时 && 又校验没通过，可报错提示
            2. 不允许输入0 && 值为0，可报错提示
          */
          const myValue = !!Number(value)
          if (myValue) { // value有值 && 不为0时就执行此区间
            if (!integer.test(value)) {
              return callback(new Error(pointzero ? '积分范围为0-9,999,999' : '积分范围为1-9,999,999'))
            }
          } else {
            if ((value != '') && (value == 0) && !pointzero) { // 不允许输入0 && 值为0
              return callback(new Error('不允许输入0'))
            }
          }
        }
      } else if (pointOffsetFlag == '100') { // 小数
        if (!requiredInfo) { // 默认 必传字段
          if (!pointzero) { // 不允许输入0
            if (value === '0' || value === '0') { // 输入0
              return callback(new Error('不允许输入0'))
            } else { // 未输入0
              if (!decimal.test(value)) {
                return callback(new Error(pointzero ? '积分范围为0-9,999,999.99' : '积分范围为0.01-9,999,999.99'))
              }
            }
          } else {
            if (!decimal.test(value)) {
              return callback(new Error(pointzero ? '积分范围为0-9,999,999.99' : '积分范围为0.01-9,999,999.99'))
            }
          }
        } else { // 不必传
          /*
            非必传字段：
            1. value有值 && 不为0时 && 又校验没通过，可报错提示
            2. 不允许输入0 && 值为0，可报错提示
          */
          const myValue = !!Number(value)
          if (myValue) { // value有值 && 不为0时就执行此区间
            if (!decimal.test(value)) {
              return callback(new Error(pointzero ? '积分范围为0-9,999,999.99' : '积分范围为0.01-9,999,999.99'))
            }
          } else {
            if ((value != '') && (value == 0) && !pointzero) { // 不允许输入0 && 值为0
              return callback(new Error(pointzero ? '积分范围为0-9,999,999.99' : '积分范围为0.01-9,999,999.99'))
            }
          }
        }
      }
      if (!regNumber.test(value) && !!value) {
        return callback(new Error('只允许输入数字'))
      }
      // 判断是否需要比较
      const scoreResult = this.compareScoreWay(min, max, requiredInfo, pointzero)
      console.log(scoreResult, 'scoreResultscoreResult')
      if (isNeedCompare) {
        if (scoreResult) {
          return callback(new Error(scoreResult))
        } else {
          if (this.lastStatus === '') {
            console.log(this.$refs[dataFormCommons], '9999')
            if (this.$refs[dataFormCommons]) {
              setTimeout(() => {
                this.$refs[dataFormCommons].validateField(twoValue)
              })
            }

            this.lastStatus = 'check'
          } else if (this.lastStatus === 'check') {
            this.lastStatus = ''
          }
        // this.$refs[dataFormCommons].clearValidate([field, twoValue])
        // this.$refs[dataFormCommons].clearValidate([twoValue])
        // this.$refs[dataFormCommons].validateField(twoValue)
        }
      }
      callback()
    },
    // 积分比较
    compareScoreWay(min, max) {
      const minValue = !!min && (min !== '') // 存在值（排除0，‘’，‘0’）
      const maxValue = !!max && (max !== '') // 存在值（排除0，‘’，‘0’）
      if ((Number(min) > Number(max))) {
        console.log(1111111111)
        return '积分上限需大于等于积分下限'
      } else if ((min === 0 || min === '0') && max === '') {
        console.log(2222222222222)
        return '积分上限需大于等于积分下限'
      } else if ((max === 0 || max === '0') && min === '') {
        console.log(333333333333)
        return '积分上限需大于等于积分下限'
      } else if (minValue && max === '') { // min 有值，max是空
        console.log(4444)
        return '积分上限需大于等于积分下限'
      } else if (maxValue && min === '') { // max有值，min是空
        console.log(555555)
        return '积分上限需大于等于积分下限'
      }
    },
                 // 输入框暗文字
    inputPlaceholder(pointzero) {
      const pointOffsetFlag = localStorage.getItem('pointOffsetFlag')
      if (pointzero) {
        //   允许输入0
        return '0-9999999'
      } else if (!pointzero && pointOffsetFlag == 1) {
        //   不允许输入0 并且是整数
        return '1-9999999'
      } else {
        //   不允许输入0 并且是小数
        return '0.01-9999999'
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

*** 存本地方法

在登录页调用偏移量接口将拿到的值利用localStorage.setItem

放本地-----localStorage.setItem(‘pointOffsetFlag’, data)

拿本地-----localStorage.getItem(‘pointOffsetFlag’)

3.遇到的问题

正则问题—

当页面保存的时候校验验证总是通过不了

当比较的时候想要两个输入框校验同步，输入第一个的时候利用方法校验第二个值

table进行校验

二、获取下一个卡号

getnumber(a,i){
      console.log(a,'getnumberaaaaaaa')
      // a是值 i是加多少位
      // 逻辑判断a时候有英文字母 有的话将他们截取
      a=a.toString()
      var A=a.split('')//['0','0','A','1']
      var B=A.reverse() //['1','A','0','0']
      var b=B
      var C=B.findIndex(v=>/[a-zA-Z]/.test(v))
      if(C!==-1){
       var D=B.splice(0,C)
      // 获取到最后一个字符串后面的数字
      var last=D.reverse().join('')
      var length=a.length-C
      var f=A.splice(0,length)
      var fist=f.reverse().join('')
     console.log(last,'字母之后',fist,'字母之前',length,fist,';',C)
     var zuihou=  this.handleposition(last, i)
     if(!zuihou){
      this.$message.error('请输入正确的卡号')
      return ''
     }else{
     return fist+zuihou
     }
      }else{
        // a还是正常的值
       var zuihou1=  this.handleposition(a, i)
       console.log(zuihou1,'lklklklk');
       return zuihou1
      }
      
    },
        // 查找卡号非零的位置 并且给数字添加0
    handleposition(a, i) {
      // a首先是字符串
      //首先判断首位是不是0  如果是0那么就得进行操作
      // Number+1之后把长度补位
      if(a){
      if (a[0] == 0) {
        // 原本的长度
        const b = a.length;
        // 相加之后的值
        const New = Number(a) + i;
        //  相加之后的长度与之前的差
        const c = b - New.toString().length;
        // 给New补0
        var d = '';
        for (var j = 0; j < c; j++) {
          d += '0';
        }
        console.log(d, '新加的几个0', d + New);
        return d + New;
      } else {
        console.log(a,a[0],isNaN(a[0]))
        if (isNaN(a[0])) {
          a=a.toString()
          let pre = a.replace(/\d+/g, '');
          var num = a.match(/\d+/g);
          if(num){
          num=num.toString()
          if(num[0]==0){
            const B = num.length;
           const New1 = Number(num) + i;
           const C = B - New1.toString().length;
           var D = '';
           for (var J = 0; J < C; J++) {
             D += '0';
           }
           return (pre + (D + New1)).trim();
          }else{
           const New = Number(num) + i;
           return (pre + New).trim();
          }
          }
        } else {
          return Number(a) + i;
        }
      }
      }
    },
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

三.千分符

getNumber(num) {
   if (typeof num !== 'string') {
    num = num.toString()
   }
   const nums = num.split('.')
   const reverseNum = nums[0].split('').reverse()
   const numList = []
   let list = []
   reverseNum.forEach((item, index) => {
    list.push(item)
    if (list.length === 3 && reverseNum[index + 1]) {
     numList.push(item, ',')
     list = []
    } else {
     numList.push(item)
    }
   })
   const numStr = numList.reverse().join('')
   return nums.length === 2 ? numStr + '.' + nums[1] : numStr
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20