Curriculum

Course: JavaScript Basic

Curriculum

JavaScript Basic

JSHome

0/216

JS Versions

0/36

JS Objects

0/15

JS Funtions

0/22

JS Classes

0/3

JS Async

0/10

JS HTML DOM

0/25

JS Browser BOM

0/17

JS Web APIs

0/7

JS AJAX

0/11

JS JSON

0/16

JS vs jQuery

0/4

JS Graphics

0/7

Text lesson

JS Operators

JavaScript operators are employed for a variety of mathematical and logical computations.

Examples:

The Assignment Operator = assigns values
The Addition Operator + adds values
The Multiplication Operator * multiplies values
The Comparison Operator > compares values

JavaScript Assignment

The assignment operator (=) is used to assign a value to a variable.

Assignment Examples

let x = 10;

// Assign the value 5 to x
let x = 5;
// Assign the value 2 to y
let y = 2;
// Assign the value x + y to z:
let z = x + y;

JavaScript Addition

The Addition Operator (+) adds numbers:

Adding

let x = 5;
let y = 2;
let z = x + y;

JavaScript Multiplication

The multiplication operator (*) performs multiplication on numbers.

Multiplying

let x = 5;
let y = 2;
let z = x * y;

Types of JavaScript Operators

JavaScript encompasses various operator types:

Arithmetic Operators
Assignment Operators
Comparison Operators
String Operators
Logical Operators
Bitwise Operators
Ternary Operators
Type Operators

JavaScript Arithmetic Operators

Arithmetic Operators facilitate numerical calculations.

Arithmetic Operators Example

let a = 3;
let x = (100 + 50) * a;

Operator	Description
+	Addition
–	Subtraction
*	Multiplication
**	Exponentiation (ES2016)
/	Division
%	Modulus (Division Remainder)
++	Increment
—	Decrement

JavaScript Assignment Operators

Assignment operators in JavaScript are responsible for assigning values to variables.

For example, the Addition Assignment Operator (+=) adds a value to a variable.

Assignment

let x = 10;
x += 5;

Operator	Example	Same As
=	x = y	x = y
+=	x += y	x = x + y
-=	x -= y	x = x – y
*=	x *= y	x = x * y
/=	x /= y	x = x / y
%=	x %= y	x = x % y
**=	x **= y	x = x ** y

JavaScript Comparison Operators

Operator	Description
==	equal to
===	equal value and equal type
!=	not equal
!==	not equal value or not equal type
>	greater than
<	less than
>=	greater than or equal to
<=	less than or equal to
?	ternary operator

JavaScript String Comparison

Each of the comparison operators listed can also be applied to strings.

Example

let text1 = “A”;
let text2 = “B”;
let result = text1 < text2;

It’s important to note that when comparing strings, they are compared alphabetically.

Example

let text1 = “20”;
let text2 = “5”;
let result = text1 < text2;

JavaScript String Addition

The plus symbol (+) can also concatenate strings, in addition to adding numerical values.

Example

let text1 = “John”;
let text2 = “Doe”;
let text3 = text1 + ” “ + text2;

The += assignment operator can also be employed for string concatenation.

Example

let text1 = “What a very “;
text1 += “nice day”;

The result of text1 will be:

What a very nice day

Note:

The + operator is referred to as the concatenation operator when applied to strings.

Adding Strings and Numbers

When you add two numbers together, the result is their sum, but when you add a number and a string, the result is a string.

let x = 5 + 5;
let y = “5” + 5;
let z = “Hello” + 5;

The outcome of x, y, and z will be:

10
55
Hello5

Note:

When you combine a number and a string, the outcome will be a string!

JavaScript Logical Operators

Operator	Description
&&	logical and
\|\|	logical or
!	logical not

JavaScript Type Operators

Operator	Description
typeof	Provides the data type of a variable.
instanceof	Returns true if an object belongs to a particular object type.

JavaScript Bitwise Operators

Bit operators operate on 32-bit numbers.

Any numeric operand involved in the operation is first converted into a 32-bit number. Subsequently, the result is converted back into a JavaScript number.

Operator	Description	Example	Same as	Result	Decimal
&	AND	5 & 1	0101 & 0001	0001	1
\|	OR	5 \| 1	0101 \| 0001	0101	5
~	NOT	~ 5	~0101	1010	10
^	XOR	5 ^ 1	0101 ^ 0001	0100	4
<<	left shift	5 << 1	0101 << 1	1010	10
>>	right shift	5 >> 1	0101 >> 1	0010	2
>>>	unsigned right shift	5 >>> 1	0101 >>> 1	0010	2

The examples demonstrate bitwise operator behavior with 4-bit unsigned numbers.

However, JavaScript employs 32-bit signed integers. Hence, when the bitwise NOT operator (~) is applied to 5 in JavaScript, it yields -6, not 10.

In binary, 5 is 00000000000000000000000000000101. After negation, it becomes 11111111111111111111111111111010, representing -6 in two’s complement notation.