详解JavaScript如何优雅地实现创建多维数组

const arr = []
for (let i = 0; i < 10; i++) {
  arr[i] = []
  for (let j = 0; j < 10; j++) {
    arr[i][j] = 0
  }
}

const arr1 = new Array(10).fill(0).map(() => new Array(10).fill(0))

const arr2 = new Array(10).fill(0).map((_, i) => new Array(10).fill(0).map((_, j) => i * 10 + j))

const arr1 = Array.from({ length: 10 }, () => Array.from({ length: 10 }, () => 0))

const arr2 = Array.from({ length: 10 }, (_, i) => Array.from({ length: 10 }, (_, j) => i * 10 + j))

int arr[10][10]

fun(0, false, 10) // 创建一个长度为10，初值为0的数组
fun(0, true, 10, 10) // 创建一个10 * 10的数组，初值为0-99

function fun(value, inc, ...dimensions) {
  // 取首元素,创建数组
  const length = dimensions.shift()
  const arr = new Array(length)
  if (dimensions.length == 0) {
      // 一维数组 赋值
      for (let i = 0; i < length; i++) {
          arr[i] = inc ? value++ : value
      }
  } else {
      // 多维数组 递归创建
      let gap = dimensions.reduce((a, b) => a * b, 1) // 初值的间隔
      for (let i = 0; i < length; i++) {
          arr[i] = fun(value + (inc ? i * gap : 0), inc, ...dimensions)
      }
  }
  return arr
}

fun(10) // 创建一个长度为10，不设置初值
fun(10)(10, 0) // 创建一个10 * 10的数组，初值为0
fun(10)(10)(10, 0, true) // 创建一个10 * 10的数组，初值为0-999

Object.setPrototypeOf(fun, Array.prototype)

let root = [] // 根数组 root[0] 将会是返回的结果
let tile = [root] // 平铺数组

// 函数实现
function fun(length) {
    if (length <= 0) {
        // 结束标志 非正数
        try {
            // 空属性会被JSON转换成null，然后再替换为初值
            let res = jsON.stringify(root[0])
            res = res.replaceAll('null', Math.abs(length))
            return JSON.parse(res)
        } finally {
            // 恢复变量
            root = []
            tile = [root]
        }
    } else {
        const next = [] // 新的平铺数组
        // 遍历平铺数组,里面的元素是倒数第二层
        for (const two of tile) {
            // 首次调用two.length为0，但需要执行一次
            for (let i = 0; i < (two.length || 1); i++) {
                const one = new Array(length) // 最后一层
                two[i] = one
                next.push(one)
            }
        }
        // 更替平铺数组
        tile = next
    }
    return fun
}

// 函数调用
fun(10)(0) // [0,0,0,0,0,0,0,0,0,0]
fun(2)(3)(-1) // [[1,1,1],[1,1,1]]
fun(2)(2)(2)(-2) // [[[2,2],[2,2]],[[2,2],[2,2]]]

let root = []
let tile = [root]
// 拦截器
const handers = {
    get(target, key) {
        key = parseInt(key)
        if (key <= 0) {
            try {
                let res = JSON.stringify(root[0])
                res = res.replaceAll('null', Math.abs(key))
                return JSON.parse(res)
            } finally {
                root = []
                tile = [root]
            }
        } else {
            const next = []
            for (const two of tile) {
                for (let i = 0; i < (two.length || 1); i++) {
                    const one = new Array(key)
                    two[i] = one
                    next.push(one)
                }
            }
            tile = next
        }
        return int
    },
}
// 用 proxy 创建 int
const int = new Proxy({}, handers)

const arr = int[10][10][0] // 10*10 初值为 0 的数组