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 first operand modulo the second operand, that is, var1 modulo var2, in the preceding statement, where var1 and var2 are variables. The modulo function is the integer remainder of dividing var1 by var2. There is a proposal to get an actual modulo operator in a future version of ECMAScript.
Operator: var1 % var2
12 % 5 // 2 -1 % 2 // -1 NaN % 2 // NaN 1 % 2 // 1 2 % 3 // 2 -4 % 2 // -0
[ECMAScript 2016 (ES7) proposal]
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 (typically ^ or **), the exponentiation operator is defined to have a higher precedence than other unary operators such as unary + and unary -, but there are a few exceptions. For example, in Bash or in the current ES7 exponentiation operator draft spec, the ** operator is defined to have a lower precedence than unary operators.
-2 ** 2 // equals 4 in ES7 or in Bash, equals -4 in other languages.
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
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 converts 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
Created by Mozilla Contributors, license: CC-BY-SA 2.5