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

时间:2017-12-08 18:35:40

标签: javascript arrays multidimensional-array

我需要编写一个函数,如果一个值存在于多维数组中,则返回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;
      }
    }
  }

5 个答案:

答案 0 :(得分:1)

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

可以这样:

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

答案 1 :(得分:0)

您可以使用类似这样的功能 - 请参阅此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循环遍历数组中的每个数组元素时,它会检查该项是否为(嵌套)数组,如果是,则返回自身(递归)以检查嵌套中是否有任何元素数组具有匹配值。如果元素不是数组,则根据所需的&#34;检查该元素的值,以找到&#34; value - 如果是,则将结果设置为true。我添加了一个&#34; visual&#34;下面(流程从第一条红色水平线开始)。我希望这会带来更多的澄清。

enter image description here

答案 2 :(得分:0)

很像“有一个应用程序!” - 通常是“有一种方法!”如果你看起来很难,这就是你的问题。您可以使用数组的.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));

答案 3 :(得分:0)

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

// using a simple for-iterator
function IsItemOmnipresent(arrayOfArrays, item, present = false) {  
    for (let i in arrayOfArrays) {
        if (arrayOfArrays[i] instanceof Array)
            return IsItemOmnipresent(arrayOfArrays[i], item, present);
        else 
            present = arrayOfArrays[i] === item;
    }
    return present;
}

// using .reduce()
function IsItemOmnipresent(arrayOfArrays, item) {
    let isPresent = function (present, val) {
        if (val instanceof Array)
            return IsItemOmnipresent(val, item);
        else 
            present = val === 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

答案 4 :(得分:-1)

您可以使用这样的功能。

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