ජාවාස්ක්‍රිප්ට් හි වස්තුවකට නිශ්චිත දේපලක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද?

ජාවාස්ක්‍රිප්ට් හි වස්තුවකට නිශ්චිත දේපලක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද?

සලකා බලන්න:

x = {'key': 1};
if ( x.hasOwnProperty('key') ) {
    //Do this
}

එය කළ හැකි හොඳම ක්‍රමය එයද?

ලබා දී ඇති පිළිතුරු වලින් මම ඇත්තටම ව්‍යාකූල වී සිටිමි - ඒවායින් බොහොමයක් සම්පූර්ණයෙන්ම වැරදිය. ඇත්ත වශයෙන්ම ඔබට නිර්වචනය නොකළ, ශුන්‍ය හෝ ව්‍යාජ අගයන් ඇති වස්තු ගුණාංග තිබිය හැකිය. එබැවින් දේපල පරීක්ෂාව අඩු කිරීම typeof this[property]හෝ ඊටත් වඩා නරක යx.key ඔබට සම්පූර්ණයෙන්ම නොමඟ යවන ප්‍රති .ල ලබා දෙනු ඇත.

එය ඔබ සොයන දේ මත රඳා පවතී. යම් වස්තුවක භෞතිකව දේපලක් තිබේදැයි දැන ගැනීමට ඔබට අවශ්‍ය නම් (එය මූලාකෘති දාමයේ කොතැනක හෝ එන්නේ නැත) එවිට object.hasOwnPropertyයා යුතු මාර්ගයයි. සියලුම නවීන බ්‍රව්සර් එයට සහය දක්වයි. (සෆාරි - 2.0.1 සහ ඊට වඩා පැරණි අනුවාද වල එය අස්ථානගත වී ඇත, නමුත් බ්‍රව්සරයේ එම අනුවාදයන් කලාතුරකින් භාවිතා වේ.)

ඔබ සොයන දෙය නම්, යම් වස්තුවක් මත එය නැවත ලබා ගත හැකි දේපලක් තිබේ නම් (ඔබ එම වස්තුවේ ගුණාංග ඉක්මවා යන විට එය දිස්වනු ඇත) එසේ කිරීමෙන්: prop in objectඔබට අපේක්ෂිත ප්‍රති give ල ලබා දෙනු ඇත.

භාවිතා hasOwnPropertyකිරීම බොහෝ විට ඔබට අවශ්‍ය දේ වන අතර, ඔබට ආපසු හැරවීමේ ක්‍රමයක් අවශ්‍ය විය හැකි බැවින්, මම ඔබට පහත විසඳුම ඉදිරිපත් කරමි:

var obj = {
    a: undefined,
    b: null,
    c: false
};

// a, b, c all found
for ( var prop in obj ) {
    document.writeln( "Object1: " + prop );
}

function Class(){
    this.a = undefined;
    this.b = null;
    this.c = false;
}

Class.prototype = {
    a: undefined,
    b: true,
    c: true,
    d: true,
    e: true
};

var obj2 = new Class();

// a, b, c, d, e found
for ( var prop in obj2 ) {
    document.writeln( "Object2: " + prop );
}

function hasOwnProperty(obj, prop) {
    var proto = obj.__proto__ || obj.constructor.prototype;
    return (prop in obj) &&
        (!(prop in proto) || proto[prop] !== obj[prop]);
}

if ( Object.prototype.hasOwnProperty ) {
    var hasOwnProperty = function(obj, prop) {
        return obj.hasOwnProperty(prop);
    }
}

// a, b, c found in modern browsers
// b, c found in Safari 2.0.1 and older
for ( var prop in obj2 ) {
    if ( hasOwnProperty(obj2, prop) ) {
        document.writeln( "Object2 w/ hasOwn: " + prop );
    }
}

ඉහත දැක්වෙන්නේ hasOwnPropertyඑක් අවවාදයක් සමඟ වැඩ කරන, හරස් බ්‍රව්සරයකි, විසඳුමකි : මූලාකෘතියේ හා නිදසුනක් ලෙස සමාන දේපලක් ඇති අවස්ථා අතර වෙනස හඳුනා ගැනීමට එයට නොහැකි ය - එය උපකල්පනය කරන්නේ එය මූලාකෘතියෙන් එන බවයි. ඔබේ තත්වය මත පදනම්ව ඔබට එය වඩාත් සැහැල්ලු හෝ දැඩි ලෙස වෙනස් කළ හැකිය, නමුත් අවම වශයෙන් මෙය වඩාත් ප්‍රයෝජනවත් විය යුතුය.

සමඟ Underscore.jsහෝ ( ඊටත් වඩා හොඳ ) lodash:

_.has(x, 'key');

කුමන ඇමතුම් Object.prototype.hasOwnProperty, නමුත් (අ) ටයිප් කිරීමට කෙටි වන අතර (ආ) “වෙත ආරක්ෂිත යොමු කිරීමක් hasOwnProperty” භාවිතා කරයි (එනම් එය ක්‍රියාත්මක වුවද)hasOwnProperty නැවත ලියනු වේ).

විශේෂයෙන්, ලොඩාෂ් මෙසේ අර්ථ දක්වයි _.has:

   function has(object, key) {
      return object ? hasOwnProperty.call(object, key) : false;
   }
   // hasOwnProperty = Object.prototype.hasOwnProperty

කුමක් ගැනද?

var x = {'key': 1};

if ('key' in x) {
    console.log('has');
}

සටහන : පහත දැක්වෙන දෑ වර්තමානයේ බොහෝ දුරට යල්පැන ඇති අතර දැඩි ක්‍රමයට ස්තුති වේ hasOwnProperty. නිවැරදි විසඳුම වන්නේ දැඩි මාදිලියක් භාවිතා කිරීම සහ භාවිතා කරන දේපලක් තිබේද යන්න පරීක්ෂා කිරීමයි obj.hasOwnProperty. මෙම පිළිතුර මේ කාරණා දෙකටම පෙර , අවම වශයෙන් පුළුල් ලෙස ක්‍රියාත්මක කර ඇත (ඔව්, එය පැරණි ය). පහත දැක්වෙන සටහන a තිහාසික සටහනක් ලෙස ගන්න.

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

එබැවින් වඩාත් ශක්තිමත් ක්‍රමයක් පහත දැක්වේ:

if (typeof(x.attribute) !== 'undefined')

අනෙක් පැත්තෙන්, මෙම ක්‍රමය වඩාත් වාචික හා මන්දගාමී වේ. : - / /

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

(function (undefined) {
    … your code …
    if (x.attribute !== undefined)
        … mode code …
})();

if (x.key !== undefined)

ආමින් රොනාචර් දැනටමත් මට එයට පහර දී ඇති බව පෙනේ , නමුත්:

Object.prototype.hasOwnProperty = function(property) {
    return this[property] !== undefined;
};

x = {'key': 1};

if (x.hasOwnProperty('key')) {
    alert('have key!');
}

if (!x.hasOwnProperty('bar')) {
    alert('no bar!');
}

ඒ ආරක්ෂිත, නමුත් මන්දගාමී විසඳුමක් පෙන්වා දෙන පරිදි විසින් කොන්රාඩ් රුඩොල්ෆ් හා Armin Ronacher වනු ඇත:

Object.prototype.hasOwnProperty = function(property) {
    return typeof this[property] !== 'undefined';
};

inවස්තුවක් මත දේපල තිබේදැයි පරීක්ෂා කිරීමට ඔබට ක්‍රියාකරු භාවිතා කළ හැකිය :

x = {'key': 1};
alert("key" in x);

ඔබට ලූපයක් භාවිතා කර වස්තුවේ සියලුම ගුණාංග හරහා ලූපයක් ලබා ගත හැකි for - inඅතර පසුව නිශ්චිත දේපල සඳහා පරීක්ෂා කරන්න:

for (prop in x) {
    if (prop == "key") {
        //Do something
    }
}

මෙම වස්තු දේපල ගණන් කළ හැකි ද නැද්ද යන්න ඔබ සලකා බැලිය යුතුය, මන්ද ගණන් කළ නොහැකි ගුණාංග for-inපුඩුවක් තුළ නොපෙන්වයි . එසේම, ගණන් කළ නොහැකි දේපල මූලාකෘතියේ ගණනය කළ නොහැකි දේපලක් සෙවනැලි කරන්නේ නම්, එය ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් 8 හි නොපෙන්වයි සහ ඊට පෙර .

ගණන් කළ හැකි වුවත් නැතත්, ඔබට සියලු නිදර්ශන දේපල ලැයිස්තුවක් අවශ්‍ය නම්, ඔබට භාවිතා කළ හැකිය

Object.getOwnPropertyNames(x);

මෙය වස්තුවක පවතින සියලුම ගුණාංගවල නම් පෙළක් ලබා දෙනු ඇත.

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

if (typeof x.key == "undefined") {
    alert("undefined");
}

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

යාවත්කාලීන කිරීම: නිර්වචනය නොකළ ජාවාස්ක්‍රිප්ට් දේපල හා සැසඳීමෙන් ඔබට දේපලක් තිබේදැයි පරීක්ෂා කළ හැකිය

if (x.key === undefined) {
    alert("undefined");
}

undefinedX වස්තුව මත යතුර නිශ්චිතව සකසා නොමැති නම් මෙය ක්‍රියාත්මක විය යුතුය

මෙහි යම් ව්‍යාකූලත්වයක් ඇති කර ගනිමු. පළමුව, hasOwnPropertyදැනටමත් පවතින බව උපකල්පනය කිරීමෙන් සරල කරමු ; භාවිතයේ පවතින වර්තමාන බ්‍රව්සර්වලින් බහුතරයක් සම්බන්ධයෙන් මෙය සත්‍යයකි.

hasOwnPropertyඑයට ලබා දුන් ආරෝපණ නාමය වස්තුවට එකතු කර ඇත්නම් එය සත්‍ය වේ. එය පවරා ඇති සත්‍ය වටිනාකමෙන් එය සම්පූර්ණයෙන්ම ස්වාධීන වේ undefined.

එබැවින්:

var o = {}
o.x = undefined

var a = o.hasOwnProperty('x')  // a is true
var b = o.x === undefined // b is also true

කෙසේවෙතත්:

var o = {}

var a = o.hasOwnProperty('x')  // a is now false
var b = o.x === undefined // b is still true

ගැටළුව වන්නේ මූලාකෘති දාමයේ ඇති වස්තුවකට නිර්වචනය නොකළ අගය සමඟ ලක්ෂණයක් ඇති විට කුමක් සිදුවේද? hasOwnPropertyඒ සඳහා අසත්‍ය වනු ඇත !== undefined. තවම,for..in එය තවමත් ගණන් බැලීමේදී ලැයිස්තුගත කරනු ඇත.

අවසාන කරුණ __prototype__නම්, නිශ්චිත හඳුනාගැනීමක් වස්තුවකට හෝ එහි මූලාකෘති දාමයේ කිසිවක් සම්බන්ධ කර නොමැති බව තීරණය කිරීම සඳහා හරස් බ්‍රව්සර් ක්‍රමයක් නොමැති වීමයි (ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් නිරාවරණය නොවන බැවින් ).

ඔබ දේපලක් සොයන්නේ නම් "නැත". ඔබට අවශ්‍යයි:

if ('prop' in obj) { }

පොදුවේ ගත් කල, දේපල මූලාකෘතියෙන් හෝ වස්තුවෙන් ලැබුණත් නැතත් ඔබ සැලකිලිමත් නොවිය යුතුය.

කෙසේ වෙතත්, ඔබ ඔබේ නියැදි කේතයේ 'යතුර' භාවිතා කර ඇති නිසා, ඔබ වස්තුව හැෂ් ලෙස සලකන බවක් පෙනේ, එවිට ඔබේ පිළිතුර අර්ථවත් වනු ඇත. සියලුම හැෂ් යතුරු වස්තුවෙහි ගුණාංග වන අතර, මූලාකෘතිය මඟින් දායක වන අමතර ගුණාංග ඔබ මග හැරේ.

ජෝන් රෙසිග්ගේ පිළිතුර ඉතා පුළුල් ය, නමුත් එය පැහැදිලි නැතැයි මම සිතුවෙමි. විශේෂයෙන් obj හි "මුක්කු" භාවිතා කළ යුත්තේ කවදාද යන්න සමඟ.

සරල වස්තු පරීක්ෂා කිරීම සඳහා: if (obj[x] !== undefined)

එය භාවිතා කරන්නේ කුමන වස්තු වර්ගයදැයි ඔබ නොදන්නේ නම්: if (obj.hasOwnProperty(x))

අනෙක් සියලුම විකල්ප මන්දගාමී වේ ..

විස්තර

මෙහි වෙනත් අය විසින් යෝජනා කරන ලද විකල්ප 5 ට Nodejs යටතේ චක්‍ර 100,000,000 ක කාර්ය සාධනය ඇගයීම:

function hasKey1(k,o) { return (x in obj); }
function hasKey2(k,o) { return (obj[x]); }
function hasKey3(k,o) { return (obj[x] !== undefined); }
function hasKey4(k,o) { return (typeof(obj[x]) !== 'undefined'); }
function hasKey5(k,o) { return (obj.hasOwnProperty(x)); }

ඇගයීම අපට පවසන්නේ අපට නිශ්චිතවම වස්තුවේ මූලාකෘති දාමය මෙන්ම වස්තුවම පරීක්ෂා කිරීමට අවශ්‍ය නම් මිස, අපි පොදු ස්වරූපය භාවිතා නොකළ යුතු බවයි: භාවිත අවස්ථාව අනුව if (X in Obj)... එය 2 සිට 6 ගුණයක් මන්දගාමී වේ

hasKey1 execution time: 4s 510.427785ms
hasKey2 execution time: 0s 904.374806ms
hasKey3 execution time: 0s 760.336193ms
hasKey4 execution time: 0s 935.19901ms
hasKey5 execution time: 2s 148.189608ms

බොටම් ලයින්, ඔබේ Obj අනිවාර්යයෙන්ම සරල වස්තුවක් නොවේ නම් සහ ඔබ වස්තුවේ මූලාකෘති දාමය පරික්ෂා කිරීමෙන් වැළකී x සෘජුවම Obj සතු බව සහතික කිරීමට නම්, 'if (obj.hasOwnProperty (x)) ...' භාවිතා කරන්න.

එසේ නොමැතිනම්, සරල වස්තුවක් භාවිතා කරන විට සහ වස්තුවේ මූලාකෘති දාමය ගැන කරදර නොවී, භාවිතා if (typeof(obj[x]) !== 'undefined')...කිරීම ආරක්ෂිතම හා වේගවත්ම ක්‍රමයයි.

ඔබ සරල වස්තුවක් හැෂ් වගුවක් ලෙස භාවිතා කරන්නේ නම් සහ කිසි විටෙකත් කිංකි කිසිවක් නොකරන්නේ if (obj[x])...නම්, එය වඩාත් කියවිය හැකි යැයි මම සිතන බැවින් මම භාවිතා කරමි.

විනෝද වන්න.

ඔව් එය එසේ ය :) දේපළක් තිබේ Object.prototype.hasOwnProperty.call(x, 'key')නම් එය ද කළ හැකි යැයි මම සිතමි :)xhasOwnProperty

නමුත් එය තමන්ගේම දේපල සඳහා පරීක්ෂා කරයි. ඔබට එය භාවිතා කළ හැකි දේපලක් තිබේදැයි පරීක්ෂා කිරීමට අවශ්‍ය නම් typeof x.foo != 'undefined'.

if (typeof x.key != "undefined") {

}

නිසා

if (x.key)

නම් අසමත් x.keyකිරීමට ෙයෝජනා false(උදාහරණයක් ලෙස, x.key = "").

ඔබට ES6 Reflectවස්තුව ද භාවිතා කළ හැකිය :

x = {'key': 1};
Reflect.has( x, 'key'); // returns true

එම්ඩීඑන් සඳහා වන ලියකියවිලි මෙතැනින්Reflect.has සොයාගත හැකිය .

ස්ථිතික Reflect.has()ක්‍රමය ශ්‍රිතයක් ලෙස ක්‍රියාකරු මෙන් ක්‍රියා කරයි.

මෙය නොකරන්න object.hasOwnProperty(key)), එය ඇත්තෙන්ම නරක නිසා මෙම ක්‍රම සැක සහිත වස්තුවෙහි ගුණාංග මගින් සෙවනැලි විය හැකිය - සලකා බලන්න { hasOwnProperty: false }- හෝ, වස්තුව ශුන්‍ය වස්තුවක් විය හැකිය (Object.create(null)).

හොඳම ක්‍රමය වන්නේ Object.prototype.hasOwnProperty.call(object, key)හෝ:

const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
/* or */
import has from 'has'; // https://www.npmjs.com/package/has
// ...
console.log(has.call(object, key));

හරි, ඔබට උරුම වූ දේපල අවශ්‍ය නැතිනම් මට නිවැරදි පිළිතුර ඇති බව පෙනේ:

if (x.hasOwnProperty('key'))

උරුම වූ දේපල ඇතුළත් කිරීමට තවත් විකල්ප කිහිපයක් මෙන්න:

if (x.key) // Quick and dirty, but it does the same thing as below.

if (x.key !== undefined)

සාපේක්ෂව තවත් සරල ක්‍රමයක් වන්නේ භාවිතා Object.keysකිරීමයි. මෙයින් arrayඅදහස් කරන්නේ ඔබ අරාවෙහි සියලුම අංග ලබා ගන්නා බවයි.

var noInfo = {};
var info = {something: 'data'};

Object.keys(noInfo).length //returns 0 or false
Object.keys(info).length //returns 1 or true

අප සිටින්නේ විශාල බ්‍රව්සර් සහාය ඇති ලෝකයක වුවද. මෙම ප්‍රශ්නය ඉතා පැරණි බැවින් මම මෙය එකතු කිරීමට සිතුවෙමි: මෙය JS v1.8.5 හි භාවිතා කිරීමට ආරක්ෂිතයි

hasOwnProperty "වස්තුවකට නිශ්චිත දේපලක් එම වස්තුවේ property ජු දේපලක් ලෙස තිබේද යන්න තීරණය කිරීමට භාවිතා කළ හැකිය; ක්‍රියාකරු මෙන් නොව , මෙම ක්‍රමය මඟින් වස්තුවේ මූලාකෘති දාමය පරීක්ෂා නොකරයි."

එබැවින් බොහෝ විට, ඔබේ ප්‍රශ්නයට අනුව පෙනෙන දේ සඳහා, ඔබට hasOwnProperty භාවිතා කිරීමට අවශ්‍ය නැත, එමඟින් දේපල පවතින්නේ වස්තුවට කෙලින්ම සම්බන්ධ වී තිබේද යන්න තීරණය කරයි .

ඔබට ප්‍රධාන වශයෙන් භාවිතා කිරීමට අවශ්‍ය මූලාකෘති දාමයේ දේපල තිබේද යන්න තීරණය කිරීමට ඔබට අවශ්‍ය නම්,

if( prop in object ){ // do something }

මම හිතනවා මේක උදව් වෙයි කියලා.

දැවැන්ත පහත වැටීමේ අවදානමක් සහිතව, විශේෂිත අවස්ථාවක් සඳහා තවත් විකල්පයක් මෙන්න. :)

ඔබට වස්තුවක් මත සාමාජිකයෙකු සඳහා පරීක්ෂා කිරීමට අවශ්‍ය නම් සහ එය වෙනත් දෙයකට සකසා ඇත්දැයි දැන ගැනීමට අවශ්‍ය නම්:

• ''
• බොරු
• ශුන්‍යයි
• නිර්වචනය නොකළ
• 0 ...

එවිට ඔබට භාවිතා කළ හැකිය:

var foo = {};
foo.bar = "Yes, this is a proper value!";
if (!!foo.bar) {
        // member is set, do something
}

ඔබට පහත ප්‍රවේශයන් භාවිතා කළ හැකිය-

var obj = {a:1}
console.log('a' in obj)               //1
console.log(obj.hasOwnProperty('a'))  //2
console.log(Boolean(obj.a))         //3

පහත දැක්වෙන ප්‍රවේශයන් අතර වෙනස පහත පරිදි වේ-

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

 var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log('b' in obj)
    console.log(Boolean(obj.b))

2. 2 වන ප්රවේශය එහි දේපල සඳහා පමණක් පරීක්ෂා කරනු ඇත. උදා -

var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log(obj.hasOwnProperty('b'))

3. 1 වන සහ තෙවන අතර වෙනස වන්නේ නිශ්චිතව දක්වා නැති වටිනාකමක් ඇති දේපලක් තිබේ නම් 3 වන ප්‍රවේශය අසත්‍යයක් වන අතර පළමුව සත්‍යය ලබා දෙනු ඇත.

var obj = {
      b : undefined
    }
    console.log(Boolean(obj.b))
    console.log('b' in obj);

ECMA ස්ක්‍රිප්ට් 6 විසඳුම පරාවර්තනය සමඟ. වැනි එතීම සාදන්න:

/**
Gets an argument from array or object.
The possible outcome:
- If the key exists the value is returned.
- If no key exists the default value is returned.
- If no default value is specified an empty string is returned.
@param obj    The object or array to be searched.
@param key    The name of the property or key.
@param defVal Optional default version of the command-line parameter [default ""]
@return The default value in case of an error else the found parameter.
*/
function getSafeReflectArg( obj, key, defVal) {
   "use strict";
   var retVal = (typeof defVal === 'undefined' ? "" : defVal);
   if ( Reflect.has( obj, key) ) {
       return Reflect.get( obj, key);
   }
   return retVal;
}  // getSafeReflectArg

වස්තුව මත "hasOwnProperty" ක්‍රමයක් පවතින නමුත් මෙම ක්‍රමය කෙලින්ම ඇමතීමට නිර්දේශ නොකරයි, මන්ද සමහර විට වස්තුව ශුන්‍ය විය හැකිය. { hasOwnProperty: false }

එබැවින් වඩා හොඳ ක්‍රමය වනුයේ:

// good
var obj = {"bar": "here bar desc"}
console.log(Object.prototype.hasOwnProperty.call(obj, "bar"));

// best
const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
console.log(has.call(obj, "bar"));

ඔබ ක්රමය භාවිතා කළ object.hasOwnProperty(property)යුතුය. වස්තුවට දේපළ තිබේ නම් එය සත්‍ය වේ.

ඔබ පරික්ෂා කරන යතුර විචල්‍යයක ගබඩා කර ඇත්නම් , ඔබට එය මේ ආකාරයෙන් පරීක්ෂා කළ හැකිය:

x = {'key': 1};
y = 'key';
x[y];

ඔබට කළ හැකි විට දේවල් ඕනෑවට වඩා සංකීර්ණ කරන්නේ ඇයි:

var isProperty =  (objectname.keyname || "") ? true : false;

බොහෝ අවස්ථාවන් සඳහා සරල හා පැහැදිලි ...

ජාවාස්ක්‍රිප්ට් දැන් විකාශනය වෙමින් පවතින අතර එය දැන් පරීක්ෂා කිරීමට හොඳ සහ හොඳම කාර්යක්ෂම ක්‍රමයක් ඇත වස්තුවට නිශ්චිත දේපලක් තිබේදැයි පරීක්ෂා කිරීමට පහසු ක්‍රම කිහිපයක්

1. භාවිතා කිරීම hasOwnProperty()

const hero = {
  name: 'Batman'
};

hero.hasOwnProperty('name');     // => true
hero.hasOwnProperty('realName'); // => false

2. යතුරුපදය / ක්‍රියාකරු භාවිතා කිරීම in

const hero = {
  name: 'Batman'
};

'name' in hero;     // => true
'realName' in hero; // => false

3. undefinedමූල පදය සමඟ සංසන්දනය කිරීම

const hero = {
  name: 'Batman'
};

hero.name;     // => 'Batman'
hero.realName; // => undefined

//so consider this
hero.realName == undefined // => true (which means property does not exists in object)
hero.name == undefined // => false (which means that property exists in object)

ඔබ වැඩි තොරතුරු පරීක්ෂා කිරීම සඳහා තව දේ තේරුම් බලාපොරොත්තු මෙතන