Question

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

http://localhost:8080/spring4_rest_angular_demo/static/css/app.css

所以我想知道var master = [12, 44, 22, 66, 222, 777, 22, 22, 22, 6, 77, 3]; var sub = [777, 22, 22];是否包含master类似的内容：

sub

那怎样才能以优雅/有效的方式完成呢？

Answer 1

在fromIndex参数

的帮助下

这个解决方案在索引上有一个闭包，用于启动搜索元素的位置（如果是数组）。如果找到子数组的元素，则搜索下一个元素将以递增的索引开始。

＆＃13;

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]));

＆＃13;

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

修改

最初误解了问题。

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

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

旧答案保留对搜索人员有用的情况。

master

重要的是要记住，这只会匹配sub字面上引用<%= link_to 'New Product', new_product_path, {style: 'font-size: 2em; color: black' } %>。如果它只包含一个具有相同内容但引用不同特定对象的数组，则它将不匹配。

Answer 4

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

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

仅检查值检查此fiddle（不使用第三方库）

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 ) );

还有更快的选项解释here。

Answer 5

您可以尝试过滤器和 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;
}

示例here。

更新：返回主数据库中子数组的索引（子数组中的封面顺序）

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;
}

演示：here

Answer 6

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

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

Answer 7

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

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 8

对于这个答案，我保留了子数组的顺序。意思是，子数组的元素应该是连续的。与母版进行比较时，如果有任何多余的元素，则为假。

我分3个步骤进行操作：

在sub中找到master的第一个元素的索引，并将其存储在数组matched_index[]中。
对于matched_index[]中的每个条目，检查sub的每个元素是否与master开始的s_index相同。如果不匹配，则返回false并中断sub的for循环，并为matched_index[]中的下一个元素启动下一个for循环
任何时候，如果在sub中找到相同的master数组，则循环将中断并返回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

尝试使用每个和 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);

Answer 10

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(',')))这行代码来完成此操作

Javascript数组包含/包含子数组

10 个答案: