# learn javascript in hindi | Arithmetic Operators

## Arithmetic Operators in JavaScript

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.

### 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 (**)

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

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

### 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 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 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
``````
{"ft_lang_label":"__label__en","ft_lang_prob":0.5997942,"math_prob":0.9866411,"size":5601,"snap":"2023-14-2023-23","text_gpt3_token_len":1550,"char_repetition_ratio":0.15186708,"word_repetition_ratio":0.051282052,"special_character_ratio":0.32083556,"punctuation_ratio":0.11724138,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9947175,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-03-27T13:08:16Z\",\"WARC-Record-ID\":\"<urn:uuid:1cc05b90-6c90-4132-8960-52eaf01218a4>\",\"Content-Length\":\"107369\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:a230c7f0-31c4-4ad0-b15a-4e12d1c82f08>\",\"WARC-Concurrent-To\":\"<urn:uuid:96eb8d30-8a9a-4bbe-83e6-7070e2cb6ad2>\",\"WARC-IP-Address\":\"82.180.167.82\",\"WARC-Target-URI\":\"https://projectworlds.in/tutorials/learn-javascript-in-hindi/learn-javascript-in-hindi-arithmetic-operators/\",\"WARC-Payload-Digest\":\"sha1:HM4BEEH7GVBCLTBNRKCERLJ7RHOZLIQG\",\"WARC-Block-Digest\":\"sha1:OHFCNS5CGHBGYTWDACTF3CD5RJOC7FJD\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-14/CC-MAIN-2023-14_segments_1679296948632.20_warc_CC-MAIN-20230327123514-20230327153514-00009.warc.gz\"}"}