# PROWAREtech

articles » current » javascript » tutorial » page-06

## JavaScript: Tutorial - A Guide to JavaScript - Page 06

Language Basics (Operators: Subtract, Multiplicative: Divide, Modulus, Multiply).

#### Subtract Operator

The subtract operator is a minus sign (`-`).

``````var result = 5 - 3;

The subtract operator has special rules in dealing with the variety of type conversions present in JavaScript. If the two operands are numbers then perform arithmetic subtract and return the result. If either operand is `NaN` then the result is `NaN`. If `Infinity` is subtracted from `Infinity` then the result is `NaN`. If `–Infinity` is subtracted from `–Infinity` then the result is `NaN`. If `–Infinity` is subtracted from `Infinity`then the result is `Infinity`. If `Infinity` is subtracted from `–Infinity` then the result is `–Infinity`. If +0 is subtracted from +0 then the result is +0. If –0 is subtracted from +0 then the result is –0. If –0 is subtracted from –0 then the result is +0. If either operand is a string, a Boolean, `null`, or `undefined` then it is converted to a number and the arithmetic is calculated using these rules. If the conversion results in NaN, the result of the subtraction is NaN. If either operand is an object then its `valueOf()` method is called to retrieve a numeric value to represent it. If that value is `NaN`, the result of the subtraction is `NaN`. If the object does not have `valueOf()` defined, `toString()` is called and the resulting string is converted into a number.

``````var v1 = 4 - true;	// 3 because true is converted to 1
var v2 = 5 - false; // 5 because false is converted to 0
var v3 = NaN - 1;	 // NaN
var v4 = 3 - 5;	 // -2
var v5 = 6 - "";	// 6 because "" is converted to 0
var v6 = 6 - "1";	 // 5 because "1" is converted to 1
var v7 = 6 - null;	// 6 because null is converted to 0``````

### Multiplicative Operators

There are three multiplicative operators: divide, modulus and multiply. If either operand in a multiplication operation is not a number then it is converted to a number behind the scenes using the `Number()` casting function. This means that an empty string is treated as 0, and the Boolean value of `true` is treated as 1.

#### Divide

The divide operator is a slash (`/`) and divides the first operand by the second.

``````var result = 55 / 10;

The divide operator has special behaviors for special values. If the operands are numbers then regular arithmetic division is performed. Two positives or two negatives equal a positive. Operands with different signs results in a negative. If the result can not be represented then it returns either `Infinity` or `–Infinity`. If either operand is `NaN` then the result is `NaN`. If `Infinity` is divided by `Infinity`, the result is `NaN`. If zero is divided by zero then the result is `NaN`. If a non-zero finite number is divided by zero then the result is either Infinity or –Infinity. If Infinity is divided by any number then the result is either Infinity or –Infinity. If either operand is not a number then it is converted to a number behind the scenes using `Number()` and then these other rules are applied.

#### Modulus

The modulus operator (remainder operator) is a percent sign (`%`).

``````var result = 16 % 5;

The modulus operator behaves differently for special values. If the operands are numbers then regular arithmetic division is performed. The remainder of the division is returned. If the dividend is an infinite number and the divisor is a finite number then the result is `NaN`. If the dividend is a finite number and the divisor is 0 then the result is `NaN`. If `Infinity` is divided by `Infinity`, the result is `NaN`. If the dividend is a finite number and the divisor is an infinite number, the result is the dividend. If the dividend is zero and the divisor is non-zero then the result is zero. If either operand is not a number then it is converted to a number behind the scenes using `Number()` and then the these rules are applied.

#### Multiply

The multiply operator is an asterisk (`*`) and multiplies two numbers.

``````var result = 3 * 5;
The multiply operator behaves differently for special values. If the operands are numbers then regular arithmetic multiplication is performed. Two positives or two negatives equal a positive. Operands with different signs result in a negative. If the result cannot be represented, either `Infinity` or `–Infinity` is returned. If either operand is `NaN` then the result is `NaN`. If `Infinity` is multiplied by 0 then the result is `NaN`. If `Infinity` is multiplied by a finite number other than 0, the result is either `Infinity` or `–Infinity`. If `Infinity` is multiplied by `Infinity` then the result is `Infinity`. If either operand is not a number then it is converted to a number behind the scenes using `Number()` and then these rules are applied.