Javascript数组包含/包含子数组

Question

我需要检查一个数组是否包含另一个数组。 子数组的顺序很重要，但实际偏移量并不重要。 它看起来像这样：

var master = [12, 44, 22, 66, 222, 777, 22, 22, 22, 6, 77, 3]; 

var sub = [777, 22, 22]; 

所以我想知道master包含sub类似的东西：

if(master.arrayContains(sub) > -1){
    //Do awesome stuff
}

那么如何以一种优雅/高效的方式做到这一点呢？

Answer 1

在fromIndex参数的帮助下

该解决方案的特点是在索引上有一个闭包，用于开始搜索元素的位置，如果是数组。 如果找到子数组的元素，则从递增索引开始搜索下一个元素。

 function hasSubArray(master, sub) { return sub.every((i => v => i = master.indexOf(v, i) + 1)(0)); } var array = [12, 44, 22, 66, 222, 777, 22, 22, 22, 6, 77, 3]; console.log(hasSubArray(array, [777, 22, 22])); console.log(hasSubArray(array, [777, 22, 3])); console.log(hasSubArray(array, [777, 777, 777])); console.log(hasSubArray(array, [42]));

Answer 2

只是想出了一个快速的想法，但效率取决于数组的大小

var master = [12, 44, 22, 66, 222, 777, 22, 22, 22, 6, 77, 3];
var sub = [777, 22, 22];

if ((master.toString()).indexOf(sub.toString()) > -1 ){
    //body here
}

Answer 3

var master = [12, 44, 22, 66, 222, 777, 22, 22, 22, 6, 77, 3]; 

var sub = [777, 22, 22]; 

console.log(master.join(',').includes(sub.join(',')))

//true

你可以通过简单的console.log(master.join(',').includes(sub.join(',')))这行代码使用 include 方法来做到这一点

Answer 4

编辑

最初误解了问题。

function arrayContainsSub(arr, sub) {
        var first = sub[0],
            i = 0,
            starts = [];

        while (arr.indexOf(first, i) >= 0) {
            starts.push(arr.indexOf(first, i));
            i = arr.indexOf(first, i) + 1;
        }

        return !!starts
                    .map(function(start) {
                        for (var i = start, j = 0; j < sub.length; i++, j++) {
                            if (arr[i] !== sub[j]) {
                                return false;
                            }
                            if (j === sub.length - 1 && arr[i] === sub[j]) {
                                return true;
                            }
                        };

                    }).filter(function(res) {
                        return res;
                    }).length;
    }

此解决方案将递归检查所有可用的起始点，因此指向 sub 的第一个索引在数组中匹配的点

---

旧答案保留以防对某人搜索有用。

if(master.indexOf(sub) > -1){ //Do awesome stuff }

重要的是要记住，这只会匹配master字面上的引用sub 。 如果它只包含一个内容相同的数组，但引用了不同的特定对象，则它不会匹配。

Answer 5

如果顺序很重要，它必须是一个实际的子数组（而不是数组的子集），如果值是严格的整数，那么试试这个

console.log ( master.join(",").indexOf( subarray.join( "," ) ) == -1 )

只检查值检查这个小提琴（不使用第三方库）

var master = [12, 44, 22, 66, 222, 777, 22, 22, 22, 6, 77, 3]; 

var sub = [777, 22, 22]; 

function isSubset( arr1, arr2 )
{
    for (var i=0; i<arr2.length; i++)
    {
        if ( arr1.indexOf( arr2[i] ) == -1 )
        {
          return false;
        }
    }
    return true;
}
console.log( isSubset( master, sub ) );

这里也解释了更快的选项。

Answer 6

您可以尝试使用filter和indexOf ，如下所示：

注意：此代码适用于我们不涵盖子数组中的顺序的情况。

Array.prototype.arrayContains = function (sub) {
  var self = this;
  var result = sub.filter(function(item) {
    return self.indexOf(item) > -1;
  });
  return sub.length === result.length;
}

示例在这里。

更新：返回主内子数组的索引（子数组中的覆盖顺序）

Array.prototype.arrayContains = function(sub) {
  var first;
  var prev;
  for (var i = 0; i < sub.length; i++) {
    var current = this.indexOf(sub[i]);
    if (current > -1) {
      if (i === 0) {
        first = prev = current;
        continue;
      } else {
        if (++prev === current) {
          continue;
        } else {
          return -1;
        }
      }
    } else {
      return -1;
    }
  }
  return first;
}

演示：这里

Answer 7

如果在下面运行此代码段，它应该可以工作

x = [34, 2, 4];
y = [2, 4];
y.reduce((included, num) => included && x.includes(num), true);

编辑：@AlexanderGromnitsky 你说得对，这段代码不正确，谢谢你的捕捉！ 上面的代码实际上并没有按照操作要求执行。 我没有足够仔细地阅读问题，这段代码忽略了顺序。 一年后，这是我想出的，希望这可以帮助某人。

var master = [12, 44, 22, 66, 222, 777, 22, 22, 22, 6, 77, 3]; 
var sub = [777, 22, 22]; 
var is_ordered_subset = master.join('|').includes(sub.join('|'))

这段代码有点优雅，可以满足 op 的要求。 分隔符无关紧要，只要它不是 int 即可。

Answer 8

对于这个答案，我保留子数组的顺序。 意味着，子数组的元素应该是连续的。 如果与master比较时有多余的元素，则为false。

我分三步做：

1. 在master中找到sub的第一个元素的索引，并将其存储在一个数组matched_index[] 。
2. 在每个条目matched_index[]检查的每个元素sub是相同master从开始s_index 。 如果它不匹配，则返回false并中断 sub 的 for 循环并开始下一个 for-loop 用于matched_index[]下一个元素
3. 在任何时候，如果在master找到相同的sub数组，循环将中断并返回 true。

 function hasSubArray(master,sub){ //collect all master indexes matching first element of sub-array let matched_index = [] let start_index = master.indexOf(master.find(e=>e==sub[0])) while(master.indexOf(sub[0], start_index)>0){ matched_index.push(start_index) let index = master.indexOf(sub[0], start_index) start_index = index+1 } let has_array //flag for(let [i,s_index] of matched_index.entries()){ for(let [j,element] of sub.entries()){ if(element != master[j+s_index]) { has_array = false break }else has_array = true } if (has_array) break } return has_array } var master = [12, 44, 22, 66, 222, 777, 22, 22, 22, 6, 77, 3]; console.log(hasSubArray(master, [777, 22, 22])); console.log(hasSubArray(master, [777, 22, 3])); console.log(hasSubArray(master, [777, 777, 777])); console.log(hasSubArray(master, [44])); console.log(hasSubArray(master, [22, 66]));

Answer 9

我遇到了类似的问题并使用集合解决了它。

function _hasSubArray( mainArray, subArray )
{
    mainArray = new Set( mainArray );
    subArray = new Set( subArray );

    for ( var element of subArray )
    {
        if ( !mainArray.has( element ) )
        {
            return false;
        }
    }
    return true;
}

Answer 10

尝试使用every和indexOf

var mainArr = [1, 2, 3, 4, 5]
var subArr = [1, 2, 3]

function isSubArray(main, sub) {
    return sub.every((eachEle) => {
        return (main.indexOf(eachEle) + 1);
    });
}
isSubArray(mainArr, subArr);