算术运算符

算术运算符用于执行数学运算，如加法、减法、乘法和除法等。本文将介绍JavaScript中的算术运算符、操作规则以及常见的数值计算问题。

基本算术运算符

JavaScript提供了以下基本算术运算符：

运算符	描述	示例
+	加法	5 + 2 = 7
-	减法	5 - 2 = 3
*	乘法	5 * 2 = 10
/	除法	5 / 2 = 2.5
%	取模（余数）	5 % 2 = 1
**	幂运算（ES2016引入）	5 ** 2 = 25

加法运算符 (+)

加法运算符执行数值的相加操作，也可用于字符串的拼接：

// 数值相加
let sum = 10 + 5;  // 15

// 字符串拼接
let greeting = "Hello" + " " + "World";  // "Hello World"

// 数值和字符串混合
let result = "The answer is " + 42;  // "The answer is 42"
let mixedResult = 5 + "10";  // "510"（注意：这里是字符串拼接，不是数值相加）

减法运算符 (-)

减法运算符执行数值的相减操作：

let difference = 10 - 5;  // 5

// 当操作数不是数值时，会尝试将其转换为数值
let result = "10" - 5;  // 5（字符串"10"被转换为数值10）
let nanResult = "hello" - 5;  // NaN（字符串"hello"无法转换为数值）

乘法运算符 (*)

乘法运算符执行数值的相乘操作：

let product = 10 * 5;  // 50

// 自动类型转换
let result = "10" * 5;  // 50（字符串"10"被转换为数值10）
let nanResult = "hello" * 5;  // NaN

除法运算符 (/)

除法运算符执行数值的相除操作：

let quotient = 10 / 5;  // 2
let decimalQuotient = 10 / 3;  // 3.3333333333333335

// 除以0
let infinityResult = 10 / 0;  // Infinity
let negativeInfinity = -10 / 0;  // -Infinity
let nanResult = 0 / 0;  // NaN

取模运算符 (%)

取模运算符返回除法操作的余数：

let remainder = 10 % 3;  // 1
let noRemainder = 10 % 2;  // 0

// 负数取模
let negativeRemainder = -10 % 3;  // -1

取模运算符常用于：

• 判断数字的奇偶性：num % 2 === 0（偶数）
• 循环访问数组：array[i % array.length]
• 限制值在特定范围内：(value % maxValue + maxValue) % maxValue

幂运算符 (**)

幂运算符计算一个数的指定次方：

let squared = 5 ** 2;  // 25（5的2次方）
let cubed = 2 ** 3;  // 8（2的3次方）

// 在ES2016之前，使用Math.pow()
let oldSquared = Math.pow(5, 2);  // 25

一元算术运算符

JavaScript还提供了一元运算符，它们只需要一个操作数：

一元加法 (+)

一元加法运算符尝试将操作数转换为数值：

let num = +5;  // 5（无变化）
let strToNum = +"42";  // 42（字符串转换为数值）
let boolToNum = +true;  // 1
let nanResult = +"hello";  // NaN

一元减法 (-)

一元减法运算符将操作数转换为数值并取反：

let negNum = -5;  // -5
let negStrToNum = -"42";  // -42
let negBoolToNum = -true;  // -1
let nanResult = -"hello";  // NaN

递增 (++) 和递减 (--)

递增和递减运算符分别将变量的值加1或减1：

let count = 5;

// 前置递增
let preIncrement = ++count;  // count先加1，然后赋值给preIncrement
console.log(preIncrement, count);  // 6, 6

// 重置
count = 5;

// 后置递增
let postIncrement = count++;  // 先将count赋值给postIncrement，然后count加1
console.log(postIncrement, count);  // 5, 6

// 前置递减
count = 5;
let preDecrement = --count;  // count先减1，然后赋值给preDecrement
console.log(preDecrement, count);  // 4, 4

// 后置递减
count = 5;
let postDecrement = count--;  // 先将count赋值给postDecrement，然后count减1
console.log(postDecrement, count);  // 5, 4

赋值算术运算符

JavaScript提供了组合赋值运算符，它们结合了算术运算和赋值操作：

运算符	等价于	示例
+=	x = x + y	x += 5
-=	x = x - y	x -= 5
*=	x = x * y	x *= 5
/=	x = x / y	x /= 5
%=	x = x % y	x %= 5
**=	x = x ** y	x **= 2

let num = 10;

num += 5;  // 等价于 num = num + 5，结果：15
num -= 3;  // 等价于 num = num - 3，结果：12
num *= 2;  // 等价于 num = num * 2，结果：24
num /= 4;  // 等价于 num = num / 4，结果：6
num %= 4;  // 等价于 num = num % 4，结果：2
num **= 3;  // 等价于 num = num ** 3，结果：8

运算符优先级

算术运算符遵循特定的优先级规则，决定了复杂表达式中的计算顺序：

1. 括号 ()
2. 一元运算符 ++, --, +, -（一元）
3. 幂运算 **
4. 乘法、除法、取模 *, /, %
5. 加法、减法 +, -（二元）
6. 赋值运算符 =, +=, -= 等

let result = 2 + 3 * 4;  // 14（先计算3 * 4，再加2）
let resultWithParens = (2 + 3) * 4;  // 20（先计算2 + 3，再乘以4）

let complex = 2 ** 3 + 4 * 5 - 6 / 2;  // 26（计算顺序：2**3, 4*5, 6/2, 然后从左到右）

数值计算的特殊情况

浮点数精度问题

JavaScript使用IEEE 754标准的双精度浮点数表示法，这可能导致一些精度问题：

let result = 0.1 + 0.2;  // 0.30000000000000004，而不是0.3
let comparison = (0.1 + 0.2 === 0.3);  // false

// 解决方法
let fixedResult = Number((0.1 + 0.2).toFixed(1));  // 0.3
let epsilon = 1e-10;
let epsilonComparison = Math.abs((0.1 + 0.2) - 0.3) < epsilon;  // true

特殊数值

JavaScript中有几个特殊的数值：

// Infinity（无穷大）
let positiveInfinity = Infinity;
let computedInfinity = 1 / 0;  // Infinity

// -Infinity（负无穷大）
let negativeInfinity = -Infinity;
let computedNegativeInfinity = -1 / 0;  // -Infinity

// NaN（非数值）
let notANumber = NaN;
let computedNaN = 0 / 0;  // NaN
let stringMath = "hello" / 5;  // NaN

// 检测NaN
console.log(isNaN(NaN));  // true
console.log(isNaN("hello"));  // true（会先尝试转换为数值）
console.log(Number.isNaN(NaN));  // true
console.log(Number.isNaN("hello"));  // false（不会尝试转换）

数值的安全范围

JavaScript能够精确表示的整数范围是有限的：

let maxSafeInteger = Number.MAX_SAFE_INTEGER;  // 9007199254740991
let minSafeInteger = Number.MIN_SAFE_INTEGER;  // -9007199254740991

// 检查是否是安全整数
console.log(Number.isSafeInteger(9007199254740991));  // true
console.log(Number.isSafeInteger(9007199254740992));  // false

// 超出安全范围的计算可能不准确
console.log(9007199254740991 + 1);  // 9007199254740992
console.log(9007199254740991 + 2);  // 9007199254740992（错误，应该是9007199254740993）

算术运算的类型转换

JavaScript在执行算术运算时会进行自动类型转换：

// 字符串转换为数值
console.log("5" - 2);  // 3
console.log("5" * 2);  // 10
console.log("5" / 2);  // 2.5

// 布尔值转换为数值
console.log(true + 1);  // 2（true转换为1）
console.log(false + 1);  // 1（false转换为0）

// null和undefined
console.log(null + 1);  // 1（null转换为0）
console.log(undefined + 1);  // NaN（undefined转换为NaN）

// 特殊情况：加法运算符和字符串
console.log("5" + 2);  // "52"（数值2被转换为字符串）
console.log(5 + "2");  // "52"
console.log(5 + 2 + "3");  // "73"（从左到右计算，先计算5+2=7，然后7+"3"="73"）
console.log("5" + 2 + 3);  // "523"（从左到右计算，先计算"5"+2="52"，然后"52"+3="523"）

实用技巧

数值转换

使用一元加法运算符快速将值转换为数值：

let str = "42";
let num = +str;  // 42

let bool = true;
let numBool = +bool;  // 1

// 与Number()函数等效
let numFunc = Number(str);  // 42

取整

使用位运算符快速取整（仅适用于32位整数范围内）：

let float = 3.7;
let truncated = ~~float;  // 3（按位取反两次）
let bitwiseOr = float | 0;  // 3（按位或0）

// 其他取整方法
let floor = Math.floor(3.7);  // 3（向下取整）
let ceil = Math.ceil(3.2);  // 4（向上取整）
let round = Math.round(3.5);  // 4（四舍五入）
let trunc = Math.trunc(3.7);  // 3（截断小数部分）

判断奇偶性

使用取模运算符判断数字的奇偶性：

function isEven(num) {
    return num % 2 === 0;
}

function isOdd(num) {
    return num % 2 !== 0;
}

console.log(isEven(4));  // true
console.log(isOdd(7));  // true

精确计算

对于需要精确计算的场景（如金融计算），可以使用以下方法：

// 方法1：使用整数计算，然后再转回小数
function preciseAdd(num1, num2, decimals = 2) {
    const factor = 10 ** decimals;
    return (Math.round(num1 * factor) + Math.round(num2 * factor)) / factor;
}

console.log(preciseAdd(0.1, 0.2));  // 0.3

// 方法2：使用专门的库，如decimal.js或big.js
// 这里只是示例，实际使用需要引入相应的库
// const x = new Decimal(0.1);
// const y = new Decimal(0.2);
// const sum = x.plus(y);  // 0.3

常见错误和最佳实践

避免的错误

1. 忽略浮点数精度问题：

   // 错误
   if (0.1 + 0.2 === 0.3) {
       // 这可能不会执行
   }
   
   // 正确
   if (Math.abs((0.1 + 0.2) - 0.3) < 1e-10) {
       // 使用误差范围比较
   }

2. 忽略NaN的特性：

   // 错误
   if (x === NaN) {  // 永远为false，因为NaN不等于任何值，包括它自己
       // ...
   }
   
   // 正确
   if (isNaN(x) || Number.isNaN(x)) {
       // ...
   }

3. 忽略除以零的情况：

   // 错误
   function divide(a, b) {
       return a / b;  // 如果b为0，将返回Infinity
   }
   
   // 正确
   function divide(a, b) {
       if (b === 0) {
           throw new Error("除数不能为零");
       }
       return a / b;
   }

4. 混淆字符串拼接和数值加法：

   // 错误
   let total = "总价: " + price + tax;  // 如果price是数值，会被转换为字符串
   
   // 正确
   let total = "总价: " + (price + tax);  // 先计算数值加法，再进行字符串拼接

最佳实践

1. 使用括号明确运算优先级：

   // 不清晰
   let result = a + b * c / d;
   
   // 更清晰
   let result = a + ((b * c) / d);

2. 避免复杂的一行表达式：

   // 难以理解
   let result = a + b * c ** d / e % f;
   
   // 更易读
   let multiplication = b * c;
   let power = multiplication ** d;
   let division = power / e;
   let remainder = division % f;
   let result = a + remainder;

3. 使用适当的方法处理浮点数：

   // 金融计算
   function calculateTotal(price, tax) {
       // 转换为整数计算，避免浮点数精度问题
       const priceInCents = Math.round(price * 100);
       const taxInCents = Math.round(tax * 100);
       const totalInCents = priceInCents + taxInCents;
       return totalInCents / 100;
   }

4. 使用Number对象的方法检查数值：

   // 检查是否是有限数
   if (Number.isFinite(value)) {
       // ...
   }
   
   // 检查是否是整数
   if (Number.isInteger(value)) {
       // ...
   }
   
   // 检查是否在安全整数范围内
   if (Number.isSafeInteger(value)) {
       // ...
   }

实际应用示例

购物车计算

function calculateCart(items) {
    // 使用reduce计算总价
    const subtotal = items.reduce((sum, item) => {
        return sum + (item.price * item.quantity);
    }, 0);
    
    // 计算税费（假设税率为8%）
    const taxRate = 0.08;
    const tax = subtotal * taxRate;
    
    // 计算总价（保留两位小数）
    const total = (subtotal + tax).toFixed(2);
    
    return {
        subtotal: subtotal.toFixed(2),
        tax: tax.toFixed(2),
        total
    };
}

const cartItems = [
    { name: "商品1", price: 10.99, quantity: 2 },
    { name: "商品2", price: 5.99, quantity: 1 },
    { name: "商品3", price: 3.49, quantity: 3 }
];

console.log(calculateCart(cartItems));
// 输出: { subtotal: "35.45", tax: "2.84", total: "38.29" }

计算器实现

class Calculator {
    constructor() {
        this.result = 0;
    }
    
    add(value) {
        this.result += value;
        return this;
    }
    
    subtract(value) {
        this.result -= value;
        return this;
    }
    
    multiply(value) {
        this.result *= value;
        return this;
    }
    
    divide(value) {
        if (value === 0) {
            throw new Error("除数不能为零");
        }
        this.result /= value;
        return this;
    }
    
    power(exponent) {
        this.result **= exponent;
        return this;
    }
    
    getResult() {
        return this.result;
    }
    
    clear() {
        this.result = 0;
        return this;
    }
}

const calc = new Calculator();
const result = calc.add(5).multiply(2).subtract(3).divide(2).power(2).getResult();
console.log(result);  // 输出: 9（(5*2-3)/2)^2 = 9）

数学统计计算

function calculateStatistics(numbers) {
    // 计算总和
    const sum = numbers.reduce((total, num) => total + num, 0);
    
    // 计算平均值
    const average = sum / numbers.length;
    
    // 计算最大值和最小值
    const max = Math.max(...numbers);
    const min = Math.min(...numbers);
    
    // 计算方差
    const variance = numbers.reduce((total, num) => {
        return total + (num - average) ** 2;
    }, 0) / numbers.length;
    
    // 计算标准差
    const stdDeviation = Math.sqrt(variance);
    
    return {
        sum,
        average,
        max,
        min,
        variance,
        stdDeviation
    };
}

const data = [5, 10, 15, 20, 25];
console.log(calculateStatistics(data));
// 输出类似: { sum: 75, average: 15, max: 25, min: 5, variance: 50, stdDeviation: 7.0710678118654755 }

总结

JavaScript的算术运算符提供了执行各种数学计算的能力，从基本的加减乘除到更复杂的幂运算和取模操作。理解这些运算符的工作原理、优先级规则以及类型转换行为，对于编写正确和高效的JavaScript代码至关重要。

特别需要注意的是浮点数精度问题、特殊数值（如NaN和Infinity）以及算术运算中的类型转换规则。通过使用适当的技巧和最佳实践，可以避免常见的陷阱，编写出更加可靠的数值计算代码。

在实际应用中，算术运算符通常与其他JavaScript特性（如函数、对象和数组方法）结合使用，以实现更复杂的计算逻辑。掌握这些基础知识，将为你的JavaScript编程打下坚实的基础。

练习

1. 编写一个函数，计算给定数组中所有数字的平均值，并处理可能的非数值元素。

2. 实现一个简单的百分比计算器，可以计算两个数的百分比关系，并正确处理小数精度问题。

3. 创建一个函数，可以将时间（小时、分钟、秒）转换为总秒数，并实现逆向转换。

4. 编写一个简单的利息计算器，可以计算复利和单利，并比较两者的差异。

5. 实现一个函数，可以检测一个数是否是素数（只能被1和自身整除的大于1的整数）。