我真的很喜欢Eric Barnard's knockout validation lib与可观察性的集成，允许分组，并提供自定义验证器的可插入性（包括动态验证器）。有几个地方它可以更灵活/更友好，但总的来说，它是合理的良好记录... except, imo, when it comes to async validators。
今天在做搜索和landing on this之前，我纠结了几个小时。我 * 认为 * 我和原作者有同样的问题，但我同意不清楚duxa到底要求什么。我想让这个问题引起更多的关注，所以我也在这里问。

function MyViewModel() {
    var self = this;
    self.nestedModel1.prop1 = ko.observable().extend({
        required: { message: 'Model1 Prop1 is required.' },
        maxLength: {
            params: 140,
            message: '{0} characters max please.'
        }
    });
    self.nestedModel2.prop2 = ko.observable().extend({
        required: { message: 'Model2 Prop2 is required' },
        validation: {
            async: true,
            validator: function(val, opts, callback) {
                $.ajax({                                  // BREAKPOINT #1
                    url: '/validate-remote',
                    type: 'POST',
                    data: { ...some data... }
                })
                .success(function(response) {
                    if (response == true) callback(true); // BREAKPOINT #2
                    else callback(false);
                });
            },
            message: 'Sorry, server says no :('
        }
    });
}

ko.validation.group(self.nestedModel1);
ko.validation.group(self.nestedModel2);

关于以上代码的几点注意事项：有两个独立的验证组，每个嵌套模型一个。嵌套模型#1没有异步验证器，而嵌套模型#2有两个同步验证器。（必需的）和一个async。async调用服务器调用来验证输入。当服务器响应时，callback参数用于告诉ko.validation用户输入是正确的还是错误的。**如果您在指定的行上放置断点并使用已知的无效值触发验证，您最终会得到一个无限循环，其中 AJAX 1 m2n1x函数导致validator函数被再次调用。**我打开了ko.validation源代码以查看发生了什么。

ko.validation.validateObservable = function(observable) {
    // set up variables & check for conditions (omitted for brevity)

    // loop over validators attached to the observable
    for (; i < len; i++) {
        if (rule['async'] || ctx['async']) {
            //run async validation
            validateAsync();
        } else {
            //run normal sync validation
            if (!validateSync(observable, rule, ctx)) {
                return false; //break out of the loop
            }
        }
    }

    //finally if we got this far, make the observable valid again!
    observable.error = null;
    observable.__valid__(true);
    return true;
}

此函数位于附加到可观察用户输入的订阅链中，因此当其值更改时，将验证新值。该算法在附加到输入的每个验证器上循环，并根据验证器是否为异步执行单独的函数。如果同步验证失败，则循环中断，整个validateObservable函数退出。如果所有同步验证器都通过，最后3行被执行，实质上告诉ko.validation这个输入是有效的。库中的__valid__函数如下所示：

//the true holder of whether the observable is valid or not
observable.__valid__ = ko.observable(true);

有两点值得注意：__valid__是一个可观测量，在validateAsync函数退出后设置为true，现在我们来看一下validateAsync：

function validateAsync(observable, rule, ctx) {
    observable.isValidating(true);

    var callBack = function (valObj) {
        var isValid = false,
            msg = '';

        if (!observable.__valid__()) {
            // omitted for brevity, __valid__ is true in this scneario
        }

        //we were handed back a complex object
        if (valObj['message']) {
            isValid = valObj.isValid;
            msg = valObj.message;
        } else {
            isValid = valObj;
        }

        if (!isValid) {
            //not valid, so format the error message...
            observable.error = ko.validation.formatMessage(...);
            observable.__valid__(isValid);
        }

        // tell it that we're done
        observable.isValidating(false);
    };

    //fire the validator and hand it the callback
    rule.validator(observable(), ctx.params || true, callBack);
}

需要注意的是，在ko.validation.validateObservable将__valid__可观测值设置为true并退出之前，只执行了该函数的第一行和最后一行。callBack函数是作为第三个参数传递给MyViewModel中声明的异步validator函数的函数。然而，在此之前，一个isValidating可观测对象的订阅者被调用来通知异步验证已经开始。当服务器调用完成时，回调被调用（在这种情况下，只传递true或false）。
下面是当服务器端验证失败时，MyViewModel中的断点导致无限乒乓循环的原因：在上面的callBack函数中，请注意当验证失败时，__valid__可观测值是如何被设置为false的。
1.无效的用户输入更改了nestedModel2.prop2可观察值。

1. ko.validation.validateObservable会透过订阅通知此变更。
   1.调用validateAsync函数。
   1.调用自定义异步验证器，该验证器向服务器提交异步$.ajax调用并退出。
2. ko.validation.validateObservable将__valid__可观测量设置为true并退出。
   1.服务器返回无效响应，并执行callBack(false)。
3. callBack函数将__valid__设置为false。
4. ko.validation.validateObservable被告知__valid__可观测量的变化（callBack将其从true更改为false）。这基本上重复了上述步骤2。
   1.重复上述步骤3、4和5。
   1.由于可观察值没有改变，服务器返回另一个无效响应，触发上面的步骤6、7、8和9。
   1.我们有一场乒乓球比赛。
   所以看起来问题是ko.validation.validateObservable订阅处理程序不仅监听用户输入值的更改，而且监听其嵌套__valid__可观察值的更改。这是一个bug，还是我做错了什么？

次要问题

从上面的ko.validation源代码中可以看出，当服务器验证时，带有异步验证器的用户输入值被视为有效。因此，调用nestedModel2.isValid()不能被视为“真实”。相反，看起来我们必须使用isValidating钩子来创建对异步验证器的订阅，并且只在它们通知false的值之后才做出这些决定。这是设计的吗？与库的其他部分相比，这似乎是最违反直觉的，因为非异步验证器没有isValidating可订阅，而且可以依靠.isValid()来讲述真相。这也是设计使然，还是我在这里也做错了什么？