Javascript：确定数组中的所有元素是否都是对象中的键

我试图弄清楚数组中的所有元素是否都是对象中的键

var obj = { name: 'Computer', cost: '$1,000' };
var myArray = [ 'name', 'cost', 'bio' ]; //another example would be var myArray = [];
for(var x = 0; x < myArray.length; x++){
if (myArray[x] in obj)
  {
     return true;
  }
}

var obj={name:'Computer'，成本：'$1000'}；
var myArray=['name'，'cost'，'bio']//另一个例子是var myArray=[]；
对于（var x=0；x

---

如何检查数组中的所有元素是否都是对象中的键？

用另一种方法检查。如果在数组中发现某个人不在对象中，则返回false。如果到达循环的末尾，则返回true，因为所有键都在对象中。

以相反的方式执行。如果在数组中发现某个人不在对象中，则返回false。如果到达循环的末尾，则返回true，因为所有关键点都在对象中。

根据需要，这可能会实现以下功能：

function hasKeys(obj, keys) {
    for (var i=0; i != keys.length; ++i) {
        if (!(keys[i] in obj))
            return false;
    }
    return true;
};

---

您需要问自己一个微妙的问题：您是否想知道对象是否直接拥有键（即不在其原型堆栈中的某个位置？），如果是这样，那么将obj中的

键[i]替换为
obj.hasOwnProperty（键[i]）
，这可能会实现以下目的：

function hasKeys(obj, keys) {
    for (var i=0; i != keys.length; ++i) {
        if (!(keys[i] in obj))
            return false;
    }
    return true;
};

您需要问自己一个微妙的问题：您是否想知道对象是否直接拥有键（即不在其原型堆栈中的某个位置？），如果是这样，则将obj

中的

keys[i]替换为
obj.hasOwnProperty（keys[i]）
可以提供一个干净的解决方案

// object in question
var obj = { ... };

// keys that need to be present in the object
var keys = [ ... ];

// iterate through the whitelist until we find a key that doesn't exist in the object. If all exist, that means Array.some() is false.
var valid = !keys.some(function(key) {
    return !obj.hasOwnProperty(key);
});

另一种解决方案是使用类似的概念，但要考虑到。需要注意的是，这通常会比较慢，因为它必须始终接触白名单中的每个元素

// iterate through the whitelist, making sure the object has each key.
var valid = keys.every(obj.hasOwnProperty);

这是一个干净的解决方案

// object in question
var obj = { ... };

// keys that need to be present in the object
var keys = [ ... ];

// iterate through the whitelist until we find a key that doesn't exist in the object. If all exist, that means Array.some() is false.
var valid = !keys.some(function(key) {
    return !obj.hasOwnProperty(key);
});

另一种解决方案是使用类似的概念，但要考虑到。需要注意的是，这通常会比较慢，因为它必须始终接触白名单中的每个元素

// iterate through the whitelist, making sure the object has each key.
var valid = keys.every(obj.hasOwnProperty);

声明，“every方法对数组中的每个元素执行一次提供的回调函数，直到找到一个回调函数，其中回调函数返回falsy值（转换为布尔值时变为false）.如果找到这样的元素，则every方法立即返回false。否则，如果回调为所有元素返回true值，则every将返回true。回调仅对数组中已赋值的索引调用；对已删除或从未赋值的索引不调用（强调我的）

声明，“every方法对数组中的每个元素执行一次提供的回调函数，直到找到一个回调函数，其中回调函数返回falsy值（转换为布尔值时变为false）.如果找到这样的元素，则every方法立即返回false。否则，如果回调为所有元素返回true值，则every将返回true。回调仅对数组中已赋值的索引调用；对已删除或从未赋值的索引不调用es”（emphasis mine）。
这个问题可以用集合包含来表示：属性键集合是否完全包含所需键的数组？所以我们可以把它写成

includes(Object.keys(obj), arr)

现在我们只需要编写
包含

function includes(arr1, arr2) {
    return arr2.every(function(key) {
        return contains(arr1, key);
    }
}

对于
contains
，我们可以使用下划线的
\uu.contains
，或者自己编写：

function contains(arr, val) {
    return arr.indexOf(val) !== -1;
}

如果我们对简洁感兴趣，而可能以可读性为代价，我们可以缩短
includes
的定义，使用
函数#bind
而不是匿名函数：

function includes(arr1, arr2) {
    return arr2.every(contains.bind(0, arr1));
}

现在我们有了可以用于其他事情的函数，而不是将问题的两个不同方面——对象的键和集合包含混为一谈。如果我们真的想编写一个一体式函数，它会变得更具可读性：

function hasMany(obj, arr) {
    return arr.every(_.contains.bind(0, Object.keys(obj));
}

如果我们想要更具可读性，就像我们在写小说一样：

function object_has_required_keys(object, required_keys) {

    var object_keys = Object.keys(object);

    function key_is_present(key) {
        return object_keys.indexOf(key) !== -1;
    }

    return required_keys.every(key_is_present);
}

下划线的
\交叉点
如果我们懒惰（或聪明），我们可以使用下划线来实现
包含
：

function includes(arr1, arr2) {
    return _.intersection(arr1, arr2).length === arr2.length;
}

我们的想法是取交集，如果第一个数组完全包含第二个数组，那么交集将包含第二个数组的所有元素，我们可以通过比较它们的长度来检查这些元素

使用ES6集
考虑到ES6，我们可以使用its实现
include
，这应该更快：

function includes(arr1, arr2) {
    var set = new Set(arr1);
    return arr2.every(Set.prototype.has.bind(set));
}

这个问题可以用集合包含来表示：属性键集合是否完全包含所需键的数组？所以我们可以把它写成

includes(Object.keys(obj), arr)

现在我们只需要编写
包含

function includes(arr1, arr2) {
    return arr2.every(function(key) {
        return contains(arr1, key);
    }
}

对于
contains
，我们可以使用下划线的
\uu.contains
，或者自己编写：

function contains(arr, val) {
    return arr.indexOf(val) !== -1;
}

如果我们对简洁感兴趣，而可能以可读性为代价，我们可以缩短
includes
的定义，使用
函数#bind
而不是匿名函数：

function includes(arr1, arr2) {
    return arr2.every(contains.bind(0, arr1));
}

现在我们有了可以用于其他事情的函数，而不是将问题的两个不同方面——对象的键和集合包含混为一谈。如果我们真的想编写一个一体式函数，它会变得更具可读性：

function hasMany(obj, arr) {
    return arr.every(_.contains.bind(0, Object.keys(obj));
}

如果我们想要更具可读性，就像我们在写小说一样：

function object_has_required_keys(object, required_keys) {

    var object_keys = Object.keys(object);

    function key_is_present(key) {
        return object_keys.indexOf(key) !== -1;
    }

    return required_keys.every(key_is_present);
}

下划线的
\交叉点
如果我们懒惰（或聪明），我们可以使用下划线来实现
包含
：

function includes(arr1, arr2) {
    return _.intersection(arr1, arr2).length === arr2.length;
}

我们的想法是取交集，如果第一个数组完全包含第二个数组，那么交集将包含第二个数组的所有元素，我们可以通过比较它们的长度来检查这些元素

使用ES6集
考虑到ES6，我们可以使用its实现
include
，这应该更快：

function includes(arr1, arr2) {
    var set = new Set(arr1);
    return arr2.every(Set.prototype.has.bind(set));
}

顺便说一句，它不会影响最终结果，但人们更常用
i
作为索引变量，而不是
x
@hugomg它是一个ha