每个函数和Includes函数都是't使用Javascript

Each Function and Includes Function isn't working in Javascript

本文关键字：函数 使用 Javascript Includes      更新时间：2024-02-18

我正试图使用each函数在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));

由于您根本没有使用call(set[i])的返回值，因此在includes中的lambda函数中包含return true将不会产生任何影响。

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

只需听取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));
}

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

这应该是这样的：

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

为什么不使用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));

原因布尔值返回给更接近的调用方（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
相关文章：