# Arithmetic operators

**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 (/).

## Addition (+)

The addition operator produces the sum of numeric operands or string concatenation.

### Syntax

Operator: x + y

### Examples

// 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"

## 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 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

## 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, 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.

### Syntax

Operator: var1 % var2

### Examples

12 % 5 // 2 -1 % 2 // -1 NaN % 2 // NaN 1 % 2 // 1 2 % 3 // 2 -4 % 2 // -0 5.5 % 2 // 1.5

## Exponentiation (**)

**This is an experimental technology, part of the ECMAScript 2016 (ES7) proposal.**

Because this technology's specification has not stabilized, check the compatibility table for usage in various browsers. Also note that the syntax and behavior of an experimental technology is subject to change in future version of browsers as the spec changes.

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)`

.

### Syntax

Operator: var1 ** var2

### Notes

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.

### 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

## 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 returns the value before incrementing.
- If used prefix with operator before operand (for example, ++x), then it 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 (for example, x--), then it returns the value before decrementing.
- If used prefix (for example, --x), then it 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 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

## Specifications

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 |

## Browser compatibility

Feature | Chrome | Firefox (Gecko) | Internet Explorer | Opera | Safari |
---|---|---|---|---|---|

Basic support | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) |

Exponentiation operator | 52.0 | Nightly build |
? | ? | ? |

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 | Nightly build |
? | ? | ? | 52.0 |

## See also

## License

© 2016 Mozilla 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