Knockout.js 剔除消毒数字

我正在使用knockout和映射插件自动创建我的视图模型。在我的视图模型中，我有一大堆绑定到文本框的金额。当用户在文本框中更改金额时，我只想确保他们输入的是一个数字，并且大于0，如果不是，我想用0替换他们输入的数字。这看起来应该很简单。。。具有自定义绑定或订阅功能

我所读到的关于敲除验证的所有内容都是关于扩展器和读/写计算观察值，或者添加另一个插件（比如jquery验证）。在这种情况下，它们似乎都是多余的，必须为每个要验证的可观察对象显式声明扩展程序/计算的可观察对象。我有很多数量是使用映射插件自动创建的，所以这似乎不合理

---

任何帮助都将不胜感激

对于您的特定场景，处理此问题的一种方法是创建一个自定义绑定，该绑定能够拦截值并进行验证。这可以通过在自定义绑定中创建一个可写的计算机来实现。其优点是，您不必担心映射插件定制对象创建

它可能看起来像：

ko.bindingHandlers.positiveNumericValue = {
    init : function(element, valueAccessor, allBindingsAccessor) {
        var underlyingObservable = valueAccessor();
        var interceptor = ko.computed({
            read: underlyingObservable,
            write: function(newValue) {
                var current = underlyingObservable(),
                    valueToWrite = isNaN(newValue) ? 0 : parseFloat(+newValue);

                if (valueToWrite < 0) {
                   valueToWrite = 0;   
                }

                //only write if it changed
                if (valueToWrite !== current) {
                    underlyingObservable(valueToWrite);
                } else {
                    //if the rounded value is the same as it was, but a different value was written, force a notification so the current field is updated to the rounded value
                    if (newValue !== current) {
                        underlyingObservable.valueHasMutated();
                    }
                }   
            } 
        });
        ko.bindingHandlers.value.init(element, function() { return interceptor }, allBindingsAccessor);
    },  
    update : ko.bindingHandlers.value.update
};

ko.bindingHandlers.positiveEnumericValue={
init:function（元素、valueAccessor、allBindingsAccessor）{
var underyingObservable=valueAccessor（）；
var拦截器=ko.computed({
阅读：潜在的可观察，
写入：函数（newValue）{
var current=underlyingObservable（），
valueToWrite=isNaN（newValue）？0:parseFloat（+newValue）；
如果（值写入<0）{
valueToWrite=0；
}
//只有改变了才写
如果（valueToWrite！==当前）{
潜在可观察（valueToWrite）；
}否则{
//如果舍入值与原来的值相同，但写入了不同的值，则强制发出通知，以便将当前字段更新为舍入值
如果（新值！==当前值）{
底层可见。值已发生突变（）；
}
}   
} 
});
bindingHandlers.value.init（元素，函数（）{return interceptor}，allBindingsAccessor）；
},  
更新：ko.bindingHandlers.value.update
};

以下是一个示例：

另一种方法是使用一个选项来扩展Observable，以创建可写的计算对象

对于您的场景，它可能看起来像：

ko.observable.fn.forcePositive = function() {
    var underlyingObservable = this;
    if (!this.forcePositiveInterceptor) {
         this.forcePositiveInterceptor = ko.computed({
            read: this,
            write: function(newValue) {
                var current = underlyingObservable(),
                    valueToWrite = isNaN(newValue) ? 0 : parseFloat(+newValue);

                if (valueToWrite < 0) {
                   valueToWrite = 0;   
                }

                //only write if it changed
                if (valueToWrite !== current) {
                    underlyingObservable(valueToWrite);
                } else {
                    //if the rounded value is the same as it was, but a different value was written, force a notification so the current field is updated to the rounded value
                    if (newValue !== current) {
                        underlyingObservable.valueHasMutated();
                    }
                }   
            } 
        });
    }            

    return this.forcePositiveInterceptor;        
};

ko.observable.fn.forcePositive=函数（）{
var UnderlyngObservable=此；
如果（！此.forcePositiveInterceptor）{
此.forcePositiveInterceptor=ko.computed({
读：这个，
写入：函数（newValue）{
var current=underlyingObservable（），
valueToWrite=isNaN（newValue）？0:parseFloat（+newValue）；
如果（值写入<0）{
valueToWrite=0；
}
//只有改变了才写
如果（valueToWrite！==当前）{
潜在可观察（valueToWrite）；
}否则{
//如果舍入值与原来的值相同，但写入了不同的值，则强制发出通知，以便将当前字段更新为舍入值
如果（新值！==当前值）{
底层可见。值已发生突变（）；
}
}   
} 
});
}            
返回此。forcePositiveInterceptor；
};

然后，你会像这样约束它：

<input type="text" name="age" data-bind="value: age.forcePositive()" />

我在这里实现它的方法是，您需要调用一个函数

forcePositive（）

，这样就可以初始化可写文件。这样，您就可以在不进行任何自定义的情况下使用映射插件，并且只需在您想要使用此功能的任何可观察对象上执行此操作

样本：

---

我认为这两种选择都适用于您的场景。我可能倾向于第二种选择，这样您就可以在使用普通绑定时添加更多的绑定。

对于您的特定场景，一种处理方法是创建一个能够截取值并进行验证的自定义绑定。这可以通过在自定义绑定中创建一个可写的计算机来实现。其优点是，您不必担心映射插件定制对象创建

它可能看起来像：

ko.bindingHandlers.positiveNumericValue = {
    init : function(element, valueAccessor, allBindingsAccessor) {
        var underlyingObservable = valueAccessor();
        var interceptor = ko.computed({
            read: underlyingObservable,
            write: function(newValue) {
                var current = underlyingObservable(),
                    valueToWrite = isNaN(newValue) ? 0 : parseFloat(+newValue);

                if (valueToWrite < 0) {
                   valueToWrite = 0;   
                }

                //only write if it changed
                if (valueToWrite !== current) {
                    underlyingObservable(valueToWrite);
                } else {
                    //if the rounded value is the same as it was, but a different value was written, force a notification so the current field is updated to the rounded value
                    if (newValue !== current) {
                        underlyingObservable.valueHasMutated();
                    }
                }   
            } 
        });
        ko.bindingHandlers.value.init(element, function() { return interceptor }, allBindingsAccessor);
    },  
    update : ko.bindingHandlers.value.update
};

ko.bindingHandlers.positiveEnumericValue={
init:function（元素、valueAccessor、allBindingsAccessor）{
var underyingObservable=valueAccessor（）；
var拦截器=ko.computed({
阅读：潜在的可观察，
写入：函数（newValue）{
var current=underlyingObservable（），
valueToWrite=isNaN（newValue）？0:parseFloat（+newValue）；
如果（值写入<0）{
valueToWrite=0；
}
//只有改变了才写
如果（valueToWrite！==当前）{
潜在可观察（valueToWrite）；
}否则{
//如果舍入值与原来的值相同，但写入了不同的值，则强制发出通知，以便将当前字段更新为舍入值
如果（新值！==当前值）{
底层可见。值已发生突变（）；
}
}   
} 
});
bindingHandlers.value.init（元素，函数（）{return interceptor}，allBindingsAccessor）；
},  
更新：ko.bindingHandlers.value.update
};

以下是一个示例：

阿诺