சமத்துவம்

ஒரு நிரலை எழுதும் போது, பிற மாறிகளுடன் தொடர்பாக மாறிகளின் சமத்துவத்தை அடிக்கடி தீர்மானிக்க வேண்டும். இது சமத்துவ ஆபரேட்டரைப் பயன்படுத்தி செய்யப்படுகிறது. மிக அடிப்படையான சமத்துவ ஆபரேட்டர் == ஆபரேட்டராகும். இந்த ஆபரேட்டர் இரண்டு மாறிகள் சமனாக இருக்கின்றனவா என்பதை தீர்மானிக்க தன்னால் முடிந்ததையெல்லாம் செய்கிறது, அவை ஒரே வகையில் இல்லாவிட்டாலும் கூட.

எடுத்துக்காட்டாக, அனுமானிக்கவும்:

let foo = 42;
let bar = 42;
let baz = "42";
let qux = "life";

foo == bar true என மதிப்பிடப்படும் மற்றும் baz == qux false என மதிப்பிடப்படும், ஒருவர் எதிர்பார்ப்பதுபோல். இருப்பினும், foo மற்றும் baz வெவ்வேறு வகைகளாக இருந்தாலும் foo == baz true என மதிப்பிடப்படும். திரைக்கு பின்னால் == சமத்துவ ஆபரேட்டர் சமத்துவத்தை தீர்மானிக்கும் முன்பு அதன் operand களை ஒரே வகைக்கு மாற்ற முயற்சிக்கிறது. இது === சமத்துவ ஆபரேட்டருக்கு மாறானது.

=== சமத்துவ ஆபரேட்டர் இரண்டு மாறிகள் ஒரே வகையில் இருந்தால் மற்றும் ஒரே மதிப்பை கொண்டிருந்தால் அவை சமனாக இருப்பதாக தீர்மானிக்கிறது. முன்பு போல் அதே அனுமானங்களுடன், இதன் பொருள் foo === bar இன்னும் true என மதிப்பிடப்படும், ஆனால் foo === baz இப்போது false என மதிப்பிடப்படும். baz === qux இன்னும் false என மதிப்பிடப்படும்.

let str1 = "hello";
let str2 = "HELLO";
let bool1 = true;
let bool2 = 1;
// == பயன்படுத்தி ஒப்பிடவும்
let stringResult1 = str1 == str2 // false
let boolResult1 =  bool1 == bool2 // true

// === பயன்படுத்தி ஒப்பிடவும்
let stringResult2 = str1 === str2 // false
let boolResult2 = bool1 === bool2 // false

assert(stringResult1 === false && stringResult2 === false && boolResult1 ==true &&  boolResult2 === false );