Javascript 如何从该数组中分离规则数组和执行函数

我有一个用于验证的类，它具有不同的验证函数。 现在我要做的是在另一个文件中创建一个对象，并使用构造函数发送所有验证数据。这个构造函数将接收一个类似“rules[is_empty:value]”的对象。左半部分是函数名，值是从输入字段中获取的值。现在我如何调用函数并将值作为参数发送。还有，当函数有多个参数时，我应该怎么做

我已经尝试使用map方法和split方法，但无法访问该函数

class Validator {
    constructor(rules) {
        let rule_obj = {}
        // rules[is_empty:value,has_valid_min_length:2;3]

    }
    /**this is to check if the field has an empty value or not */
    is_empty = (value) => {
        if (value == '' || value == null) {
            return true
        }
        else {
            return false
        }
    }

    /**this is to check if value has required minimum length or not */
    has_valid_min_length = (value, min_length = 0) => {
        if (this.is_empty(value)) {
            return false
        }
        if (value.length < min_length) {
            return false
        }
        else {
            return true
        }
    }

    /**this is to check if value has more characters than maximum length */
    has_valid_max_length = (value, max_length = 0) => {
        if (this.is_empty(value)) {
            return false
        }
        if (value.length > max_length) {
            return false
        }
        else {
            return true
        }
    }

    //this is to check if selected date is less than given limit
    is_before_min_date = (value_date, min_date) => {
        if (this.is_empty(value)) {
            return false
        }
        if (value_date < min_date) {
            return true
        }
        else { return false }
    }

    //this is to check if selected date is higher than given limit
    is_after_max_date = (value_date, max_date) => {
        if (this.is_empty(value)) {
            return false
        }
        if (value_date > max_date) {
            return true
        }
        else {
            return false
        }
    }

}

类验证程序{
建造师（规则）{
让规则_obj={}
//规则[为空：值，具有有效的最小长度：2；3]
}
/**这是为了检查字段是否有空值*/
是否为空=（值）=>{
如果（值=“”| |值==null）{
返回真值
}
否则{
返回错误
}
}
/**这是为了检查该值是否具有所需的最小长度*/
具有有效的最小长度=（值，最小长度=0）=>{
如果（此值为空（值））{
返回错误
}
if（value.length<最小长度）{
返回错误
}
否则{
返回真值
}
}
/**这是为了检查值的字符数是否超过最大长度*/
具有有效的最大长度=（值，最大长度=0）=>{
如果（此值为空（值））{
返回错误
}
如果（value.length>max_length）{
返回错误
}
否则{
返回真值
}
}
//这是为了检查所选日期是否小于给定的限制
_在_min_date之前=（值_date，min_date）=>{
如果（此值为空（值））{
返回错误
}
如果（值日期<最小日期）{
返回真值
}
else{return false}
}
//这是为了检查所选日期是否高于给定的限制
是否在\u max\u date=（值\u date，max\u date）=>{
如果（此值为空（值））{
返回错误
}
如果（值日期>最大日期）{
返回真值
}
否则{
返回错误
}
}
}

我想调用数组中“：”符号之前的函数，并给出“：”右侧的值中的函数参数

---

请提供帮助。

您可以通过构造函数发送对象

x = {
      "is_empty": [0, 2, 2],
      "has_valid_min_length": [ [value, min_length], [value, min_length] ],
      "has_valid_max_length": [ [value, max_length], [value, max_length] ],
      "is_before_min_date": [ [value_date, min_date], [value_date, min_date] ],
      "is_after_max_date": [ [value_date, max_date], [value_date, max_date] ]
    }

然后在构造函数中，通过对象和值数组设置一个循环

constructor(to_be_validated) {
        let validator_names = Object.keys(to_be_validated);

        for (let validator of validator_names) {
            let values = to_be_validated[validator];

            if (validator === "is_empty") {
                for (let value of values) {
                    this.is_empty(value);
                }
            } else if (validator === "has_valid_min_length") {
                for (let value of values) {
                    this.has_valid_min_length(value[0], value[1]);
                }
            } etc...
        }
    }

然后，当您调用函数时，方法应该执行

let my_validator = new Validator(x);

我附和上述评论。需要的方法和特定语法

let my_validator = new Validator(rules[validator_name:values]);

---

像这样一条干净的线，有点不对劲。我从未见过这样做。

您可以通过构造函数发送对象

x = {
      "is_empty": [0, 2, 2],
      "has_valid_min_length": [ [value, min_length], [value, min_length] ],
      "has_valid_max_length": [ [value, max_length], [value, max_length] ],
      "is_before_min_date": [ [value_date, min_date], [value_date, min_date] ],
      "is_after_max_date": [ [value_date, max_date], [value_date, max_date] ]
    }

然后在构造函数中，通过对象和值数组设置一个循环

constructor(to_be_validated) {
        let validator_names = Object.keys(to_be_validated);

        for (let validator of validator_names) {
            let values = to_be_validated[validator];

            if (validator === "is_empty") {
                for (let value of values) {
                    this.is_empty(value);
                }
            } else if (validator === "has_valid_min_length") {
                for (let value of values) {
                    this.has_valid_min_length(value[0], value[1]);
                }
            } etc...
        }
    }

然后当调用函数时，应该执行这些方法

let my_validator = new Validator(x);

我附和上述评论。需要的方法和特定语法

let my_validator = new Validator(rules[validator_name:values]);

---

像这样一条干净的线，有点不对劲。我从未见过这样做。

您可能希望在类中添加一个函数，根据您的规则调用所有检查函数

class Validator {
    constructor(rules) {
        this.rules = rules;
        // rules={is_empty:[],has_valid_min_length:[2]};

    }

    validate = (value) => {
        let pass = true;
        Object.keys(this.rules).forEach(k=>pass = pass && this[k](value, ...this.rules[k]));
        return pass;
    }

    ...
}

规则

-对象具有键-值对，其中键是各个检查的函数名，值是将要传递的参数数组。此数组可以有零个或多个条目

编辑：

forEach

将迭代所有键。每次转动时，

k

将保持当前键

pass

是一个布尔值，用于收集checker函数的所有返回值。（

true&&false==false

）这样，如果任何检查返回false，则最终返回值将为false

然后将规则应用于数据，如下所示：

---

myValidatorObj.validate（数据）
您可能希望在类中增加一个函数，根据您的规则调用所有检查函数

class Validator {
    constructor(rules) {
        this.rules = rules;
        // rules={is_empty:[],has_valid_min_length:[2]};

    }

    validate = (value) => {
        let pass = true;
        Object.keys(this.rules).forEach(k=>pass = pass && this[k](value, ...this.rules[k]));
        return pass;
    }

    ...
}

规则
-对象具有键-值对，其中键是各个检查的函数名，值是将要传递的参数数组。此数组可以有零个或多个条目

编辑：
forEach
将迭代所有键。每次转动时，
k
将保持当前键
pass
是一个布尔值，用于收集checker函数的所有返回值。（
true&&false==false
）这样，如果任何检查返回false，则最终返回值将为false

然后将规则应用于数据，如下所示：
myValidatorObj.validate（数据）
您的方法很奇怪，将规则和值作为需要解析的字符串传递有什么意义？它在某些情况下有效，但似乎不是正确的方法。我对另一种方法持开放态度。我真的很想知道是否还有其他方法可以做到这一点。@Blitz你的沙盒编码是我需要的，唯一我不明白的是什么是。every（布尔）？你能解释一下它是做什么的吗？@Bhumikbhatt为什么不直接用值调用验证函数，而不是构造一个
验证程序
对象？事实上，直接调用验证函数似乎更好。
.every（Boolean）
检查所有值是否真实。您的方法很奇怪，将规则和值作为必须解析的字符串传递有什么意义？它在某些情况下有效，但似乎不是正确的方法。我对另一种方法持开放态度。我真的很想知道是否还有其他方法可以做到这一点。@Blitz你的沙盒编码是我需要的，唯一我不明白的是什么是。every（布尔）？你能解释一下是什么意思吗