10
function getBouns(base, level) {
20
  if (level == 'A') {
30
    return base * 5
40
  }
50
  if (level == 'B') {
60
    return base * 4
70
  }
80
  if (level == 'C') {
90
    return base * 3
10
  }
11
  if (level == 'D') {
12
    return base * 2
13
  }
14
  if (level == 'E') {
15
    return base * 1
16
  }
17
}

1
const p1 = {
2
  name: '张三',
3
  base: 1000,
4
  level: 'A'
5
}
6
p1.bouns = getBouns(p1.base, p1.level)
7

8
console.log(p1)

10
const map = {
20
  A: function(base) {
30
    return base * 5
40
  },
50
  B: function (base) {
60
    return base * 4
70
  },
80
  C: function (base) {
90
    return base * 3
10
  },
11
  D: function (base) {
12
    return base * 2
13
  },
14
  E: function (base) {
15
    return base * 1
16
  },
17
}

1
function getBouns(base, level) {
2
  return map[level](base)
3
}

1
const p2 = {
2
  name: '李四',
3
  base: 1200,
4
  level: 'B'
5
}
6
p2.bouns = getBouns(p2.base, p2.level)
7

8
console.log(p2)

10

20
// 从组件中获取到的字段内容，其中包括了具体的值，与传入的校验规则
30
const fields = {
40
  username: {
50
    value: '张三',
60
    rules: [{required: true, message: '该字段为必填'}, {max: 10}]
70
  },
80
  password: {
90
    value: '123',
10
    rules: [{required: true}, {min: 6}]
11
  },
12
  phone: {
13
    value: '123123',
14
    rules: [{pattern: /(^1[3|5|8][0-9]{9}$)/, message: '手机号码规则不匹配'}]
15
  }
16
}

10
var strategys = {
20
  required: function (value, rule) {
30
    if (value === '') {
40
      return rule.message || '该字段不能为空';
50
    }
60
  },
70
  // 限制最小长度
80
  min: function (value, rule) {
90
    if (value.length < rule.min) {
10
      return rule.message || `该字段最小长度为${rule.min}`;
11
    }
12
  },
13
  // 限制最小长度
14
  max: function (value, rule) {
15
    if (value.length > rule.max) {
16
      return rule.message || `该字段最大长度为${rule.max}`;
17
    }
18
  },
19
  // 手机号码格式
20
  pattern: function (value, rule) {
21
    if (!rule.pattern.test(value)) {
22
      return rule.message || '正则匹配失败';
23
    }
24
  }
25
};
26

10
function Validator () {
20
  // 格式 { username: { value: '张三', rules: [{}, {}] } }
30
  this.fields = {};
40
};
50

60
// 添加一个字段
70
Validator.prototype.addField = function (name, value, rules) {
80
  this.fields[name] = {
90
    value,
10
    rules
11
  }
12
};
13

14
// 添加多个字段
15
Validator.prototype.addFields = function(fields) {
16
  this.fields = fields
17
}
18

19
// 验证，并返回验证结果
20
Validator.prototype.validate = function() {
21
  // 通过的字段，与错误的字段
22
  const result = { fields: [], errorFields: [] }
23
  Object.keys(this.fields).forEach(key => {
24
    // 错误验证结果
25
    let errorMessage = ''
26
    const value = this.fields[key].value
27
    const rules = this.fields[key].rules
28
    
29
    for (var i = 0; i < rules.length; i++) {
30
      Object.keys(rules[i]).forEach(validateField => {
31
        if (strategys[validateField]) {
32
          const message = strategys[validateField](value, rules[i])
33
          if (message) {
34
            errorMessage = message
35
          }
36
        }
37
      })
38
      if (errorMessage) {
39
        break
40
      }
41
    }
42

43
    if (errorMessage) {
44
      result.errorFields.push({field: key, value, message: errorMessage})
45
    } else {
46
      result.fields.push({field: key, value})
47
    }
48
  })
49

50
  return result
51
};

1
var validator = new Validator();
2
validator.addFields(fields)
3
const result = validator.validate()
4
console.log(result)
5

6
if (result.errorFields.length > 0) {
7
  console.error('字段验证不通过')
8
}