ජාවාස්ක්‍රිප්ට් හි == භාවිතා කිරීම කවදා හෝ අර්ථවත්ද?

දී JavaScript, සුබ අමතර කොටස් , ඩග්ලස් Crockford මෙසේ ලිවීය:

ජාවාස්ක්‍රිප්ට් හි සමානාත්මතා ක්‍රියාකරුවන් දෙදෙනෙකු ඇත: ===සහ !==, ඔවුන්ගේ නපුරු නිවුන් දරුවන් ==සහ !=. හොඳ අය ඔබ බලාපොරොත්තු වන ආකාරයට ක්‍රියා කරයි. ඔපෙරන්ඩ් දෙක එකම වර්ගයේ සහ එකම අගයක් තිබේ නම්, ===නිෂ්පාදනය 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සමඟ නිෂ්පාදනය කරයි ===.

මෙම නිසැක නිරීක්‍ෂණය සැලකිල්ලට ගෙන, භාවිතා කිරීම ==ඇත්ත වශයෙන්ම සුදුසු විය හැකි කාලයක් තිබේද?

මම තර්කයක් ඉදිරිපත් කරන්නයි යන්නේ ==

ඔබ උපුටා දැක්වූ ඩග්ලස් ක්‍රොක්ෆර්ඩ් ඔහුගේ බොහෝ හා බොහෝ විට ප්‍රයෝජනවත් අදහස් සඳහා ප්‍රසිද්ධය. මෙම විශේෂ අවස්ථාවෙහිදී මම ක්‍රොක්ෆර්ඩ් සමඟ සිටින අතර එය එකම මතය නොවන බව සඳහන් කිරීම වටී . භාෂා නිර්මාතෘ බ්‍රෙන්ඩන් අයිච් වැනි තවත් අය විශාල ගැටලුවක් නොදකිති ==. තර්කය පහත දැක්වෙන ආකාරයට මඳක් ඉදිරියට යයි:

ජාවාස්ක්‍රිප්ට් යනු චර්යාත්මකව * ටයිප් කළ භාෂාවකි. දේවල් සලකනු ලබන්නේ ඔවුන්ට කළ හැකි දේ මත මිස ඒවායේ නියම වර්ගය මත නොවේ. ඔබට .mapNodeList එකක හෝ jQuery තේරීම් කට්ටලයක් මත අරාව ක්‍රමයක් ඇමතිය හැක්කේ මේ නිසා ය . ඔබට එය කළ හැකි 3 - "5"අතර අර්ථවත් යමක් ආපසු ලබා ගත හැක්කේ එබැවිනි - "5" අංකයක් ලෙස ක්‍රියා කළ හැකි බැවිනි.

ඔබ ==සමානාත්මතාවයක් සිදු කරන විට , විචල්‍යයක අන්තර්ගතය එහි වර්ගයට වඩා සංසන්දනය කරයි . මෙය ප්‍රයෝජනවත් වන අවස්ථා කිහිපයක් මෙන්න:

• පරිශීලකයාගෙන් අංකයක් කියවීම - .valueDOM හි ආදාන අංගයක් කියවීම ? කිසිම ප්රශ්නයක් නැ! ඔබට එය වාත්තු කිරීම හෝ එහි වර්ගය ගැන කරදර වීම ආරම්භ කළ යුතු නැත - ඔබට ==එය වහාම අංකවලට යොමු කර අර්ථවත් යමක් ලබා ගත හැකිය.
• ප්‍රකාශිත විචල්‍යයක “පැවැත්ම” පරීක්ෂා කිරීමට අවශ්‍යද? - == nullචර්යාත්මකව nullනිරූපණය වන බැවින් එහි කිසිවක් නොමැති අතර නිර්වචනය කර ඇති කිසිවක් එහි නොමැත.
• ඔබට පරිශීලකයෙකුගෙන් අර්ථවත් ආදානයක් තිබේදැයි පරීක්ෂා කළ යුතුද? - ==තර්කය සමඟ ආදානය අසත්‍ය දැයි පරීක්ෂා කරන්න , එය පරිශීලකයා කිසිවක් ඇතුළත් කර නැති අවස්ථාවන්ට හෝ ඔබට සුදු අවකාශයක් ලබා දෙනු ඇත.

අපි ක්‍රොක්ෆර්ඩ්ගේ උදාහරණ දෙස බලා ඒවා චර්යාත්මකව පැහැදිලි කරමු:

'' == '0'           // got input from user vs. didn't get input - so false
0 == ''             // number representing empty and string representing empty - so true
0 == '0'            // these both behave as the number 0 when added to numbers - so true    
false == 'false'    // false vs got input from user which is truthy - so false
false == '0'        // both can substitute for 0 as numbers - so again true

false == undefined  // having nothing is not the same as having a false value - so false
false == null       // having empty is not the same as having a false value - so false
null == undefined   // both don't represent a value - so true

' \t\r\n ' == 0     // didn't get meaningful input from user vs falsey number - true 

මූලික වශයෙන්, ජාවාස්ක්‍රිප්ට් හි ==ප්‍රාථමිකයන් හැසිරෙන ආකාරය මත පදනම්ව ක්‍රියා කිරීමට සැලසුම් කර ඇත . මෙම දෘෂ්ටි කෝණයෙන් මා පෞද්ගලිකව එකඟ නොවන අතර එය සිදුකිරීමේ අනිවාර්යයෙන්ම සුදුසුකමක් ඇත - විශේෂයෙන් ඔබ භාෂාව පුරා පැතිරී ඇති හැසිරීම් මත පදනම්ව ප්‍රතිකාර කිරීමේ මෙම ආදර්ශය ගතහොත්.

^{* සමහරු වඩාත් පොදු වන ව්‍යුහාත්මක ටයිප් කිරීමට කැමති විය හැකි නමුත් වෙනසක් ඇත - මෙහි වෙනස සාකච්ඡා කිරීමට සැබවින්ම උනන්දු නොවේ.}

JQuery විසින් ඉදිකිරීම් භාවිතා කරන බව පෙනේ

if (someObj == null) {
  // do something
}

සමාන කේතය සඳහා කෙටිමං ලෙස පුළුල් ලෙස:

if ((someObj === undefined) || (someObj === null))  {
  // do something
}

මෙම ප්රතිඵලයක් වන මෙම සම්මතයන් භාෂා පිරිවිතර § 11.9.3, නිපැයුමක් සමානතා සංසන්දනය ඇල්ගොරිතමය බව, වෙනත් දේ අතර, සඳහන් කර

1.  If Type(x) is the same as Type(y), then  
    a.  If Type(x) is Undefined, return true.  
    b.  If Type(x) is Null, return true.

හා

2.  If x is null and y is undefined, return true.
3.  If x is undefined and y is null, return true.

මෙම විශේෂිත තාක්‍ෂණය JSHint සඳහා විශේෂයෙන් නිර්මාණය කර ඇති ධජයක් ඇති තරම් පොදු ය.

බහුල ලෙස පැහැදිලි කර ඇති පරිදි, එක් දෙයක් සඳහා අගයන් පරීක්ෂා කිරීම nullහෝ undefinedඑකකි.

තවත් දෙයක් තිබේ, එහිදී ==බැබළෙයි:

ඔබට ඒ හා >=සමාන සංසන්දනය අර්ථ දැක්විය හැකිය (මිනිසුන් සාමාන්‍යයෙන් ආරම්භ වන >නමුත් මට මෙය වඩාත් අලංකාරයි):

• a > b <=> a >= b && !(b >= a)
• a == b <=> a >= b && b >= a
• a < bහා a <= bපාඨකයා වෙත අභ්යාස ලෙස ඉතිරි වේ.

අප දන්නා පරිදි, ජාවාස්ක්‍රිප්ට් "3" >= 3සහ "3" <= 3ඔබ ලබා ගන්නා 3 == "3". නූල් විග්‍රහ කිරීමෙන් නූල් සහ සංඛ්‍යා අතර සංසන්දනය ක්‍රියාත්මක කිරීමට ඉඩ දීම භයානක අදහසක් බව ඔබට පෙන්වා දිය හැකිය. නමුත් මේ ඒක වැඩ මාර්ගය බව ලබා දී, ==සයුරු තෙර විසින් එම සම්බන්ධතාව ක්රියාකරු ක්රියාත්මක නිවැරදි ක්රමය.

ඉතින් ඇත්තෙන්ම හොඳ දෙය ==නම් එය අනෙක් සියලුම සම්බන්ධතාවන්ට අනුකූල වීමයි. එය වෙනස් ලෙස කිවහොත්, ඔබ මෙය ලියන්නේ නම්:

function compare(a, b) {
  if (a > b) return 1;
  if (a < b) return -1;
  return 0;
}

ඔබ ==දැනටමත් ව්‍යංගයෙන් භාවිතා කරයි.

දැන් තරමක් සම්බන්ධ ප්‍රශ්නයට: අංක සහ නූල් එය ක්‍රියාත්මක කරන ආකාරය සංසන්දනය කිරීම නරක තේරීමක් ද? හුදකලාව සිටිනු දැකීම තරමක් මෝඩ දෙයක් ලෙස පෙනේ. නමුත් ජාවාස්ක්‍රිප්ට් සහ ඩොම් හි අනෙකුත් කොටස් වල සන්දර්භය තුළ එය සාපේක්ෂව ප්‍රායෝගික ය:

• ගුණාංග සෑම විටම නූල් වේ
• යතුරු සැමවිටම නූල් වේ (භාවිතයේ අවස්ථාව නම් ඔබ භාවිතා කරන්නේ Objectඉන්ට්ස් සිට අගයන් දක්වා විරල සිතියමක් තිබීමයි)
• පරිශීලක ආදානය සහ පෝරම පාලන අගයන් සැමවිටම නූල් වේ (ප්‍රභවය ගැලපුණත් input[type=number])

හේතු ගණනාවක් නිසා අවශ්‍ය වූ විට නූල් සංඛ්‍යා ලෙස හැසිරවීම අර්ථවත් විය. නූල් සංසන්දනය හා නූල් ::සම්මුතියට විවිධ ක්‍රියාකරුවන් සිටින බව උපකල්පනය කිරීම (උදා: සම්මුතිය සඳහා සහ සංසන්දනය කිරීමේ ක්‍රමයක් (එහිදී ඔබට සිද්ධි සංවේදීතාව පිළිබඳ සියලු වර්ගවල පරාමිතීන් භාවිතා කළ හැකිය සහ නොකළ යුතු දේ), මෙය ඇත්ත වශයෙන්ම අවුලකට වඩා අඩු වනු ඇත. නමුත් මෙම ක්‍රියාකරු අධික ලෙස පැටවීම බොහෝ විට “ජාවාස්ක්‍රිප්ට්” හි “ජාවා” පැමිණෙන්නේ;)

වෘත්තීය ගණිතඥයෙකු ලෙස මා දකින Javscript ගේ විෂමත්වයක් ක්රියාකරු == (ද "වියුක්ත සංසන්දනය" නම්, "නින්දිත සමානාත්මතාවය" ) යනු ගොඩ නැගීමට උත්සාහ සමතාව සම්බන්ධයෙන් වීම ද ඇතුළත් වන, ආයතන අතර සිද්ධ , සමමිතික හා අධිෂ්ඨාන පූර්වකව . අවාසනාවට, මෙම මූලික ගුණාංග තුනෙන් දෙකක් අසමත් වේ:

==ප්‍රත්‍යාවර්තක නොවේ :

A == A අසත්‍ය විය හැකිය, උදා

NaN == NaN // false

==සංක්‍රාන්ති නොවේ :

A == Bහා B == Cඑකට අදහස් කරන්නේ නැහැ A == C, උදා:

'1' == 1 // true
1 == '01' // true
'1' == '01' // false

සමමිතික දේපල පමණක් ඉතිරිව පවතී:

A == Bඑයින් ගම්‍ය වන්නේ B == A, කුමන උල්ලං violation නයක් ඕනෑම අවස්ථාවක සිතාගත නොහැකි අතර බරපතල කැරැල්ලකට තුඩු දෙනු ඇත;)

සමානතා සම්බන්ධතා වැදගත් වන්නේ ඇයි?

මක්නිසාද යත් එය උදාහරණ සහ යෙදුම් ගණනාවක සහාය ඇතිව වඩාත්ම වැදගත් හා ප්‍රචලිත සම්බන්ධතාවයකි. වැදගත්ම යෙදුම වන්නේ ආයතන සමානතා පංතිවලට දිරාපත් වීමයි , එය සබඳතා අවබෝධ කර ගැනීමේ ඉතා පහසු සහ අවබෝධාත්මක ක්‍රමයකි. සමානාත්මතාවය අසමත් වීම සමානාත්මතා පංති නොමැතිකමට හේතු වන අතර, එමඟින් ප්‍රකට බුද්ධිමය හා අනවශ්‍ය සංකීර්ණතාවයේ lack නතාවයට හේතු වේ.

==සමාන නොවන සම්බන්ධතාවයක් සඳහා ලිවීම එතරම් භයානක අදහසක් වන්නේ ඇයි?

මක්නිසාද යත් එය අපගේ හුරුපුරුදුකම සහ ප්‍රතිභානය බිඳ හෙළන හෙයිනි, වචනාර්ථයෙන් සමානකම්, සමානාත්මතාවය, සමගිය, සමාවයවිකතාව, අනන්‍යතාවය යනාදී ඕනෑම රසවත් සම්බන්ධතාවයක් සමාන වේ.

පරිවර්තනය ටයිප් කරන්න

ජාවාස්ක්‍රිප්ට් ප්‍රත්‍යක්‍ෂ සමානතාවයක් මත රඳා සිටීම වෙනුවට, වර්ග පරිවර්තනය පරිවර්තනය කරයි:

සමානාත්මතා ක්‍රියාකරු ඔපෙරන්ඩ් එකම වර්ගයට අයත් නොවේ නම් පරිවර්තනය කරයි, පසුව දැඩි සංසන්දනය අදාළ වේ.

නමුත් වර්ගය පරිවර්තනය අර්ථ දක්වන්නේ කෙසේද? බොහෝ ව්‍යතිරේකයන් සහිත සංකීර්ණ නීති මාලාවක් හරහා?

සමානතා සම්බන්ධතාවයක් ගොඩනඟා ගැනීමට උත්සාහ කිරීම

බූලියන්. පැහැදිලිවම trueහා falseසමාන නොවන අතර විවිධ පංතිවල සිටිය යුතුය.

අංක. වාසනාවකට මෙන්, සංඛ්‍යා වල සමානාත්මතාවය දැනටමත් මනාව නිර්වචනය කර ඇති අතර, විවිධ සංඛ්‍යා දෙකක් කිසි විටෙකත් එකම සමානතා පන්තියේ නොමැත. ගණිතයේ දී, එනම්. ජාවාස්ක්‍රිප්ට් හි සංඛ්‍යා පිළිබඳ සංකල්පය තරමක් විකෘති වී ඇත්තේ වඩාත් විදේශීය -0, Infinityසහ -Infinity. අපගේ ගණිතමය දෙබස් කවන ශිල්පීනියක ආඥාවන් 0හා -0එකම පන්තිය තුළ විය යුතු (ඇත්ත -0 === 0ය true), infinities එක් එක් වෙනම පන්ති ගතවේ.

අංක සහ බූලියන්. පන්ති අංක අනුව, අපි බූලියන් තබන්නේ කොහේද? falseසමාන බවට පත් වෙයි 0බැවින්ද, trueසමාන බවට පත් වෙයි 1නමුත් වෙනත් කිසිදු අංකය:

true == 1 // true
true == 2 // false

එහි කිසිදු තර්ක දමා මෙතන trueසමග එක්ව 1? පිළිගත හැකි 1ලෙස කැපී පෙනේ, නමුත් එසේ ය -1. මම පෞද්ගලිකව බවට පරිවර්තනය කිරීමට කිසිදු සාධාරණ හේතුවක් නැහැ trueකිරීමට 1.

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

true + 2 // 3
true - 1 // 0

එබැවින් trueසැබවින්ම 1සියලු සංඛ්‍යා අතරට පරිවර්තනය වේ! එය තර්කානුකූලද? එය බුද්ධිමත් ද? පිළිතුර ව්‍යායාමයක් ලෙස ඉතිරිව ඇත;)

නමුත් මේ ගැන කුමක් කිව හැකිද:

1 && true // true
2 && true // true

එකම වීජ xසමග x && trueවීම trueය x = true. දෙකම බව ඔප්පු 1හා 2(සහ වඩා වෙනත් ඕනෑම අංකය 0) පරිවර්තනය true! වීම - මොකක්ද ඒ පෙන්නුම් අපගේ පරිවර්තනය තවත් වැදගත් දේපල අසමත් බව ය bijection . විවිධ ආයතන දෙකක් එකම එකකට පරිවර්තනය කළ හැකි බව එයින් අදහස් වේ. එය තනිවම විශාල ගැටලුවක් විය යුතු නැත. විශාල පරිවර්තනයක් අප මෙම පරිවර්තනය භාවිතා කරන විට අපට එය හැඳින්වීමට අවශ්‍ය ඕනෑම දෙයක “සමානත්වය” හෝ “ලිහිල් සමානාත්මතාවය” පිළිබඳ විස්තරයක් විස්තර කරයි. නමුත් එක් දෙයක් පැහැදිලිය - එය සමානතා සම්බන්ධතාවයක් නොවනු ඇති අතර එය සමානතා පන්ති හරහා බුද්ධිමත්ව විස්තර කිරීමට යන්නේ නැත.

නමුත් අපට මීට වඩා හොඳින් කළ හැකිද?

අවම වශයෙන් ගණිතමය වශයෙන් - අනිවාර්යයෙන්ම ඔව්! Booleans සහ අංක අතර සරල සමතාව සම්බන්ධයෙන් පමණක් ඉදි කිරීමට falseහා 0එකම පන්තිය තුළ වීම. ඒ නිසා false == 0එකම-නොවැදගත් නොවන ලිහිල් සමානාත්මතාවය වනු ඇත.

නූල් ගැන කුමක් කිව හැකිද?

ආරම්භයේ සහ අවසානයේ සංඛ්‍යා බවට පරිවර්තනය කිරීම සඳහා අපට හිස් අවකාශයේ සිට නූල් කපා දැමිය හැකිය, එසේම අපට ඉදිරියෙන් ඇති ශුන්‍යයන් නොසලකා හැරිය හැකිය:

'   000 ' == 0 // true
'   0010 ' == 10 // true

එබැවින් අපට නූලක් සඳහා සරල රීතියක් ලැබේ - ඉදිරියෙන් ඇති සුදු අවකාශය සහ ශුන්‍යය කපා දමන්න. එක්කෝ අපට අංකයක් හෝ හිස් නූලක් ලැබෙනු ඇත, එම අවස්ථාවේදී අපි එම අංකයට හෝ ශුන්‍යයට පරිවර්තනය කරමු. නැතහොත් අපට අංකයක් ලැබෙන්නේ නැත, එවැනි අවස්ථාවකදී අපි හැරී නොයන අතර නව සම්බන්ධතාවයක් නොලැබේ.

මේ ආකාරයෙන් අපට ඇත්ත වශයෙන්ම සම්පූර්ණ බූලියන්, සංඛ්‍යා සහ නූල් සමූහයට පරිපූර්ණ සමානතා සම්බන්ධතාවයක් ලබා ගත හැකිය! එය හැර ... ජාවාස්ක්‍රිප්ට් නිර්මාණකරුවන්ට පැහැදිලිවම වෙනත් මතයක් තිබේ:

' ' == '' // false

එබැවින් දෙකම පරිවර්තනය කරන නූල් දෙක 0හදිසියේම සමාන නොවේ! ඇයි හෝ ඇයි? රීතියට අනුව, නූල් තදින් සමාන වන විට හරියටම ලිහිල්ව සමාන වේ! මෙම රීතිය අප දකින පරිදි පාරදෘශ්‍යතාව බිඳ දමනවා පමණක් නොව එය අතිරික්තයක් ද වේ! අනෙක් ක්‍රියාකරු ==සමඟ අනෙකට වඩා තදින් සමාන කිරීමට වෙනත් ක්‍රියාකරුවෙකු නිර්මාණය කිරීමේ තේරුම ===කුමක්ද?

නිගමනය

==සමහර මූලික ගණිතමය නීතිවලට අනුකූල නම් ලිහිල් සමානාත්මතා ක්‍රියාකරුට එය බෙහෙවින් ප්‍රයෝජනවත් වනු ඇත. නමුත් එය කනගාටුවට කරුණක් නොවන බැවින් එහි ප්‍රයෝජනය දුක් විඳියි.

ඔව්, මම ඒ සඳහා භාවිත නඩුවක් හරහා දිව ගියෙමි, එනම් ඔබ යතුරක් සංඛ්‍යාත්මක අගයක් සමඟ සංසන්දනය කරන විට :

for (var key in obj) {
    var some_number = foo(key, obj[key]);  // or whatever -- this is just an example
    if (key == some_number) {
        blah();
    }
}

මම එය ලෙස සංසන්දනය ඉටු කිරීමට වඩා ගොඩක් ස්වාභාවික හිතන්නේ key == some_numberලෙස වඩා Number(key) === some_numberහෝ key === String(some_number).

මම අද ඉතා ප්‍රයෝජනවත් යෙදුමක් හරහා දිව ගියෙමි. 01සාමාන්‍ය නිඛිල සංඛ්‍යාවක් මෙන් පෑඩ් අංක සංසන්දනය කිරීමට ඔබට අවශ්‍ය නම් ==එය හොඳින් ක්‍රියාත්මක වේ. උදාහරණයක් වශයෙන්:

'01' == 1 // true
'02' == 1 // false

එමඟින් 0 ඉවත් කර පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය වේ.

මෙය ප්‍රමාද පිළිතුරක් බව මම දනිමි, නමුත් යම් යම් ව්‍යාකූලතා ඇති බව පෙනේ , nullසහ undefinedIMHO යනු ==නපුරට හේතුවන දෙයයි , ඊට වඩා සංක්‍රාන්ති lack නතාවය, එය නරක ය. සලකා බලන්න:

p1.supervisor = 'Alice';
p2.supervisor = 'None';
p3.supervisor = null;
p4.supervisor = undefined;

මේවායින් අදහස් කරන්නේ කුමක්ද?

• p1 "ඇලිස්" යන නමින් අධීක්ෂකවරයෙක් සිටී.
• p2 "කිසිවක් නැත" යන නමින් අධීක්ෂකවරයෙක් සිටී.
• p3පැහැදිලිවම, නිසැකවම, අධීක්ෂකවරයෙකු නොමැත .
• p4අධීක්ෂකවරයෙකු හෝ විය හැකිය. අපි දන්නේ නැහැ, අපි ගණන් ගන්නේ නැහැ, අපි දැනගත යුතු නැහැ (රහස්‍යතා ප්‍රශ්නය?), එය අපගේ ව්‍යාපාරයක් නොවේ.

ඔබ භාවිතා කරන විට ==ඔබ ගොඩට දැමීමක් ද ඇත nullහා undefinedවන පූර්ණ අනිසි වේ. මෙම පද දෙකෙන් අදහස් කරන්නේ සම්පූර්ණයෙන්ම වෙනස් දේවල්! මගේ අධීක්ෂක කවුදැයි ඔබට පැවසීම ප්‍රතික්ෂේප කළ නිසා මට අධීක්ෂකවරයෙකු නොමැති බව පැවසීම වැරදිය!

මෙම වචන අතර වෙනස ගැන තැකීමක් නොකරන nullසහ undefinedමෙම යෙදුම් වෙනස් ලෙස භාවිතා කිරීමට තෝරා ගන්නා ක්‍රමලේඛකයින් සිටින බව මට වැටහේ . ඔබේ ලෝකය භාවිතා කරන්නේ නම් නැත nullහා undefinedනිවැරදිව නම්, හෝ ඔබ විසින් එය විය යුතු අතර, මෙම නියමයන් ඔබේ ම අර්ථ දෙන්න කැමති. මම හිතන්නේ නැහැ ඒක හොඳ අදහසක් කියලා.

දැන් මාර්ගය වන විට මට කිසිදු ගැටළුවක් නොමැති nullඅතර undefinedදෙදෙනාම බොරු ය! කීම කමක් නැත

if (p.supervisor) { ... }

එවිට nullසහ undefinedඅධීක්ෂක සැකසෙන කේතය මඟ හැරීමට හේතු වේ. එය නිවැරදියි, මන්ද අප නොදන්නා හෝ අධීක්ෂකවරයෙකු නොමැති බැවිනි. සියල්ල හොඳයි. නමුත් අවස්ථා දෙක සමාන නොවේ . මේ නිසා ==වැරදියි. නැවතත්, දේවල් ව්‍යාජ විය හැකි අතර තාරා ටයිප් කිරීමේ අර්ථයෙන් භාවිතා කළ හැකිය, එය ගතික භාෂාවන් සඳහා විශිෂ්ටයි. එය නිසි ජාවාස්ක්‍රිප්ට්, පයිතොනික්, රුබිෂ් යනාදියයි. නමුත් නැවතත්, මේ දේවල් සමාන නොවේ.

මට-transitivity නොවන දින ආරම්භ නැහැ ලබා ගන්න: "0x16" == 10, 10 == "10"නමුත් "10" == "0x16". ඔව්, ජාවාස්ක්‍රිප්ට් දුර්වල ලෙස වර්ග වේ. ඔව්, එය බලහත්කාරය. එහෙත් බලහත්කාරය කිසි විටෙකත් සමානාත්මතාවයට අදාළ නොවිය යුතුය.

මාර්ගය වන විට, ක්‍රොක්ෆර්ඩ්ට ප්‍රබල මත තිබේ. නමුත් ඔබ දන්නවාද මොකක්ද? ඔහු මෙහි නිවැරදියි!

FWIW ==පහසු අවස්ථා ඇති බව මම පෞද්ගලිකව තේරුම් ගෙන ඇත්තෙමි . සංඛ්‍යා සඳහා නූල් ආදානය ගැනීම හා 0 ට සාපේක්ෂව කියන්න. කෙසේ වෙතත්, මෙය හැක් වේ. ලෝකයේ සාවද්‍ය ආකෘතියක් සඳහා වෙළඳාමක් ලෙස ඔබට පහසුව ඇත.

TL; DR: ව්‍යාජත්වය යනු විශිෂ්ට සංකල්පයකි. එය සමානාත්මතාවයට ව්‍යාප්ත නොවිය යුතුය.