===

How does people manage to work with that language?

So in JavaScript there’s the assignment

=

and the comparator is

==

Since there’s no types JS will do implicit conversion before comparison when using == in a case like this

if(false == '0'){
    //this is true
}

But with === it doesn’t. It means literally compare these

if(false === '0'){
    //this is false
}else{
    //so this will execute instead 
}

But this, however, will

var someState = false;
 if(someState === false){
    //this is true
}

> 1 == 1
true
> 1 == '1'
true
> 1 === '1'
false

(from node REPL)

Basically it's the real equals sign

The short answer is that your language needs === when it fucked up the semantics of ==, but it's also too popular and you can't fix it without breaking half the web.

It's like the ==, but there's one more =

JS's == has some gotchas and you almost never want to use it. So === is what == should have been.

All examples are true:

"1" == true
[1, 2] == "1,2" 
" " == false
null == undefined 

It isn't that insane. But some invariants that you may expect don't hold.

"" == 0
"0" == 0
"" != "0" 

It's also important if you're checking hashes (at least, it was - if you're using correct hashing algorithm that isn't ancient, you will not have this problem).

Because if you take for example "0e462097431906509019562988736854" (which is md5("240610708"), but also applicable to most other hashing algorithms that hash to a hex string), if("0e462097431906509019562988736854" == 0) is true. So any other data that hashes to any variantion of "0e[1-9]+" will pass the check, for example:

md5("240610708") == md5("hashcatqlffzszeRcrt")

that equals to

"0e462097431906509019562988736854" == "0e242700999142460696437005736231"

which thanks to scientific notation and no strict type checking can also mean

0^{462097431906509019562988736854} == 0^{242700999142460696437005736231}

which is

0 == 0 `

I did use md5 as an example because the strings are pretty short, but it's applicable to a whole lot of other hashes. And the problem is that if you use one of the strings that hash to a magic hash in a vulnerable site, it will pass the password check for any user who's password also hashes to a magic hash. There's not really a high chance of that happening, but there's still a lot of hashes that do hash to it.

== but for JavaScript. What you don't understand is the == of JavaScript.

The other comments explains it in pretty good detail, but when I was learning my teacher explained it sort of like a mnemonic.

1 + 1 = 2 is read "one plus one equals two"

1 + 1 == 2 is read "one plus one is equal to two"

1 + 1 === 2 is read "one plus one is really equal to two"

And you hit the nail on the head, is that === is type explicit while == is implicit.

You don't need Typescript, you need an linter (eslint).

=== is your basic equality like most languages. == will implicitly cast type.

The breakdown is here: https://262.ecma-international.org/5.1/#sec-11.9.3

Modern JS says to never use == unless you're comparing against null or undefined.

Like == but more strict. The == operator will do type conversion, so 0 == '' will actually be true, as an example. Sometimes (honestly, most times) you may want to compare more strictly.

See this StackOverflow answer: https://stackoverflow.com/questions/359494/which-equals-operator-vs-should-be-used-in-javascript-comparisons

People are giving you dumb or overly complicated answers. == will normalize the types between the things you're comparing

1 == '1'

=== requires the types to be the same

1 === 1

x 👈 5

:=

In Haskell, it's the same as the mathematical = symbol.

Reddit: 1+1=your muther (sic, x2)

X: 1+1≈we should violently overthrow the government

4chan: nvm, I don't want to get banned for saying this one

I also came to represent my php breathren.

Basically Java in a nutshell

it depends on what your definition of is is

classic

==    same (after magic)
===   same and same type (in Javascript)
====  same and same type and same actual type (in the backend before conversion to JSON)
===== same and same type and same actual type and same desired type (what the customer wanted)

Lol

Lolololol

It's also very language specific, like Pascal/Delphi also have ":=" for assignments and "=" for comparison, etc

What does the walrus operator do?

In javascript, === does not perform type coercion when checking for equality

Because in JS:

1 == "1" // true
1 === "1" // false