Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value. The standard arithmetic operators are addition (+), subtraction (-), multiplication (*), and division (/).
The addition operator produces the sum of numeric operands or string concatenation.
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"
The subtraction operator subtracts the two operands, producing their difference.
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, not the divisor. It uses a built-in modulo
function to produce the result, which is the integer remainder of dividing var1
by var2
— for example — var1
modulo var2
. There is a proposal to get an actual modulo operator in a future version of ECMAScript, the difference being that the modulo operator result would take the sign of the divisor, not the dividend.
Operator: var1 % var2
12 % 5 // 2 -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, var1
var2
, 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 (typically ^ or **), 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
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
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 NaN.
Operator: +x
+3 // 3 +'3' // 3 +true // 1 +false // 0 +null // 0 +function(val){ return val } // NaN
Specification | Status | Comment |
---|---|---|
ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
ECMAScript 5.1 (ECMA-262) | Standard | Defined in several sections of the specification: Additive operators, Multiplicative operators, Postfix expressions, Unary operators. |
ECMAScript 2015 (6th Edition, ECMA-262) | Standard | Defined in several sections of the specification: Additive operators, Multiplicative operators, Postfix expressions, Unary operators. |
ECMAScript 2016 (ECMA-262) | Standard | Added Exponentiation operator. |
ECMAScript 2017 Draft (ECMA-262) | Draft |
Feature | Chrome | Firefox (Gecko) | Internet Explorer | Opera | Safari |
---|---|---|---|---|---|
Basic support | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) |
Exponentiation operator | 52.0 | 52.0 (52.0) | ? | ? | ? |
Feature | Android | Android Webview | Firefox Mobile (Gecko) | IE Mobile | Opera Mobile | Safari Mobile | Chrome for Android |
---|---|---|---|---|---|---|---|
Basic support | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) |
Exponentiation operator | No support | 51.0 | 52.0 (52.0) | ? | ? | ? | 52.0 |
© 2005–2017 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators