JavaScript Operators
Hello there, JavaScript enthusiasts! Today, we’re going to dive into the world of JavaScript Operators. Buckle up, because we’re about to embark on a journey of discovery and learning!
Table of Contents
Introduction to JavaScript Operators
JavaScript operators are the building blocks of any JavaScript program. They’re like the verbs of the JavaScript language, performing actions on our data, or as we call them in the programming world, operands. But why are they so important? Well, without operators, we wouldn’t be able to do much with our data. So, let’s get started!
JavaScript Arithmetic Operators
Arithmetic operators in JavaScript are used to perform mathematical operations on numbers. These include addition (+), subtraction (), multiplication (*), division (/), and modulus (%), among others.
Operator  Description  Example 

+  Addition  5 + 10 = 15 
–  Subtraction  10  5 = 5 
*  Multiplication  5 * 10 = 50 
/  Division  10 / 5 = 2 
%  Modulus (Remainder)  10 % 3 = 1 
For instance, let’s look at a simple addition operation:
let a = 5;
let b = 10;
let sum = a + b; // 15
console.log(sum);
JavaScriptIn this example, +
is the arithmetic operator that adds the values of a
and b
.
JavaScript Assignment Operators
Assignment operators in JavaScript are used to assign values to variables. The most common assignment operator is =
.
However, JavaScript also provides other assignment operators such as +=
, =
, *=
, and /=
, which are shorthand for operations that combine arithmetic and assignment.
Operator  Description  Example 

=  Assigns value to variable  let a = 5; 
+=  Adds and assigns value  a += 5; // a = a + 5 > a = 10 
=  Subtracts and assigns value  a = 2; // a = a  2 > a = 8 
*=  Multiplies and assigns value  a *= 3; // a = a * 3 > a = 24 
/=  Divides and assigns value  a /= 4; // a = a / 4 > a = 6 
Here’s an example of the +=
operator:
let a = 5;
a += 10; // a = a + 10 > a = 15
console.log(a);
JavaScriptJavaScript Comparison Operators
Comparison operators are used to compare two values. These operators include ==
(equal to), !=
(not equal to), ===
(strictly equal to), !==
(strictly not equal to), >
(greater than), <
(less than), >=
(greater than or equal to), and <=
(less than or equal to).
Operator  Description  Example 

==  Equal to  5 == "5" // true 
!=  Not equal to  5 != "6" // true 
===  Strictly equal to  5 === "5" // false 
!==  Strictly not equal to  5 !== "5" // true 
>  Greater than  10 > 5 // true 
<  Less than  5 < 10 // true 
>=  Greater than or equal to  10 >= 10 // true 
<=  Less than or equal to  5 <= 10 // true 
Here’s an example of the ==
operator:
let a = 5;
let b = "5";
console.log(a == b); // true
JavaScriptIn this example, ==
checks if the values of a
and b
are equal, and it returns true
because it does not check the data type.
JavaScript Logical Operators
Logical operators are used to determine the logic between variables or values. JavaScript includes three logical operators: &&
(and), 
(or), and !
(not).
Operator  Description  Example 

&&  Logical AND  (5 > 3) && (10 > 5) // true 
  Logical OR  (2 > 3)  (10 > 5) // False 
!  Logical NOT  !(5 > 10) // true 
Here’s an example of the &&
operator:
let a = 5;
let b = 10;
console.log(a < 10 && b > 5); // true
JavaScriptIn this example, &&
checks if both conditions are true. If they are, it returns true
.
JavaScript String Operators
The +
operator can also be used to concatenate (join) two string values:
let greeting = "Hello, " + "world!";
console.log(greeting); // "Hello, world!"
JavaScriptJavaScript Bitwise Operators
Bitwise operators treat their operands as a sequence of 32 bits (zeros and ones), rather than as decimal, hexadecimal, or octal numbers. For example, the binary bitwise AND operator (&
) returns a one in each bit position where the corresponding bits of both operands are ones.
Operator  Description  Example 

&  Bitwise AND  5 & 1 // 1 
  Bitwise OR  5  1 // 5 
^  Bitwise XOR  5 ^ 1 // 4 
~  Bitwise NOT  ~ 5 // 6 
<<  Left shift  5 << 1 // 10 
>>  Right shift  5 >> 1 // 2 
>>>  Zerofill right shift  5 >>> 1 // 2 
let a = 5; // binary: 0101
let b = 3; // binary: 0011
console.log(a & b); // binary: 0001, decimal: 1
JavaScriptJavaScript Ternary Operator (?:)
The ternary operator is a shortcut for the if
statement. It’s composed of three parts: a condition, a result for a true comparison, and a result for a false comparison. Here’s how it looks:
let age = 15;
let beverage = (age >= 21) ? "Beer" : "Juice";
console.log(beverage); // "Juice"
JavaScriptIn this example, if the age
is greater than or equal to 21, beverage
is assigned the value “Beer”. Otherwise, it’s assigned the value “Juice”.
Absolutely! Here are the new sections:
JavaScript Increment and Decrement Operators
Increment and decrement operators are used to increase or decrease a variable’s value by 1.
Operator  Description  Example 

++  Increment  let a = 5; a++; // a = 6 
—  Decrement  let b = 5; b; // b = 4 
Code Example:
let a = 5;
console.log(a++); // 5
console.log(a); // 6
let b = 5;
console.log(b); // 5
console.log(b); // 4
JavaScriptIn this example, a++
increments the value of a
by 1 after the current statement is executed, while b
decrements the value of b
by 1 after the current statement is executed.
JavaScript Exponentiation Operator
The exponentiation operator (**
) is used to raise the first operand to the power of the second operand.
Operator  Description  Example 

**  Exponentiation  5 ** 2 // 25 
Code Example:
let base = 5;
let exponent = 2;
console.log(base ** exponent); // 25
JavaScriptIn this example, 5 ** 2
raises 5 to the power of 2, resulting in 25.
JavaScript Operator Examples
Let’s put everything together with a couple of complete JavaScript code examples.
Example 1:
let a = 5, b = 10, c = 15, d = 20;
// Arithmetic Operators
console.log(a + b); // 15
console.log(d  c); // 5
// Assignment Operators
a += b; // a = a + b > a = 15
console.log(a); // 15
// Comparison Operators
console.log(a == b); // false
console.log(a != b); // true
// Logical Operators
console.log(a > b && c < d); // false
// String Operators
let greeting = "Hello, " + "world!";
console.log(greeting); // "Hello, world!"
// Bitwise Operators
console.log(a & b); // 0
// Ternary Operator
let age = 18;
let status = (age >= 18) ? 'adult' : 'minor';
console.log(status); // "adult"
JavaScriptExample 2:
let x = 7, y = 14, z = 21, w = 28;
// Arithmetic Operators
console.log(x * y); // 98
console.log(w / z); // 1.3333333333333333
// Assignment Operators
x *= y; // x = x * y > x = 98
console.log(x); // 98
// Comparison Operators
console.log(x === y); // false
console.log(x !== y); // true
// Logical Operators
console.log(x < y  z > w); // true
// String Operators
let welcome = "Welcome to " + "JavaScript!";
console.log(welcome); // "Welcome to JavaScript!"
// Bitwise Operators
console.log(y & z); // 4
// Ternary Operator
let score = 85;
let grade = (score > 90) ? 'A' : 'B';
console.log(grade); // "B"
JavaScriptWrapping Up
Understanding JavaScript operators is crucial for writing effective JavaScript code. They allow us to perform operations on our data and make decisions based on certain conditions. Remember, practice makes perfect. So, keep coding and have fun!
Frequently Asked Questions (FAQ)

What are the 7 most common JavaScript operators?
The seven most common JavaScript operators are
+
(addition),
(subtraction),*
(multiplication),/
(division),=
(assignment),==
(equality), and!=
(inequality). 
What are the 4 types of JavaScript operators?
The four types of JavaScript operators are Arithmetic Operators (
+
,
,*
,/
), Assignment Operators (=
,+=
,=
,*=
,/=
), Comparison Operators (==
,!=
,===
,!==
,>
,<
,>=
,<=
), and Logical Operators (&&
,
,!
). 
What are all 5 types of operators that the JavaScript supports?
JavaScript supports Arithmetic, Assignment, Comparison, Logical, and Bitwise operators.

How does the JavaScript ternary operator work?
The ternary operator is a shortcut for the
if
statement. It’s composed of three parts: a condition, a result for a true comparison, and a result for a false comparison. For example,let result = (a > b) ? 'a is greater' : 'b is greater';

What is the difference between
==
and===
in JavaScript?==
is the equality operator that performs type coercion if the types of the two variables being compared are different.===
is the strict equality operator that does not perform type coercion, meaning it checks both the value and the type. 
How do JavaScript bitwise operators work?
Bitwise operators treat their operands as a sequence of 32 bits (zeros and ones), rather than as decimal, hexadecimal, or octal numbers. For example, the binary bitwise AND operator (
&
) returns a one in each bit position where the corresponding bits of both operands are ones. 
Can the
+
operator be used with strings in JavaScript?Yes, the
+
operator can be used to concatenate (join) two string values in JavaScript. 
What is the purpose of assignment operators in JavaScript?
Assignment operators in JavaScript are used to assign values to variables. They can also perform an operation on the value of the variable and then assign the result to the same variable.

How do JavaScript logical operators work?
JavaScript logical operators are used to determine the logic between variables or values. The
&&
operator returns true if both conditions are true. The
operator returns true if at least one condition is true. The!
operator returns the opposite of the condition. 
Can I use operators with nonnumeric data in JavaScript?
Yes, certain operators can be used with nonnumeric data in JavaScript. For example, the
+
operator can be used to concatenate strings, and comparison operators can be used to compare strings based on lexicographic (dictionary) order.
Related Tutorials
 JavaScript Arithmetic Operators
 JavaScript Logical Operators
 JavaScript Comparison Operators
 JavaScript Type Conversion
 JavaScript Control Structures
 JavaScript Loops
 JavaScript Functions
 JavaScript Events
That’s all, folks! Keep coding and exploring the wonderful world of JavaScript. Remember, the key to mastering JavaScript, or any programming language for that matter, is consistent practice and neverending curiosity. Happy coding!