如何检查数组中的一个或多个数组中是否不存在一个值？

Question

我需要编写一个函数，如果一个值存在于多维数组中，则返回 true；如果该值不存在于多维数组中的至少一个数组中，则返回 false。

    function isItemOmnipresent (arrayOfArrays, item) {

     var arrays = arrayOfArrays;
     var itemCheck = item;

     for(var i = 0; i < arrays.length; i++){
      for(var j = 0; j < arrays[i].length; j++){
       if(arrays[i][j] == itemCheck) {
         return true;
      } else {
         return false;
      }
    }
  }

Answer 1

 const check = (multi, value) => multi.some(array => array.includes(value));

可以这样使用：

check([[1,2],[3,4]], 2);

Answer 2

您可以使用类似这样的功能 - 请参阅此https://jsfiddle.net/jde2urL6/：

    function isValuePresent(arr, value) {
  var result = false;

  if (Array.isArray(arr)) {
    for (var i = 0; i < arr.length; i++) {
      if (Array.isArray(arr[i])) {
        result = isValuePresent(arr[i], value);
      }
      else {
        if (arr[i] === value)
          result = true;
      }
    }
  }

  return result;
}

当 for 循环遍历数组中的每个数组元素时，它会检查该项目是否为（嵌套）数组，如果是，则该方法回调自身（递归）以检查嵌套中是否有任何元素数组有一个匹配的值。如果元素不是数组，则根据所需的“查找”值检查该元素的值 - 如果是，则将结果设置为 true。我在下面添加了一个“视觉”（流程从第一条红色水平线开始）。我希望这会带来更多的澄清。

Answer 3

很像 “有一个应用程序！” - 通常是 “有一个方法！” 如果你足够努力并且你的问题就是这种情况.您可以使用数组的.some 方法来确定其中的任何内容是否满足所需的值。

我们设置了一个名为 inArrays 的标志来跟踪 some 函数的返回值是否为真，并在函数调用结束时返回它。

function isItemPresent(OuterArr, item) {
  let inArrays = false;

  for (let InnerArr of OuterArr) {
    if(InnerArr.some(array_item => array_item === item)) {
    inArrays = true;
    }
  }
  return inArrays;
}

let _2dArr = [
  [1, 2, 3, 4],
  [6, 7, 8, 9]
];


function isItemPresent(OuterArr, item) {
  let inArrays = false;

  for (let InnerArr of OuterArr) {
    if(InnerArr.some(array_item => array_item === item)) {
    inArrays = true;
    }
  }
  return inArrays;
}

console.log(isItemPresent(_2dArr, 3));
console.log(isItemPresent(_2dArr, 5));

ES5/IE

如果您担心这类事情，这里有一个 IE/ES5 友好版本

function isItemPresent(OuterArr, item) {
  var inArrays = false;

  for (InnerArr = 0; InnerArr < OuterArr.length; InnerArr++) {
    if(OuterArr[InnerArr].some(function(array_item) { return array_item === item; })) {
    inArrays = true;
    }
  }
  return inArrays;
}

var _2dArr = [
  [1, 2, 3, 4],
  [6, 7, 8, 9]
];


function isItemPresent(OuterArr, item) {
  var inArrays = false;

  for (InnerArr = 0; InnerArr < OuterArr.length; InnerArr++) {
    if(OuterArr[InnerArr].some(function(array_item) { return array_item === item; })) {
    inArrays = true;
    }
  }
  return inArrays;
}

console.log(isItemPresent(_2dArr, 3));
console.log(isItemPresent(_2dArr, 5));

Answer 4

这里有两种清晰有效的方法：

// using a simple for-iterator
function IsItemOmnipresent(arrayOfArrays, item, present = false) {  
  for (const e of arrayOfArrays) {
    if (typeof e === 'object' && e.length) {
      return IsItemOmnipresent(e, item, present);
    }
    else {
        present = e === item;
    }
  }

  return present;
}

// using .reduce()
function IsItemOmnipresent(arrayOfArrays, item) {
  let isPresent = function (present, e) {
    if (typeof e === 'object' && e.length) {
      return IsItemOmnipresent(e, item);
    }
    else {
      present = e === item;
    }

    return present;
  };

  return arrayOfArrays.reduce(isPresent, false);  
}

console.log(IsItemOmnipresent([[1, 1], [1, 3], [5, 1], [6, 1]], 1)) //true
console.log(IsItemOmnipresent([[1, 1], [1, 3], [5, 1], [6, 1]], 6)) // false
console.log(IsItemOmnipresent([[5], [5], [5], [6, 5]], 5)) // true
console.log(IsItemOmnipresent([[5], [5], [5], [6, 5]], 6)) // false
console.log(IsItemOmnipresent([[5, 1], [5, 1], [5, 1], [6, 5, 1]], 1)) // true

Answer 5

你可以使用这样的功能。

    function isOmnipresent(arr, val) {
     return arr.every(ar=>ar.includes(val));
}