The operators ===and are the strict!== comparison operators . This means that if the operands have different types, they are not the same. For example,

1 === "1" // false
1 !== "1"  // true
null === undefined // false

The operators ==and are the relaxed!= comparison operators . That is, if the operands have different types, JavaScript tries to convert them so that they are comparable. For example,

1 == "1" // true
1 != "1" // false
null == undefined // true

It is worth mentioning that the operator ==is not transitive , unlike ===.

"0" == 0 // true
0 == ""  // true
"0" == ""// false

It's not very easy to remember all the rules of relaxed comparison, and sometimes it works in a counterintuitive way. Therefore, I recommend using ===instead of ==.

I don't remember all the little details of the operator ==, so let's take a look at the spec, point 11.9.3:

The Abstract Equality Comparison Algorithm

The comparison x == y , where x and y are values, returns true or false . This comparison is done as follows:

1. If Type(x) and Type(y) are the same,
   1. If Type(x) is Undefined , it returns true .
   2. If Type(x) is Null , it returns true .
   3. If Type(x) is Number ,
      1. If x is NaN , it returns false .
      2. If y is NaN , return false .
      3. If x is the same value of Number as y , it returns true .
      4. If x is +0 and y is −0 , return true .
      5. If x is -0 and y is +0 , return true .
      6. Return false .
   4. If Type(x) is String , it returns true if x and y are exactly the same sequence of characters (with the same length and the same characters in the corresponding positions). Otherwise, it returns false .
   5. If Type(x) is Boolean , it returns true , if x and y are both true or both are false . Otherwise, it returns false .
   6. Returns true if x and y refer to the same object. Otherwise, it returns false .
2. If x is null and y is undefined , return true .
3. If x is undefined and y is null , return true .
4. If Type(x) is Number and Type(y) is String ,
   return the result of the comparison x == ToNumber(y) .
5. If Type(x) is String and Type(y) is Number ,
   return the result of the comparison ToNumber(x) == y .
6. If Type(x) is Boolean , return the result of the comparison ToNumber(x) == y .
7. If Type(y) is Boolean , return the result of the comparison x == ToNumber(y) .
8. If Type(x) is String or Number , and Type(y) is Object ,
   return the result of the comparison x == ToPrimitive(y) .
9. If Type(x) is Object and Type(y) is String or Number ,
   return the result of the comparison ToPrimitive(x) == y .
10. Return false .

This answer is a translation of my answer to the same question on the Russian site .

The difference is that == first tries to convert the types before comparing them. The === operator does not, it does a direct comparison although it always returns false if the types are different. source (in English)

ex:

1 == "1" // verdadero    
1 === "1" // falso
'' == 0 // verdadero
'' === 0 // falso

These graphs may help you visualize the difference:

'==' operator

Operator '==='

( source of images )

It effectively ==compares value, while ===also comparing type. For example.

"1" == 1 // true
"1" === 1 // false
null == undefined // true
null === undefined // false

You can read the technical details (in English) in Equality comparisons and sameness

undefinedis a reserved word and is used without quotes.

Not quite. It is true that the operator ===compares the type and the value, without doing conversions as the operator would ==. However that is only true for value types. In reference types, what it does is verify that it is the same object, it is not enough that it is of the same type and value. So it ===would be an identity operator, as opposed to ==.

For example:

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

a === b  // false
a === c  // true

The string case would work as a value type, unless you used the constructor String, which would be a reference type.

Also note that the operator ==is not transitive in some conversions. For example:

'' == '0'  // false
0 == ''    // true

Given the ambiguity of this operator, it is advised that the operator be used ===whenever possible.

In any case, you can take a look at this page that will resolve doubts regarding both operators. There you can check among other things that undefined == nullbut undefined !== null.

very simple

==it is equality of value and not of type.
===is equality of value and type.

 console.log("1 == '1   =>", 1 == '1')  // true
 console.log("1 === '1' =>", 1 === '1') // false, ya que uno es un string.
 console.log("1 === 1   =>", 1 === 1)   // son iguales

Your question has already been answered correctly, but I would like to make a comment on what seems to be your problem (I also started with java and there are certain things that javascript makes easy).

A variable can have 2 states, "undefined" or have something, null as in SQl is a value type, that is to say that if your variable has null it is defined and has something, nothing but something :P , undefined means that your variable has not been defined, this fact is curious especially because null == undefined responds true.

Now when you search for an element with js and you don't find it (for example document.getElementById("inpt")) its value is null, in the case that if you find it you ask for its value and if it doesn't have it it answers "" .

The interesting part is that with a simple if you solve a lot.

var una,dos = null,tres =[],cuatro = 1;

if(noexisto) //es undefinided, saca error por que estas preguntando por ella
if( typeof notoy == "undefined") //es la manera correcta de preguntar si una variable no ha sido definida
if(una)//false pero no saca error por que implicitamente tiene un null
if(una == null) //es lo mismo que la anterior
if(dos) //false pero no saca error
if(tres) //true por que contiene un array, vacio pero es algo
if("")//false por que esta vacio
if(cuatro)//tiene algo por tanto es true

In case you don't transpile your JS code (with Babel for example) the "==" operation is faster than the type check with "===" therefore if your code is going to be used many times (it is part of the architecture or some library) it is preferable to use "==" considering that you are not going to pass a type filter. In all other cases (the vast majority) it is better to use type checking with "===" to avoid unexpected results.

Let's clarify concepts:

• Every variable in JavaScript has a type and a value .

• In JavaScript there is something called coercion . Coercion is an automatic (and implicit) conversion that the JavaScript engine performs in an attempt to operate on values ​​of different types. For example:

const valor1 = '5';
const valor2 = 9;
let suma = valor1 + valor2;
console.log(suma);

Since value1 is of type string and value2 is of type number , JavaScript performs the automatic conversion of the second value in an attempt to be able to perform the sum. In this way, the value of the variable sumawill be of type string :

'59'

CONCLUSION

The operator ==compares two values ​​regardless of type. That is, it coerces and then compares. If the values ​​are the same after conversion, return the value true.

The operator ===instead returns trueonly in the case where value and type match.

Clarification: this only applies to the 6 primitive types.