sum

计算数组中所有数字的总和。

基础用法

import { sum } from 'radash'

const numbers = [1, 2, 3, 4, 5]
const total = sum(numbers)
// 15

语法

function sum(array: readonly number[]): number

参数

• array (readonly number[]): 要计算总和的数字数组

返回值

返回数组中所有数字的总和。如果数组为空，返回0。

示例

基本求和

import { sum } from 'radash'

console.log(sum([1, 2, 3, 4, 5]))     // 15
console.log(sum([10, 20, 30]))        // 60
console.log(sum([-1, -2, -3]))        // -6
console.log(sum([0, 0, 0]))           // 0

处理空数组

import { sum } from 'radash'

console.log(sum([]))                   // 0
console.log(sum([0]))                  // 0

处理小数

import { sum } from 'radash'

console.log(sum([1.5, 2.5, 3.5]))     // 7.5
console.log(sum([0.1, 0.2, 0.3]))    // 0.6000000000000001 (浮点数精度问题)
console.log(sum([1.1, 2.2, 3.3]))    // 6.6

处理大数字

import { sum } from 'radash'

console.log(sum([1000000, 2000000, 3000000])) // 6000000
console.log(sum([Number.MAX_SAFE_INTEGER, 1])) // 9007199254740992

处理混合数字

import { sum } from 'radash'

console.log(sum([1, 2.5, 3, 4.5, 5])) // 16
console.log(sum([-1, 0, 1, 2]))       // 2
console.log(sum([1, -1, 2, -2]))      // 0

在对象数组中使用

import { sum } from 'radash'

const products = [
  { id: 1, name: 'Laptop', price: 999 },
  { id: 2, name: 'Phone', price: 599 },
  { id: 3, name: 'Tablet', price: 399 }
]

const prices = products.map(product => product.price)
const totalPrice = sum(prices)
console.log(totalPrice) // 1997

计算平均值

import { sum } from 'radash'

function average(numbers: number[]): number {
  if (numbers.length === 0) return 0
  return sum(numbers) / numbers.length
}

console.log(average([1, 2, 3, 4, 5])) // 3
console.log(average([10, 20, 30]))    // 20
console.log(average([]))               // 0

计算加权平均

import { sum } from 'radash'

interface WeightedItem {
  value: number
  weight: number
}

function weightedAverage(items: WeightedItem[]): number {
  if (items.length === 0) return 0
  
  const totalWeight = sum(items.map(item => item.weight))
  const weightedSum = sum(items.map(item => item.value * item.weight))
  
  return totalWeight > 0 ? weightedSum / totalWeight : 0
}

const grades = [
  { value: 85, weight: 0.3 },
  { value: 90, weight: 0.3 },
  { value: 95, weight: 0.4 }
]

console.log(weightedAverage(grades)) // 90.5

计算统计信息

import { sum } from 'radash'

function calculateStats(numbers: number[]) {
  if (numbers.length === 0) {
    return { sum: 0, average: 0, min: 0, max: 0 }
  }
  
  const total = sum(numbers)
  const average = total / numbers.length
  const min = Math.min(...numbers)
  const max = Math.max(...numbers)
  
  return { sum: total, average, min, max }
}

const scores = [85, 92, 78, 96, 88, 90]
const stats = calculateStats(scores)

console.log(stats)
// { sum: 529, average: 88.16666666666667, min: 78, max: 96 }

处理时间序列数据

import { sum } from 'radash'

interface TimeSeriesPoint {
  timestamp: number
  value: number
}

function calculateTotalValue(data: TimeSeriesPoint[]): number {
  const values = data.map(point => point.value)
  return sum(values)
}

const timeSeriesData = [
  { timestamp: 1000, value: 10 },
  { timestamp: 2000, value: 20 },
  { timestamp: 3000, value: 30 },
  { timestamp: 4000, value: 40 }
]

const total = calculateTotalValue(timeSeriesData)
console.log(total) // 100

计算财务数据

import { sum } from 'radash'

interface Transaction {
  id: number
  amount: number
  type: 'income' | 'expense'
}

function calculateNetIncome(transactions: Transaction[]): number {
  const incomes = transactions
    .filter(t => t.type === 'income')
    .map(t => t.amount)
  
  const expenses = transactions
    .filter(t => t.type === 'expense')
    .map(t => t.amount)
  
  const totalIncome = sum(incomes)
  const totalExpenses = sum(expenses)
  
  return totalIncome - totalExpenses
}

const transactions: Transaction[] = [
  { id: 1, amount: 1000, type: 'income' },
  { id: 2, amount: 500, type: 'expense' },
  { id: 3, amount: 200, type: 'expense' },
  { id: 4, amount: 300, type: 'income' }
]

const netIncome = calculateNetIncome(transactions)
console.log(netIncome) // 600 (1000 + 300 - 500 - 200)

处理嵌套数组

import { sum } from 'radash'

function sumNestedArrays(arrays: number[][]): number {
  const flattened = arrays.flat()
  return sum(flattened)
}

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

const total = sumNestedArrays(nestedArrays)
console.log(total) // 45

计算百分比

import { sum } from 'radash'

function calculatePercentages(values: number[]): number[] {
  const total = sum(values)
  if (total === 0) return values.map(() => 0)
  
  return values.map(value => (value / total) * 100)
}

const votes = [150, 200, 100, 50]
const percentages = calculatePercentiles(votes)

console.log(percentages) // [30, 40, 20, 10]

处理销售数据

import { sum } from 'radash'

interface Sale {
  product: string
  quantity: number
  price: number
}

function calculateTotalSales(sales: Sale[]): number {
  const revenues = sales.map(sale => sale.quantity * sale.price)
  return sum(revenues)
}

const sales: Sale[] = [
  { product: 'Laptop', quantity: 2, price: 999 },
  { product: 'Phone', quantity: 3, price: 599 },
  { product: 'Tablet', quantity: 1, price: 399 }
]

const totalSales = calculateTotalSales(sales)
console.log(totalSales) // 4194 (2*999 + 3*599 + 1*399)

注意事项

1. 空数组: 如果数组为空，返回0
2. 浮点数精度: 浮点数相加可能有精度问题
3. 大数字: 对于非常大的数字，注意JavaScript的数字精度限制
4. 性能: 时间复杂度为 O(n)，其中 n 是数组长度
5. 类型: 只接受数字数组，其他类型会报错

与其他方法的区别

• reduce(): 更灵活但需要提供累加函数
• sum(): radash提供的专门用于求和的简洁方法
• Array.prototype.reduce((a, b) => a + b, 0): 功能相同但更冗长

实际应用场景

1. 财务计算: 计算收入、支出、利润等
2. 统计分析: 计算总和、平均值等统计量
3. 销售分析: 计算销售额、订单总额等
4. 评分系统: 计算总分、平均分等
5. 数据聚合: 汇总各种数值数据