OPERATORS IN JAVASCRIPT
Operators
JavaScript language supports following type of operators.
01 02 03 04
Arithmetic
Comparision Operators Logical Operators Assignment Operators
Operators
Arithmetic Operators
Assume variable A holds 10 and variable B holds 20 then :
Operator Description Example
+ Adds two operands A + B will give 30
- Subtracts second operand from the first A - B will give -10
* Multiply both operand A * B will give 200
/ Divide numerator by denominator B/A will give 2
% Modulus Operator and remainder of after an integer division B%A will give 0
++ Increment operator, increases integer value by one A++ will give 11
-- Decrement operator, decreases integer value by one A-- will give 9
Comparison Operators
Given that x=5, the table below explains the comparison operator:
:
Operator Description Example
== Is equal to x==8 false x==5 true
=== Is exactly equal to(value and type) x===“5” false x===5 true
!= Is not equal x != 8 true
!== Is not equal (either value or type) x !==“5” true x!==5 false
> Is greater than x>8 false
< Is less than x<8 true
>= Is greater than or equal to x>=8 false
<= Is less than or equal to x<=8 true
Logical Operators
Logical operators are used to determine the logic between variables or values.
Given that x=6 and y=3, the table below explains the logical operators:
Operator Description Example
&& AND (x < 10 && y > 1) is true
|| OR (x==5 || y==5) is false
! NOT !(x==y) is true
Assignment Operators
Assignment operators are used to assign values to JavaScript variables.
Given that x=10 and y=5, the table below explains the assignment operators:
Operator Example Same As Result
= x=y x=5
+= x+=y x=x+y x=15
-= x-=y x=x-y x=5
*= x*=y x=x*y x=50
/= x/=y x=x/y x=2
%= x%=y x=x%y x=0
The typeof Operator
In JS, the typeof operator returns the data type of its operand in the form of a string.
Operand can be variables , expressions and even objects.
Syntax Examples
typeof operand console.log(typeof 42);
OR // output: "number“
typeof (operand) console.log(typeof ‘bhopal');
// output: "string“
console.log(typeof true);
// output: "boolean“
console.log(typeof (3+4));
// output: “number"
Some More Examples
Examples
console.log(typeof (3.4));
// output: "number"
var myCar;
console.log(typeof myCar);
// output: "undefined "
var myBike= " ";
console.log(typeof myBike); This is considered to
// output: "string“ be a bug within JS as
it is expected that null
var myBicycle=null; itself is a data type.
More on this:https://2ality.com/
console.log(typeof myBicycle); 2013/10/typeof-null.html
// output: "object"
Type Conversion & Type Coercion
Like other languages , JS, also allows a programmer to convert a variable/value from
one type to another.
This is called Type Conversion.
On the other hand if this conversion is done by JS itself , then we call it as
Type Coercion
Converting Values To String
To convert a value to a string , JS provides 2 ways:
1. Using the global function called String( )
2. Using the method toString( ) on the value to be converted
Syntax Of String( )
String (value to be converted)
Syntax Of toString( )
value.toString( )
Examples Of String Conversion
Basic Examples Some Special Examples
String(10) String(null) Remember , that the
//"10" //"null" method toString()
doesn’t work with null
(10).toString() String(undefined) and undefined types .
//"10" //"undefined“ Although it works with
NaN
String(true) String(NaN)
//"true" //"NaN”
true.toString() NaN.toString()
//"true" //"NaN”
String(false)
//"false"
false.toString()
//"false”
Converting Values To Number
To convert a value to a number , JS provides 3 ways:
Remember , that
1. Using the global function called Number( ) parseInt(),
2. Using the function parseInt( ) or parseFloat( ) parseFloat() can
only
3. Using the method Math.floor( ) be used to convert
String values to
Syntax Of Number( ) number and not for
Number (value to be converted) boolean values
Syntax Of parseInt( )
parseInt (value to be converted)
Syntax Of parseFloat( )
parseFloat (value to be converted)
Syntax Of Math.floor( )
Math.floor(value to be converted)
Examples Of Number Conversion
Basic Examples Some Special Examples
Number("1") Number("1A2")
//1 //NaN If a string contains
Remember , strings invalid characters,
Number("0") are trimmed before Number(true) the function
//0 being converted to //1 Number( ) will
number generate a NaN.
Number(" 1 ") Number(false)
//1 //0
Number("") Number(null)
//0 //0
Number("12.2") Number(undefined)
//12.2 //NaN
Examples Of Number Conversion
Basic Examples Some Special Examples
parseInt("1") parseInt("1A2")
//1 If a string contains
//1
invalid characters,
Remember , that
parseInt("0") these functions
the functions parseInt("A12")
//0 extract initial digits
parseInt() and //NaN
and return it as a
parseFloat() return
parseInt(" 1 ") number. If no initial
NaN for empty strings parseInt(true)
//1 digits are present or
//NaN
value is boolean they
parseInt("") return NaN
parseInt(false)
//NaN //NaN
parseInt("12.2") parseInt(null)
//12 //NaN
parseInt(undefined)
//NaN
Examples Of Number Conversion
Basic Examples Some Special Examples
parseFloat("1") parseFloat("1A2")
//1 //1
parseFloat ("0") parseFloat("A12")
//0 //NaN
parseFloat(" 1 ") parseFloat(true)
//1 //NaN
parseFloat("") parseFloat(false)
//NaN //NaN
parseFloat("12.2") parseFloat(null)
//12.2 //NaN
parseFloat(undefined)
//NaN
Examples Of Number Conversion
Basic Examples Some Special Examples
Math.floor("1") Math.floor("1A2") If a string contains
//1 //NaN invalid characters,
the mehod
Remember , that
Math.floor("0") Math.floor() will
like Number( )
//0 Math.floor(true) generate a NaN.
function, the method
Math.floor() also //1
Math.floor(" 1 ") returns 0 for
//1 empty string Math.floor(false)
//0
Math.floor("")
//0 Math.floor(null)
//0
Math.floor("12.2")
//12 Math.floor(undefined)
//NaN
Standard Rules Of Number Conversion
Value Becomes…
undefined NaN
null 0
true and false 1 and 0
Whitespaces from the start and end are
removed. If the remaining string is
string empty, the result is 0. Otherwise, the
number is “read” from the string. An
error gives NaN.
Converting Values To Boolean
To convert a value to a number , JS provides only 1 way:
1. Using the global function called Boolean( ) IMPORTANT POINTS:
1. Any value can be converted
to boolean passing it
to Boolean().
Syntax Of Boolean( )
Boolean(value to be converted) 2. All values will resolve
to true except
FALSY VALUES, which are
0,””,NaN,null and undefined
Examples Of Boolean Conversion
Basic Examples Some Special Examples
Boolean(10) Boolean("")
//true //false
Boolean(0) Boolean(" ")
//false //true
Boolean("bhopal") Boolean(null)
//true //false
Boolean(false) Boolean(undefined)
//false //false
Type Coercion
As discussed previously , there are some cases in JS , when it automatically converts
value of one type to another and this is called Type Coercion
The Behaviour Of Operator “+”:
If any of the operands is a string , all others are converted to string and concatenation is
done ,otherwise arithmetic addition is done.
Examples Of Type Coercion
Basic Examples Some Special Examples
10+20 true+false
//30 //1
" Good " + " Morning " true+true
// "GoodMorning" //2
true+true+""
"42"+0 //”2"
//"420"
Type Coercion
The Behaviour Of Other Arithmetic Operators:
All other arithmetic operators will try to convert their operands to number and then apply the
operation .
If conversion fails they give NaN.
Examples Of Type Coercion
Basic Examples Some Special Examples
10*20 true * false
//200 //0
" Good " * " Morning " true/false
// NaN //Infinity
"42" * 7 true%true
//294 //0
"42" - 7 "Bhopal" /10
//35 //NaN
Controlling Decimal Points
Normally JS, displays numeric values upto 16 decimal places while displaying floats ,
leaving trailing zeros.
To understand this behavior consider the following codes and their output
Example
let x=10/3;
console.log(x)
//3.3333333333333335
x=10/4;
console.log(x)
//2.5
x=3.0;
console.log(x)
//3
Controlling Decimal Points
To control this behavior , JS provides us a method called toFixed() for number type
values , which can be used to write a number with specified number of decimals
Syntax Of toFixed( )
numericValue.toFixed (some number)
Controlling Decimal Points
Example
let x=10/3;
console.log(x.toFixed(2))
//3.33
x=10/4;
console.log(x.toFixed(3))
//2.500
x=3.0;
console.log(x.toFixed(1))
//3.0
x=10/3;
console.log(x.toFixed(0))
//3
