ජාවාස්ක්‍රිප්ට් හි නූල් සමානාත්මතාවය පරීක්ෂා කිරීමට නිවැරදි ක්‍රමය කුමක්ද?

ජාවාස්ක්‍රිප්ට් හි නූල් අතර සමානාත්මතාවය පරීක්ෂා කිරීමට නිවැරදි ක්‍රමය කුමක්ද?

සැමවිටම ඔබ==සහ===ක්‍රියාකරුවන්භාවිතා කිරීමේ වෙනස්කම් සහ ඇඟවුම් සම්පූර්ණයෙන් තේරුම් ගන්නා තෙක්, ක්‍රියාකරු භාවිතා කරන්න,===එය අපැහැදිලි (පැහැදිලි නොවන) දෝෂ සහ WTF වලින් ඔබව ගලවා ගනු ඇත. ==අභ්‍යන්තරව ටයිප්-බලහත්කාරය හේතුවෙන්"නිත්‍ය"ක්‍රියාකරුට ඉතා අනපේක්ෂිත ප්‍රති results ල ලබා ගත හැකිය, එබැවින් භාවිතා===කිරීම සැමවිටම නිර්දේශිත ප්‍රවේශය වේ.

මේ පිළිබඳ අවබෝධය සඳහා සහ ජාවාස්ක්‍රිප්ට් හි අනෙකුත් "හොඳ එදිරිව නරක" කොටස් ඩග්ලස් ක්‍රොක්ෆර්ඩ් මහතා සහ ඔහුගේ කෘති පිළිබඳව කියවනු ලැබේ. ඔහු හොඳ තොරතුරු රාශියක් සාරාංශ කරන විශිෂ්ට ගූගල් තාක්ෂණික කතාවක් තිබේ: http://www.youtube.com/watch?v=hQVTIJBZook

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

මෙම ඔබ එපා දැන හඳුනා JS කයිල් සිම්ප්සන් විසින් මාලාවක් විශිෂ්ට (හා සමඟ අමුත්තන් කියවීමට නිදහස්) වේ. මෙම කතා මාලාව භාෂාවේ පොදුවේ වරදවා වටහාගෙන ඇති ප්‍රදේශවලට ගොස් ක්‍රොක්ෆර්ඩ් ඔබට මඟ හැරීමට යෝජනා කරන “නරක කොටස්” පැහැදිලි කරයි. ඒවා තේරුම් ගැනීමෙන් ඔබට ඒවා නිසි ලෙස භාවිතා කළ හැකි අතර අන්තරායන් වළක්වා ගත හැකිය.

" ඉහළට සහ ඉදිරියට යාම " පොතේ සමානාත්මතාවය පිළිබඳ කොටසක් ඇතුළත් වන අතර , ලිහිල් ( ==) එදිරිව දැඩි ( ===) ක්‍රියාකරුවන් භාවිතා කළ යුත්තේ කවදාද යන්න පිළිබඳ මෙම නිශ්චිත සාරාංශය සමඟ :

සරල තොරතුරු කිහිපයක් සඳහා සම්පූර්ණ තොරතුරු තම්බා ගැනීමට සහ භාවිතා කිරීමට ==හෝ ===විවිධ අවස්ථාවන්හිදී ඔබට දැන ගැනීමට උදව් කිරීමට , මෙන්න මගේ සරල නීති:

• සංසන්දනයක දී අගය (අකා පැත්ත) trueහෝ falseඅගය විය හැකි නම් , වළක්වා ==භාවිතා කරන්න ===.
• සංසන්දනය එක්කෝ අගය මෙම නිශ්චිත අගයන් (විය හැකි නම් 0, ""හෝ [], වැලැක්විමට - හිස් අරා) ==හා භාවිතය ===.
• දී සියලු අවස්ථාවල දී, ඔයා තමයි භාවිතා කිරීමට ආරක්ෂිත ==. එය ආරක්ෂිත පමණක් නොව, බොහෝ අවස්ථාවලදී එය කියවීමේ හැකියාව වැඩි දියුණු කරන ආකාරයෙන් ඔබේ කේතය සරල කරයි.

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

ඒවා නූල් බව ඔබ දන්නේ නම්, වර්ගය පරීක්ෂා කිරීම අවශ්‍ය නොවේ.

"a" == "b"

කෙසේ වෙතත්, නූල් වස්තු සමාන නොවන බව සලකන්න.

new String("a") == new String("a")

බොරු නැවත පැමිණේ.

සංගීත වස්තු සඳහා ප්‍රාථමිකයක් බවට පරිවර්තනය කිරීම සඳහා අගය ඕෆ් () ක්‍රමය අමතන්න,

new String("a").valueOf() == new String("a").valueOf()

නැවත සත්‍ය වනු ඇත

පිළිතුරු සඳහා එක් එකතු කිරීමක් පමණි: මෙම සියලු ක්‍රම අසත්‍ය බවට පත්වුවහොත්, නූල් සමාන යැයි පෙනුනත්, එක් නූලක වමට හෝ දකුණට සුදු පැහැති අවකාශයක් තිබිය හැකිය. එබැවින්, .trim()සංසන්දනය කිරීමට පෙර නූල් අවසානයේ a එකක් තබන්න :

if(s1.trim() === s2.trim())
{
    // your code
}

වැරැද්ද කුමක්දැයි වටහා ගැනීමට මට පැය ගණනක් අහිමි වී ඇත. මෙය යමෙකුට උපකාරී වේ යැයි සිතමු!

මෙම ප්‍රශ්නයට මා යොමු කළේ paddingසහwhite-spaces

මගේ නඩුව පරීක්ෂා කරන්න

 if (title === "LastName")
      doSomething();

සහ මාතෘකාව විය " LastName"

ඒ නිසා සමහර විට ඔබට මේ trimවගේ ශ්‍රිතයක් භාවිතා කිරීමට සිදුවේ

var title = $(this).text().trim();

ජාවාස්ක්‍රිප්ට් වල නූල් සෑදිය හැකි ආකාර දෙකක් තිබේ.

1. var str = 'Javascript'; මෙය ප්‍රාථමික නූල් අගයක් නිර්මාණය කරයි.

2. var obj = new String('Javascript');මෙය වර්ගයේ එතීමේ වස්තුවක් නිර්මාණය කරයි String.

   typeof str // string
typeof obj // object

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

ඔබට වස්තු දෙකක් අතර සමානාත්මතාවය පරීක්ෂා කිරීමට අවශ්‍ය නම් භාවිතා String.prototype.valueOfකිරීම නිවැරදි ක්‍රමයයි.

new String('javascript').valueOf() == new String('javascript').valueOf()

සංගීත Objectsභාවිතා පරීක්ෂා කළ හැක JSON.stringyfy()උපක්රමය.

var me = new String("me");
var you = new String("me");
var isEquel = JSON.stringify(me) === JSON.stringify(you);
console.log(isEquel);

ඔබට භාවිතා කළ හැකි ==හෝ ===නමුත් පසුගිය තවත් එක් සරල ක්රමයක් (වැඩ src )

a == b (සහ එය ප්‍රතික්ෂේප කිරීම ! = )

a === b (සහ එය ප්‍රතික්ෂේප කිරීම ! == )

නූල් දෙකම ඉතා විශාල විය හැකි බව සලකන විට, ප්‍රධාන ප්‍රවේශයන් 2 ක් bitwise searchසහlocaleCompare

මම මෙම කාර්යය නැවත නිර්දේශ කළෙමි

function compareLargeStrings(a,b){
    if (a.length !== b.length) {
         return false;
    }
    return a.localeCompare(b) === 0;
}

පරීක්ෂා කිරීමේදී මම විකල්ප විසඳුමක් ඉදිරිපත් කළෙමි. ඔබට නූල් මූලාකෘතියේ ක්‍රියාකාරිත්වය භාවිතා කළ හැකිය.

String.prototype.betwenStr = function(one){

return JSON.stringify(new String(this)) === JSON.stringify(new String(one));

}


 //call it
 "hello world".betweenStr("hello world"); //returns boolean 
 //value

ක්‍රෝම් බ්‍රව්සර් වල හොඳින් ක්‍රියා කරයි