JavaScript中获取二维数组最大值的多种方法

更新时间：2025年12月16日 09:24:08 作者：纸上笔下

在 JavaScript 中获取二维数组最大值的多种方法,包括基础循环、高阶函数、递归等技术,并提供性能比较和使用建议,本文就通过代码示例来给大家详细说说,需要的朋友可以参考下

一、二维数组简介

二维数组是一种常见的数据结构，它由多个一维数组组成，常用于表示表格、矩阵等数据。在 JavaScript 中，二维数组实际上是数组的数组，例如：

const matrix = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
];

二、方法一：使用嵌套循环

这是最基础的方法，通过两层循环遍历二维数组的每个元素，比较并找到最大值。

/**
 * 使用嵌套循环获取二维数组的最大值
 * @param {Array} arr - 二维数组
 * @returns {number} - 最大值
 */
function getMaxValue(arr) {
    let max = -Infinity; // 初始化最大值为负无穷
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr[i].length; j++) {
            if (arr[i][j] > max) {
                max = arr[i][j]; // 更新最大值
            }
        }
    }
    return max;
}

// 使用示例
const arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
console.log(getMaxValue(arr)); // 输出: 9

优点：兼容性好，性能较高。
缺点：代码较长。

三、方法二：使用 Math.max 和展开运算符

利用 Array.prototype.flat() 方法将二维数组展平，然后使用 Math.max() 和展开运算符获取最大值。

/**
 * 使用 Math.max 和展开运算符获取二维数组的最大值
 * @param {Array} arr - 二维数组
 * @returns {number} - 最大值
 */
function getMaxValue(arr) {
    return Math.max(...arr.flat()); // 展平数组后求最大值
}

// 兼容性更好的写法
function getMaxValueCompat(arr) {
    const flatArray = [].concat(...arr); // 使用 concat 展平数组
    return Math.max.apply(null, flatArray); // 使用 apply 调用 Math.max
}

// 使用示例
const arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
console.log(getMaxValue(arr)); // 输出: 9

优点：代码简洁。
缺点：展平大数组时可能占用较多内存。

四、方法三：使用 reduce 方法

使用 reduce() 方法逐个子数组计算最大值，并返回整体最大值。

/**
 * 使用 reduce 方法获取二维数组的最大值
 * @param {Array} arr - 二维数组
 * @returns {number} - 最大值
 */
function getMaxValue(arr) {
    return arr.reduce((max, subArr) => {
        const subMax = Math.max(...subArr); // 获取当前子数组的最大值
        return Math.max(max, subMax); // 返回当前最大值和子数组最大值的较大者
    }, -Infinity); // 初始值为负无穷
}

// 简洁写法
function getMaxValueShort(arr) {
    return arr.reduce((max, subArr) => Math.max(max, ...subArr), -Infinity);
}

// 使用示例
const arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
console.log(getMaxValue(arr)); // 输出: 9

优点：函数式编程风格，代码简洁。
缺点：性能略低于循环。

五、方法四：使用递归方法

递归方法可以处理任意维度的数组，不仅限于二维。

/**
 * 使用递归方法获取多维数组的最大值
 * @param {Array} arr - 多维数组
 * @returns {number} - 最大值
 */
function getMaxValue(arr) {
    let max = -Infinity; // 初始化最大值为负无穷
    
    /**
     * 递归查找最大值
     * @param {Array} nestedArr - 当前处理的数组
     */
    function findMax(nestedArr) {
        for (let item of nestedArr) {
            if (Array.isArray(item)) {
                findMax(item); // 如果是数组，递归处理
            } else if (item > max) {
                max = item; // 更新最大值
            }
        }
    }
    
    findMax(arr);
    return max;
}

// 使用示例
const arr = [[1, [2, 10]], [3, 4], [5, [6, [7, 8, 9]]]];
console.log(getMaxValue(arr)); // 输出: 10

优点：可处理任意维度数组。
缺点：递归可能导致栈溢出，性能较差。

六、方法五：处理空数组和特殊情况

增强版本可处理空数组、非数字值等特殊情况。

/**
 * 增强版本：处理空数组和非数字值
 * @param {Array} arr - 二维数组
 * @returns {number|undefined} - 最大值或undefined
 */
function getMaxValue(arr) {
    if (!Array.isArray(arr) || arr.length === 0) {
        return undefined; // 处理非数组或空数组
    }
    
    // 展平数组并过滤非数字值
    const flatArray = arr.flat(Infinity).filter(item => 
        typeof item === 'number' && !isNaN(item) // 只保留数字类型且非NaN的值
    );
    
    if (flatArray.length === 0) {
        return undefined; // 如果没有有效数字，返回undefined
    }
    
    return Math.max(...flatArray); // 返回最大值
}

// 使用示例
const arr = [[1, 2], [3, 'text'], [null, 9], []];
console.log(getMaxValue(arr)); // 输出: 9

优点：健壮性强，能处理特殊情况。
缺点：代码稍复杂。

七、方法六：性能优化版本

针对大型数组，使用基础循环方法进行性能优化。

/**
 * 性能优化版本：适用于大型数组
 * @param {Array} arr - 二维数组
 * @returns {number} - 最大值
 */
function getMaxValue(arr) {
    let max = -Infinity; // 初始化最大值为负无穷
    
    for (let i = 0; i < arr.length; i++) {
        const subArr = arr[i];
        for (let j = 0; j < subArr.length; j++) {
            if (subArr[j] > max) {
                max = subArr[j]; // 更新最大值
            }
        }
    }
    
    return max;
}

优点：性能最佳。
缺点：代码较长。

八、方法比较与总结

以下是对上述方法的比较总结：

方法	优点	缺点	适用场景
嵌套循环	性能好，兼容性好	代码稍长	大型数组，高性能要求
Math.max + flat	代码简洁	可能受调用栈限制	中小型数组
reduce	函数式编程风格	性能稍差	函数式编程场景
递归	处理任意维度	性能差，可能栈溢出	多维数组
增强版本	健壮性强	代码复杂	需处理特殊情况
性能优化版本	性能最佳	代码较长	超大型数组