如何在JavaScript中检查一个数组是否为另一个数组的子集？

Question

假设我有两个数组，

var PlayerOne = ['B', 'C', 'A', 'D'];
var PlayerTwo = ['D', 'C'];

如何使用JavaScript检查arrayTwo是否是arrayOne的子集？

原因：我正在试图整理游戏"井字棋"的基本逻辑，但卡在了中间。无论如何，这是我的代码... 非常感谢！

var TicTacToe = {


  PlayerOne: ['D','A', 'B', 'C'],
  PlayerTwo: [],

  WinOptions: {
      WinOne: ['A', 'B', 'C'],
      WinTwo: ['A', 'D', 'G'],
      WinThree: ['G', 'H', 'I'],
      WinFour: ['C', 'F', 'I'],
      WinFive: ['B', 'E', 'H'],
      WinSix: ['D', 'E', 'F'],
      WinSeven: ['A', 'E', 'I'],
      WinEight: ['C', 'E', 'G']
  },

  WinTicTacToe: function(){

    var WinOptions = this.WinOptions;
    var PlayerOne = this.PlayerOne;
    var PlayerTwo = this.PlayerTwo;
    var Win = [];

    for (var key in WinOptions) {
      var EachWinOptions = WinOptions[key];

        for (var i = 0; i < EachWinOptions.length; i++) {
          if (PlayerOne.includes(EachWinOptions[i])) {
            (got stuck here...)
          }

        }
        // if (PlayerOne.length < WinOptions[key]) {
        //   return false;
        // }
        // if (PlayerTwo.length < WinOptions[key]) {
        //   return false;
        // }
        // 
        // if (PlayerOne === WinOptions[key].sort().join()) {
        //   console.log("PlayerOne has Won!");
        // }
        // if (PlayerTwo === WinOptions[key].sort().join()) {
        //   console.log("PlayerTwo has Won!");
        // } (tried this method but it turned out to be the wrong logic.)
    }
  },


};
TicTacToe.WinTicTacToe();

- yangmei

Answer 1

这是解决方案：

使用ES7（ECMAScript 2016）:

const result = PlayerTwo.every(val => PlayerOne.includes(val));

代码片段:

const PlayerOne = ['B', 'C', 'A', 'D'];
const PlayerTwo = ['D', 'C'];

const result = PlayerTwo.every(val => PlayerOne.includes(val));

console.log(result);

使用ES5（ECMAScript 2009）：

var result = PlayerTwo.every(function(val) {

  return PlayerOne.indexOf(val) >= 0;

});

代码片段:

var PlayerOne = ['B', 'C', 'A', 'D'];
var PlayerTwo = ['D', 'C'];

var result = PlayerTwo.every(function(val) {

  return PlayerOne.indexOf(val) >= 0;

});

console.log(result);

---

以下是对下方评论中提出的问题的答复：

我们如何处理重复项？

解决方案：只需在上述解决方案中添加准确的条件来检查数组中足够元素的数量即可：

const result = PlayerTwo.every(val => PlayerOne.includes(val) 
    && PlayerTwo.filter(el => el === val).length
       <=
       PlayerOne.filter(el => el === val).length
);

第一种情况的代码片段：:

const PlayerOne = ['B', 'C', 'A', 'D'];
const PlayerTwo = ['D', 'C'];

const result = PlayerTwo.every(val => PlayerOne.includes(val) 
    && PlayerTwo.filter(el => el === val).length
       <=
       PlayerOne.filter(el => el === val).length
);

console.log(result);

第二种情况的代码片段:

const PlayerOne = ['B', 'C', 'A', 'D'];
const PlayerTwo = ['D', 'C', 'C'];

const result = PlayerTwo.every(val => PlayerOne.includes(val) 
    && PlayerTwo.filter(el => el === val).length
       <=
       PlayerOne.filter(el => el === val).length
);

console.log(result);

- simhumileco

---

我们如何处理重复项？例如：var PlayerOne = ['B', 'C', 'A', 'D']; var PlayerTwo = ['D', 'C']; 上述比较应该返回truevar PlayerOne = ['B', 'C', 'A', 'D']; var PlayerTwo = ['D', 'C', 'C']; 上述比较应该返回false - Nrupesh

我刚刚扩展了答案，包括对你的好问题@Nrupesh的回答。享受吧！ :) - simhumileco

Answer 2

如果你正在使用ES6：

!PlayerTwo.some(val => PlayerOne.indexOf(val) === -1);

如果必须使用ES5，请使用some函数的兼容性脚本，然后使用常规函数语法：

!PlayerTwo.some(function(val) { return PlayerOne.indexOf(val) === -1 });

- tothemario

---

更好的写法是：!PlayerTwo.some(val => !PlayerOne.includes(val)); - Terry

使用 every 比反转 some 更好，如果元素为 false，则 every 会短路，因此需要相同的时间，而且更易读。 - Amr Saber

Answer 3

function isSubsetOf(set, subset) {
    return Array.from(new Set([...set, ...subset])).length === set.length;
}

- Armen Zakaryan

---

不需要使用 Array.from(...)，可以直接使用新集合的 .size 属性：new Set([...set, ...subset]).size。 - Fabian

Answer 4

您可以使用这个简单的代码片段。

PlayerOne.every(function(val) { return PlayerTwo.indexOf(val) >= 0; })

- SuperNova

Answer 5

如果PlayerTwo是PlayerOne的子集，那么set(PlayerOne + PlayerTwo)的长度必须等于set(PlayerOne)的长度。

var PlayerOne = ['B', 'C', 'A', 'D'];
var PlayerTwo = ['D', 'C'];

// Length of set(PlayerOne + PlayerTwo) == Length of set(PlayerTwo)

Array.from(new Set(PlayerOne) ).length == Array.from(new Set(PlayerOne.concat(PlayerTwo)) ).length

- SuperNova

---

重复的情况怎么办？['B', 'B'] 是 ['B', 'C', 'A', 'D'] 的子集吗？还是只针对 ['B', 'B', 'C', 'A', 'D']？上述逻辑没有处理这些情况。 - gazdagergo

Answer 6

如果您想比较两个数组并考虑顺序，这里有一个解决方案：

  let arr1 = [ 'A', 'B', 'C', 'D' ];
  let arr2 = [ 'B', 'C' ];
  arr1.join().includes(arr2.join()); //true

  arr2 = [ 'C', 'B' ];
  arr1.join().includes(arr2.join()); //false

- Piotr Gajek

Answer 7

这里有一个利用集合数据类型及其has函数的解决方案。

let PlayerOne = ['B', 'C', 'A', 'D', ],
    PlayerTwo = ['D', 'C', ],
    [one, two] = [PlayerOne, PlayerTwo, ]
        .map( e => new Set(e) ),
    matches = Array.from(two)
        .filter( e => one.has(e) ),
    isOrisNot = matches.length ? '' : ' not',
    message = `${PlayerTwo} is${isOrisNot} a subset of ${PlayerOne}`;
console.log(message)

Out: D,C is a subset of B,C,A,D

- dmmfll

Answer 8

这里有一个更好的例子，涵盖了子集数组中包含重复元素的情况：

function isArraySubset(source, subset) {
  if (subset.length > source.length) return false;

  const src = [...source]; // copy to omit changing an input source
  for (let i = 0; i < subset.length; i++) {
    const index = src.indexOf(subset[i]);
    if (index !== -1) {
      src.splice(index, 1);
    } else {
      return false;
    }
  }
  return true;
}

console.log(isArraySubset(['b', 'c', 'a', 'd'], ['d', 'c'])); // true
console.log(isArraySubset(['b', 'c', 'a', 'd'], ['d', 'c', 'c'])); // false

- Den Skulimovskiy

---

根据定义，集合不包含重复项。因此，如果它包含 - 如您在答案中所述，那么项目将按其索引排序，您的答案是错误的。如果它不包含重复项，那么您已经命名了它。 - hakre

这并没有回答问题。一旦您拥有足够的声望，您将能够评论任何帖子；相反，提供不需要询问者澄清的答案。- 来自审核 - hakre

Answer 9

对我来说，这似乎是最清晰的：

function isSubsetOf(set, subset) {
    for (let i = 0; i < set.length; i++) {
        if (subset.indexOf(set[i]) == -1) {
            return false;
        }
    }
    return true;
}

它还具有一旦发现非成员就立即退出的优点。

- Sanford Staab

---

.every和.some都会在最终结果确定后立即退出。 - Shenme