මම ජාවාස්ක්‍රිප්ට් හරහා යාමට ජේඑස්ලින්ට් භාවිතා කරන අතර, ප්‍රකාශයක් ඇතුළත සංසන්දනය කිරීම වැනි දේවල් කරන විට ( ==සමාන ලකුණු දෙකක්) ===(සමාන ලකුණු තුනක් ) සමඟ ප්‍රතිස්ථාපනය කිරීමට බොහෝ යෝජනා ඉදිරිපත් කරයි.idSele_UNVEHtype.value.length == 0if

වෙනුවට කිරීමට කාර්ය සාධන ප්රතිලාභ පවතී ==සමග ===?

බොහෝ සංසන්දනාත්මක ක්‍රියාකරුවන් සිටින බැවින් ඕනෑම කාර්ය සාධනයක් වැඩිදියුණු කිරීම පිළිගනු ලැබේ.

කිසිදු ආකාරයක පරිවර්තනයක් සිදු නොවන්නේ නම්, කාර්ය සාධනය ඉක්මවා යා ==හැකිද?

දැඩි සමානාත්මතා ක්‍රියාකරු ( ===) වියුක්ත සමානාත්මතා ක්‍රියාකරුට ( ==) සමාන ආකාරයකින් ක්‍රියා කරයි.

යොමුව: ජාවාස්ක්‍රිප්ට් නිබන්ධනය: සංසන්දනාත්මක ක්‍රියාකරුවන්

මෙම ==ක්රියාකරු සමානාත්මතාවය සඳහා සංසන්දනය කරනු ලැබේ , අවශ්ය ඕනෑම වර්ගයේ ආගමට හරවා කරන්නේ පසු . මෙම ===ක්රියාකරු ඇත නොහැකි වටිනාකම් දෙකක් එකම වර්ගයේ නොවේ නම්, ඒ නිසා, පරිවර්තනය කරන්න ===සරලව ආපසු false. දෙකම සමානව ඉක්මන් වේ.

ඩග්ලස් ක්‍රොක්ෆර්ඩ්ගේ විශිෂ්ට ජාවාස්ක්‍රිප්ට් උපුටා දැක්වීමට : හොඳ කොටස් ,

ජාවාස්ක්‍රිප්ට් හි සමානාත්මතා ක්‍රියාකරුවන් දෙදෙනෙකු ඇත: ===සහ !==, ඔවුන්ගේ නපුරු නිවුන් දරුවන් ==සහ !=. හොඳ අය ඔබ බලාපොරොත්තු වන ආකාරයට ක්‍රියා කරයි. ඔපෙරන්ඩ් දෙක එකම වර්ගයේ සහ එකම අගයක් තිබේ නම්, ===නිෂ්පාදනය trueකර !==නිෂ්පාදනය කරයි false. ඔපෙරන්ඩ්ස් එකම වර්ගයේ වන විට නපුරු නිවුන් දරුවන් නිවැරදි දේ කරයි, නමුත් ඔවුන් විවිධ වර්ගවල නම්, ඔවුන් සාරධර්ම බල කිරීමට උත්සාහ කරයි. ඔවුන් කරන නීති රීති සංකීර්ණ හා මතක තබා ගත නොහැකි ය. මේවා සිත්ගන්නා අවස්ථා කිහිපයකි:

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

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

false == undefined  // false
false == null       // false
null == undefined   // true

' \t\r\n ' == 0     // true

පාරදෘශ්‍යතාවයේ lack නතාවය තැතිගන්වන සුළුය. මගේ අවවාදය නම් කිසි විටෙකත් නපුරු නිවුන් දරුවන් භාවිතා නොකරන්න. ඒ වෙනුවට, සෑම විටම භාවිතා කරන්න ===සහ !==. දැන් පෙන්වා ඇති සියලුම සැසඳීම් ක්‍රියාකරු falseසමඟ නිෂ්පාදනය කරයි ===.

යාවත්කාලීන කිරීම:

හොඳ ස්ථානයක් ලබා ගෙන සිටියේ @Casebash අදහස් හා @Phillipe Laybaert ගේ පිළිතුර වස්තූන් ගැන. වස්තූන් සඳහා, ==සහ ===එකිනෙකා සමඟ ස්ථාවරව ක්‍රියා කරන්න (විශේෂ අවස්ථාවක හැර).

var a = [1,2,3];
var b = [1,2,3];

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

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

විශේෂ අවස්ථාව වන්නේ ඔබ ප්‍රාථමිකයක් එහි toStringහෝ valueOfක්‍රමවේදය හේතුවෙන් එකම ප්‍රාථමිකයට තක්සේරු කරන වස්තුවක් සමඟ සංසන්දනය කිරීමයි . නිදසුනක් ලෙස, Stringඉදිකිරීම්කරු භාවිතා කර සාදන ලද නූල් වස්තුවක් සමඟ ප්‍රාථමික නූලක් සංසන්දනය කිරීම සලකා බලන්න .

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

මෙහිදී ==ක්‍රියාකරු වස්තූන් දෙකේ අගයන් පරීක්ෂා කර නැවත පැමිණේ true, නමුත් ===ඒවා එකම වර්ගයේ නොවන බවත් නැවත පැමිණෙන බවත් falseපෙනේ. මොන එකද නිවැරදි? එය සැබවින්ම රඳා පවතින්නේ ඔබ සංසන්දනය කිරීමට උත්සාහ කරන දේ මත ය. මගේ අවවාදය නම් ප්‍රශ්නය මුළුමනින්ම මග හැරීම සහ Stringවචන වචනාර්ථයෙන් වචන වස්තු නිර්මාණය කිරීම සඳහා ඉදිකිරීම්කරු භාවිතා නොකරන්න .

යොමුව
http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

==ක්රියාකරු භාවිතා කිරීම ( සමානාත්මතාවය )

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

===ක්රියාකරු භාවිතා කිරීම ( අනන්යතාවය )

true === 1; //false
"2" === 2;  //false

මෙයට හේතුව සමානාත්මතා ක්‍රියාකරු ==බලහත්කාරය ටයිප් කිරීමයි , එයින් අදහස් කරන්නේ පරිවර්තකයා ව්‍යංගයෙන් සංසන්දනය කිරීමට පෙර අගයන් පරිවර්තනය කිරීමට උත්සාහ කරන බවයි.

අනෙක් අතට, අනන්‍යතා ක්‍රියාකරු ===බලහත්කාරයෙන් ක්‍රියා නොකරන අතර, සංසන්දනය කිරීමේදී අගයන් පරිවර්තනය නොකරයි, එබැවින් එය එක් පියවරක් මඟ හැරෙන විට වේගවත් වේ ( මෙම JS මිණුම් දණ්ඩ පරීක්ෂණයට අනුව).

==සහ අතර සමානාත්මතාවයේ සංසන්දනාත්මක සිත්ගන්නාසුලු රූපමය නිරූපණයකි ===.

මුලාශ්‍රය: http://dorey.github.io/JavaScript-Equality-Table/

var1 === var2

===ජාවාස්ක්‍රිප්ට් සමානාත්මතා පරීක්ෂණ සඳහා භාවිතා කරන විට , සෑම දෙයක්ම එසේමය. ඇගයීමට පෙර කිසිවක් පරිවර්තනය නොවේ.

var1 == var2

==ජාවාස්ක්‍රිප්ට් සමානාත්මතා පරීක්ෂණ සඳහා භාවිතා කරන විට , සමහර විනෝදජනක පරිවර්තනයන් සිදු වේ.

කතාවේ සදාචාරය:

සිදුවන ===පරිවර්තනයන් ඔබ සම්පූර්ණයෙන්ම වටහාගෙන නොමැතිනම් භාවිතා කරන්න ==.

මෙහි ඇති පිළිතුරු වලදී, සමාන මාධ්‍යයන් ගැන මම කිසිවක් කියවා නැත . සමහරු කියනුයේ එයින් ===අදහස් වන්නේ සමාන හා එකම වර්ගයේ බවයි , නමුත් එය ඇත්ත වශයෙන්ම සත්‍ය නොවේ. එහි ඇත්ත වශයෙන්ම අදහස් වන්නේ ඔපෙරන්ඩ් දෙකම එකම වස්තුවක් යොමු කරන බවයි , නැතහොත් අගය වර්ග වලදී එකම අගයක් ඇති බවයි.

එබැවින්, අපි පහත කේතය ගනිමු:

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

මෙහෙත් එහෙම්මමයි:

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

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

හෝ පවා:

var a = { };
var b = { };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

මෙම හැසිරීම සැමවිටම පැහැදිලිව පෙනෙන්නට නැත. සමාන වීමට හා එකම වර්ගයට වඩා කතාවට තවත් බොහෝ දේ ඇත.

රීතිය:

අගය වර්ග (අංක) සඳහා:
a === b ප්රතිලාභ සැබෑ නම්aසහbඑම අගය ඇති අතර එකම වර්ගයේ

: යොමු වර්ග සඳහා
a === b ප්රතිලාභ සැබෑ නම්aසහbසඳහනක් හරියටම සමාන වස්තුවක්

: නූල් සඳහා
a === b නම් සැබෑ ප්රතිලාභaසහbදෙකම නූල් වන අතර හරියටම සමාන අකුරු අඩංගු

නූල්: විශේෂ අවස්ථාව ...

නූල් අගය වර්ග නොවේ, නමුත් ජාවාස්ක්‍රිප්ට් වල ඒවා අගය වර්ග ලෙස හැසිරේ, එබැවින් නූල්වල අක්ෂර සමාන වන විට හා එකම දිගකින් යුක්ත වන විට ඒවා “සමාන” වනු ඇත (තෙවන රීතියේ විස්තර කර ඇති පරිදි)

දැන් එය සිත්ගන්නාසුළු වේ:

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

නමුත් මෙය කෙසේද?:

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

මම හිතුවේ නූල් අගය වර්ග ලෙස හැසිරෙන බවයි? හොඳයි, එය රඳා පවතින්නේ ඔබ අසන්නේ කවුරුන්ද යන්නයි ... මේ අවස්ථාවේ දී a සහ b එකම වර්ගයේ නොවේ. aවර්ගය Objectවන අතර bවර්ගය stringවේ. Stringඉදිකිරීම්කරු භාවිතා කරමින් නූල් වස්තුවක් නිර්මාණය කිරීම බොහෝObject විට නූල් ලෙස හැසිරෙන ආකාරයේ යමක් නිර්මාණය කරන බව මතක තබා ගන්න .

මට මෙම උපදෙස් එකතු කිරීමට ඉඩ දෙන්න:

සැකයක් ඇත්නම්, පිරිවිතර කියවන්න !

ECMA-262 යනු ජාවාස්ක්‍රිප්ට් උපභාෂාවක් වන ස්ක්‍රිප්ටින් භාෂාවක් සඳහා පිරිවිතරයකි. ඇත්ත වශයෙන්ම ප්‍රායෝගිකව එය වැදගත් වන්නේ යම් දෙයක් හැසිරවිය යුතු ආකාරය පිළිබඳ විචක්ෂණ අර්ථ දැක්වීමකට වඩා වැදගත් බ්‍රව්සර් හැසිරෙන ආකාරයයි. නමුත් නව නූල් ("අ") ඇයි දැයි තේරුම් ගැනීම ප්‍රයෝජනවත් වේ ! == "අ" .

කරුණාකර මෙම ප්‍රශ්නය පැහැදිලි කිරීම සඳහා පිරිවිතර කියවන්නේ කෙසේදැයි පැහැදිලි කිරීමට මට ඉඩ දෙන්න. මෙම ඉතා පැරණි මාතෘකාව තුළ කිසිවෙකුට ඉතා අමුතු බලපෑමක් සඳහා පිළිතුරක් නොමැති බව මට පෙනේ. එබැවින්, ඔබට පිරිවිතරයක් කියවිය හැකි නම්, මෙය ඔබේ වෘත්තියට ඉමහත් පිටුවහලක් වනු ඇත. එය අත්පත් කරගත් කුසලතාවකි. එබැවින්, අපි ඉදිරියට යමු.

=== සඳහා PDF ගොනුව සෙවීම පිරිවිතරයේ 56 වන පිටුවට මා ගෙන එයි: 11.9.4. දැඩි සමාන ක්‍රියාකරු (===) , සහ පිරිවිතරයන් හරහා ගමන් කිරීමෙන් පසුව මට හමු වන්නේ:

11.9.6 දැඩි සමානාත්මතා සංසන්දනය ඇල්ගොරිතම
x හා y අගයන් වන x === y සංසන්දනය සත්‍ය හෝ අසත්‍යය නිපදවයි . එවැනි සංසන්දනයක් පහත පරිදි සිදු කරයි:
  1. වර්ගය (x) වර්ගය (y) ට වඩා වෙනස් නම්, වැරදි ලෙස ආපසු යන්න .
  2. වර්ගය (x) නිර්වචනය කර නොමැති නම් සත්‍යය වෙත ආපසු යන්න .
  3. වර්ගය (x) ශුන්‍ය නම් සත්‍යය වෙත ආපසු යන්න .
  4. නම් වර්ගය (x) අංකය නොවේ, පියවර 11. යන්න
  x නම් 5. නන් , නැවත බොරු .
  6. y නම් නන් , නැවත බොරු .
  X යනු y ට සමාන සංඛ්‍යා අගයක් නම්, ආපසු යන්න සත්‍ය .
  8. x +0 සහ y −0 නම්, සත්‍ය ලෙස ආපසු යන්න .
  9. x −0 සහ y +0 නම්, සත්‍ය ලෙස ආපසු යන්න .
  10. සාවද්‍ය ලෙස ආපසු යන්න .
  11. වර්ගය (x) නූල් නම්, x සහ y හරියටම එකම අනුක්‍රම අනුපිළිවෙලක් නම් සත්‍යය වෙත ආපසු යන්න (අනුරූප ස්ථානවල එකම දිග හා එකම අක්ෂර); එසේ නොමැතිනම්, බොරු ආපසු එවන්න .
  12. (x) වර්ගය බූලියන් නම්, x සහ y යන දෙකම සත්‍ය හෝ දෙකම අසත්‍ය නම් සත්‍යය වෙත ආපසු යන්න ; එසේ නොමැතිනම්, බොරු ආපසු එවන්න .   13. සත්‍යය වෙත ආපසු යන්න
x සහ y එකම වස්තුවකට යොමු කරන්නේ නම් හෝ ඒවා එකිනෙකට සම්බන්ධ වූ වස්තූන් වෙත යොමු කරන්නේ නම් (13.1.2 බලන්න). එසේ නොමැතිනම්, බොරු ආපසු එවන්න .

සිත්ගන්නා සුළු පියවර 11 යි. ඔව්, නූල් අගය වර්ග ලෙස සලකනු ලැබේ. නමුත් නව නූල් ("අ")! == "අ" යන්න මෙයින් පැහැදිලි නොවේ . ECMA-262 ට අනුකූල නොවන බ්‍රව්සරයක් අප සතුව තිබේද?

එතරම් වේගවත් නොවේ!

අපි ඔපෙරන්ඩ් වර්ග පරීක්ෂා කරමු. () ටයිප් ඔෆ් ඔතා එය ඔබම අත්හදා බලන්න . නව නූල් ("අ") වස්තුවක් බව මට පෙනී ගිය අතර, පියවර 1 භාවිතා කරයි: වර්ග වෙනස් නම් ව්‍යාජ ලෙස ආපසු එවන්න .

නව නූල් ("අ") නූලක් ආපසු නොදෙන්නේ මන්දැයි ඔබ සිතන්නේ නම් , යම් ව්‍යායාමයක් පිරිවිතරයක් කියවන්නේ කෙසේද? විනෝද වන්න!

අයිඩියාකාපි මෙය ලියා ඇත්තේ පහත දැක්වෙන විවරණයකිනි.

පිරිවිතරයෙන්

11.2.2 නව ක්‍රියාකරු :

වර්ගය (ඉදිකිරීම්කරු) වස්තුව නොවේ නම්, TypeError ව්‍යතිරේකයක් විසි කරන්න.

වෙනත් වචන වලින් කිවහොත්, String වර්ගය වස්තුවක් නොවන්නේ නම් එය නව ක්‍රියාකරු සමඟ භාවිතා කළ නොහැක.

අළුත් සෑම විටම සංගීත නිර්මාණකරුවන් සඳහා පවා වස්තුවක් ලබා දෙයි. අහෝ! නූල් සඳහා අගය අර්ථ නිරූපණය (11 වන පියවර බලන්න) නැති වී ඇත.

අවසාන වශයෙන් මෙයින් අදහස් වන්නේ: නව නූල් ("අ")! == "අ" .

PHP සහ JavaScript වල එය දැඩි සමානාත්මතා ක්‍රියාකරුවෙකි. එහි තේරුම, එය වර්ගය සහ අගයන් දෙකම සංසන්දනය කරනු ඇත.

මම මෙය ෆයර්ෆොක්ස් සමඟ ෆයර්බග් සමඟ මෙවැනි කේතයක් භාවිතා කර පරීක්ෂා කළෙමි :

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

හා

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

මගේ ප්‍රති results ල (පස් වතාවක් පරීක්ෂා කර සාමාන්‍යය):

==: 115.2
===: 114.4

එබැවින් කුඩා වෙනස (මෙය පුනරාවර්තන 100000 ඉක්මවයි, මතක තබා ගන්න) නොසැලකිලිමත් යැයි මම කියමි. කාර්ය සාධනය කිරීමට හේතුවක් නොවේ=== . ආරක්ෂාව ටයිප් කරන්න (හොඳයි, ඔබ ජාවාස්ක්‍රිප්ට් ලබා ගැනීමට යන තරමටම ආරක්ෂිතයි), සහ කේතයේ ගුණාත්මකභාවය.

ජාවාස්ක්‍රිප්ට් හි එය එකම අගය හා වර්ගය අදහස් කරයි.

උදාහරණයක් වශයෙන්,

4 == "4" // will return true

එහෙත්

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

මෙම === ක්රියාකරු, දැඩි හා සසඳන ක්රියාකරු ලෙස හැඳින්වේ එය කරන්නේ වඩා වෙනස් == ක්රියාකරු.

A සහ b වර්ග 2 ක් ගනිමු.

සඳහා "වූ == ආ" සඳහා කළ යුතු සැබෑ a හා b අවශ්යතාව ඇගයීමට එම අගය .

පිළිබඳ පැමිණිල්ලේ දී "ඉතා === ආ" a හා b ද විය යුතුය එම අගය හා ද එකම වර්ගයේ එය සැබෑ කිරීමට ඇගයීමට සඳහා.

පහත උදාහරණය ගන්න

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");
}

සාරාංශයක් ලෙස ; භාවිතා කරමින් == ක්රියාකරු ඔබට අවශ්ය නැහැ එහිදී එය එසේ භාවිතා කිරීමට තත්වයන් තුළ සැබෑ කිරීමට ඇගයීමට හැකි === ක්‍රියාකරු ආරක්ෂිත වේ.

90% භාවිතා කිරීමේ අවස්ථාවෙහිදී, ඔබ කුමන එකක් භාවිතා කළත් කමක් නැත, නමුත් එක් දිනක් ඔබට අනපේක්ෂිත හැසිරීමක් ලැබුණු විට වෙනස දැන ගැනීම පහසුය.

==එතරම් අනාවැකි කිව නොහැක්කේ ඇයි ?

හිස් නූලක් ""ශුන්‍ය අංකය සමඟ සංසන්දනය කළ විට ඔබට ලැබෙන්නේ 0කුමක්ද?

true

ඔව්, ==එය හිස් නූලකට අනුව නිවැරදි වන අතර ශුන්‍ය අංකය එකම වේලාවකි.

එය එතැනින් අවසන් නොවේ, මෙන්න තවත් එකක්:

'0' == false // true

අරා සමඟ දේවල් ඇත්තෙන්ම අමුතුයි.

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

ඉන්පසු නූල්වලින් වෙහෙසට පත් වන්න

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

එය වඩාත් නරක අතට හැරේ:

සමාන නොවන්නේ කවදාද?

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!

මට නැවත එය කියන්නට ඉඩ දෙන්න:

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

මෙය ප්‍රාථමිකයන් සමඟ ඔබට ලැබෙන පිස්සු දේවල් පමණි.

ඔබ ==වස්තූන් සමඟ භාවිතා කරන විට එය සම්පූර්ණයෙන්ම නව පිස්සුවකි .

මේ අවස්ථාවේදී ඔබ පුදුම වන්නට පුළුවන ...

මෙය සිදුවන්නේ ඇයි?

හොඳයි, එයට හේතුව “ත්‍රිත්ව සමාන” ( ===) මෙන් නොව, අගයන් දෙකක් සමාන දැයි පරික්ෂා කිරීමයි.

==එය කරන්නේ වෙනත් දේවල් මුළු පොකුරක් .

එහි කාර්යයන් සඳහා විශේෂ හැසිරවීමක් ඇත, ශුන්‍ය සඳහා විශේෂ හැසිරවීමක්, නිර්වචනය නොකළ, නූල් ඇත, ඔබ එය නම් කරන්න.

එය ඉතා විකාරයකි.

ඇත්ත වශයෙන්ම, ඔබ ශ්‍රිතයක් ලිවීමට උත්සාහ කළහොත් ==එය කරන්නේ කුමක්ද?

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();
}

ඉතින් මෙයින් අදහස් කරන්නේ කුමක්ද?

එහි තේරුම == වන්නේ සංකීර්ණ බවයි.

එය සංකීර්ණ බැවින් ඔබ එය භාවිතා කරන විට කුමක් සිදුවේදැයි දැන ගැනීම දුෂ්කර ය.

එයින් අදහස් කරන්නේ ඔබට දෝෂ වලින් අවසන් විය හැකි බවයි.

ඉතින් කතාවේ සදාචාරය නම් ...

ඔබේ ජීවිතය අඩු සංකීර්ණ කරන්න.

===වෙනුවට භාවිතා කරන්න ==.

අවසානය.

===චෙක්පත් එකම පැති වර්ගය හා වටිනාකම සමාන වේ .

උදාහරණයක්:

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

පොදු උදාහරණය:

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

තවත් පොදු උදාහරණයක්:

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

ක බොහෝ වතාවක් untyped චෙක්පත වටිනාකම එක්කෝ නම් ඔබ සැලකිලිමත් නැති නිසා ප්රයෝජනවත් වනු ඇත undefined, null, 0 හෝ""

දැඩි සමානාත්මතාවය සඳහා ජාවාස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීමේ ප්‍රවාහ සටහන / සංසන්දනය '==='

දැඩි නොවන සමානාත්මතාවය / සංසන්දනය සඳහා ජාවාස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීමේ ප්‍රවාහ සටහන '=='

ජාවාස්ක්‍රිප්ට් === එදිරිව == .

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

එහි අර්ථය වන්නේ බලහත්කාරයෙන් බල කිරීමකින් තොරව සමානාත්මතාවය යන්නෙන් අදහස් වන්නේ ජාවාස්ක්‍රිප්ට් වෙනත් දත්ත වර්ග ස්වයංක්‍රීයව නූල් දත්ත වර්ග බවට පරිවර්තනය නොකරන බවයි.

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 

සාමාන්‍ය පිටපතක කාර්ය සාධන වෙනසක් නොමැත. වඩා වැදගත් වන්නේ දහස් "===" දහසකට වඩා 1 KB බරයි "==" :) ඔබේ නඩුවේ කාර්ය සාධන වෙනසක් තිබේ නම් ජාවාස්ක්‍රිප්ට් පැතිකඩකරුවන්ට ඔබට පැවසිය හැකිය.

නමුත් පෞද්ගලිකව මම ජේඑස්ලින්ට් යෝජනා කරන දේ කරන්නෙමි. මෙම නිර්දේශය ඇත්තේ කාර්ය සාධන ගැටළු නිසා නොව, බලහත්කාරය ටයිප් ('\t\r\n' == 0)කිරීම සත්‍ය වන බැවිනි.

සමාන සංසන්දනාත්මක ක්‍රියාකරු == අවුල් සහගත වන අතර එය වළක්වා ගත යුතුය.

ඔබ නම් ඇති ඒ සමඟ ජීවත්, පසුව පහත සඳහන් දේවල් 3 මතක තබා ගන්න:

1. එය සංක්‍රාන්ති නොවේ: (අ == ආ) සහ (== ඇ ආ) තුඩු නැත (අ == ඇ)
2. එය ප්‍රතික්ෂේප කිරීම සඳහා අන්‍යෝන්‍ය වශයෙන් සුවිශේෂී වේ: (a == b) සහ (a! = B) සෑම විටම ප්‍රතිවිරුද්ධ බූලියන් අගයන් දරයි.
3. සැකයක් ඇත්නම්, පහත සත්‍ය වගුව හදවතින්ම ඉගෙන ගන්න:

ජාවාස්ක්‍රිප්ට් හි සමාන මෙහෙයුම්කරු සත්‍ය වගුව

• වගුවේ ඇති සෑම පේළියක්ම අන්‍යෝන්‍ය “සමාන” අගයන් 3 කින් සමන්විත වේ, එයින් අදහස් වන්නේ ඒවා අතර ඇති ඕනෑම අගයන් 2 ක් සමාන == ලකුණ * භාවිතා කර සමාන බවයි.

** ශක්තිමත් කරන්න: පළමු තීරුවේ ඇති ඕනෑම අගයන් දෙකක් එම අර්ථයෙන් සමාන නොවන බව සලකන්න. **

''       == 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.

ඔබගේ භාවිතයේ ඇති මෙහෙයුම් දෙක අතර කාර්ය සාධන වෙනසක් ඇති වීමට ඉඩක් නැත. පරාමිති දෙකම දැනටමත් එකම වර්ගයේ බැවින් කළ යුතු ආකාරයේ පරිවර්තනයක් නොමැත. මෙම මෙහෙයුම් දෙකටම වර්ග සංසන්දනයක් ඇති අතර පසුව අගය සංසන්දනයක් ඇත.

ඔව්! එය වැදගත් ය.

===ජාවාස්ක්රිප්ට් තුල ක්රියාකරු චෙක්පත් අගය මෙන්ම වර්ගය ලෙස එහිදී ==ක්රියාකරු පමණක් පරික්ෂා වටිනාකම (අවශ්ය නම් වර්ගය පරිවර්තනය කරන්නේ) .

ඔබට එය පහසුවෙන් පරීක්ෂා කළ හැකිය. පහත කේතය HTML ගොනුවක අලවා බ්‍රව්සරයේ විවෘත කරන්න

<script>

function onPageLoad()
{
    var x = "5";
    var y = 5;
    alert(x === 5);
};

</script>

</head>

<body onload='onPageLoad();'>

ඔබට ' අසත්‍යය ' අවදියෙන් ලැබෙනු ඇත. දැන් ඔබට onPageLoad()ක්‍රමය වෙනස් කිරීමෙන් alert(x == 5);එය සත්‍ය වනු ඇත .

=== ක්රියාකරු විසින් සමානාත්මතාවය සඳහා අගයන් මෙන්ම විචල්යයන් වර්ග පරීක්ෂා කරයි.

== ක්රියාකරු සමානාත්මතාවය සඳහා විචල්යයන්ගේ වටිනාකම පරීක්ෂා කරයි.

එය දැඩි චෙක් පරීක්ෂණයකි.

විශේෂයෙන් ඔබ 0 සහ අසත්‍ය සහ ශුන්‍ය අතර පරික්ෂා කරන්නේ නම් එය හොඳ දෙයකි.

උදාහරණයක් ලෙස, ඔබට තිබේ නම්:

$a = 0;

ඉන්පසු:

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

සියලු ප්‍රතිලාභ සත්‍ය වන අතර ඔබට මෙය අවශ්‍ය නොවනු ඇත. අරාවෙහි 0 වන දර්ශකය ආපසු ලබා දිය හැකි හෝ අසමත් වූ විට අසත්‍යයක් ඔබට ශ්‍රිතයක් ඇතැයි සිතමු. ඔබ "==" අසත්‍යයෙන් පරික්ෂා කළහොත් ඔබට ව්‍යාකූල ප්‍රති .ලයක් ලබා ගත හැකිය.

එබැවින් ඉහත සඳහන් දේ සමඟම, නමුත් දැඩි පරීක්ෂණයක්:

$a = 0;

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

JSLint සමහර විට ඔබට දේවල් වෙනස් කිරීමට යථාර්ථවාදී නොවන හේතු සපයයි. ===හරියටම සමාන කාර්ය සාධනයක් ඇත==වර්ග දැනටමත් සමාන නම් .

එය වේගවත් වන්නේ වර්ග එක හා සමාන නොවන විට පමණි, එම අවස්ථාවේ දී එය වර්ග පරිවර්තනය කිරීමට උත්සාහ නොකරන නමුත් කෙලින්ම අසත්‍යයක් ලබා දෙයි.

ඉතින්, IMHO, JSLint නව කේත ලිවීමට භාවිතා කරනු ඇත, නමුත් වැඩකට නැති අධික ලෙස ප්‍රශස්තිකරණය සෑම වියදමකින්ම වළක්වා ගත යුතුය.

අර්ථය, වෙනස් කිරීමට හේතුවක් නැත ==කිරීමට ===මෙන් චෙක් පතක් දීif (a == 'test') ඔබ පමණක්, සංගීත විය හැකි බව ඇත්ත එය දැන විට.

බොහෝ කේත වෙනස් කිරීම මඟින් සංවර්ධකයින්ගේ සහ සමාලෝචකයින්ගේ කාලය නාස්ති වන අතර කිසිවක් අත්කර ගත නොහැක.

සරලවම

==අදහස් සංසන්දනය operands අතර සමග type conversion

සහ

===අදහස් සංසන්දනය operands අතර තොරව type conversion

ජාවාස්ක්‍රිප්ට් තුළ ටයිප් පරිවර්තනය යන්නෙන් අදහස් වන්නේ ජාවාස්ක්‍රිප්ට් වෙනත් ඕනෑම දත්ත වර්ගයක් ස්වයංක්‍රීයව දත්ත වර්ග බවට පරිවර්තනය කිරීමයි.

උදාහරණයක් වශයෙන්:

123=='123'   //will return true, because JS convert integer 123 to string '123'
             //as we used '==' operator 

123==='123' //will return false, because JS do not convert integer 123 to string 
            //'123' as we used '===' operator 

සරල උදාහරණයක්

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

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

සඳහන් කර ඇති ඉහළම පිළිතුරු දෙකම == යන්නෙන් සමානාත්මතාවය සහ === යන්නෙන් අනන්‍යතාවය අදහස් වේ. අවාසනාවට, මෙම ප්‍රකාශය වැරදිය.

== ඔපෙරන්ඩ් දෙකම වස්තු නම්, ඒවා සමාන වස්තුවක් දැයි බැලීමට සැසඳේ. ඔපෙරන්ඩ් දෙකම එකම වස්තුවකට යොමු කරන්නේ නම්, සමාන ක්‍රියාකරු සත්‍ය වේ. එසේ නොමැති නම්, දෙක සමාන නොවේ.

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

ඉහත කේතයේ == සහ === යන දෙකම ව්‍යාජ වන්නේ a සහ b එකම වස්තු නොවන බැවිනි.

එනම්, == ඔපෙරන්ඩ් දෙකම වස්තු නම්, == හැසිරෙන්නේ === ලෙසය, එයින් අදහස් වන්නේ අනන්‍යතාවයයි. මෙම ක්‍රියාකරුවන් දෙදෙනාගේ අත්‍යවශ්‍ය වෙනස වන්නේ වර්ගය පරිවර්තනය කිරීමයි. == සමානාත්මතාවය පරීක්ෂා කිරීමට පෙර පරිවර්තනයක් ඇත, නමුත් === එසේ නොවේ.

රීතියක් ලෙස, මම සාමාන්‍යයෙන් භාවිතා ===කරන්නේ ==(සහ !==ඒ වෙනුවට!= ).

ඉහත පිළිතුරු වලින් හේතු පැහැදිලි කර ඇති අතර ඩග්ලස් ක්‍රොක්ෆර්ඩ් ඒ පිළිබඳව පැහැදිලිය ( ජාවාස්ක්‍රිප්ට්: හොඳ කොටස් ).

කෙසේ වෙතත් එක් ව්‍යතිරේකයක් ඇත : == null'ශුන්‍ය හෝ නිර්වචනය කර නොමැතිද' යන්න පරීක්ෂා කිරීම සඳහා කාර්යක්ෂම ක්‍රමයකි:

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

උදාහරණයක් ලෙස jQuery 1.9.1 මෙම රටාව 43 වතාවක් භාවිතා කරයි, සහ JSHint සින්ටැක්ස් පරීක්ෂක විසින් පවා සපයයිeqnull මෙම හේතුව නිසා ලිහිල් කිරීමේ විකල්පය .

සිට jQuery විලාස මාර්ගෝපදේශකය :

දැඩි සමානාත්මතා චෙක්පත් (===) == ට පක්ෂව භාවිතා කළ යුතුය. එකම ව්‍යතිරේකය වන්නේ නිර්වචනය නොකළ හා ශුන්‍ය ලෙස පරීක්ෂා කිරීමේදී ය.

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

ගැටළුව වන්නේ ජාවාස්ක්‍රිප්ට් වල ව්‍යාජ පරිවර්තන අර්ථ රාශියක් ඇති බැවින් ඔබට පහසුවෙන් කරදරයට පත්විය හැකිය ...

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

එය ඉතා ඉක්මනින් ගැටලුවක් බවට පත්වේ. ව්‍යංග පරිවර්තනය "නපුර" වන්නේ ඇයිද යන්න පිළිබඳ හොඳම නියැදිය MFC / C ++ හි ඇති මෙම කේතයෙන් ලබා ගත හැකි අතර එය සැබවින්ම සම්පාදනය කරනු ලබන්නේ CString සිට HANDLE දක්වා ව්‍යංග පරිවර්තනයක් නිසා වන අතර එය දර්ශක යතුරු ලියනය කරන ලද වර්ගයකි ...

CString x;
delete x;

පැහැදිලිවම ධාවන කාලය තුළ ඉතා නිර්වචනය නොකළ දේවල් කරයි ...

ගූගල් එයට එරෙහිව තර්ක කිහිපයක් ලබා ගැනීම සඳහා සී ++ සහ එස්ටීඑල් හි ව්‍යාජ පරිවර්තනයන් සඳහා ...

සිට ප්රධාන ජාවාස්ක්රිප්ට් සඳහනක්

===ප්රතිලාභ trueමේ operands දැඩි සමාන නම් (ඉහත බලන්න) කිසිදු වර්ගය පරිවර්තනය සමග.

සමානාත්මතා සංසන්දනය:

ක්රියාකරු ==

ඔපෙරන්ඩ් දෙකම සමාන වන විට සත්‍ය වේ. සැසඳීමට පෙර ඔපෙරන්ඩ් එකම වර්ගයට පරිවර්තනය වේ.

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

සමානාත්මතාවය සහ වර්ගය සංසන්දනය:

ක්රියාකරු ===

ඔපෙරන්ඩ් දෙකම සමාන හා එකම වර්ගයේ නම් සත්‍ය වේ. ඔබ මේ ආකාරයට සංසන්දනය කරන්නේ නම් එය සාමාන්‍යයෙන් වඩා හොඳ සහ ආරක්ෂිත වේ, මන්ද තිරය පිටුපස ආකාරයේ පරිවර්තන නොමැත.

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

මෙහි ප්රයෝජනවත් සංසන්දනය වගුව ආශ්රයෙන් සිදු වන පරිවර්ථනයන් හා ඒ අතර වෙනස්කම් බව ය ==සහ ===.

නිගමනයෙහි දැක්වෙන පරිදි:

"සමාන දෙකක් සඳහා සිදුවන පරිවර්තනයන් ඔබ සම්පූර්ණයෙන් වටහා නොගන්නේ නම් සමාන තුනක් භාවිතා කරන්න."

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

ශුන්‍ය හා නිර්වචනය නොකළ කිසිවක් නැත, එනම්,

var a;
var b = null;

මෙහි aසහ bසාරධර්ම නොමැත. 0, අසත්‍ය සහ '' යන සියල්ලම අගයන් වේ. මේ සියල්ල අතර පොදු දෙයක් නම්, ඒවා සියල්ලම ව්‍යාජ සාරධර්ම වන අතර එයින් අදහස් කරන්නේ ඒවා සියල්ලම තෘප්තිමත් වන බවයි ව්‍යාජ තත්වයන් බවයි.

ඉතින්, 0, අසත්‍ය සහ '' එක්ව උප කාණ්ඩයක් සාදයි. අනෙක් අතට, ශුන්‍ය හා නිර්වචනය නොකළ දෙවන උප සමූහය සාදයි. පහත රූපයේ සැසඳීම් පරීක්ෂා කරන්න. ශුන්‍ය හා නිර්වචනය නොකළ සමාන වේ. අනෙක් තිදෙනා එකිනෙකාට සමාන වේ. එහෙත්, ඒවා සියල්ලම ජාවාස්ක්‍රිප්ට් හි ව්‍යාජ තත්වයන් ලෙස සලකනු ලැබේ.

මෙය ඕනෑම වස්තුවකට සමාන වේ ({}, අරා, ආදිය), හිස් නොවන නූල් සහ බූලියන් සත්‍ය යන සියල්ල සත්‍ය කොන්දේසි වේ. නමුත්, ඔවුන් සියල්ලම සමාන නොවේ.