文档是这样子说的，看不懂，
// 代码里面
new Error()
// or
return new Error() // 都不对
翻看源码
/**
* 校验数据
* 按表格行、列顺序依次校验（同步或异步）
* 校验规则根据索引顺序依次校验，如果是异步则会等待校验完成才会继续校验下一列
* 如果校验失败则，触发回调或者Promise<不通过列的错误消息>
* 如果是传回调方式这返回一个校验不通过列的错误消息
*
* rule 配置：
* required=Boolean 是否必填
* min=Number 最小长度
* max=Number 最大长度
* validator=Function({ cellValue, rule, rules, row, column, rowIndex, columnIndex }) 自定义校验，接收一个 Promise
* trigger=blur|change 触发方式（除非特殊场景，否则默认为空就行）
*/
validCellRules (type, row, column, val) {
const { editRules } = this
const { property } = column
const errorRules = []
const cellVailds = []
if (property && editRules) {
const rules = XEUtils.get(editRules, property)
if (rules) {
const cellValue = XEUtils.isUndefined(val) ? XEUtils.get(row, property) : val
rules.forEach(rule => { // ← 1.这儿开始遍历
cellVailds.push(
new Promise(resolve => {
if (type === 'all' || !rule.trigger || type === rule.trigger) { // ← 2.进这个if
if (XEUtils.isFunction(rule.validator)) { // ← 3.再进这个if
// 在 v3.0 中废弃 setup.validArgs
if (GlobalConfig.validArgs === 'obsolete') { // ← 4.这个被废弃了，跳到对应的else
rule.validator(rule, cellValue, e => {
if (XEUtils.isError(e)) {
const cusRule = { type: 'custom', trigger: rule.trigger, message: e.message, rule: new Rule(rule) }
errorRules.push(new Rule(cusRule))
}
return resolve()
}, { rule, rules, row, column, rowIndex: this.getRowIndex(row), columnIndex: this.getColumnIndex(column), $table: this })
} else { // ← 5.这个里面搞事情
Promise.resolve(rule.validator({
cellValue,
rule,
rules,
row,
rowIndex: this.getRowIndex(row),
column,
columnIndex: this.getColumnIndex(column),
$table: this
})).catch(e => {
errorRules.push(new Rule({ type: 'custom', trigger: rule.trigger, message: e ? e.message : rule.message, rule: new Rule(rule) }))
// ↑ 6.最终要到这里 把 e.message 或者 rule.message 推到errorRules里面。
// 再在另一个方法里面把提示提示出来。
}).then(resolve)
}
} else {
const isNumber = rule.type === 'number'
const numVal = isNumber ? XEUtils.toNumber(cellValue) : XEUtils.getSize(cellValue)
if (cellValue === null || cellValue === undefined || cellValue === '') {
if (rule.required) {
errorRules.push(new Rule(rule))
}
} else if (
(isNumber && isNaN(cellValue)) ||
(!isNaN(rule.min) && numVal < parseFloat(rule.min)) ||
(!isNaN(rule.max) && numVal > parseFloat(rule.max)) ||
(rule.pattern && !(rule.pattern.test ? rule.pattern : new RegExp(rule.pattern)).test(cellValue))
) {
errorRules.push(new Rule(rule))
}
resolve()
}
} else {
resolve()
}
})
)
})
}
}
return Promise.all(cellVailds).then(() => {
if (errorRules.length) {
const rest = { rules: errorRules, rule: errorRules[0] }
return Promise.reject(rest)
}
})
},
翻看 #文档# 是这样子说的：
Promise.resolve()
有时需要将现有对象转为 Promise 对象，Promise.resolve()方法就起到这个作用。
const jsPromise = Promise.resolve($.ajax('/whatever.json'));
上面代码将 jQuery 生成的deferred对象，转为一个新的 Promise 对象。
Promise.resolve()等价于下面的写法。
Promise.resolve('foo')
// 等价于
new Promise(resolve => resolve('foo'))
Promise.resolve()方法的参数分成四种情况。
（1）参数是一个 Promise 实例
如果参数是 Promise 实例，那么Promise.resolve将不做任何修改、原封不动地返回这个实例。
（2）参数是一个thenable对象
thenable对象指的是具有then方法的对象，比如下面这个对象。
let thenable = {
then: function(resolve, reject) {
resolve(42);
}
};
Promise.resolve()方法会将这个对象转为 Promise 对象，然后就立即执行thenable对象的then()方法。
let thenable = {
then: function(resolve, reject) {
resolve(42);
}
};
let p1 = Promise.resolve(thenable);
p1.then(function (value) {
console.log(value); // 42
});
上面代码中，thenable对象的then()方法执行后，对象p1的状态就变为resolved，从而立即执行最后那个then()方法指定的回调函数，输出42。
（3）参数不是具有then()方法的对象，或根本就不是对象
如果参数是一个原始值，或者是一个不具有then()方法的对象，则Promise.resolve()方法返回一个新的 Promise 对象，状态为resolved。
const p = Promise.resolve('Hello');
p.then(function (s) {
console.log(s)
});
// Hello
上面代码生成一个新的 Promise 对象的实例p。由于字符串Hello不属于异步操作（判断方法是字符串对象不具有 then 方法），返回 Promise 实例的状态从一生成就是resolved，所以回调函数会立即执行。Promise.resolve()方法的参数，会同时传给回调函数。
（4）不带有任何参数
Promise.resolve()方法允许调用时不带参数，直接返回一个resolved状态的 Promise 对象。
所以，如果希望得到一个 Promise 对象，比较方便的方法就是直接调用Promise.resolve()方法。
const p = Promise.resolve();
p.then(function () {
// ...
});
上面代码的变量p就是一个 Promise 对象。
需要注意的是，立即resolve()的 Promise 对象，是在本轮“事件循环”（event loop）的结束时执行，而不是在下一轮“事件循环”的开始时。
setTimeout(function () {
console.log('three');
}, 0);
Promise.resolve().then(function () {
console.log('two');
});
console.log('one');
// one
// two
// three
上面代码中，setTimeout(fn, 0)在下一轮“事件循环”开始时执行，Promise.resolve()在本轮“事件循环”结束时执行，console.log('one')则是立即执行，因此最先输出。
大致这样子弄：
var validator = () => {
// do something...
return {
then: function (resolve, reject) {
try {
throw new Error('test');
} catch (e) {
reject({ message: '提示信息！！' })
}
}
}
}
Promise
.resolve(validator())
.then(res => console.log('then', res))
.catch(e => {
console.log('catch', e || e.message || ' - ') // 输出： 提示信息！！
})