suppose we have x=5,
== is equal to
x==8 is false
x==5 is true
=== is exactly equal to (value and type)
x===5 is true
x==="5" is false
Hope you understand this concept
(or)
|
=== checks for the same type as well. You'll understand with a few examples:
(1 == '1') //Returns true
Since == doesn't bother with types, that returns true. However, if you want strict type checking, you'd use === because that returns true only if the it's of the same type, and is the same value.
(1 === '1') //Returns false
(1 === 1) //Returns true
- Two strings are strictly equal when they have the same sequence of
characters, same length, and same characters in corresponding
positions.
- Two numbers are strictly equal when they are numerically equal (have the same number value). NaN is not equal to anything,
including NaN. Positive and negative zeros are equal to one another.
- Two Boolean operands are strictly equal if both are true or both are false.
- Two objects are strictly equal if they refer to the same Object.
- Null and Undefined types are == (but not ===).
|
(or)
== is just comparing the two values, and if they are of different types, type conversion is done
=== compares the values and well as their types - so no type conversion will be done here.
(or)
up vote
5
down vote
accepted
==
attempts to convert the values to the same type before testing if they're the same. "5" == 5
===
does not do this; it requires objects to be of the same type to be equal. "5" !== 5
In this case, the result is:
x == undefined
will be true if x
is undefined
or null
.
x === undefined
will only be true if x
is undefined
.
You should prefer the first method if you'd like undefined and null
to be treated equivalently. One common use of this is optional function
arguments.
function greet(name, greeting) {
if (name == undefined) name = 'World';
if (greeting == undefined) greeting = 'Hello';
alert(greeting + ' ' + name);
}
greet(); // alerts "Hello World"
greet("Bob"); // alerts "Hello Bob"
No comments:
Post a Comment