The Master of Variables does a good job of creating variables that you might need, but storing variables alone doesn’t bring you much value. Variables are static. You put something in it and it is there, waiting for something. You won’t write any useful program without modifying, manipulating the data in your variables. The world is a dynamic place, so are the programs that people write. Therefore, we, as programmers, should be able to operate on our variables in various ways.

## Meet “The Manipulator”

Can you tell whether it is true or false? Besides storing values in variables, you will need to compare and combine existing variables and values in different ways in your programs. And not always you will have variables of the same type. Different data types might seem as completely different things to compare and to operate on in real life, like *“comparing a cat and a book”* or *“adding 320 meters and $100,”* but don’t worry, as **The Manipulator** knows his job very good.

He has no trouble comparing anything you might give him and at the same time he can combine variables in various ways. Take the above example. There is a boolean, null, string, array and a number there, yet The Manipulator can do the math and the comparison. He often likes to show his smartness and ingenuity in this way.

However, a big part of his smartness resides in a small Toolbox that he carries everywhere with him and that is full of tools and tricks to perform any operation on any variable you might give to him.

Let’s dive in more details and learn how The Manipulator combines, compares and operates on variables.

## Types of operators

As there are many types of operators, we will discuss them one by one:

- Assignment operators
- Arithmetic operators
- Logical operators
- Ternary operator
- Comparison operators
- Bitwise operators
- Unary operators
- Relational operator

All these operators are either *unary* or *binary* (and there is only one *ternary* operator). We will discuss the first four in this article and the next four in the next article.

Unary operators require a single operand, either before or after the operator:

```
operator operand
// or
operand operator
```

An example of unary operator is `typeof y`

or `x++`

Binary operators require two operands, one before the operator and one after:

```
operand operator operand
```

An example of binary operator is `x + y`

.

Ternary operator requires three operands. We’ll address its structure later on in this chapter.

### Assignment operators

The assignment operator is straightforward: it assigns a value to its left operand the value of its right operand.

There are two types of assignment operators:

- simple
- compound

#### Simple Assignment Operator

The simple assignment operator is *equal* `=`

, which simply assigns the value of its right operand to its left operand.

```
var x, y;
x = 3; // `=` assigns the value 3 to x
y = x; // `=` assigns the value of x (which is 3) to y
```

#### Compound Assignment Operator

Compound assignment operators contain two operations: a simple assignment operation and one operation that modifies the right operand. The compound assignment operators are shortcuts for the following operations:

Name | Shortcut | Meaning |
---|---|---|

Addition assignment | x += y | x = x + y |

Subtraction assignment | x -= y | x = x - y |

Multiplication assignment | x *= y | x = x * y |

Division assignment | x /= y | x = x / y |

Remainder assignment | x %= y | x = x % y |

Exponentiation assignment | x **= y | x = x ** y |

Left shift assignment | x «= y | x = x « y |

Right shift assignment | x »= y | x = x » y |

Bitwise AND assignment | x &= y | x = x & y |

Bitwise OR assignment | x |= y | x = x | y |

Bitwise XOR assignment | x ^= y | x = x ^ y |

You will find the explanation of operators that are part of compound assignment operators in the following sections. As for the simple assignment operator, just remember that it assigns the value of the left operand to the right operand.

## Arithmetic operators

Arithmetic operations are fundamental to math, therefore some of these operators won’t need an in-deep analysis. There are, however, some operators that are encountered only in programming languages. There are unary and binary arithmetic operators, therefore we will address them separately.

### Binary arithmetic operators

In this context, binary means operators that have two operands and not operators that operate with 0 and 1. These operators do not need any serious introduction, as these are basic math operations. The standard arithmetic operations are addition (+), subtraction (-), multiplication (*) and division (/). Besides these operators, there is a *remainder operator (%),* that returns the remainder after division and an *exponentiation operator (**)* that raises a number to a power. Note that the exponentiation operator is an experimental feature, meaning that it may not be implemented in all browsers.

Generally speaking, the arithmetic operators take two numerical (or not!) values as their operands and return a *single numerical value*.

```
7 + 4; // 11 <- addition operator
7 - 4; // 3 <- subtraction operator
7 * 4; // 28 <- multiplication operator
7 / 4; // 1.75 <- division operator
7 % 4; // 3 <- remainder operator
```

We are accustomed to work with numerical values when using arithmetic operations, but they can be applied on other values as well. This is **The Manipulator** expressing his ingenuity and smartness, although he has quirks of his own.

For instance, whenever the operands of an arithmetic operator are not numbers, The Manipulator will automatically **convert them to numbers,** using the methods from the *group B* described in the previous chapter (using `Number`

or `+`

unary operator). Check out the type conversion chapter for a refresh on how it works.

```
3 + true; // 4
2 - false; // 2
true - 5; // -4
[3] - 1; // 2
100 * false; // 0
2 / '10'; // 0.2
null - 4; // -4
'111' - '11'; // 100
'1' - true; // 0
null + true; // 1
```

**The result of any arithmetic operation is always a number.**

**The only exception** to this rule (life would be so much simpler without all these exceptions, isn’t it? :) is the addition operator. Whenever one of the operands is a *string,* then **both operands are converted to strings** and the `+`

operator concatenates those strings.

```
'1' + 2; // '12'
1 + '2'; // '12'
'0' + true; // '0true'
false + ''; // 'false'
null + 'null'; // 'nullnull'
[1,2] + '3'; // '1,23'
```

### Unary arithmetic operators

You already know one unary arithmetic operator, the `+`

operator. And you should know how it works already. Its counterpart, the `-`

unary operator works exactly the same as the `+`

operator, but negates the resulting value.

```
-''; // -0
-true; // -1
-'123'; // -123
```

Besides these two, JavaScript has 2 more unary arithmetic operators: the increment (++) and decrement (--) operators. Unsurprisingly, they either *increment* the value by one, or *decrement* it.

You can place the unary operator *before* or *after* the operand, obtaining different results.

```
var x = 2;
var y = '5';
var a = ++x;
var b = y++;
console.log(x); // 3
console.log(y); // 6
console.log(a); // 3
console.log(b); // 5
```

Therefore, the prefix unary operator *increases the variable first, and then returns the result*.

The postfix unary operator *returns the variable first, and then increases the variable’s value*.

Note that you can’t use the increment and decrement operators on primitive values, as these operators require a variable to change:

```
++2; // ReferenceError: Invalid left-hand side expression in prefix operation
// The above is similar to the following code:
2 = 2 + 1; // You cannot assign a value to a value, hence the error.
```

When using increment and decrement unary operators, they are executed in two steps:

```
var x = 4;
var a = x--; // <- this statement is executed in the following two steps
// 1. As the decrement operator is *after* variable x, the value of x is returned
a = x; // at this point x is still 4
// 2. After the value of x is returned, it is decremented by 1
x = x - 1; // only now x is decreased, having a value of 3
console.log(x); // 3
console.log(a); // 4
var y = 7;
var b = --y; // <- this statement is executed in the following two steps
// 1. As the decrement operator is *before* the variable, its value is
// modified first
x = x - 1;
// 2. After the value is modified, it is assigned to y
b = x;
console.log(y); // 6
console.log(b); // 6
```

## Logical operators

Logical operations are at the core of computers’ way of functioning, as everything is 0 and 1 inside them and logical operators handle the operations with these values.

But logical operators are required when writing programs too, not only inside computers. There are several of them we’ll discuss here:

- Logical AND (
`&&`

) - Logical OR (
`||`

) - Logical NOT (
`!`

)

All these operators are typically used with Boolean values. However, when used with other than Boolean values, in order to perform the operation, values are converted to Boolean values according to the rules of converting [something] -> Boolean.

Another important characteristic is that the `&&`

and `||`

operators actually **return the value of one of the operands.**

### AND logical operator

The classical logical AND operator states that both `operand1`

AND `operand2`

should be true, in order for the result to be true. The following table summarizes all possible cases.

Operand 1 | Operator | Operand 2 | Result |
---|---|---|---|

false | && | false | false |

false | && | true | false |

true | && | false | false |

true | && | true | true |

However, as mentioned above, in JavaScript the AND and OR operators return one of the operands. Therefore, the rules of the AND operator in JavaScript are the following:

- if
`operand1`

can be converted to`false`

, return`operand1`

- otherwise return
`operand2`

And it’s quite logically. If the first operand will be converted to `false`

, then the result of `&&`

operator cannot be `true`

no matter what the second operand is. Conversely, if the first operand can be converted to `true`

, then the result of the `&&`

operator depends on the value of the second operand, which is being returned.

Let’s examine some specific cases:

```
var e1 = true && false; // t && f returns operand2, which is false
var e2 = false && true; // f && t returns operand1, which is false
var e3 = 2 && false; // t && f returns operand2, which is false
var e4 = 4 && ''; // t && f returns operand2, which is "" (empty string)
var e5 = null && true; // f && t returns operand1, which is null
var e6 = [1] && undefined; // t && f returns operand2, which is undefined
var e7 = true && 'zero'; // t && t returns operand2, which is "zero"
var e8 = {} && [1, 2, 3]; // t && t returns operand2, which is [1, 2, 3]
```

### OR logical operator

The classical OR operator states that either `operand1`

OR `operand2`

should be true, in order for the result to be true. The following tables summarizes all possible cases.

Operand 1 | Operator | Operand 2 | Result |
---|---|---|---|

false | || | false | false |

false | || | true | true |

true | || | false | true |

true | || | true | true |

Similarly to the AND operator, the OR operator returns one of the operands. The rules of the OR operator are the following:

- if
`operand1`

can be converted to`true`

, return`operand1`

- otherwise return
`operand2`

Let’s examine some specific cases:

```
var e1 = true && false; // t && f returns operand1, which is true
var e2 = false && true; // f && t returns operand2, which is true
var e3 = 2 && false; // t && f returns operand1, which is 2
var e4 = 4 && ''; // t && f returns operand1, which is 4
var e5 = null && true; // f && t returns operand2, which is true
var e6 = [1] && undefined; // t && f returns operand1, which is [1]
var e7 = true && 'zero'; // t && t returns operand1, which is true
var e8 = {} && [1, 2, 3]; // t && t returns operand1, which is {}
```

### NOT logical operator

The NOT operator is an unary operator that returns a boolean value no matter what type the operand is. And it negates the boolean value:

- if the operand can be converted to
`true`

, then the NOT operator returns`false`

- if the operand can be converted to
`false`

, then the NOT operator returns`true`

```
var e1 = !true; // !t returns false
var e2 = !false; // !f returns true
var e3 = !10; // !t returns false
var e4 = !0; // !f returns true
var e5 = !''; // !f returns true
var e6 = !null; // !f returns true
var e7 = ![1,2]; // !t returns false
var e8 = !{}; // !t returns false
```

By the way, do you remember one way of converting from [something] -> Boolean? The double negation `!!`

method. It first negates a value and then negates the negation, giving you the Boolean alternative to your initial value.

### Short-circuit evaluation

One interesting thing about the AND and OR operators in JavaScript is that they are tested for possible “short-circuit” evaluation. As they both are evaluated from left to right, this means that in some cases the result can be predicted from evaluating the first operand only using the following rules:

- false &&
*anything*is short-circuit evaluated to false - true ||
*anything*is short-circuit evaluated to true

The rules of logic guarantee that these evaluations are always correct. Moreover, in the above cases the *anything* expression is not evaluated, meaning that whatever you will write there will not be executed.

```
// Note that the second operands are not strings. However, the second
// operands won't even be evaluated, so no error will be thrown.
var e1 = false && абв; // e1 = false
var e2 = true || абв; // e2 = true
```

## Conditional (ternary) operator

The conditional operator is the only JavaScript operator that takes three operands. The operator returns one of two values based on a condition.

The syntax of the conditional operator is `condition ? val1 : val2`

.

If condition is `true`

, then the operator returns `val1`

, otherwise it returns `val2`

.

```
var flower = 'rose';
var color = (flower == 'rose') ? 'red' : 'blue';
console.log(color); // 'red'
```

You can also nest conditional operator to construct more complex conditions. But be aware that this can quickly become unreadable and hard to read and understand.

```
var flower = 'violet';
var color = (flower == 'rose') ? 'red' : (flower == 'violet' ? 'blue' : 'yellow');
console.log(color); // 'blue'
```

In the next article, you will find out about the comparison operators, bitwise operators, and unary and relational operators. Keep tuned!