这个递归函数返回给定数组的所有维度，如果一个或多个维度不是直的（即数组元素之间的大小不同），则返回false。它使用一个helper函数来确定两个简单数组是否相同（使用前请阅读函数注解）。

// pre: a !== b, each item is a scalar
function array_equals(a, b)
{
  return a.length === b.length && a.every(function(value, index) {
    return value === b[index];
  });
};

function getdim(arr)
{
  if (/*!(arr instanceof Array) || */!arr.length) {
    return []; // current array has no dimension
  }
  var dim = arr.reduce(function(result, current) {
    // check each element of arr against the first element
    // to make sure it has the same dimensions
    return array_equals(result, getdim(current)) ? result : false;
  }, getdim(arr[0]));

  // dim is either false or an array
  return dim && [arr.length].concat(dim);
}

console.log(getdim(123)); // []
console.log(getdim([1])); // [1]
console.log(getdim([1, 2])); // [2]
console.log(getdim([1, [2]])); // false
console.log(getdim([[1, 2], [3]])); // false
console.log(getdim([[1, 2],[1, 2]])); // [2, 2]
console.log(getdim([[1, 2],[1, 2],[1, 2]])); // [3, 2]

console.log(getdim([[[1, 2, 3],[1, 2, 4]],[[2, 1, 3],[4, 4, 6]]])); // [2, 2, 3]

console.log(getdim([[[1, 2, 3], [1, 2, 4]], [[2, 1], [4, 4]]])); // false

这里有一个简单的递归函数可以做到这一点。写得很快，所以可能容易出错。
此函数返回每个维的长度。如果它包含不同长度的子数组，则此函数返回false。
此函数适用于不同的维度。
例如，传递一个2x3的二维数组将返回[2, 3]，传递一个2x3x4的三维数组将返回[2, 3, 4]。维度（即 n d）可以通过检查返回数组的长度来获得。

// Array dimension checker
// Returns:
//   false when array dimensions are different
//   an Array when is rectangular 0d (i.e. an object) or >=1d
function arrayDimension(a) {
    // Make sure it is an array
    if (a instanceof Array) {
        // First element is an array
        var sublength = arrayDimension(a[0]);
        if (sublength === false) {
            // Dimension is different
            return false;
        } else {
            // Compare every element to make sure they are of the same dimensions
            for (var i = 1; i < a.length; i++) {
                var _sublength = arrayDimension(a[i]);
                // HACK: compare arrays...
                if (_sublength === false || sublength.join(",") != _sublength.join(",")) {
                    // If the dimension is different (i.e. not rectangular)
                    return false;
                }
            }
            // OK now it is "rectangular" (could you call 3d "rectangular"?)
            return [a.length].concat(sublength);
        }
    } else {
        // Not an array
        return [];
    }
}

Demo（检查javaScript控制台：））

使用Array.every如何？
示例：

var firstLen = ar[0].length;

var isRectangular = ar.every(function(item) {
return item.length == firstLen;
}

function isRectangular(arr){
    for(x in arr){
        if(arr[x+1].length != arr[x].length)
            return false;
    }
    return true;
}

更多尺寸：

function isPrismatic(arr){
    for(x in arr){
        if(typeof arr[x] == "object" && arr[x+1].length == arr[x].length)
            return isPrismatic(arr[x]);
        else if(arr[x].length != arr[x+1].length)
            return false;
    } return true;
}

简单的实现是检查所有内部数组的长度是否与外部数组的长度相同：

function isSquare(arr) {
  var len = arr.length;

  for (var i=0; i<len; i++) {

    if (arr[i].length != len) {
      return false;
    }
  }
  return true;
}

因此：

isSquare([[1,2],[3,4]]);   // true
isSquare([[1,2],[3,4,5]]); // false

编辑

如果您想要“矩形”数组，其中每个成员数组的长度都相同，但不一定与外部数组的长度相同：

function isRectangleArray(arr) {
  var len = arr[0].length;

  for (var i=0, iLen=arr.length; i<iLen; i++) {

    if (arr[i].length != len) {
      return false;
    }
  }
  return true;
}

我不知道如何定义一个多维的“矩形”数组，除了说它们必须都有相同的长度。你可以通过一个函数循环成员，如果它是一个数组的数组，递归地调用它自己，直到它得到一个非数组的数组，然后调用一个类似isRectangularArray的函数，并传递长度来检查。

使用recursive方法来获取没有大小限制的数组的维数是非常简单和直接的：

const getArrayDimension = (array) => {
    if (!Array.isArray(array)) {
      return 0;
    }
    return 1 + getArrayDimension (array[0]);
};

示例：

console.log(getArrayDimension(123)); // 0 -> invalid
console.log(getArrayDimension([8])); // 1
console.log(getArrayDimension([[8, 11], [8, 9]])); // 2
console.log(getArrayDimension([[[8, 11], [5, 1]], [8, 9]])); // 3

我是这样做的，如果你知道可能的尺寸，这是如此之轻：

//If i want to test if 2x2 or 3x3
if (typeof(array[0][0][0]) == "undefined")
{
  //stuff for array 3x3
}
else
{
  //stuff for array 2x2
}