# (JavaScript Tutorials for Beginners)

In this end-to-end example, you will learn – JavaScript tutorials for Beginners -JavaScript Operators.

# JavaScript Operators

#### In this tutorial, you will learn about different operators available in JavaScript and how to use them with the help of examples.

## What is an Operator?

In JavaScript, an operator is a special symbol used to perform operations on operands (values and variables). For example,

`2 + 3; // 5`

Here `+`

is an operator that performs addition, and `2`

and `3`

are operands.

## JavaScript Operator Types

Here is a list of different operators you will learn in this tutorial.

- Assignment Operators
- Arithmetic Operators
- Comparison Operators
- Logical Operators
- Bitwise Operators
- String Operators
- Other Operators

## JavaScript Assignment Operators

Assignment operators are used to **assign** values to variables. For example,

`let x = 5;`

Here, the `=`

operator is used to assign value `5`

to variable `x`

.

Here’s a list of commonly used assignment operators:

Operator | Name | Example |
---|---|---|

`=` |
Assignment operator | `a = 7; // 7` |

`+=` |
Addition assignment | `a += 5; // a = a + 5` |

`-=` |
Subtraction Assignment | `a -= 2; // a = a - 2` |

`*=` |
Multiplication Assignment | `a *= 3; // a = a * 3` |

`/=` |
Division Assignment | `a /= 2; // a = a / 5` |

`%=` |
Remainder Assignment | `a %= 2; // a = a % 2` |

`**=` |
Exponentiation Assignment | `a **= 2; // a = a^2` |

**Note:** The commonly used assignment operator is `=`

. You will understand other assignment operators such as `+=`

, `-=`

, `*=`

etc. once we learn arithmetic operators.

## JavaScript Arithmetic Operators

Arithmetic operators are used to perform **arithmetic calculations**. For example,

`let number = 3 + 5; // 8`

Here, the `+`

operator is used to add two operands.

Operator | Name | Example |
---|---|---|

`+` |
Addition | `x + y` |

`-` |
Subtraction | `x - y` |

`*` |
Multiplication | `x * y` |

`/` |
Division | `x / y` |

`%` |
Remainder | `x % y` |

`++` |
Increment (increments by 1) | `++x` or `x++` |

`--` |
Decrement (decrements by 1) | `--x` or `x--` |

`**` |
Exponentiation (Power) | `x ** y` |

### Example 1: Arithmetic operators in JavaScript

```
let x = 5;
let y = 3;
// addition
console.log('x + y = ', x + y);
// subtraction
console.log('x - y = ', x - y);
// multiplication
console.log('x * y = ', x * y);
// division
console.log('x / y = ', x / y);
// remainder
console.log('x % y = ', x % y);
// increment
console.log('++x = ', ++x); // x is now 6
console.log('x++ = ', x++); // x returns 6 and then increases by 1
console.log('x = ', x);
// decrement
console.log('--x = ', --x); // x is now 6
console.log('x-- = ', x--); // x returns 6 and then increases by 1
console.log('x = ', x);
//exponentiation
console.log('x ** y =', x ** y);
```

**Output**

x + y = 8 x - y = 2 x * y = 15 x / y = 1.6666666666666667 x % y = 2 ++x = 6 x++ = 6 x = 7 --x = 6 x-- = 6 x = 5 x ** y = 125

**Note**: The ** operator was introduced in EcmaScript 2016. And, some browsers may not support the exponentiation operator. To learn more, visit JavaScript exponentiation browser support.

## JavaScript Comparison Operators

Comparison operators **compare** two values and return a boolean value, either `true`

or `false`

. For example,

```
let a = 3, b = 2;
console.log(a > b); // true
```

Here, the comparison operator `>`

is used to compare whether `a` is greater than `b`.

Operator | Description | Example |
---|---|---|

`==` |
Equal to: returns `true` if the operands are equal |
`x == y` |

`!=` |
Not equal to: returns `true` if the operands are not equal |
`x != y` |

`===` |
Strict equal to: `true` if the operands are equal and of the same type |
`x === y` |

`!==` |
Strict not equal to: `true` if the operands are equal but of different type or not equal at all |
`x !== y` |

`>` |
Greater than: `true` if left operand is greater than the right operand |
`x > y` |

`>=` |
Greater than or equal to: `true` if left operand is greater than or equal to the right operand |
`x >= y` |

`<` |
Less than: `true` if the left operand is less than the right operand |
`x < y` |

`<=` |
Less than or equal to: `true` if the left operand is less than or equal to the right operand |
`x <= y` |

### Example 2: Comparison operators in JavaScript

```
// equal operator
console.log(2 == 2); // true
console.log(2 == '2'); // true
// not equal operator
console.log(3 != 2); // true
console.log('hello' != 'Hello'); // true
// strict equal operator
console.log(2 === 2); // true
console.log(2 === '2'); // false
// strict not equal operator
console.log(2 !== 2'); // false
console.log(2 !== '2'); // true
```

**Output**

true true true true true false false true

Comparison operators are used in decision making and loops. You will learn about the use of comparison operators in detail in the later tutorials.

### JavaScript Logical Operators

Logical operators perform logical operations and return a boolean value, either `true`

or `false`

. For example,

```
let x = 5, y = 3;
(x < 6) && (y < 5); // true
```

Here, `&&`

is a logical operator **AND**. Since both `x < 6`

and `y < 5`

are `true`

, the result is `true`

.

Operator | Description | Example |
---|---|---|

`&&` |
Logical AND: `true` if both the operands are `true` , else returns `false` |
`x && y` |

`||` |
Logical OR: `true` if either of the operands is `true` ; returns false if both are `false` |
`x || y` |

`!` |
Logical NOT: `true` if the operand is `false` and vice-versa. |
`!x` |

### Example 3: Logical Operators in JavaScript

```
// logical AND
console.log(true && true); // true
console.log(true && false); // false
// logical OR
console.log(true || false); // true
// logical NOT
console.log(!true); // false
```

**Output**

true false true false

Logical operators are used in decision making and loops. You will learn about the use of logical operators in detail in the later tutorials.

### JavaScript Bitwise Operators

Bitwise operators perform operations on binary representations of numbers.

Operator | Description |
---|---|

`&` |
Bitwise AND |

`|` |
Bitwise OR |

`^` |
Bitwise XOR |

`~` |
Bitwise NOT |

`<<` |
Left shift |

`>>` |
Sign-propagating right shift |

`>>>` |
Zero-fill right shift |

Bitwise operators are rarely used in everyday programming. If you are interested, visit *JavaScript Bitwise Operators* to learn more.

### JavaScript String Operators

In JavaScript, you can also use the `+`

operator to concatenate (join) two or more strings.

### Example 4: String operators in JavaScript

```
// concatenation operator
console.log('hello' + 'world');
let a = 'JavaScript';
a += ' tutorial'; // a = a + ' tutorial';
console.log(a);
```

**Output**

helloworld JavaScript tutorial

**Note:** When `+`

is used with strings, it performs concatenation. However, when `+`

is used with numbers, it performs addition.

### Other JavaScript Operators

For the sake of completeness, here’s a list of other operators available in JavaScript. You will learn about these operators in the later tutorials.

Operator | Description | Example |
---|---|---|

`,` |
evaluates multiple operands and returns the value of the last operand. | `let a = (1, 3 , 4); // 4` |

`?:` |
returns value based on the condition | `(5 > 3) ? 'success' : 'error'; // "success"` |

`delete` |
deletes an object’s property, or an element of an array | `delete x` |

`typeof` |
returns a string indicating the data type | `typeof 3; // "number"` |

`void` |
discards the expression’s return value | `void(x)` |

`in` |
returns `true` if the specified property is in the object |
`prop in object` |

`instanceof` |
returns `true` if the specified object is of of the specified object type |
`object instanceof object_type` |

Disclaimer: The information and code presented within this recipe/tutorial is only for educational and coaching purposes for beginners and developers. Anyone can practice and apply the recipe/tutorial presented here, but the reader is taking full responsibility for his/her actions. The author (content curator) of this recipe (code / program) has made every effort to ensure the accuracy of the information was correct at time of publication. The author (content curator) does not assume and hereby disclaims any liability to any party for any loss, damage, or disruption caused by errors or omissions, whether such errors or omissions result from accident, negligence, or any other cause.The information presented here could also be found in public knowledge domains.

# Learn by Coding: v-Tutorials on Applied Machine Learning and Data Science for Beginners

Latest end-to-end Learn by Coding Projects (Jupyter Notebooks) in Python and R:

**All Notebooks in One Bundle: Data Science Recipes and Examples in Python & R****. **

**End-to-End Python Machine Learning Recipes & Examples.**

**End-to-End R Machine Learning Recipes & Examples.**

**Applied Statistics with R for Beginners and Business Professionals**

**Data Science and Machine Learning Projects in Python: Tabular Data Analytics**

**Data Science and Machine Learning Projects in R: Tabular Data Analytics**

**Python Machine Learning & Data Science Recipes: Learn by Coding**

**R Machine Learning & Data Science Recipes: Learn by Coding**

**Comparing Different Machine Learning Algorithms in Python for Classification (FREE)**

There are 2000+ End-to-End Python & R Notebooks are available to build **Professional Portfolio as a Data Scientist and/or Machine Learning Specialist**. All Notebooks are only $29.95. We would like to request you to have a look at the website for FREE the end-to-end notebooks, and then decide whether you would like to purchase or not.