怎么判断一个数组里是否嵌套子数组

Question

我怎么判断一个数组是不是双层呢，判断后返回true和false,比如[1,1,1,1]就是false，[1,[2,2,2],1,1,1]就是true,有啥方法么，如果是三层,怎么判断呢

Answer 1

isDeepThen() 用来判断最大深度是否超出指定 level；getMaxDeep() 用来获取最大深度。都是递归实现。两个函数没有直接关系，只是用来干不同的事情。

const cases = [
    [1, [2, [3, [4], [5]]]],
    [1, [2, [3]]],
    [2, [2, 3]],
    [1, 2, 4],
    1
];

// 检查最大深度是否超过指定 level，如果 level 传 0 表示只要是数组就行
// 可以通过 getMaxDeep() 来判断，但是 getMaxDeep() 会遍历所有项，效率较低
// isDeepThen() 有快递中断机制
function isDeeperThen(arr, level = 0) {
    // 不是数数组，肯定是 false
    if (!Array.isArray(arr)) { return false; }
    // 如果是数组，层次肯定大于 0
    if (level === 0) { return true; }

    // 找到所有数组元素进行递归检查
    return arr.filter(el => Array.isArray(el)).some(el => isDeeperThen(el, level - 1));
}

// 获取最大深度（与上面那个 isDeepThen() 没关系）
function getMaxDeep(arr) {
    // 不是数组，深度为 0
    if (!Array.isArray(arr)) {
        return 0;
    }

    // 是数组，深度 + 1，具体是多深，还要递归判断元素中的数组
    return 1 + Math.max(...arr.map(el => getMaxDeep(el)));
}

cases.forEach(data => {
    console.log(
        isDeeperThen(data, 2).toString().padEnd(6, " "),
        getMaxDeep(data),
        JSON.stringify(data)
    );
});

true   4 [1,[2,[3,[4],[5]]]]
true   3 [1,[2,[3]]]
false  2 [2,[2,3]]
false  1 [1,2,4]
false  0 1

Answer 2

const getLevel = list => Array.isArray(list) ? Math.max(...list.map(getLevel)) + 1 : 0

可读性高一点的就是

const getLevel = list => {
  return Array.isArray(list)
    // 当前层级等于子元素层级最大值+1
    ? Math.max(...list.map(getLevel)) + 1
    : 0
}

Answer 3

 arr.some(v=>Array.isArray(v))

Answer 4

我的一个思路，result为层数；想判断几层就几层

const data = [1, [2, 2, [3, [4], [5]]], 1, 1, [6], 1];
    let result = 1;
    const func = arrs => {
      let a = false;
      const arr = arrs.filter(r => Array.isArray(r));
      if (arr.length) {
        a = true;
        arr.forEach(func);
      }
      if (a) result += 1;
    };
    func(data);
    console.log(result);

Answer 5

层数 = ((a,f=a=>a.reduce((r,i)=>r+(Array.isArray(i)+0&&f(i)),1))=>f(a))(myArray);

Answer 6

获取最大层级数

function getMaxLevel(arr){
    return arr.reduce((maxlevel, item) => {
        return Array.isArray(item) ? Math.max(maxlevel, getMaxLevel(item) + 1) : maxlevel
    }, 1)
}

getMaxLevel([1,[2,2,2],1,1,1]) // 2
getMaxLevel([1,[2,2,2],[[1]],1,1]) // 3

Answer 7

可以写个函数获取嵌套层数

function getArrLevel(arr,level=0){
    let num=[];
    arr.forEach((x)=>{
        if(Array.isArray(x)){
             num.push(getArrLevel(x,level+1));
    }
    else 
    {
        num.push(0);
    }
    });
    return  level>Math.max(...num)?level:Math.max(...num);
}
getArrLevel([1,2,3])   //无嵌套
getArrLevel([1,2,[3]]) //嵌套一级
getArrLevel([1,[2], [1,2,[1,2]] ])  //既有一级嵌套也有二级嵌套，取极大值

Answer 8

function maxDepth(arr) {
    var depth = 0;
    for (var i = 0; i < arr.length; ++i) {
        if (arr[i] instanceof Array) {
            var currentDepth = 1 + maxDepth(arr[i]);
            if (depth < currentDepth) depth = currentDepth;
        }
    }
    return depth;
}
console.dir(!!maxDepth([1, 1, 1, 1])); // false
console.dir(!!maxDepth([1, [2, 2, 2], 1, 1, 1])); // true

Answer 9

如果只想知道是否，而不在乎有几层

const a=(arr)=>arr.length===arr.flat().length

当然是否靠谱就不知道了