ජාවාස්ක්‍රිප්ට් හි වස්තු දේපලක් තිබේදැයි පරීක්ෂා කිරීමට හොඳම ක්‍රමය undefinedකුමක්ද?

දේපලක වටිනාකම විශේෂ වටිනාකම දැයි පරීක්ෂා කිරීමට සුපුරුදු ක්‍රමය නම් undefined:

if(o.myProperty === undefined) {
  alert("myProperty value is the special value `undefined`");
}

වස්තුවකට ඇත්ත වශයෙන්ම එවැනි දේපලක් නොමැතිදැයි පරීක්ෂා කිරීම සඳහා, undefinedඔබ උත්සාහ කර ප්‍රවේශ වූ විට පෙරනිමියෙන් ආපසු එනු ඇත :

if(!o.hasOwnProperty('myProperty')) {
  alert("myProperty does not exist");
}

හඳුනාගැනීමක් සමඟ සම්බන්ධිත අගය විශේෂ අගයද undefined, නැතහොත් එම අනන්‍යතාවය ප්‍රකාශයට පත් කර නොමැතිද යන්න පරීක්ෂා කිරීම. සටහන: මෙම ක්රමය ඉතා සඳහන් වන එකම ආකාරය වන්නේ අප්රසිද්ධ : (එහි වටිනාකම සහිත වෙනස් සටහනක් undefinedමුල් දෝෂයක් නොමැතිව හඳුනාගැනීමේ):

if(typeof myVariable === 'undefined') {
  alert('myVariable is either the special value `undefined`, or it has not been declared');
}

ECMAScript 5 ට පෙර ජාවාස්ක්‍රිප්ට් හි අනුවාද වල, ගෝලීය වස්තුවෙහි “නිර්වචනය නොකළ” නම් දේපල ලිවිය හැකි අතර, එබැවින් සරල චෙක්පතක් foo === undefinedඅහම්බෙන් නැවත අර්ථ දක්වා ඇත්නම් එය අනපේක්ෂිත ලෙස හැසිරෙනු ඇත. නූතන ජාවාස්ක්‍රිප්ට් හි, දේපල කියවීමට පමණි.

කෙසේ වෙතත්, නූතන ජාවාස්ක්‍රිප්ට් හි, “නිර්වචනය නොකළ” මූල පදයක් නොවන අතර, එම නිසා ශ්‍රිත තුළ ඇති විචල්‍යයන් “නිර්වචනය නොකළ” ලෙස නම් කළ හැකි අතර ගෝලීය දේපල සෙවනැල්ල කරයි.

මෙම (අනපේක්ෂිත) අද්දර නඩුව ගැන ඔබ කනස්සල්ලට පත්ව සිටී නම්, ඔබට අවලංගු ක්‍රියාකරු භාවිතා කර විශේෂ undefinedවටිනාකමක් ලබා ගත හැකිය:

if(myVariable === void 0) {
  alert("myVariable is the special value `undefined`");
}

මෙම මාතෘකාවට වැරදි පිළිතුරු ගණනාවක් ඇති බව මම විශ්වාස කරමි. පොදු විශ්වාසයන්ට පටහැනිව, "නිර්වචනය නොකළ" යනු ජාවාස්ක්‍රිප්ට් හි මූල පදයක් නොවන අතර ඇත්ත වශයෙන්ම එයට වටිනාකමක් ලබා දිය හැකිය.

නිවැරදි කේතය

මෙම පරීක්ෂණය සිදු කිරීමට වඩාත්ම ශක්තිමත් ක්‍රමය නම්:

if (typeof myVar === "undefined")

මෙය සැමවිටම නිවැරදි ප්‍රති result ලය ලබා දෙනු ඇති අතර myVarප්‍රකාශ නොකල තත්වය පවා හසුරුවයි .

කේතය පිරිහෙන්න. පාවිච්චි කරන්න එපා.

var undefined = false;  // Shockingly, this is completely legal!
if (myVar === undefined) {
    alert("You have been misled. Run away!");
}

මීට අමතරව, myVar === undefinedmyVar ප්‍රකාශයට පත් නොකල තත්වයේ දෝෂයක් මතු කරයි.

මෙහි වෙනත් බොහෝ පිළිතුරු මගින් දැඩි ලෙස නිර්දේශ කර ඇතත්, typeof එය නරක තේරීමකි . විචල්‍යයන්ට අගය තිබේදැයි පරීක්ෂා කිරීම සඳහා එය කිසි විටෙකත් භාවිතා නොකළ යුතුය undefined, මන්ද එය අගය සඳහා ඒකාබද්ධ පරීක්‍ෂණයක් ලෙස ක්‍රියා කරන undefinedඅතර විචල්‍යයක් තිබේද යන්න සොයා බැලීම සඳහා ය. බොහෝ අවස්ථාවන්හීදී, විචල්‍යයක් පවතින විට ඔබ දන්නා අතර typeofඔබ විචල්‍ය නාමයෙන් හෝ වචනාර්ථයෙන් අක්ෂර වින්‍යාසයක් කළහොත් නිහ silent ව අසමත් වීමේ විභවය හඳුන්වා දෙනු ඇත 'undefined'.

var snapshot = …;

if (typeof snaposhot === 'undefined') {
    //         ^
    // misspelled¹ – this will never run, but it won’t throw an error!
}

var foo = …;

if (typeof foo === 'undefned') {
    //                   ^
    // misspelled – this will never run, but it won’t throw an error!
}

එබැවින් ඔබ විශේෂාංග හඳුනාගැනීම සිදු නොකරන්නේ නම්, දී ඇති නමක් විෂය පථයට ඇතුළත් වේද යන්න අවිනිශ්චිතතාවයක් තිබේ නම් ( typeof module !== 'undefined'පොදු ජේඑස් පරිසරයට විශේෂිත කේතයේ පියවරක් ලෙස පරීක්ෂා කිරීම වැනි ), typeofවිචල්‍යයක භාවිතා කරන විට හානිකර තේරීමක් වන අතර නිවැරදි විකල්පය අගය කෙලින්ම සංසන්දනය කිරීමට:

var foo = …;

if (foo === undefined) {
    ⋮
}

මේ පිළිබඳ පොදු වැරදි වැටහීම් වලට ඇතුළත් වන්නේ:

• “ආරම්භ නොකළ” විචල්‍යය ( var foo) හෝ පරාමිතිය ( function bar(foo) { … }ලෙස හැඳින්වේ bar()) කියවීම අසාර්ථක වන බව. මෙය සරලවම සත්‍ය නොවේ - පැහැදිලි ආරම්භයක් නොමැති විචල්‍යයන් සහ අගයන් ලබා නොදුන් පරාමිතීන් සැමවිටම බවට පත්වන undefinedඅතර ඒවා සැමවිටම විෂය පථයට අයත් වේ.

• බව undefinedනැවත ලියවෙනු ඇත හැක. මේ සඳහා තවත් බොහෝ දේ ඇත. undefinedජාවාස්ක්‍රිප්ට් හි මූල පදයක් නොවේ. ඒ වෙනුවට, එය නිර්වචනය නොකළ අගය සහිත ගෝලීය වස්තුවේ දේපලකි. කෙසේ වෙතත්, ES5 සිට, මෙම දේපල කියවීමට පමණක් වන අතර වින්‍යාසගත කළ නොහැක. කිසිදු නවීන බ්‍රව්සරයක් undefinedදේපල වෙනස් කිරීමට ඉඩ නොදෙන අතර 2017 වන විට මෙය දීර් time කාලයක් තිස්සේ පැවතුනි. දැඩි මාදිලියක් නොමැතිකම ඔවුන්ගේ undefinedහැසිරීමට බලපාන්නේ නැත - එය undefined = 5විසි කිරීම වෙනුවට කිසිවක් නොකරන්න වැනි ප්‍රකාශ කරයි . එය මූල පදයක් නොවන බැවින්, ඔබට නම සමඟ විචල්‍යයන් ප්‍රකාශ කළ හැකි අතර undefined, එම විචල්‍යයන් වෙනස් කළ හැකි අතර, මෙය වරක් පොදු වූ රටාවක් බවට පත් කරයි:

  (function (undefined) {
      // …
  })()

  ගෝලීය භාවිතයට වඩා භයානක ය undefined. ඔබට ES3 අනුකූල විය යුතු නම්, ඒ වෙනුවට ආදේශ undefinedකරන්න void 0- යොමුවන්න එපා typeof. ( voidසෑම විටම ඕනෑම ක්‍රියාකාරීත්වයක් සඳහා නිර්වචනය නොකළ අගය තක්සේරු කරන ඒකීය ක්‍රියාකරුවෙකි.)

විචල්‍යයන් ක්‍රියා විරහිත වන ආකාරය සමඟ, සත්‍ය ප්‍රශ්නය ආමන්ත්‍රණය කිරීමට කාලයයි: වස්තු ගුණාංග. typeofවස්තු ගුණාංග සඳහා කිසි විටෙකත් භාවිතා කිරීමට හේතුවක් නැත . විශේෂාංග අනාවරණය කර ගැනීම පිළිබඳ පෙර ව්‍යතිරේකය මෙහි අදාළ නොවේ - typeofවිචල්‍යයන් පිළිබඳ විශේෂ හැසිරීමක් පමණක් ඇති අතර වස්තු ගුණාංග යොමු කරන විචල්‍යයන් විචල්‍ය නොවේ.

මෙය:

if (typeof foo.bar === 'undefined') {
    ⋮
}

වන සෑම විටම හරියටම සමාන this³ කිරීමට:

if (foo.bar === undefined) {
    ⋮
}

සමානාත්මතාවය පරීක්ෂා කිරීම සඳහා typeofභාවිතා ===කිරීම වඩාත් අර්ථවත් වන නිසාත්, පසුව විචල්‍යයක අගය පරික්ෂා කිරීම සඳහා එය ප්‍රතිනිර්මාණය කළ හැකි නිසාත්, එය සරල නිසාත්, ඔබ භාවිතා කරන්නේ ඇයිද යන්න පා readers කයන් ව්‍යාකූල කිරීමෙන් වළක්වා ගැනීමට ඉහත උපදෙස් සැලකිල්ලට ගැනීම. වඩා හොඳ පෙනුමක්, ඔබ සැමවිටම === undefinedමෙහි භාවිතා කළ යුතුය .

වස්තු ගුණාංග සම්බන්ධයෙන් සලකා බැලිය යුතු තවත් දෙයක් නම් ඔබට සැබවින්ම පරීක්ෂා කිරීමට අවශ්‍යද යන්නයි undefined. දී ඇති දේපල නමක් වස්තුවක් මත නොතිබිය හැකිය ( undefinedකියවන විට වටිනාකම නිපදවයි ), undefinedවටිනාකම සමඟ වස්තුවම ඉදිරිපත් කිරීම, වටිනාකම සමඟ වස්තුවේ මූලාකෘතිය undefinedමත ඉදිරිපත් කිරීම හෝ undefinedවටිනාකමක් නැති අයගෙන් එකක් හෝ ඉදිරිපත් කිරීම . 'key' in objයතුරක් වස්තුවක මූලාකෘති දාමයක කොතැනක හෝ Object.prototype.hasOwnProperty.call(obj, 'key')තිබේදැයි ඔබට කියනු ඇති අතර එය කෙලින්ම වස්තුව මත දැයි ඔබට කියනු ඇත. මූලාකෘති සහ වස්තු නූල් යතුරු සිතියම් ලෙස භාවිතා කිරීම පිළිබඳ මෙම පිළිතුරේ මම විස්තරාත්මකව නොයන්නෙමි, මන්දයත්, බොහෝ දුරට අදහස් කර ඇත්තේ මුල් ප්‍රශ්නයේ අර්ථ නිරූපණයන් නොසලකා වෙනත් පිළිතුරු වල ඇති සියලුම නරක උපදෙස් වලට විරුද්ධ වීමයි. කියවන්නවැඩි විස්තර සඳහා MDN හි වස්තු මූලාකෘති !

_{Variable අසාමාන්‍ය ලෙස උදාහරණ විචල්‍ය නාමය තෝරා ගැනීම? මෙය ෆයර්ෆොක්ස් සඳහා වන නොස්ක්‍රිප්ට් දිගුවේ නියම මළ කේතයයි.
Sc සාමාන්‍යයෙන් විෂය පථයේ ඇති දේ නොදැන සිටීම සුදුසු යැයි නොසිතන්න. ගතික විෂය පථය අනිසි ලෙස භාවිතා කිරීම නිසා ඇති වන ප්‍රසාද අවදානම: ව්‍යාපෘති ශුන්‍ය 1225
again නැවත වරක් ES5 + පරිසරයක් උපකල්පනය කරන අතර එය ගෝලීය වස්තුවේ දේපල undefinedගැන සඳහන් කරයි undefined. void 0වෙනත් ආකාරයකින් ආදේශ කරන්න .}

ජාවාස්ක්‍රිප්ට් හි ශුන්‍ය වන අතර නිර්වචනය කර නොමැත . ඔවුන්ට විවිධ අර්ථයන් ඇත.

• නිර්වචනය නොකළ අර්ථය නම් විචල්‍ය අගය අර්ථ දක්වා නොමැති බවයි; වටිනාකම කුමක්දැයි නොදනී.
• null යන්නෙන් අදහස් කරන්නේ විචල්ය අගය අර්ථ දක්වා ඇති අතර එය ශුන්‍ය ලෙස සකසා ඇත (කිසිදු වටිනාකමක් නැත).

මරිජ්න් හැවර්බෙක් සිය නිදහස්, මාර්ගගත පොතක් වන “ එලොකන්ට් ජාවාස්ක්‍රිප්ට් ” (අවධාරණය මගේ):

සමාන අගයක් ද ඇත, ශූන්‍යය, එහි අර්ථය 'මෙම අගය අර්ථ දක්වා ඇත, නමුත් එයට වටිනාකමක් නැත' යන්නයි. නිර්වචනය නොකළ සහ ශුන්‍ය අතර අර්ථයේ වෙනස බොහෝ දුරට ශාස්ත්‍රීය වන අතර සාමාන්‍යයෙන් එතරම් සිත්ගන්නා සුළු නොවේ. ප්‍රායෝගික වැඩසටහන් වලදී, යම් දෙයකට 'වටිනාකමක් තිබේද' යන්න පරීක්ෂා කිරීම බොහෝ විට අවශ්‍ය වේ. මෙම අවස්ථා වලදී, == නිර්වචනය නොකළ දෙයක් භාවිතා කළ හැකිය, මන්ද ඒවා හරියටම එකම අගයක් නොවුනත්, ශුන්‍ය == නිර්වචනය නොකළ සත්‍යය නිපදවනු ඇත.

එබැවින්, යමක් නිර්වචනය කර ඇත්දැයි පරීක්ෂා කිරීමට හොඳම ක්‍රමය වනු ඇතැයි මම සිතමි.

if (something == undefined)

මෙය උපකාරී වේ යැයි සිතමු!

සංස්කරණය කරන්න: ඔබගේ සංස්කරණයට ප්‍රතිචාර වශයෙන්, වස්තු ගුණාංග එකම ආකාරයකින් ක්‍රියා කළ යුතුය.

var person = {
    name: "John",
    age: 28,
    sex: "male"
};

alert(person.name); // "John"
alert(person.fakeVariable); // undefined

මෙයින් අදහස් කරන්නේ කුමක්ද: “නිර්වචනය නොකළ වස්තු දේපල” ?

ඇත්ත වශයෙන්ම එය වෙනස් කරුණු දෙකක් අදහස් කළ හැකිය! පළමුව, එය කිසි විටෙකත් වස්තුවෙහි අර්ථ දක්වා නොමැති දේපල අදහස් කළ හැකි අතර, දෙවනුව, අර්ථ දැක්විය නොහැකි වටිනාකමක් ඇති දේපල අදහස් කළ හැකිය . මෙම කේතය දෙස බලමු:

var o = { a: undefined }

ඇත o.aනිර්වචනය නොකළ? ඔව්! එහි වටිනාකම නිර්වචනය කර නැත. ඇත o.bනිර්වචනය නොකළ? ෂුවර්! 'බී' දේපළක් නැත! හරි, අවස්ථා දෙකේදීම විවිධ ප්‍රවේශයන් හැසිරෙන ආකාරය දැන් බලන්න:

typeof o.a == 'undefined' // true
typeof o.b == 'undefined' // true
o.a === undefined // true
o.b === undefined // true
'a' in o // true
'b' in o // false

අපට එය පැහැදිලිව දැකිය හැකි typeof obj.prop == 'undefined'අතර obj.prop === undefinedසමාන වේ, ඒවා එම වෙනස් තත්වයන් වෙන්කර හඳුනා නොගනී. හා 'prop' in objදේපළ සියලු දී අර්ථ දක්වා නැත විට ඇති අතර නිර්වචනය නොකළ යුතු විය හැකි දේපල වටිනාකම අවධානය යොමු කරන්නේ නැත තත්ත්වය හඳුනා ගත හැක.

ඉතින් කුමක් කළ යුතුද?

1) දේපලක් පළමු හෝ දෙවන අර්ථයෙන් නිර්වචනය කර ඇත්දැයි දැන ගැනීමට ඔබට අවශ්‍යය (වඩාත්ම සාමාන්‍ය තත්වය).

obj.prop === undefined // IMHO, see "final fight" below

2) ඔබට දැන ගැනීමට අවශ්‍ය වන්නේ වස්තුවට යම් දේපලක් තිබේද යන්න සහ එහි වටිනාකම ගැන තැකීමක් නොකරන්නේද යන්නයි.

'prop' in obj

සටහන්:

• ඔබට එකවර වස්තුවක් සහ එහි දේපල පරීක්ෂා කළ නොහැක. උදාහරණයක් ලෙස, x නිර්වචනය කර නොමැති නම් මෙය x.a === undefinedහෝ මෙය typeof x.a == 'undefined'මතු කරයි ReferenceError: x is not defined.
• විචල්‍යය undefinedයනු ගෝලීය විචල්‍යයකි (එබැවින් ඇත්ත වශයෙන්ම එය window.undefinedබ්‍රව්සර් වල ඇත). එය ECMAScript 1 වන සංස්කරණයේ සිට සහය දක්වන අතර ECMAScript 5 සිට එය කියවීමට පමණි . නූතන බ්‍රව්සර් වලදී බොහෝ කතුවරුන් අපව බිය ගැන්වීමට ප්‍රිය කරන බැවින් එය සත්‍ය ලෙස නැවත අර්ථ දැක්විය නොහැක , නමුත් පැරණි බ්‍රව්සර් සඳහා මෙය තවමත් සත්‍යයකි.

අවසාන සටන: obj.prop === undefinedඑදිරිවtypeof obj.prop == 'undefined'

ප්ලස් obj.prop === undefined:

• එය ටිකක් කෙටි වන අතර මඳක් ලස්සනයි
• ඔබ අක්ෂර වින්‍යාසය ලියා ඇත්නම් ජාවාස්ක්‍රිප්ට් එන්ජිම ඔබට දෝෂයක් ලබා දෙනු ඇත undefined

අවම obj.prop === undefined:

• undefined පැරණි බ්‍රව්සර් වල අභිබවා යා හැක

ප්ලස් typeof obj.prop == 'undefined':

• එය සැබවින්ම විශ්වීයයි! එය නව සහ පැරණි බ්‍රව්සර් වල ක්‍රියා කරයි.

අවම typeof obj.prop == 'undefined':

• 'undefned'( අක්ෂර වින්‍යාසය ) මෙහි ඇත්තේ නියත නියතයකි, එබැවින් මා කළාක් මෙන් ඔබ එය අක්ෂර වින්‍යාසය කර ඇත්නම් ජාවාස්ක්‍රිප්ට් එන්ජිමට ඔබට උදව් කළ නොහැක.

යාවත්කාලීන කිරීම (සේවාදායක පැත්තේ ජාවාස්ක්‍රිප්ට් සඳහා):

Node.js ගෝලීය විචල්ය සහය undefinedලෙස global.undefined(එය ද 'ගෝලීය' උපසර්ගය තොරව භාවිතා කළ හැක). සේවාදායක පැත්තේ ජාවාස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීම ගැන මම නොදනිමි.

ගැටළුව අවස්ථා තුනකට තල්ලු වේ:

1. වස්තුවට දේපළ ඇති අතර එහි වටිනාකම එසේ නොවේ undefined.
2. වස්තුවට දේපළ ඇති අතර එහි වටිනාකම වේ undefined.
3. වස්තුවට දේපළ නැත.

මෙය මා වැදගත් යැයි සලකන දෙයක් අපට කියයි:

නිර්වචනය නොකළ සාමාජිකයෙකු සහ නිර්වචනය නොකළ සාමාජිකයෙකු අතර වෙනසක් ඇත.

නමුත් අවාසනාවන්ත ලෙස typeof obj.fooඅපට ඇති අවස්ථා තුනෙන් කවරේදැයි අපට නොකියයි. කෙසේ වෙතත් අපට මෙය "foo" in objවෙන් කොට හඳුනාගත හැකිය.

                               |  typeof obj.x === 'undefined' | !("x" in obj)
1.                     { x:1 } |  false                        | false
2.    { x : (function(){})() } |  true                         | false
3.                          {} |  true                         | true

මෙම පරීක්ෂණ nullඇතුළත් කිරීම් සඳහා ද සමාන බව සඳහන් කිරීම වටී

                               |  typeof obj.x === 'undefined' | !("x" in obj)
                    { x:null } |  false                        | false

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

උදාහරණයක් ලෙස: මම දැන් කේත පොකුරක් ප්‍රතිනිර්මාණය කරමින් සිටිමි.

if( typeof blob.x != 'undefined' ) {  fn(blob.x); }

නිර්වචනය නොකළ චෙක්පතක් නොමැතිව ලියන විට එය වඩාත් පැහැදිලි විය.

if( "x" in blob ) { fn(blob.x); }

නමුත් සඳහන් කර ඇති පරිදි මේවා හරියටම සමාන නොවේ (නමුත් මගේ අවශ්‍යතා සඳහා ප්‍රමාණවත් නොවේ).

if ( typeof( something ) == "undefined") 

මෙය මට වැඩ කළ අතර අනෙක් අය එසේ නොකළේය.

භාවිතා සම්භවය එහිදී මට විශ්වාස නෑ ===සමඟ typeofසිට පැමිණි අතර, මම දකින සමුළුවක් ලෙස එය බොහෝ පුස්තකාලවල භාවිතා, නමුත් typeof ක්රියාකරු වැලක් ප්රායෝගික නැවත, අපි ඒක ඉදිරිපිට දන්නවා, ඉතින් ඇයි ඔබ ද වර්ගය අවශ්ය වනු ඇත එයත් පරීක්ෂා කරන්න?

typeof x;                      // some string literal "string", "object", "undefined"
if (typeof x === "string") {   // === is redundant because we already know typeof returns a string literal
if (typeof x == "string") {    // sufficient

අදාළ ප්‍රශ්නයෙන් මගේ පිළිතුර හරස් පෝස්ට් කිරීම ජාවාස්ක්‍රිප්ට් හි “නිර්වචනය නොකළ” දේ පරීක්ෂා කරන්නේ කෙසේද?

මෙම ප්‍රශ්නයට විශේෂිත, සමඟ පරීක්ෂණ අවස්ථා බලන්න someObject.<whatever>.

විවිධ පිළිතුරු වල ප්‍රති results ල විදහා දක්වන සමහර අවස්ථා: http://jsfiddle.net/drzaus/UVjM4/

( පරික්ෂා කරන ලද ආවරණයක් තුළ පරීක්ෂණ varසඳහා භාවිතා කිරීම inවෙනසක් ඇති කරන බව සලකන්න )

යොමු සඳහා කේතය:

(function(undefined) {
    var definedButNotInitialized;
    definedAndInitialized = 3;
    someObject = {
        firstProp: "1"
        , secondProp: false
        // , undefinedProp not defined
    }
    // var notDefined;

    var tests = [
        'definedButNotInitialized in window',
        'definedAndInitialized in window',
        'someObject.firstProp in window',
        'someObject.secondProp in window',
        'someObject.undefinedProp in window',
        'notDefined in window',

        '"definedButNotInitialized" in window',
        '"definedAndInitialized" in window',
        '"someObject.firstProp" in window',
        '"someObject.secondProp" in window',
        '"someObject.undefinedProp" in window',
        '"notDefined" in window',

        'typeof definedButNotInitialized == "undefined"',
        'typeof definedButNotInitialized === typeof undefined',
        'definedButNotInitialized === undefined',
        '! definedButNotInitialized',
        '!! definedButNotInitialized',

        'typeof definedAndInitialized == "undefined"',
        'typeof definedAndInitialized === typeof undefined',
        'definedAndInitialized === undefined',
        '! definedAndInitialized',
        '!! definedAndInitialized',

        'typeof someObject.firstProp == "undefined"',
        'typeof someObject.firstProp === typeof undefined',
        'someObject.firstProp === undefined',
        '! someObject.firstProp',
        '!! someObject.firstProp',

        'typeof someObject.secondProp == "undefined"',
        'typeof someObject.secondProp === typeof undefined',
        'someObject.secondProp === undefined',
        '! someObject.secondProp',
        '!! someObject.secondProp',

        'typeof someObject.undefinedProp == "undefined"',
        'typeof someObject.undefinedProp === typeof undefined',
        'someObject.undefinedProp === undefined',
        '! someObject.undefinedProp',
        '!! someObject.undefinedProp',

        'typeof notDefined == "undefined"',
        'typeof notDefined === typeof undefined',
        'notDefined === undefined',
        '! notDefined',
        '!! notDefined'
    ];

    var output = document.getElementById('results');
    var result = '';
    for(var t in tests) {
        if( !tests.hasOwnProperty(t) ) continue; // bleh

        try {
            result = eval(tests[t]);
        } catch(ex) {
            result = 'Exception--' + ex;
        }
        console.log(tests[t], result);
        output.innerHTML += "\n" + tests[t] + ": " + result;
    }
})();

සහ ප්‍රති results ල:

definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined

ඔබ එසේ කරන්නේ නම්

if (myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

විචල්‍යය myvarනොපවතින විට එය අසාර්ථක වනු ඇත , මන්ද මයිවර් නිර්වචනය කර නොමැති නිසා ස්ක්‍රිප්ට් එක කැඩී ඇති අතර පරීක්ෂණයට කිසිදු බලපෑමක් නැත.

කවුළු වස්තුවට ශ්‍රිතයකට පිටතින් ගෝලීය විෂය පථයක් (පෙරනිමි වස්තුවක්) ඇති බැවින් ප්‍රකාශයක් කවුළු වස්තුවට 'අමුණා' ඇත.

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

var myvar = 'test';

ගෝලීය විචල්‍ය මයිවර් එක window.myvar හෝ window ['myvar'] ට සමාන වේ.

ගෝලීය විචල්‍යයක් පවතින විට පරීක්ෂා කිරීම සඳහා දෝෂ මඟහරවා ගැනීම සඳහා, ඔබ වඩා හොඳ භාවිතා කරන්නේ:

if(window.myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

විචල්යයක් ඇත්ත වශයෙන්ම තිබේද යන ප්රශ්නය වැදගත් නැත, එහි වටිනාකම වැරදිය. එසේ නොමැති නම්, නිර්වචනය නොකළ විචල්‍යයන් ආරම්භ කිරීම මෝඩකමක් වන අතර, ආරම්භ කිරීම සඳහා අසත්‍ය අගය භාවිතා කිරීම වඩා හොඳය. ඔබ ප්‍රකාශ කරන සියලුම විචල්‍යයන් ව්‍යාජ ලෙස ආරම්භ කර ඇති බව ඔබ දැනගත් විට, ඔබට එහි වර්ගය !window.myvarපරීක්ෂා කර බැලීමට හෝ එයට නිසි / වලංගු අගයක් තිබේදැයි පරීක්ෂා කිරීමට විශ්වාසය තැබිය හැකිය. ඒ නිසා විචල්ය පසුව අර්ථ දක්වා නැත විට පවා !window.myvarසඳහා ම ය myvar = undefinedහෝ myvar = falseහෝ myvar = 0.

ඔබ විශේෂිත වර්ගයක් අපේක්ෂා කරන විට, විචල්‍යයේ වර්ගය පරීක්ෂා කරන්න. ඔබ වඩා හොඳ තත්වයක් පරීක්ෂා කිරීම වේගවත් කිරීම සඳහා:

if( !window.myvar || typeof window.myvar != 'string' )
{
    alert('var does not exists or is not type of string');
}

පළමු හා සරල කොන්දේසිය සත්‍ය වූ විට, පරිවර්තකයා ඊළඟ පරීක්ෂණ මඟ හැරේ.

වලංගු අගයක් තිබේදැයි පරීක්ෂා කිරීම සඳහා විචල්‍යයේ නිදසුන / වස්තුව භාවිතා කිරීම සැමවිටම හොඳය. එය වඩාත් ස්ථායී වන අතර ක්‍රමලේඛනයේ වඩා හොඳ ක්‍රමයකි.

(y)

දේපල ඉදිරිපිට කිසිවෙකු වස්තුව පරීක්ෂා කරන බවක් මා දුටුවේ නැත (මම එය අතපසු නොකළේ යැයි සිතමි). ඉතින්, මෙය කෙටිම හා වඩාත්ම effective ලදායී වේ (අවශ්‍යයෙන්ම වඩාත්ම පැහැදිලි නැත):

if (obj && obj.prop) {
  // Do something;
}

Obj හෝ obj.prop නිර්වචනය කර නොමැති නම්, ශුන්‍ය හෝ "ව්‍යාජ" නම්, if ප්‍රකාශය කේත වාරණය ක්‍රියාත්මක නොකරයි. මෙය සාමාන්‍යයෙන් බොහෝ කේත වාරණ ප්‍රකාශ වල (ජාවාස්ක්‍රිප්ට් වල) අපේක්ෂිත හැසිරීමයි.

ජාවාස්ක්‍රිප්ට් හි අබිස් ගවේෂණය කිරීම සහ නිර්වචනය නොකිරීම යන ලිපියෙන් මම කියවා ඇත්තේ Underscore.js වැනි රාමු මෙම ශ්‍රිතය භාවිතා කරන බවයි:

function isUndefined(obj){
    return obj === void 0;
}

හුදෙක් කිසිවක් ජාවාස්ක්‍රිප්ට් හි අර්ථ දක්වා නැත, නිර්වචනය කර නැත, එය වස්තුවක් / අරාවක් තුළ ඇති දේපලක් නම් කමක් නැත හෝ සරල විචල්‍යයක් ...

JavaScript ඇත typeof මඟින් නිර්වචනය නොකළ විචල්‍යයක් හඳුනා ගැනීම ඉතා පහසු කරයි.

දැයි පරීක්ෂා කරන්න typeof whatever === 'undefined' කර බැලීමෙන් එය බූලියන් නැවත ලබා දෙනු ඇත.

isUndefined()AngularJs v.1x හි ප්‍රසිද්ධ ශ්‍රිතය ලියා ඇත්තේ එලෙසිනි:

function isUndefined(value) {return typeof value === 'undefined';} 

ශ්‍රිතයට අගයක් ලැබෙන බව ඔබ දකින පරිදි, එම අගය අර්ථ දක්වා ඇත්නම්, එය නැවත ලැබෙනු ඇත false, එසේ නොමැති නම් නිර්වචනය නොකළ අගයන් සඳහා ආපසු එනු ඇතtrue .

එබැවින් පහත දැක්වෙන වස්තු ගුණාංග ඇතුළුව අපි අගයන් පසු කරන විට එහි ප්‍රති results ල කුමක් වේදැයි සොයා බලමු, මෙය අප සතුව ඇති විචල්‍යයන්ගේ ලැයිස්තුවයි:

var stackoverflow = {};
stackoverflow.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;

අපි ඒවා පහත පරිදි පරීක්ෂා කර බලමු, ඔබට ඔවුන් ඉදිරිපිට ප්‍රති a ල විවරණයක් ලෙස දැකිය හැකිය:

isUndefined(stackoverflow); //false
isUndefined(stackoverflow.javascipt); //false
isUndefined(today); //true
isUndefined(self); //false
isUndefined(num); //false
isUndefined(list); //false
isUndefined(y); //false
isUndefined(stackoverflow.java); //true
isUndefined(stackoverflow.php); //true
isUndefined(stackoverflow && stackoverflow.css); //true

ඔබ දකින පරිදි, අපගේ කේතයේ මෙවැනි දෙයක් භාවිතා කිරීමෙන් අපට ඕනෑම දෙයක් පරික්ෂා කළ හැකිය, සඳහන් කර ඇති පරිදි ඔබට typeofඔබේ කේතයේ සරලව භාවිතා කළ හැකිය , නමුත් ඔබ එය නැවත නැවතත් භාවිතා කරන්නේ නම්, මා බෙදා ගන්නා කෝණික නියැදිය වැනි ශ්‍රිතයක් සාදන්න සහ නැවත භාවිතා කරන්න පහත දැක්වෙන DRY කේත රටාව.

තවත් එක් දෙයක් නම්, සැබෑ යෙදුමක ඇති වස්තුවක දේපල පරික්ෂා කිරීම සඳහා, එම වස්තුව පවා තිබේදැයි ඔබට විශ්වාස නැති නම්, එම වස්තුව පළමුව තිබේදැයි පරීක්ෂා කරන්න.

ඔබ යම් වස්තුවක් මත දේපලක් පරික්ෂා කර බැලුවහොත් සහ වස්තුව නොපවතින්නේ නම්, දෝෂයක් ඇති වී මුළු යෙදුමම ක්‍රියාත්මක වනු ඇත.

isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)

ඉතා සරල නම් පහත දැක්වෙන පරිදි if ප්‍රකාශයක් තුළට ඔතා තැබිය හැකිය:

if(typeof x !== 'undefined') {
  //do something
}

කෝණික 1.x හි අර්ථ දක්වා ඇති දෙයට සමාන වේ ...

function isDefined(value) {return typeof value !== 'undefined';}

යටි ඉරි වැනි වෙනත් ජාවාස්ක්‍රිප්ට් රාමු වලට සමාන අර්ථ දැක්වීමක් ඇත, නමුත් typeofඔබ දැනටමත් කිසිදු රාමු භාවිතා නොකරන්නේ නම් භාවිතා කිරීමට මම නිර්දේශ කරමි .

යතුරු ලියනය, නිර්වචනය නොකළ සහ අවලංගු (0) පිළිබඳ ප්‍රයෝජනවත් තොරතුරු ලබාගෙන ඇති එම්.ඩී.එන්.

දැඩි සමානාත්මතාවය සහ නිර්වචනය නොකළ
විචල්‍යයකට වටිනාකමක් තිබේද යන්න තීරණය කිරීම සඳහා ඔබට නිර්වචනය නොකළ සහ දැඩි සමානාත්මතාවය සහ අසමානතා ක්‍රියාකරුවන් භාවිතා කළ හැකිය. පහත දැක්වෙන කේතයේ x විචල්‍යය නිර්වචනය කර නොමැති අතර if ප්‍රකාශය සත්‍ය ලෙස තක්සේරු කරයි.

var x;
if (x === undefined) {
   // these statements execute
}
else {
   // these statements do not execute
}

සටහන: සම්මත සමානාත්මතා ක්‍රියාකරුට වඩා දැඩි සමානාත්මතා ක්‍රියාකරු මෙහි භාවිතා කළ යුතුය. ශුන්‍යය නිර්වචනය කිරීමට සමාන නොවේ. විස්තර සඳහා සංසන්දනාත්මක ක්‍රියාකරුවන් බලන්න.

Typeof operator සහ undefined
විකල්පයක් ලෙස, typeof භාවිතා කළ හැකිය:

var x;
if (typeof x === 'undefined') {
   // these statements execute
}

Typeof භාවිතා කිරීමට එක් හේතුවක් නම් විචල්‍යය ප්‍රකාශ කර නොමැති නම් එය දෝෂයක් නොදක්වයි.

// x has not been declared before
if (typeof x === 'undefined') { // evaluates to true without errors
   // these statements execute
}

if (x === undefined) { // throws a ReferenceError

}

කෙසේ වෙතත්, මේ ආකාරයේ තාක්ෂණයෙන් වැළකී සිටිය යුතුය. ජාවාස්ක්‍රිප්ට් යනු සංඛ්‍යාත්මකව විෂය පථයට අයත් භාෂාවකි, එබැවින් විචල්‍යයක් ප්‍රකාශයට පත් කර ඇත්දැයි දැන ගැනීමෙන් එය සංවෘත සන්දර්භයක් තුළ ප්‍රකාශයට පත් කර ඇත්දැයි බැලීමෙන් කියවිය හැකිය. එකම ව්‍යතිරේකය වන්නේ ගෝලීය විෂය පථයයි, නමුත් ගෝලීය විෂය පථය ගෝලීය වස්තුවට බැඳී ඇත, එබැවින් ගෝලීය සන්දර්භය තුළ විචල්‍යයක පැවැත්ම පරීක්ෂා කිරීම ගෝලීය වස්තුව මත දේපලක පැවැත්ම පරීක්ෂා කිරීමෙන් කළ හැකිය (ක්‍රියාකරු භාවිතා කරමින්, උදාහරණයක් වශයෙන්).

අවලංගු ක්‍රියාකරු සහ නිර්වචනය නොකළ

අවලංගු ක්‍රියාකරු තුන්වන විකල්පයයි.

var x;
if (x === void 0) {
   // these statements execute
}

// y has not been declared before
if (y === void 0) {
   // throws a ReferenceError (in contrast to `typeof`)
}

more> මෙහි

' if (window.x) error } ' දෝෂය ආරක්ෂිතයි

බොහෝ දුරට ඔබට අවශ්යයි if (window.x). X ප්‍රකාශ කර නොමැති වුවද මෙම චෙක්පත ආරක්ෂිතයි ( var x;) - බ්‍රව්සරය දෝෂයක් නොදක්වයි.

උදාහරණය: මගේ බ්‍රව්සරය ඉතිහාස API සඳහා සහය දක්වයිදැයි දැන ගැනීමට මට අවශ්‍යය

if (window.history) {
    history.call_some_function();
}

මෙය ක්‍රියාත්මක වන ආකාරය:

කවුළුව යනු සියළුම ගෝලීය විචල්‍යයන් එහි සාමාජිකයන් ලෙස තබා ඇති වස්තුවක් වන අතර, නොපවතින සාමාජිකයෙකුට ප්‍රවේශ වීමට උත්සාහ කිරීම නීත්‍යානුකූල ය. නම් x ප්රකාශ කර නොමැති හෝ ඉන් නියම කර නැත window.xප්රතිලාභ නිර්වචනය නොකළ . නිර්වචනය නොකළ මඟ පෙන්වන බොරු විට නම් () එය පරීක්ෂා කර බැලීමයි.

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

කිසි විටෙකත් අර්ථ දක්වා නැත

වස්තුවක වටිනාකම කිසි විටෙක නිර්වචනය කර trueනොමැති නම්, මෙය අර්ථ දැක්වුවහොත් nullහෝ නැවත පැමිණීම වළක්වනු ඇත undefined. නියම කර ඇති අගයන් සඳහා සත්‍යය නැවත ලබා ගැනීමට ඔබට අවශ්‍ය නම් මෙය ප්‍රයෝජනවත් වේundefined

if(obj.prop === void 0) console.log("The value has never been defined");

නිර්වචනය නොකළ හෝ කිසි විටෙකත් අර්ථ දක්වා නැත

trueඅගය සමඟ අර්ථ දක්වා ඇති undefinedහෝ කිසි විටෙකත් අර්ථ දක්වා නැති අගයන් සඳහා එය ප්‍රති result ල ලබා ගැනීමට ඔබට අවශ්‍ය නම් , ඔබට සරලව භාවිතා කළ හැකිය=== undefined

if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined");

ව්‍යාජ වටිනාකමක් ලෙස අර්ථ දක්වා ඇති අතර, නිර්වචනය නොකළ, ශුන්‍ය හෝ කිසි විටෙක අර්ථ දක්වා නැත.

පොදුවේ, මේ අගය එක්කෝ falsy නම් හොයාගන්න ඇල්ගොරිතමයක් මට ඉල්ලා ඇත, undefinedහෝ null. පහත සඳහන් ක්‍රියා කරයි.

if(obj.prop == false || obj.prop === null || obj.prop === undefined) {
    console.log("The value is falsy, null, or undefined");
}

"propertyName" in obj //-> true | false

void 0ආතතිය සඳහා සංසන්දනය කරන්න .

if (foo !== void 0)

එය තරම් වාචික නොවේ if (typeof foo !== 'undefined')

විසඳුම වැරදිය. ජාවාස්ක්‍රිප්ට් හි,

null == undefined

ඒවා සත්‍යයක් බවට පත්වනු ඇත, මන්ද ඔවුන් දෙදෙනාම “බූලියන්” වෙතට තල්ලු කර ඇති අතර ඒවා අසත්‍යය. නිවැරදි ක්‍රමය වන්නේ පරීක්ෂා කිරීමයි

if (something === undefined)

අනන්‍යතා ක්‍රියාකරු ...

පහත දැක්වෙන කේතය භාවිතා කර ඔබට මාර්ගය සමඟ නිර්වචනය කර ඇති අරාව ලබා ගත හැකිය.

 function getAllUndefined(object) {

        function convertPath(arr, key) {
            var path = "";
            for (var i = 1; i < arr.length; i++) {

                path += arr[i] + "->";
            }
            path += key;
            return path;
        }


        var stack = [];
        var saveUndefined= [];
        function getUndefiend(obj, key) {

            var t = typeof obj;
            switch (t) {
                case "object":
                    if (t === null) {
                        return false;
                    }
                    break;
                case "string":
                case "number":
                case "boolean":
                case "null":
                    return false;
                default:
                    return true;
            }
            stack.push(key);
            for (k in obj) {
                if (obj.hasOwnProperty(k)) {
                    v = getUndefiend(obj[k], k);
                    if (v) {
                        saveUndefined.push(convertPath(stack, k));
                    }
                }
            }
            stack.pop();

        }

        getUndefiend({
            "": object
        }, "");
        return saveUndefined;
    }

jsFiddle සබැඳිය

මෙන්න මගේ තත්වය:

මම REST ඇමතුමක ප්‍රති result ලය භාවිතා කරමි. ප්‍රති result ලය JSON සිට JavaScript වස්තුවකට විග්‍රහ කළ යුතුය.

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

මෙයින් ආරක්ෂා වීමට මට මෙම ලිපිය භාවිතා කරන අතරේ, මම මෙය උත්සාහ කළෙමි.

if( typeof restResult.data[0] === "undefined" ) { throw  "Some error"; }

මගේ තත්වය සඳහා, restResult.data [0] === "වස්තුව" නම්, මට ආරක්ෂිතව සෙසු සාමාජිකයන් පරීක්ෂා කිරීම ආරම්භ කළ හැකිය. නිර්වචනය නොකළහොත් ඉහත පරිදි දෝෂය විසි කරන්න.

මා පවසන දෙය නම් මගේ තත්වය සඳහා මෙම ලිපියේ ඉහත යෝජනා සියල්ලම ක්‍රියාත්මක නොවීමයි. මම කියන්නේ නැහැ මම හරි, හැමෝම වැරදියි කියලා. මම කිසිසේත් ජාවාස්ක්‍රිප්ට් මාස්ටර් නොවෙමි, නමුත් මෙය යමෙකුට උපකාරී වනු ඇතැයි බලාපොරොත්තු වෙමි.

නිර්වචනය කරන ලද දේපලක් නව විචල්‍යයකට අර්ථ දැක්වුවහොත් එය පැවරීමට හොඳ හෝ අලංකාර ක්‍රමයක් ඇත.

var a = obj.prop || defaultValue;

ඔබට අතිරේක වින්‍යාස දේපලක් ලැබෙන ශ්‍රිතයක් තිබේ නම් එය සුදුසු ය:

var yourFunction = function(config){

   this.config = config || {};
   this.yourConfigValue = config.yourConfigValue || 1;
   console.log(this.yourConfigValue);

}

දැන් ක්රියාත්මක කරයි

yourFunction({yourConfigValue:2});
//=> 2

yourFunction();
//=> 1

yourFunction({otherProperty:5});
//=> 1

සියලුම පිළිතුරු අසම්පූර්ණයි. 'නිර්වචනය නොකළ' ලෙස අර්ථ දක්වා ඇති දේපලක් ඇති බව දැන ගැනීමේ නිවැරදි ක්‍රමය මෙයයි:

var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){
  return ((prop in obj) && (typeof obj[prop] == 'undefined')) ;
} ;

උදාහරණයක්:

var a = { b : 1, e : null } ;
a.c = a.d ;

hasUndefinedProperty(a, 'b') ; // false : b is defined as 1
hasUndefinedProperty(a, 'c') ; // true : c is defined as undefined
hasUndefinedProperty(a, 'd') ; // false : d is undefined
hasUndefinedProperty(a, 'e') ; // false : e is defined as null

// And now...
delete a.c ;
hasUndefinedProperty(a, 'c') ; // false : c is undefined

මෙය නිවැරදි පිළිතුර වීම වැරදිසහගත පිළිතුරු වල තැන්පත් කර ඇත> _ <

ඉතින්, ඒ හරහා යන ඕනෑම කෙනෙකුට, මම ඔබට නිර්වචන නොමිලේ ලබා දෙන්නෙමි !!

var undefined ; undefined ; // undefined
({}).a ;                    // undefined
[].a ;                      // undefined
''.a ;                      // undefined
(function(){}()) ;          // undefined
void(0) ;                   // undefined
eval() ;                    // undefined
1..a ;                      // undefined
/a/.a ;                     // undefined
(true).a ;                  // undefined

අදහස් විමසා බැලීමේදී, දෙකම පරීක්ෂා කිරීමට කැමති අයට එය නිර්වචනය කර නොමැතිද නැතහොත් එහි වටිනාකම අහෝසි වේ:

//Just in JavaScript
var s; // Undefined
if (typeof s == "undefined" || s === null){
    alert('either it is undefined or value is null')
}

ඔබ jQuery පුස්තකාලය භාවිතා කරන්නේ නම් jQuery.isEmptyObject()මෙම අවස්ථා දෙකටම ප්‍රමාණවත් වේ,

var s; // Undefined
jQuery.isEmptyObject(s); // Will return true;

s = null; // Defined as null
jQuery.isEmptyObject(s); // Will return true;

//Usage
if (jQuery.isEmptyObject(s)) {
    alert('Either variable:s is undefined or its value is null');
} else {
     alert('variable:s has value ' + s);
}

s = 'something'; // Defined with some value
jQuery.isEmptyObject(s); // Will return false;

ඔබ කෝණික භාවිතා කරන්නේ නම්:

angular.isUndefined(obj)
angular.isUndefined(obj.prop)

Underscore.js:

_.isUndefined(obj) 
_.isUndefined(obj.prop) 

if (this.variable)එය නිර්වචනය කර ඇත්දැයි පරීක්ෂා කිරීමට මම භාවිතා කරමි . ඉහත නිර්දේශ කර ඇති සරල if (variable), මා අසමත් වේ. එය ක්‍රියාත්මක වන්නේ විචල්‍යය කිසියම් වස්තුවක ක්ෂේත්‍රයක් වූ විට පමණක් බව එය ශබ්ද කෝෂයේ අර්ථ දක්වා ඇත්දැයි පරීක්ෂා කරයි. නමුත් අපි භාවිත කළ හැක හෝ ඕනෑම විචල්ය, වර්තමාන කවුළුව තුළ ක්ෂේත්ර නිසා මම එය තේරුම් ලෙස ශබ්ද කෝෂය වස්තුව ලෙස. එබැවින් මෙන්න පරීක්ෂණයකිobj.someFieldthiswindow

if (this.abc) alert("defined"); else alert("undefined");

abc = "abc";
if (this.abc) alert("defined"); else alert("undefined");

විචල්‍යය abcනිර්වචනය කර නොමැති බව එය මුලින්ම හඳුනා ගන්නා අතර එය ආරම්භ කිරීමෙන් පසුව අර්ථ දැක්වේ.

අමුතු පිළිතුරු බලාපොරොත්තු වන අය සඳහා මම මෙහි ක්‍රම තුනක් සපයමි:

function isUndefined1(val) {
    try {
        val.a;
    } catch (e) {
        return /undefined/.test(e.message);
    }
    return false;
}
function isUndefined2(val) {
    return !val && val+'' === 'undefined';
}
function isUndefined3(val) {
    const defaultVal={};
    return ((input=defaultVal)=>input===defaultVal)(val);
}
function test(func){
    console.group(`test start :`+func.name);
    console.log(func(undefined));
    console.log(func(null));
    console.log(func(1));
    console.log(func("1"));
    console.log(func(0));
    console.log(func({}));
    console.log(func(function () { }));
    console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);

isUndefined1:

ආදාන අගයේ දේපලක් ලබා ගැනීමට උත්සාහ කරන්න, දෝෂ පණිවිඩය තිබේදැයි පරීක්ෂා කරන්න. ආදාන අගය නිර්වචනය කර නොමැති නම්, දෝෂ පණිවිඩය වනු ඇත Uncought TypeError : නිර්වචනය නොකළ දේපල 'b' කියවිය නොහැක

isUndefined2:

සංසන්දනය කිරීම සඳහා ආදාන අගය නූල් බවට පරිවර්තනය කරන්න "undefined" බවට පරිවර්තනය කර එය negative ණ අගයක් බව සහතික කරන්න.

isUndefined3:

Js හි, ආදාන අගය හරියටම වූ විට විකල්ප පරාමිතිය ක්‍රියා කරයි undefined.

ES2019 නව අංගයක් හඳුන්වා දුන්නේය - වෛකල්පිත දම්වැලක් මඟින් ඔබට වස්තුවක දේපලක් භාවිතා කිරීමට භාවිතා කළ හැක්කේ වස්තුවක් මේ ආකාරයට අර්ථ දක්වා ඇති විට පමණි:

const userPhone = user?.contactDetails?.phone;

එය දුරකථන දේපල ගැන සඳහන් කරන්නේ පරිශීලකයා සහ සම්බන්ධතා විස්තර නිර්වචනය කළ විට පමණි.

Ref. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining

function isUnset(inp) {
  return (typeof inp === 'undefined')
}

විචල්‍යය සකසා ඇත්නම් සාවද්‍ය වන අතර නිර්වචනය කර නොමැති නම් සත්‍ය වේ.

ඉන්පසු භාවිතා කරන්න:

if (isUnset(var)) {
  // initialize variable here
}

undefinedවිචල්‍යය ආරක්ෂා කිරීම සඳහා මා භාවිතා කරන දෙයක් ඔබට පෙන්වීමට මම කැමතියි :

Object.defineProperty(window, 'undefined', {});

මෙය ඕනෑම කෙනෙකුට window.undefinedඅගය වෙනස් කිරීමට තහනම් කරයි, එම නිසා එම විචල්‍යය මත පදනම් වූ කේතය විනාශ කරයි. භාවිතා කරන්නේ නම් "use strict", එහි වටිනාකම වෙනස් කිරීමට උත්සාහ කරන ඕනෑම දෙයක් වැරදීමකින් අවසන් වනු ඇත, එසේ නොමැති නම් එය නිහ ly ව නොසලකා හරිනු ඇත.

ඔබට ප්‍රොක්සි භාවිතා කළ හැකිය, එය කැදැලි ඇමතුම් සමඟ ක්‍රියා කරයි, නමුත් එක් අමතර චෙක්පතක් අවශ්‍ය වේ:

function resolveUnknownProps(obj, resolveKey) {
  const handler = {
    get(target, key) {
      if (
        target[key] !== null &&
        typeof target[key] === 'object'
      ) {
        return resolveUnknownProps(target[key], resolveKey);
      } else if (!target[key]) {
        return resolveUnknownProps({ [resolveKey]: true }, resolveKey);
      }

      return target[key];
    },
  };

  return new Proxy(obj, handler);
}

const user = {}

console.log(resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else); // { isUndefined: true }

එබැවින් ඔබ එය භාවිතා කරන්නේ:

const { isUndefined } = resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else;
if (!isUndefined) {
  // do someting
}