Question

如果我有一个包含对象的数组，其中每个对象都有一个id属性，我可以使用以下命令找到索引：

data.findIndex(x=>x.id === newData.id);

但是，如果数据是一个对象数组的数组呢？有没有一种很好的方法来获取这个数据结构的两个索引？因此，data.findIndex会以某种方便的形式返回i和j。

Answer 1

这是我对基于where的递归查找索引的处理，它可以处理多个嵌套级别：

Array.prototype.reduce()

使用for循环的更通用的性能（它会在找到匹配后立即停止搜索并返回）：

const recursiveFindIndex = (data, id) =>
  data.reduce((indexes, item, index) => {
    let subIndex;

    Array.isArray(item) && (subIndex = recursiveFindIndex(item, id));

    if (subIndex && subIndex.length) {
      return indexes.concat([index], subIndex);
    }

    item.id === id && (indexes.push(index));

    return indexes;
  }, []);

const data = [
  { id: 0 },
  [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }],
  [{ id: 6 }, { id: 7 }, { id: 8 }, { id: 9 }, [
    { id: 10 }, { id: 11 }, { id: 12 }, { id: 13 }, { id: 14 }]
  ]
];

console.log('id: 3', recursiveFindIndex(data, 0));
console.log('id: 3', recursiveFindIndex(data, 3));
console.log('id: 6', recursiveFindIndex(data, 8));
console.log('id: 12', recursiveFindIndex(data, 12));
console.log('id: 3', recursiveFindIndex(data, 20));

Answer 2

那么，这样的事情呢？

它可能不是最优雅的解决方案，但它有效：

const newData = { id: 1 };
const data = [[{id: 0}, {id: 1}], [{id: 2}, {id: 3}]];

data.reduce((res, x, i) => {
  let j = x.findIndex(y => y.id === newData.id);

  if (~j) {
    return [i, j];
  }

  return res;
}, [-1, -1]);

Answer 3

如果Array.includes是值数组，则可以使用findIndex。

var data = [
  [1,2,3],
  [4,5,6],
  [7,8,9]
]
var searchParam = 8;
var index = data.findIndex(x=>x.includes(searchParam))
console.log(index)

如果它是一个更高级别数组的对象数组，则可以使用递归。

var data = [
  [{id: 1},{id: 2},{id: 3}],
  [{id: 4},{id: 5},{id: 6}],
  [{id: 7},{id: 8},{id: 9}]
]
var searchValue = 8;
var index = data.findIndex(x=>{
  return searchInObject(x, searchValue);
})

function searchInObject(obj, searchValue){
  var _s = JSON.stringify(obj);
  if(_s.indexOf(searchValue)>-1){
     if(Array.isArray(obj)){
       return obj.some(function(o){
         if(searchInObject(o, searchValue)) return true;
       });
     }
    else if(typeof(obj) === 'object'){
      for(var k in obj){
        if(searchInObject(obj[k], searchValue)) return true;
      }
    }
    else{
      if(obj === searchValue) return true;
    }
  }
}
console.log(index)

Answer 4

使用reduce的另一个人：

const data = [
    [{ id : 1}, { id: 4 }],
  [{ id :2 }, { id : 3}]
]

const findIJ = ( data, id ) => 
  data.reduce( (p, c, i) => {
    let j = c.findIndex( x => x.id === id );
    if( j > - 1){
        p = { i, j }
    }
    return p;
  }, { i : -1, j : -1 });

https://jsfiddle.net/05cubh2b/

在二维数组中查找索引

4 个答案: