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. 數據聚合: 匯總各種數值數據