javascript-检查数组是否包含任何其他字符串数组

检查

test\u数组

中的每个数组是否包含

strings\u to\u check

数组中的任何字符串的正确方法是什么？即

a、b或c

我可以执行以下操作，但它有一个缺点，即即使其中一个字符串存在，它仍然会检查其余的字符串

strings_to_check = ["a", "b", "c"]

test_arrrays = [ [ "a", "c", "e", "g"], [ "v", "x", "y", "z"] ]

for（设i=0；i-1）{
控制台日志（“匹配”）；
}
}
}

如果只需要匹配一个字符串，只需添加

break

，如下所示：

for(let i = 0; i < test_arrrays.length; i++){
  for(let j = 0; j < strings_to_check.length; j++){
      if(test_arrrays[i].indexOf(strings_to_check[j]) > -1) {
          console.log("matched");
      }
  }
}

---

如果只需要匹配一个字符串，只需添加

break

，如下所示：

for(let i = 0; i < test_arrrays.length; i++){
  for(let j = 0; j < strings_to_check.length; j++){
      if(test_arrrays[i].indexOf(strings_to_check[j]) > -1) {
          console.log("matched");
      }
  }
}

---

假设要检查

测试数组中的每个数组是否包含
字符串到
数组中的至少一个元素，可以混合使用
数组#每个
和
数组#一些
函数


var strings\u to\u check=[“a”、“b”、“c”]，
测试射线=[“a”、“c”、“e”、“g”]、[“v”、“x”、“y”、“z”]，
res=test\u arrrays.every（v=>v.some（c=>strings\u to\u check.indexOf（c）>-1））；
控制台日志（res）
假设要检查
test\u array
中的每个数组是否包含
strings\u-check
数组中的至少一个元素，可以混合使用
array#every
和
array#一些
函数


var strings\u to\u check=[“a”、“b”、“c”]，
测试射线=[“a”、“c”、“e”、“g”]、[“v”、“x”、“y”、“z”]，
res=test\u arrrays.every（v=>v.some（c=>strings\u to\u check.indexOf（c）>-1））；
控制台日志（res）这可以更简单地用高阶函数完成，而不是使用for循环和大量索引

我们想看看是否所有的
test\u arrays
元素都符合某些标准，因此我们知道应该使用
每个
：

for(/*loop settings*/){
  /*some code*/
  for(/*loop settings*/){
    /*some code*/
    if(/*some conditionnal statement*/){
      /*handling stuff*/
      break;
    }
  }
}


现在我们只需要找出标准是什么。“包含strings\u to\u check中的任何字符串”听起来像是我们需要在
test\u array
上使用
some
，以确定它的任何字符串是否包含在
strings\u to\u check
中。因此，我们的“标准”将是：

综合起来，我们得到：

test_arrray => test_arrray.some(s => strings_to_check_set.includes(s))


includes
具有线性时间复杂度，因此我们可以通过使用
Set
来改进此算法，并将
includes
替换为具有恒定时间复杂度的
has
，以获得此最终结果：

test_arrrays.every( test_arrray => 
    test_arrray.some(s => strings_to_check_set.includes(s))
  )


这可以更简单地用高阶函数来完成，而不是使用for循环和大量索引

我们想看看是否所有的
test\u arrays
元素都符合某些标准，因此我们知道应该使用
每个
：

for(/*loop settings*/){
  /*some code*/
  for(/*loop settings*/){
    /*some code*/
    if(/*some conditionnal statement*/){
      /*handling stuff*/
      break;
    }
  }
}


现在我们只需要找出标准是什么。“包含strings\u to\u check中的任何字符串”听起来像是我们需要在
test\u array
上使用
some
，以确定它的任何字符串是否包含在
strings\u to\u check
中。因此，我们的“标准”将是：

综合起来，我们得到：

test_arrray => test_arrray.some(s => strings_to_check_set.includes(s))


includes
具有线性时间复杂度，因此我们可以通过使用
Set
来改进此算法，并将
includes
替换为具有恒定时间复杂度的
has
，以获得此最终结果：

test_arrrays.every( test_arrray => 
    test_arrray.some(s => strings_to_check_set.includes(s))
  )


正如Vivick所说，您必须通过添加
break


break
始终停止最里面的循环

这就是你必须要做的：

strings_to_check = ["a", "b", "c"]

test_arrrays = [ [ "a", "c", "e", "g"], [ "v", "x", "y", "z"] ]

strings_to_check_set = new Set(strings_to_check)

test_arrrays.every(test_arrray =>
    test_arrray.some(s => strings_to_check_set.has(s))
)

for（设i=0；i-1）{
控制台日志（“匹配”）；
打破
}
}
}
正如Vivick所说，您必须通过添加
break


break
始终停止最里面的循环

这就是你必须要做的：

strings_to_check = ["a", "b", "c"]

test_arrrays = [ [ "a", "c", "e", "g"], [ "v", "x", "y", "z"] ]

strings_to_check_set = new Set(strings_to_check)

test_arrrays.every(test_arrray =>
    test_arrray.some(s => strings_to_check_set.has(s))
)

for（设i=0；i-1）{
控制台日志（“匹配”）；
打破
}
}
}
如果您有多个
测试数组
，将
字符串_to _check
转换为一个
集合
进行固定时间查找是有意义的。然后，总体时间复杂度从O（mn）降低到O（m+n log n），其中n是
字符串中的元素数，m是所有
测试数组中的元素总数，O（n log n）是
设置时间

通用的
检查
函数如下所示：
//检查每个干草堆是否至少包含一根针：
功能检查（打捆针、干草堆）{
针=新组（针）；
返回haystacks.every（haystack=>haystack.some（元素=>pines.has（元素））；
}
//例如：
控制台日志（检查(
[“a”、“b”、“c”]，
[“a”、“c”、“e”、“g”]、[“v”、“x”、“y”、“z”]
));如果您有多个
测试数组
，则将
字符串转换为
集合
以进行固定时间查找是有意义的。然后，总体时间复杂度从O（mn）降低到O（m+n log n），其中n是
字符串中的元素数，m是所有
测试数组中的元素总数，O（n log n）是
设置时间

通用的
检查
函数如下所示：
//检查每个干草堆是否至少包含一根针：
功能检查（打捆针、干草堆）{
针=新组（针）；
返回haystacks.every（haystack=>haystack.some（元素=>pines.has（元素））；
}
//例如：
控制台日志（检查(
[“a”、“b”、“c”]，
[a]、[c]、[e]、[g]、[v]、[x]，