Javascript 如何检查一个数组是否包含另一个数组？

我需要2d数组，所以我制作了嵌套数组，因为JavaScript不允许它们

它们看起来是这样的：

var myArray = [
      [1, 0],
      [1, 1],
      [1, 3],
      [2, 4]
    ]

如何检查此数组是否包含vanilla JS中的特定元素（即其中一个

[0,1]

数组）

以下是我尝试过的，但没有成功（所有内容都返回

false

）（编辑：我在代码片段中包含了答案）：

var myArray=[
[1, 0],
[1, 1],
[1, 3],
[2, 4]
]
var itemTrue=[2,4]；
var itemFalse=[4,4]；
函数包含（a，obj）{
var i=a.长度；
而(我--){
如果（a[i]==obj）{
返回true；
}
}
返回false；
}
//编辑：第一个答案的解决方案
函数isArrayInArray（x，检查）{
对于（变量i=0，len=x.length；ilog（“false:+isArrayInArray2（myArray，itemflse））

嵌套数组本质上是一个二维数组，

var x=[[1,2]，[3,4]

将是一个二维数组，因为我用两个索引引用它，例如

x[0][1]

将是

2

对于您的问题，您可以使用一个简单的循环来判断它们是否包含在内，因为复杂阵列不支持此操作：

var x = [[1,2],[3,4]];
var check = [1,2];
function isArrayInArray(source, search) {
    for (var i = 0, len = source.length; i < len; i++) {
        if (source[i][0] === search[0] && source[i][1] === search[1]) {
            return true;
        }
    }
    return false;
}
console.log(isArrayInArray(x, check)); // prints true

var x=[[1,2]，[3,4]；
var检查=[1,2]；
函数isArrayInArray（源，搜索）{
对于（变量i=0，len=source.length；i

更新任何长度数组的帐户

函数isArrayInArray（源代码，搜索）{
var searchLen=search.length；
对于（变量i=0，len=source.length；i

简单明了，将数组字符串化并作为字符串进行比较

function isArrayInArray(arr, item){
  var item_as_string = JSON.stringify(item);

  var contains = arr.some(function(ele){
    return JSON.stringify(ele) === item_as_string;
  });
  return contains;
}

var myArray = [
  [1, 0],
  [1, 1],
  [1, 3],
  [2, 4]
]
var item = [1, 0]

console.log(isArrayInArray(myArray, item));  // Print true if found

---

查看一些文档，你不能这样做。例如，你必须自己做一些事情。。 首先，您必须从数组中执行foreach，以便为数组中的每个项搜索并运行“compareArray”函数

function compareArray( arrA, arrB ){

    //check if lengths are different
    if(arrA.length !== arrB.length) return false;


    for(var i=0;i<arrA.length;i++){
         if(arrA[i]!==arrB[i]) return false;
    }

    return true;

}

功能比较阵列（arrA、arrB）{
//检查长度是否不同
如果（arrA.length！==arrB.length）返回false；
对于（var i=0；iD.Young注释提供的检查任何长度数组的代码是错误的。它只检查第一个元素是否相同

D.Young评论的更正版本：

function isArrayInArray(source, search) {
    var searchLen = search.length;
    for (var i = 0, len = source.length; i < len; i++) {
        // skip not same length
        if (source[i].length != searchLen) continue;
        // compare each element
        for (var j = 0; j < searchLen; j++) {
            // if a pair doesn't match skip forwards
            if (source[i][j] !== search[j]) {
                break;
            } else if (j == searchLen - 1) {return true}
        }
    }
    return false; 
}

函数isArrayInArray（源代码，搜索）{
var searchLen=search.length；
对于（变量i=0，len=source.length；i
这里有一个解决方案：

myArray.some(
    r => r.length == itemTrue.length &&
         r.every((value, index) => itemTrue[index] == value)
);

检查一下

查看对象的方法和。
对于那些有兴趣在另一个数组中查找数组并获取索引号的人，以下是一个修改版本：

函数findArrayInArray（内部数组，外部数组）{
const innerArrayString=JSON.stringify（innerArray）；
设指数=0；
const inArray=outerArray.some（函数（元素）{
索引++；
返回JSON.stringify（element）==innerArrayString；
});
如果（inArray）{
回报指数-1；
}否则{
返回-1；
}
}
findArrayInArray（[1,2,3]，[3,3]，[1,2,3]，[2]]）；//1
findArrayInArray（[1,2,3]，[1,2,3]，[2]]）/-1

此函数返回在外部数组中搜索的数组的索引，如果未找到，则返回-1

签出此项。
可能重复我读到的问题，但它没有解决我的问题。请参阅添加了该问题答案2解决方案的更新片段。在内部，函数将检查
if（paramArray[I]==searchElement）
，失败，因为您无法使用
==
比较两个数组，因此无法使用
包含
来执行此操作。再次复制，考虑到这是一种特定情况（伪2d数组），这不是一个副本，它没有直接解决我的问题。请删除标记谢谢。我用你的代码以函数的形式更新了我的代码片段。虽然这很简单，但我觉得在数组中循环并比较每个元素更正确。它也更快：我在开始时只更新了一次字符串化检查项，并且这里所有的项都是嵌套数组，它将对每个项进行递归，所有这些都应该考虑到只要所有的i
myArray.some(
    r => r.length == itemTrue.length &&
         r.every((value, index) => itemTrue[index] == value)
);