console.time("testEquality");
var n = 0;
while (true) {
  n++;
  if (n == 100000)
    break;
}
console.timeEnd("testEquality");

---

Antwoord 7, autoriteit 2%

In PHP en JavaScript is het een strikte gelijkheidsoperator. Dat betekent dat het zowel het type als de waarden vergelijkt.

---

Antwoord 8

In JavaScript betekent dit van dezelfde waarde en hetzelfde type.

Bijvoorbeeld

4 == "4" // will return true

maar

4 === "4" // will return false 

---

Antwoord 9

De operator ===wordt een strikte vergelijkingsoperator genoemd en verschiltvan de operator ==.

Laten we 2 vars a en b nemen.

Voor “a == b”om te evalueren tot waar moeten a en b dezelfde waardezijn.

In het geval van “a === b”moeten a en b de dezelfde waardezijn en ook het hetzelfde typeervoor waar te maken.

Neem het volgende voorbeeld

var a = 1;
var b = "1";
if (a == b) //evaluates to true as a and b are both 1
{
    alert("a == b");
}
if (a === b) //evaluates to false as a is not the same type as b
{
    alert("a === b");
}

Samengevat; het gebruik van de operator ==kan resulteren in true in situaties waarin u dit niet wilt, dus het gebruik van de operator ===zou veiliger zijn.

In het 90% gebruiksscenario maakt het niet uit welke je gebruikt, maar het is handig om het verschil te weten als je op een dag onverwacht gedrag krijgt.

---

Antwoord 10

Waarom ==zo onvoorspelbaar is?

Wat krijg je als je een lege string ""vergelijkt met het getal nul 0?

true

Ja, dat klopt volgens ==een lege string en het getal nul zijn dezelfde tijd.

En daar houdt het niet op, hier is er nog een:

'0' == false // true

Dingen worden echt raar met arrays.

[1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true

Dan nog vreemder met strings

[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!

Het wordt nog erger:

Wanneer is gelijk niet gelijk?

let A = ''  // empty string
let B = 0   // zero
let C = '0' // zero string
A == B // true - ok... 
B == C // true - so far so good...
A == C // **FALSE** - Plot twist!

Laat me dat nog eens zeggen:

(A == B) && (B == C) // true
(A == C) // **FALSE**

En dit zijn gewoon de gekke dingen die je krijgt met primitieven.

Het is een heel nieuw niveau van gekheid als je ==met objecten gebruikt.

Op dit moment vraag je je waarschijnlijk af…

Waarom gebeurt dit?

Nou, het is omdat in tegenstelling tot “triple is gelijk aan” (===) die alleen controleert of twee waarden hetzelfde zijn.

==doet een hele reeks andere dingen.

Het heeft een speciale behandeling voor functies, een speciale behandeling voor nulls, undefined, strings, noem maar op.

Het wordt behoorlijk maf.

In feite, als je zou proberen een functie te schrijven die doet wat ==doet, zou het er ongeveer zo uitzien:

function isEqual(x, y) { // if `==` were a function
    if(typeof y === typeof x) return y === x;
    // treat null and undefined the same
    var xIsNothing = (y === undefined) || (y === null);
    var yIsNothing = (x === undefined) || (x === null);
    if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);
    if(typeof y === "function" || typeof x === "function") {
        // if either value is a string 
        // convert the function into a string and compare
        if(typeof x === "string") {
            return x === y.toString();
        } else if(typeof y === "string") {
            return x.toString() === y;
        } 
        return false;
    }
    if(typeof x === "object") x = toPrimitive(x);
    if(typeof y === "object") y = toPrimitive(y);
    if(typeof y === typeof x) return y === x;
    // convert x and y into numbers if they are not already use the "+" trick
    if(typeof x !== "number") x = +x;
    if(typeof y !== "number") y = +y;
    // actually the real `==` is even more complicated than this, especially in ES6
    return x === y;
}
function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}

Dus wat betekent dit?

Het betekent dat ==ingewikkeld is.

Omdat het ingewikkeld is, is het moeilijk om te weten wat er gaat gebeuren als je het gebruikt.

Wat betekent dat je bugs zou kunnen krijgen.

Dus de moraal van het verhaal is…

Maak je leven minder ingewikkeld.

Gebruik ===in plaats van ==.

Het einde.

---

Antwoord 11

===controleert of dezelfde zijden gelijk zijn in typeen ook in waarde.

---

Voorbeeld:

'1' === 1 // will return "false" because `string` is not a `number`

Veelvoorkomend voorbeeld:

0 == ''  // will be "true", but it's very common to want this check to be "false"

Een ander veelvoorkomend voorbeeld:

null == undefined // returns "true", but in most cases a distinction is necessary

---

Vaak zou een ongetyptecontrole handig zijn omdat het u niet uitmaakt of de waarde undefined, null, 0of ""

---

Antwoord 12

Javascript-uitvoeringsstroomdiagram voor strikte gelijkheid / vergelijking ‘===’

Javascript-uitvoeringsstroomdiagram voor niet-strikte gelijkheid / vergelijking ‘==’

---

Antwoord 13

JavaScript ===vs==.

0==false   // true
0===false  // false, because they are of a different type
1=="1"     // true, auto type coercion
1==="1"    // false, because they are of a different type

---

Antwoord 14

Het betekent gelijkheid zonder typedwang
type dwang betekent dat JavaScript andere datatypes niet automatisch converteert naar string datatypes

0==false   // true,although they are different types
0===false  // false,as they are different types
2=='2'    //true,different types,one is string and another is integer but 
            javaScript convert 2 to string by using == operator 
2==='2'  //false because by using === operator ,javaScript do not convert 
           integer to string 
2===2   //true because both have same value and same types 

---

Antwoord 15

In een typisch script zal er geen prestatieverschil zijn. Belangrijker kan het feit zijn dat duizend “===” 1 KB zwaarder is dan duizend “==” 🙂 JavaScript-profilers kan u vertellen of er in uw geval een prestatieverschil is.

Maar persoonlijk zou ik doen wat JSLint voorstelt. Deze aanbeveling is er niet vanwege prestatieproblemen, maar omdat type dwang betekent dat ('\t\r\n' == 0)waar is.

---

Antwoord 16

De operator voor gelijke vergelijking == is verwarrend en moet worden vermeden.

Als je MOETermee leven, onthoud dan de volgende 3 dingen:

1. Het is niet transitief: (a == b)en (b == c)leidt niet tot (a == c )
2. Het sluit elkaar uit voor zijn ontkenning: (a == b)en (a != b)hebben altijd tegengestelde Booleaanse waarden, met alle a en b.
3. In geval van twijfel, leer de volgende waarheidstabel uit het hoofd:

GELIJKE OPERATOR WAARHEIDSTABEL IN JAVASCRIPT

• Elke rij in de tabel is een set van 3 onderling “gelijke” waarden, wat betekent dat elke 2 waarden ertussen gelijk zijn met het gelijk == teken*

** STRANGE: merk op dat twee waarden in de eerste kolom in die zin niet gelijk zijn.**

''       == 0 == false   // Any two values among these 3 ones are equal with the == operator
'0'      == 0 == false   // Also a set of 3 equal values, note that only 0 and false are repeated
'\t'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\r'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\n'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\t\r\n' == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
null == undefined  // These two "default" values are not-equal to any of the listed values above
NaN                // NaN is not equal to any thing, even to itself.

---

Antwoord 17

Het is onwaarschijnlijk dat er een prestatieverschil is tussen de twee bewerkingen in uw gebruik. Er hoeft geen typeconversie te worden uitgevoerd omdat beide parameters al van hetzelfde type zijn. Beide bewerkingen hebben een typevergelijking gevolgd door een waardevergelijking.

---

Antwoord 18

Ja!Het maakt wel uit.

===operator in javascript controleert zowel de waarde als het typeterwijl de ==operator gewoon de waarde controleert type conversie indien nodig).

Je kunt het eenvoudig testen. Plak de volgende code in een HTML-bestand en open het in de browser

<script>
function onPageLoad()
{
    var x = "5";
    var y = 5;
    alert(x === 5);
};
</script>
</head>
<body onload='onPageLoad();'>

Je krijgt de melding ‘false‘. Pas nu de methode onPageLoad()aan naar alert(x == 5);je krijgt true.

---

Antwoord 19

===operator controleert zowel de waarden als de typen variabelen op gelijkheid.

==operator controleert alleen de waarde van de variabelen op gelijkheid.

---

Antwoord 20

Gewoon

==betekent vergelijkingtussen operanden mettype dwang

en

===betekent vergelijkingtussen operanden zonderdwang van het type.

Typedwang in JavaScript betekent het automatisch converteren van gegevenstypen naar andere gegevenstypen.

Bijvoorbeeld:

123 == "123"  // Returns true, because JS coerces string "123" to number 123
              // and then goes on to compare `123 == 123`.
123 === "123" // Returns false, because JS does not coerce values of different types here.

---

Antwoord 21

Het is een strenge controletest.

Het is een goede zaak, vooral als je tussen 0 en false en null controleert.

Bijvoorbeeld als u:

$a = 0;

Dan:

$a==0; 
$a==NULL;
$a==false;

Alles retourneert waar en u wilt dit misschien niet. Laten we aannemen dat je een functie hebt die de 0-index van een array of false kan retourneren bij een fout. Als u controleert met “==” false, kunt u een verwarrend resultaat krijgen.

Dus met hetzelfde als hierboven, maar een strenge test:

$a = 0;
$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false

---

Antwoord 22

JSLint geeft je soms onrealistische redenen om dingen aan te passen. ===heeft exact dezelfde prestaties als ==als de typen al hetzelfde zijn.

Het is alleen sneller als de typen niet hetzelfde zijn, in welk geval het niet probeert om typen te converteren, maar direct een false retourneert.

Dus, IMHO,JSLint kan worden gebruikt om nieuwe code te schrijven, maar nutteloze over-optimalisatie moet ten koste van alles worden vermeden.

Dit betekent dat er geen reden is om ==te wijzigen in ===in een vinkje zoals if (a == 'test')als je zeker weet dat a alleen een String kan zijn.

Als je veel code op die manier aanpast, verspil je de tijd van ontwikkelaars en reviewers en bereik je niets.

---

Antwoord 23

Als vuistregel zou ik over het algemeen ===gebruiken in plaats van ==(en !==in plaats van !=).

Redenen worden uitgelegd in de antwoorden hierboven en ook Douglas Crockford is er vrij duidelijk over (JavaScript: de goede kanten).

Er is echter één enkele uitzondering:
== nullis een efficiënte manier om te controleren op ‘is null of niet gedefinieerd’:

if( value == null ){
    // value is either null or undefined
}

Bijvoorbeeld jQuery 1.9.1 gebruikt dit patroon 43 keer en de JSHint-syntaxiscontrolebiedt om deze reden zelfs de ontspannende optie eqnull.

Uit de jQuery-stijlgids:

Strikte gelijkheidscontroles (===) moeten worden gebruikt in het voordeel van ==. De enige
uitzondering is bij het controleren op undefined en null door middel van null.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

BEWERK 2021-03:

Tegenwoordig de meeste browsers
ondersteuning van de Nullish coalescing-operator (??)
en de Logische nullish-toewijzing (??=), wat een beknoptere manier mogelijk maakt om
wijs een standaardwaarde toe als een variabele null of ongedefinieerd is, bijvoorbeeld:

if (a.speed == null) {
  // Set default if null or undefined
  a.speed = 42;
}

kan als elk van deze vormen worden geschreven

a.speed ??= 42;
a.speed ?? a.speed = 42;
a.speed = a.speed ?? 42;

---

Antwoord 24

Een eenvoudig voorbeeld is

2 == '2'  -> true, values are SAME because of type conversion.
2 === '2'  -> false, values are NOT SAME because of no type conversion.

---

Antwoord 25

De top 2 antwoorden beide genoemde == betekent gelijkheid en === betekent identiteit. Helaas is deze stelling onjuist.

Als beide operanden van == objecten zijn, worden ze vergeleken om te zien of ze hetzelfde object zijn. Als beide operanden naar hetzelfde object wijzen, retourneert de gelijke-operator waar. Anders,
de twee zijn niet gelijk.

var a = [1, 2, 3];  
var b = [1, 2, 3];  
console.log(a == b)  // false  
console.log(a === b) // false  

In de bovenstaande code krijgen zowel == als === false omdat a en b niet dezelfde objecten zijn.

Dat wil zeggen: als beide operanden van == objecten zijn, gedraagt ​​== zich hetzelfde als ===, wat ook identiteit betekent. Het essentiële verschil tussen deze twee operators gaat over typeconversie. == heeft conversie voordat het de gelijkheid controleert, maar === niet.

---

Antwoord 26

Het probleem is dat u gemakkelijk in de problemen kunt komen, aangezien JavaScript veel impliciete conversies heeft, wat betekent…

var x = 0;
var isTrue = x == null;
var isFalse = x === null;

Wat al snel een probleem wordt. Het beste voorbeeld van waarom impliciete conversie “slecht” is, kan uit deze code worden gehaald in MFC/ C++ die daadwerkelijk zal compileren vanwege een impliciete conversie van CString naar HANDLE, wat een pointer typedef-type is…

CString x;
delete x;

Wat tijdens runtime duidelijk zeerongedefinieerde dingen doet…

Google voor impliciete conversies in C++ en STLom enkele van de argumenten ertegen te krijgen.. .

---

Antwoord 27

Van de kern javascript-referentie

===Retourneert trueals de operanden strikt gelijk zijn (zie hierboven)
zonder typeconversie.

---

Antwoord 28

Gelijkheidsvergelijking:

Operator ==

Retourneert waar als beide operanden gelijk zijn. De operanden worden geconverteerd naar hetzelfde type voordat ze worden vergeleken.

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

Gelijkheid en typevergelijking:

Operator ===

Retourneert waar als beide operanden gelijk en van hetzelfde type zijn. Het is over het algemeen
beter en veiliger als je op deze manier vergelijkt, omdat er geen typeconversies achter de schermen zijn.

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

---

Antwoord 29

Hier is een handige vergelijkingstabel die de conversies laat zien die plaatsvinden en de verschillen tussen ==en ===.

Zoals de conclusie stelt:

‘Gebruik drie gelijken, tenzij u de conversies die nodig zijn volledig begrijpt
plaats voor twee gelijken.”

http://dorey.github.io/JavaScript-Equality-Table/

---

Antwoord 30

null en undefined zijn niets, dat wil zeggen,

var a;
var b = null;

Hier hebben aen bgeen waarden. Terwijl 0, false en ” allemaal waarden zijn. Een ding dat tussen al deze waarden gemeenschappelijk is, is dat het allemaal valse waarden zijn, wat betekent dat ze allemaal voldoenaan valse voorwaarden.

Dus de 0, false en ” vormen samen een subgroep. En aan de andere kant, null & undefined vormen de tweede subgroep. Controleer de vergelijkingen in de onderstaande afbeelding. null en undefined zouden gelijk zijn. De andere drie zouden aan elkaar gelijk zijn. Maar ze worden allemaal behandeld als valse voorwaarden in JavaScript.

Dit is hetzelfde als elk object (zoals {}, arrays, etc.), niet-lege string & Boolean true zijn allemaal waarheidsgetrouwe voorwaarden. Maar ze zijn niet allemaal gelijk.