Question

我正在尝试使用每个函数在lodash上重新创建“includes”方法，但似乎我的代码没有按预期工作。我不确定为什么当我搜索数组中的目标时，返回的是false而不是true。这是我的代码：

var array = [1.1,1.3,2.3,2.5,3.1,3.5];

function each(set, call) {
    for (var i =0; i<set.length; i++) {
        call(set[i]);
    };
};

function includes(collection, target) {
    each(collection, function(element) {
        if (element === target) {
            return true;
        }
    });
    return false;
}

console.log(includes(array, 1.1));

Answer 1

由于您根本没有使用call(set[i])的返回值，因此在return true的lambda函数中使用includes将无效。

用includes来定义each是没有意义的，因为当找到匹配的值时，你将无法使逻辑短路。

只需接受MDN的建议，并将includes作为for循环实施：

function includes(collection, target) {
    for(var i = 0; i < collection.length; i += 1) {
        if (collection[i] === target) {
            return true;
        }
    }
    return false;
}

或者更好，使用indexOf：

function includes(collection, target) {
    return Array.prototype.indexOf.call(collection, target) !== -1;
}

如果您想根据HOF定义includes，那么有必要根据some或every来定义它。

使用some：

function includes(collection, target) {
    return some(collection, function (item) {
        return item === target;
    });
}

使用every：

function includes(collection, target) {
    return !every(collection, function (item) {
        return item !== target;
    });
}

此处some和every的简单实现是：

function some(collection, predicate) {
    for (var i = 0; i < collection.length; i += 1) {
        if(predicate(collection[i], i, collection)) {
            return true;
        }
    }
    return false;
}

function every(collection, predicate) {
    for (var i = 0; i < collection.lenght; i += 1) {
         if(!predicate(collection[i], i, collection)) {
             return false;
         }
    }
    return true;
}

它们也可以相互定义（当然不是同时）：

// Creates the inverse of a function with the same parameters
function negate(func) {
    return function () {
        return !func.apply(this, arguments);
    }
}

function some(collection, predicate) {
    return !every(collection, negate(predicate));
}

function every(collection, predicate) {
    return !some(collection, negate(predicate));
}

Answer 2

return true;返回作为each参数传递的函数值，而不是includes函数的值。

这应该是这样的：

function includes(set, target) {
    for (var i = 0; i<set.length; i++) {
        if (set[i] === target) return true;
    };
    return false;
}

Answer 3

为什么不使用indexOf。

var array = [1.1,1.3,2.3,2.5,3.1,3.5];
function include(arr, i){
    if(arr.indexOf(i)==-1) return false;
    return true;
}    
console.log(include(array,1.1));

Answer 4

原因布尔值返回给更近的调用者（each（））而不是父调用者（includes（））。它有效：

function includes(collection, target) {
    var retval = false;
    each(collection, function(element) {
        if (element === target) {
            retval = true;
        }
    });
    return retval;
}

然而，更好地避免计算机整个序列：

//it works with String and Array objects
function inSequence(searchValue, target){
    if (-1 != target.indexOf(searchValue)) {
        return true;
    }
    return false;
}

所以请调用includes（）让我们调用inSequence（）：

inSequence(1.1, array); //returns true

每个函数和包含函数都不能在Javascript中工作

4 个答案: