JavaScript函数：高效查找数组中的最大值与最小值-js教程-PHP中文网

JavaScript函数：高效查找数组中的最大值与最小值

本教程详细探讨了在javascript中查找数组最大值和最小值的方法。从处理空数组、单元素数组等边界条件入手，逐步优化初始方案，避免`math.max/min`在空数组上的错误行为。最终展示了两种主要实现方式：一种结合条件判断和`math`函数，另一种利用`reduce`方法实现单次遍历的高效查找，并强调了代码的健壮性和性能考量。

在JavaScript开发中，从数字数组中找出最大值和最小值是一个常见的需求。这个功能不仅要正确处理包含多个数字的常规情况，还需要考虑一些边界条件，例如数组为空或只包含一个数字时。本教程将深入探讨如何健壮且高效地实现这一功能。

1. 初始尝试与潜在问题

许多开发者初次尝试时可能会直观地使用Math.max()和Math.min()配合扩展运算符（...）来解决这个问题。

function findBiggestAndSmallest(numbers) {
  let obj = {};
  obj.biggest = Math.max(...numbers);
  obj.smallest = Math.min(...numbers);
  return obj;
}

console.log(findBiggestAndSmallest([5, 2, 9, 7])); // { biggest: 9, smallest: 2 }

登录后复制

这种方法对于包含数字的数组是有效的。然而，当传入一个空数组时，Math.max()会返回-Infinity，而Math.min()会返回Infinity。这与期望的空对象结果不符，会导致程序行为异常。

console.log(findBiggestAndSmallest([])); // { biggest: -Infinity, smallest: Infinity }
// 期望结果是 {}

登录后复制

2. 解决方案一：添加边界条件处理

为了解决Math.max/min在空数组上的问题，关键在于在执行主要逻辑前处理所有边界情况。这包括检查输入是否为null或undefined，数组是否为空，以及数组是否只包含一个元素。通过在函数开头添加这些“守卫条款”（guard clauses），我们可以确保函数在处理不同输入时都返回预期结果。

立即学习“Java免费学习笔记（深入）”；

实现步骤：

处理无效输入： 如果numbers参数本身是null或undefined，可以返回null或抛出错误，以明确表示无效输入。
处理空数组： 如果数组长度为0，根据需求返回一个空对象{}。
处理单元素数组： 如果数组长度为1，最大值和最小值都是该元素本身。
处理多元素数组： 在通过上述边界条件检查后，数组至少包含两个元素，此时可以安全地使用Math.max()和Math.min()。

示例代码：

/**
 * 查找数组中的最大值和最小值，并以对象形式返回。
 * 处理空数组、单元素数组及无效输入等边界情况。
 * @param {number[]} numbers - 数字数组。
 * @returns {{biggest: number, smallest: number}|{}|null} 包含最大值和最小值的对象，
 *          或空对象（数组为空时），或null（输入无效时）。
 */
function findBiggestAndSmallest(numbers) {
  // 1. 处理无效输入：如果numbers为null或undefined
  if (numbers === null || numbers === undefined) {
    return null;
  }

  // 2. 处理空数组
  if (numbers.length === 0) {
    return {};
  }

  // 3. 处理单元素数组
  if (numbers.length === 1) {
    const [first] = numbers; // 使用解构赋值获取第一个元素
    return { biggest: first, smallest: first }; // 使用对象字面量语法
  }

  // 4. 处理多元素数组
  return {
    biggest: Math.max(...numbers),
    smallest: Math.min(...numbers)
  };
}

// 测试用例
const areEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b); // 辅助函数用于深度比较对象

console.log('--- 解决方案一测试 ---');
console.log(`findBiggestAndSmallest(null): ${JSON.stringify(findBiggestAndSmallest(null))} (Expected: null)`);
console.log(`findBiggestAndSmallest(undefined): ${JSON.stringify(findBiggestAndSmallest(undefined))} (Expected: null)`);
console.log(`findBiggestAndSmallest([]): ${JSON.stringify(findBiggestAndSmallest([]))} (Expected: {})`);
console.log(`findBiggestAndSmallest([5]): ${JSON.stringify(findBiggestAndSmallest([5]))} (Expected: {biggest:5,smallest:5})`);
console.log(`findBiggestAndSmallest([5, 2, 9, 7]): ${JSON.stringify(findBiggestAndSmallest([5, 2, 9, 7]))} (Expected: {biggest:9,smallest:2})`);

// 验证结果
console.log(`null input test: ${areEqual(null, findBiggestAndSmallest(null))}`);
console.log(`empty array test: ${areEqual({}, findBiggestAndSmallest([]))}`);
console.log(`single element array test: ${areEqual({biggest:5,smallest:5}, findBiggestAndSmallest([5]))}`);
console.log(`multiple elements array test: ${areEqual({biggest:9,smallest:2}, findBiggestAndSmallest([5, 2, 9, 7]))}`);

登录后复制

注意事项：

Medeo

AI视频生成工具

191

查看详情

对象字面量语法： 在创建并返回对象时，推荐直接使用对象字面量语法{ key: value }，而不是先创建空对象再逐个赋值，这样代码更简洁清晰。
解构赋值： 对于单元素数组，使用const [first] = numbers;来获取第一个元素是ES6的优雅写法。

3. 解决方案二：使用 reduce() 进行优化（单次遍历）

虽然上述方法有效，但Math.max和Math.min在内部会分别遍历数组，这意味着对于一个包含N个元素的数组，我们实际上进行了两次遍历（一次找最大值，一次找最小值），时间复杂度为O(2N)。对于大型数组，我们可以通过Array.prototype.reduce()方法实现单次遍历来查找最大值和最小值，从而达到O(N)的时间复杂度，提高效率。

实现步骤：

处理边界条件： reduce方法同样需要先处理null/undefined输入、空数组和单元素数组的边界情况，原因同上。reduce方法本身在空数组上调用时会报错（如果没有提供初始值），或者返回初始值（如果提供了）。
reduce逻辑：
- 为reduce提供一个初始值（accumulator），它是一个对象，包含biggest和smallest属性。初始的biggest可以设置为负无穷大（Number.MIN_VALUE或-Number.MAX_VALUE），smallest可以设置为正无穷大（Number.MAX_VALUE）。
- 在每次迭代中，比较当前元素n与累加器中的biggest和smallest，并更新它们。

示例代码：

/**
 * 查找数组中的最大值和最小值，使用reduce方法实现单次遍历。
 * 处理空数组、单元素数组及无效输入等边界情况。
 * @param {number[]} numbers - 数字数组。
 * @returns {{biggest: number, smallest: number}|{}|null} 包含最大值和最小值的对象，
 *          或空对象（数组为空时），或null（输入无效时）。
 */
function findBiggestAndSmallestOptimized(numbers) {
  // 1. 处理无效输入
  if (numbers === null || numbers === undefined) {
    return null;
  }

  // 2. 处理空数组
  if (numbers.length === 0) {
    return {};
  }

  // 3. 处理单元素数组 (reduce 也可以处理，但为了清晰和性能，这里单独处理)
  if (numbers.length === 1) {
    const [first] = numbers;
    return { biggest: first, smallest: first };
  }

  // 4. 使用 reduce 方法进行单次遍历
  // 初始值可以设置为数组的第一个元素，或者使用极值
  // 这里我们使用极值作为初始值，确保无论数组元素正负都能正确比较
  return numbers.reduce((result, n) => {
    if (n < result.smallest) {
      result.smallest = n;
    }
    if (n > result.biggest) {
      result.biggest = n;
    }
    return result;
  }, {
    biggest: -Number.MAX_VALUE, // 初始最大值设置为尽可能小的数
    smallest: Number.MAX_VALUE  // 初始最小值设置为尽可能大的数
  });
}

// 测试用例
console.log('\n--- 解决方案二测试 (优化版) ---');
console.log(`findBiggestAndSmallestOptimized(null): ${JSON.stringify(findBiggestAndSmallestOptimized(null))} (Expected: null)`);
console.log(`findBiggestAndSmallestOptimized(undefined): ${JSON.stringify(findBiggestAndSmallestOptimized(undefined))} (Expected: null)`);
console.log(`findBiggestAndSmallestOptimized([]): ${JSON.stringify(findBiggestAndBiggestOptimized([]))} (Expected: {})`);
console.log(`findBiggestAndSmallestOptimized([5]): ${JSON.stringify(findBiggestAndSmallestOptimized([5]))} (Expected: {biggest:5,smallest:5})`);
console.log(`findBiggestAndSmallestOptimized([5, 2, 9, 7]): ${JSON.stringify(findBiggestAndSmallestOptimized([5, 2, 9, 7]))} (Expected: {biggest:9,smallest:2})`);

// 验证结果
console.log(`null input test (optimized): ${areEqual(null, findBiggestAndSmallestOptimized(null))}`);
console.log(`empty array test (optimized): ${areEqual({}, findBiggestAndSmallestOptimized([]))}`);
console.log(`single element array test (optimized): ${areEqual({biggest:5,smallest:5}, findBiggestAndSmallestOptimized([5]))}`);
console.log(`multiple elements array test (optimized): ${areEqual({biggest:9,smallest:2}, findBiggestAndSmallestOptimized([5, 2, 9, 7]))}`);

登录后复制

关于reduce初始值的选择： 在reduce的初始值中，将biggest初始化为-Number.MAX_VALUE（或Number.MIN_VALUE）以及smallest初始化为Number.MAX_VALUE，是一个通用的做法，可以确保即使数组包含负数或非常大的数也能正确比较。另一种常见做法是，如果数组长度大于等于1，可以将reduce的初始值设置为{ biggest: numbers[0], smallest: numbers[0] }，然后从数组的第二个元素开始遍历。但为了简化逻辑并保持一致性，上述示例选择了极值作为初始累加器。