算術運算子接受數值（資料型態為字串或變數都可）作為其運算子並回傳單個數值。 標準算術運算符號有加號（+），減號（ - ），乘（*）和除（/）。
加法運算子生成數字(運算元)的總和或字串串接。
Operator: x + y
// Number + Number -> addition 1 + 2 // 3 // Boolean + Number -> addition true + 1 // 2 // Boolean + Boolean -> addition false + false // 0 // Number + String -> concatenation 5 + 'foo' // "5foo" // String + Boolean -> concatenation 'foo' + false // "foofalse" // String + String -> concatenation 'foo' + 'bar' // "foobar"
減法運算子能算出兩個運算元間的差異。
Operator: x - y
5 - 3 // 2 3 - 5 // -2 'foo' - 3 // NaN
The division operator produces the quotient of its operands where the left operand is the dividend and the right operand is the divisor.
Operator: x / y
1 / 2 // returns 0.5 in JavaScript 1 / 2 // returns 0 in Java // (neither number is explicitly a floating point number) 1.0 / 2.0 // returns 0.5 in both JavaScript and Java 2.0 / 0 // returns Infinity in JavaScript 2.0 / 0.0 // returns Infinity too 2.0 / -0.0 // returns -Infinity in JavaScript
The multiplication operator produces the product of the operands.
Operator: x * y
2 * 2 // 4 -2 * 2 // -4 Infinity * 0 // NaN Infinity * Infinity // Infinity 'foo' * 2 // NaN
The remainder operator returns the remainder left over when one operand is divided by a second operand. It always takes the sign of the dividend.
Operator: var1 % var2
12 % 5 // 2 -1 % 2 // -1 1 % -2 // 1 NaN % 2 // NaN 1 % 2 // 1 2 % 3 // 2 -4 % 2 // -0 5.5 % 2 // 1.5
The exponentiation operator returns the result of raising first operand to the power second operand. that is, var1var2, in the preceding statement, where var1 and var2 are variables. Exponentiation operator is right associative. a ** b ** c is equal to a ** (b ** c).
Operator: var1 ** var2
In most languages like PHP and Python and others that have an exponentiation operator (**), the exponentiation operator is defined to have a higher precedence than unary operators such as unary + and unary -, but there are a few exceptions. For example, in Bash the ** operator is defined to have a lower precedence than unary operators. In JavaScript, it is impossible to write an ambiguous exponentiation expression, i.e. you cannot put a unary operator (+/-/~/!/delete/void/typeof) immediately before the base number.
-2 ** 2; // 4 in Bash, -4 in other languages. // This is invalid in JavaScript, as the operation is ambiguous. -(2 ** 2); // -4 in JavaScript and the author's intention is unambiguous.
2 ** 3 // 8 3 ** 2 // 9 3 ** 2.5 // 15.588457268119896 10 ** -1 // 0.1 NaN ** 2 // NaN 2 ** 3 ** 2 // 512 2 ** (3 ** 2) // 512 (2 ** 3) ** 2 // 64
To invert the sign of the result of an exponentiation expression:
-(2 ** 2) // -4
To force the base of an exponentiation expression to be a negative number:
(-2) ** 2 // 4
Note: JavaScript also has a bitwise operator ^ (logical XOR). ** and ^ are different (for example : 2 ** 3 === 8 when 2 ^ 3 === 1.)
The increment operator increments (adds one to) its operand and returns a value.
Operator: x++ or ++x
// Postfix var x = 3; y = x++; // y = 3, x = 4 // Prefix var a = 2; b = ++a; // a = 3, b = 3
The decrement operator decrements (subtracts one from) its operand and returns a value.
Operator: x-- or --x
// Postfix var x = 3; y = x--; // y = 3, x = 2 // Prefix var a = 2; b = --a; // a = 1, b = 1
The unary negation operator precedes its operand and negates it.
Operator: -x
var x = 3; y = -x; // y = -3, x = 3 // Unary negation operator can convert non-numbers into a number var x = "4"; y = -x; // y = -4
The unary plus operator precedes its operand and evaluates to its operand but attempts to convert it into a number, if it isn't already. Although unary negation (-) also can convert non-numbers, unary plus is the fastest and preferred way of converting something into a number, because it does not perform any other operations on the number. It can convert string representations of integers and floats, as well as the non-string values true, false, and null. Integers in both decimal and hexadecimal ("0x"-prefixed) formats are supported. Negative numbers are supported (though not for hex). If it cannot parse a particular value, it will evaluate to {{jsxref("NaN")}}.
Operator: +x
+3 // 3
+'3' // 3
+true // 1
+false // 0
+null // 0
+function(val){ return val } // NaN
| Specification | Status | Comment |
|---|---|---|
| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Initial definition. |
| {{SpecName('ES5.1', '#sec-11.3')}} | {{Spec2('ES5.1')}} | Defined in several sections of the specification: Additive operators, Multiplicative operators, Postfix expressions, Unary operators. |
| {{SpecName('ES2015', '#sec-postfix-expressions')}} | {{Spec2('ES2015')}} | Defined in several sections of the specification: Additive operators, Multiplicative operators, Postfix expressions, Unary operators. |
| {{SpecName('ES2016', '#sec-postfix-expressions')}} | {{Spec2('ES2016')}} | Added Exponentiation operator. |
| {{SpecName('ES2017', '#sec-postfix-expressions')}} | {{Spec2('ES2017')}} | |
| {{SpecName('ESDraft', '#sec-additive-operators')}} | {{Spec2('ESDraft')}} |
{{Compat("javascript.operators.arithmetic")}}