淘汰赛：indexOf返回-1时更加困惑

Question

背景

我试图在第二个数组B中检查数组A中是否存在值。每个值都是一个可观察的数字。 每个可观察的数字都包含在一个可观察的数组中。 比较总是返回-1，这已知是不正确的（只要A和B中的值重叠）。 因此，我的逻辑或语法有问题，但我无法弄清楚在哪里。

JSBin （完整项目）： http ： //jsbin.com/fehoq/190/edit

JS

//set up my two arrays that will be compared
this.scores = ko.observableArray();

//lowest is given values from another method that splices from scores
this.lowest = ko.observableArray();

//computes and returns mean of array less values in lowest
this.mean = (function(scores,i) {
    var m = 0;
    var count = 0;

    ko.utils.arrayForEach(_this.scores(), function(score) {

        if (!isNaN(parseFloat(score()))) {

            //check values
            console.log(score());

            // always returns -1
            console.log(_this.lowest.indexOf(score()));

            //this returns an error, 'not a function'
            console.log(_this.lowest()[i]());

            //this returns undefined
            console.log(_this.lowest()[i]);

            //only do math if score() isn't in lowest
            // again, always returns -1, so not a good check
            if (_this.lowest.indexOf(score())<0) {
                m += parseFloat(score());
                count += 1;
            }
        }

    });

    // rest of the math
    if (count) {
        m = m / count;
        return m.toFixed(2);
    } else {
        return 'N/A';
    }
});

更新

@Major Byte指出，在将任何东西推到lowest之前计算mean（），因此我得到了undefined 。 如果这是真的，那么确保mean（）将根据lowest变化更新的最佳方法是什么？

Answer 1

你真的可以使用一个计算的mean

this.mean = ko.computed(
    function() {
      var sum  = 0;
      var count = 0;
      var n = 0;
      for(n;n < _this.scores().length;n++)
      {
        var score = _this.scores()[n];
          if (_this.lowest.indexOf(score)<0) {
            sum += parseFloat(score());
            count++;
          }
      }

      if (count > 0) {
        sum = sum / count;
        return sum.toFixed(2);
      } else {
        return 'N/A';
      }
});

当你添加到lower（），score（）和更改分数（）时会触发这个。

强制性的jsfiddle 。

更新：
忘记提到我也改变了一些关键的东西。 从你原始代码：

this.dropLowestScores = function() {
    ko.utils.arrayForEach(_this.students(), function(student){
        var comparator = function(a,b){
            if(a()<b()){
                return 1;
            } else if(a() > b()){
                return -1;
            } else {
                return 0;
            }
        };
        var tmp = student.scores().sort(comparator).slice(0);
        student.lowest = ko.observableArray(tmp.splice((tmp.length-2),tmp.length-1));
    });
 };

除了在dropLowestScores函数之外移动comparator ，我改变了这一行：

student.lowest = ko.observableArray(tmp.splice((tmp.length-2),tmp.length-1));

至

student.lowest(tmp.splice((tmp.length-2),tmp.length-1));

student.lowest是一个可观察的数组，不需要再将它定义为observableArray，事实上它实际上打破了计算的mean 。 （根据我之前的评论，删除最低分数的修正在这里省略）。