Javascript 基于维度获取多维数组中属性的长度？

使用vanillarjavascript，我想根据多维数组所在的“维度”来访问它的长度

示例：

这是一个多维数组

  var myArray = [a, b, c, d, [e, [f], g]]

中的维度0有5个元素

[a、b、c、d、[e、[f]、g]

维度1有3个元素

[e[f]，g]

维度2有1个元素

[f]

到目前为止，这就是我所拥有的（没有太多东西可以做，我真的被卡住了）

---

您能帮忙吗？

您可以减少和递归，同时跟踪已看到的数组：

var depthCount = function(xss, depth) {
  depth = depth || 0
  var seen = []
  return xss.reduce(function(acc, xs) {
    if (Array.isArray(xs)) {
      return acc.concat(depthCount(xs, depth + 1))
    }
    if (seen.indexOf(xss) < 0) {
      seen.push(xss)
      return acc.concat({depth: depth, count: xss.length})
    }
    return acc
  }, [])
}

var xs = [1, 2, 3, 4, [5, [6], 7]]

console.log(depthCount(xs))
// [{depth: 0, count: 5},
//  {depth: 1, count: 3},
//  {depth: 2, count: 1}]

---

您可以让一个helper方法递归地获取成员数，然后使用main方法通过“layer”访问需要的层数：

辅助函数的伪代码：

// Count members, and store if object
// Recursively get list of lengths from those objects
// Sum up those lists
    // find length of longest array
    // sum up all values, up to length of longest array
// Insert 'count' at front of the list
// Return

完整代码：

/*
Main function
Returns a number: the count of members in a layer
*/
function getLength(layer, obj)
{
    return getAllLengths(obj)[layer];
}



/*
Helper function for getLength(..)
Returns an array
*/
function getAllLengths(obj)
{
    var count = 0; // for this layer's # of members
    var objectMembers = []; // list of members that are objects
    var objectsLists = []; // to store list of lists produced recursively from objectMembers
    var result = []; // to return


    // count, and store if object
    for (var mem in obj)
    {
        count++;
        if (obj[mem] instanceof Object)
        {
            objectMembers.push(obj[mem] );
        }
    }


    // recursively get objects' lists
    for (var i in objectMembers)
    {
        objectsLists.push(getAllLengths(objectMembers[i] ));
    }


    ////// sum up lists
    // find length of longest array
    var maxLength = 0;
    for (var i in objectsLists)
    {
        if (objectsLists[i].length > maxLength)
        {
            maxLength = objectsLists[i].length;
        }
    }
    // sum
    for (var i = 0; i < maxLength; i++)
    {
        var sum = 0;
        for (var j = 0; j < objectsLists.length; j++)
        {
            if (objectsLists[j][i] != undefined)
                sum += objectsLists[j][i];
        }
        result.push(sum);
    }


    // complete resulting list to return
    result.splice(0,0, count);

    return result;
}

/*
主要功能
返回一个数字：层中成员的计数
*/
函数getLength（图层，obj）
{
返回GetAllLength（obj）[层]；
}
/*
getLength（..）的帮助函数
返回一个数组
*/
函数GetAllLength（obj）
{
var count=0；//此层的#个成员
var objectMembers=[]；//对象成员列表
var objectsLists=[]；//存储从objectMembers递归生成的列表列表
var result=[]；//返回
//计数，如果对象为
用于（obj中的var mem）
{
计数++；
if（对象的obj[mem]实例）
{
objectMembers.push（obj[mem]）；
}
}
//递归地获取对象的列表
for（objectMembers中的var i）
{
push（getAllLength（objectMembers[i]）；
}
//////总结清单
//查找最长数组的长度
var maxLength=0；
for（ObjectsList中的变量i）
{
if（objectsLists[i].length>maxLength）
{
maxLength=objectsLists[i].length；
}
}
//总数
对于（变量i=0；i

您希望得到什么输出？@connexo：输出将是基于维度编号的子阵列的长度。那么getLength（myArray，1）

//3

如果有多个“维度1”呢：

[a[b]，[c，d]，[e[f]，g]

？

// Count members, and store if object
// Recursively get list of lengths from those objects
// Sum up those lists
    // find length of longest array
    // sum up all values, up to length of longest array
// Insert 'count' at front of the list
// Return

/*
Main function
Returns a number: the count of members in a layer
*/
function getLength(layer, obj)
{
    return getAllLengths(obj)[layer];
}



/*
Helper function for getLength(..)
Returns an array
*/
function getAllLengths(obj)
{
    var count = 0; // for this layer's # of members
    var objectMembers = []; // list of members that are objects
    var objectsLists = []; // to store list of lists produced recursively from objectMembers
    var result = []; // to return


    // count, and store if object
    for (var mem in obj)
    {
        count++;
        if (obj[mem] instanceof Object)
        {
            objectMembers.push(obj[mem] );
        }
    }


    // recursively get objects' lists
    for (var i in objectMembers)
    {
        objectsLists.push(getAllLengths(objectMembers[i] ));
    }


    ////// sum up lists
    // find length of longest array
    var maxLength = 0;
    for (var i in objectsLists)
    {
        if (objectsLists[i].length > maxLength)
        {
            maxLength = objectsLists[i].length;
        }
    }
    // sum
    for (var i = 0; i < maxLength; i++)
    {
        var sum = 0;
        for (var j = 0; j < objectsLists.length; j++)
        {
            if (objectsLists[j][i] != undefined)
                sum += objectsLists[j][i];
        }
        result.push(sum);
    }


    // complete resulting list to return
    result.splice(0,0, count);

    return result;
}