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

sxsrh06p
  • 6

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

回复
阅读 4.5k
9 个回答
✓ 已被采纳

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
const getLevel = list => Array.isArray(list) ? Math.max(...list.map(getLevel)) + 1 : 0

image.png

可读性高一点的就是

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

我的一个思路,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);

如果你强迫症,就想用一条if语句解决,不想额外创建函数…… [狗头笑脸]

var myArray = [1,[2,2,2],1,1,1];

//只判断两层
if(myArray.some(i=>Array.isArray(i))) {
    console.log('有2层')
}

//只判断三层
if(myArray.some(i=>Array.isArray(i) && i.some(v=>Array.isArray(v)))) {
    console.log('有3层')
}

//可判断任意层
if(((a,f=a=>a.reduce((r,i)=>r+(Array.isArray(i)+0&&f(i)),1))=>f(a))(myArray) == 123) {
    console.log('有123层')
}

获取最大层级数

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

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

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]] ])  //既有一级嵌套也有二级嵌套,取极大值

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

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

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

当然是否靠谱就不知道了

撰写回答
你尚未登录,登录后可以
  • 和开发者交流问题的细节
  • 关注并接收问题和回答的更新提醒
  • 参与内容的编辑和改进,让解决方法与时俱进
宣传栏