Аритметичните оператори приемат числови стойности като техен операнд и връща единична числова стойност. Стандартните аритметични оператори са събиране (+), изваждане (-), умножение (*), делене(/)
Събиране (+)
Операторът за събиране произвежда сумата от числови операнди или конкатенация на стрингове.
Синтаксис
Operator: x + y
Примери
// Number + Number -> събиране
1 + 2 // 3
// Boolean + Number -> събиране
true + 1 // 2
// Boolean + Boolean -> събиране
false + false // 0
// Number + String -> конкатенация
5 + 'foo' // "5foo"
// String + Boolean -> конкатенация
'foo' + false // "foofalse"
// String + String -> конкатенация
'foo' + 'bar' // "foobar"
Subtraction (-)
The subtraction operator subtracts the two operands, producing their difference.
Syntax
Operator: x - y
Examples
5 - 3 // 2
3 - 5 // -2
'foo' - 3 // NaN
Division (/)
The division operator produces the quotient of its operands where the left operand is the dividend and the right operand is the divisor.
Syntax
Operator: x / y
Examples
1 / 2 // returns 0.5 in JavaScript (In Java, returns 0; both are integers)
// (neither 1 nor 2 is explicitly a floating point number)
Math.floor(3 / 2) // returns 1
1.0 / 2.0 // returns 0.5 in both JavaScript and Java
2.0 / 0 // returns Infinity
2.0 / 0.0 // ditto, because 0.0 === 0
2.0 / -0.0 // returns -Infinity
Multiplication (*)
The multiplication operator produces the product of the operands.
Syntax
Operator: x * y
Examples
2 * 2 // 4
-2 * 2 // -4
Infinity * 0 // NaN
Infinity * Infinity // Infinity
'foo' * 2 // NaN
Remainder (%)
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.
Syntax
Operator: var1 % var2
Examples
12 % 5 // 2
-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
Exponentiation (**)
The exponentiation operator returns the result of raising the first operand to the power of the second operand. That is, var1
var2
, in the preceding statement, where var1
and var2
are variables. The exponentiation operator is right-associative. a ** b ** c
is equal to a ** (b ** c)
.
Syntax
Operator: var1 ** var2
Notes
In most languages, such as PHP, 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; that is, 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.
Examples
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
.)
Increment (++)
The increment operator increments (adds one to) its operand and returns a value.
- If used postfix, with operator after operand (for example,
x++
), then it increments and returns the value before incrementing. - If used prefix, with operator before operand (for example,
++x
), then it increments and returns the value after incrementing.
Syntax
Operator: x++ or ++x
Examples
// Postfix
var x = 3;
y = x++; // y = 3, x = 4
// Prefix
var a = 2;
b = ++a; // a = 3, b = 3
Decrement (--)
The decrement operator decrements (subtracts one from) its operand and returns a value.
- If used postfix, with operator after operand (for example,
x--
), then it decrements and returns the value before decrementing. - If used prefix, with operator before operand (for example,
--x
), then it decrements and returns the value after decrementing.
Syntax
Operator: x-- or --x
Examples
// Postfix
var x = 3;
y = x--; // y = 3, x = 2
// Prefix
var a = 2;
b = --a; // a = 1, b = 1
Unary negation (-)
The unary negation operator precedes its operand and negates it.
Syntax
Operator: -x
Examples
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
Unary plus (+)
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
.
Syntax
Operator: +x
Examples
+3 // 3
+'3' // 3
+true // 1
+false // 0
+null // 0
+function(val){ return val } // NaN
Specifications
Browser compatibility
No compatibility data found. Please contribute data for "javascript.operators.arithmetic" (depth: 1) to the MDN compatibility data repository.