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

යතුරක් නොපවතින අතර මම එයට ප්‍රවේශ වීමට උත්සාහ කළහොත් එය අසත්‍යයක් වේවිද? නැත්නම් දෝෂයක් විසි කරන්නද?

නිර්වචනය නොකළ-නෙස් සඳහා පරීක්ෂා කිරීම යතුරක් තිබේදැයි පරීක්ෂා කිරීමේ නිවැරදි ක්‍රමයක් නොවේ. යතුර පවතින නමුත් වටිනාකම ඇත්ත වශයෙන්ම තිබේ නම් undefinedකුමක් කළ යුතුද?

var obj = { key: undefined };
obj["key"] !== undefined // false, but the key exists!

ඔබ ඒ වෙනුවට inක්‍රියාකරු භාවිතා කළ යුතුය :

"key" in obj // true, regardless of the actual value

යතුරක් නොපවතී දැයි පරීක්ෂා කිරීමට ඔබට අවශ්‍ය නම්, වරහන් භාවිතා කිරීමට මතක තබා ගන්න:

!("key" in obj) // true if "key" doesn't exist in object
!"key" in obj   // ERROR!  Equivalent to "false in obj"

නැතහොත්, වස්තු නිදර්ශනයේ ගුණාංග සඳහා විශේෂයෙන් පරීක්ෂා කිරීමට ඔබට අවශ්‍ය නම් (සහ උරුම වූ ගුණාංග නොවේ), භාවිතා කරන්න hasOwnProperty:

obj.hasOwnProperty("key") // true

බව ක්රම කාර්ය සාධනය සංසන්දනය කිරීම සඳහා in, hasOwnPropertyසහ ප්රධාන කියන්නේ undefined, මේ බලන්න මිණුම් ලකුණක්

ඉක්මන් පිළිතුර

ජාවාස්ක්‍රිප්ට් වස්තුවක හෝ අරාවක කිසියම් යතුරක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද? යතුරක් නොපවතින අතර මම එයට ප්‍රවේශ වීමට උත්සාහ කළහොත් එය අසත්‍යයක් වේවිද? නැත්නම් දෝෂයක් විසි කරන්නද?

(සහායක) අරාව ශෛලිය හෝ වස්තු ශෛලිය භාවිතා කර නැතිවූ දේපලකට කෙලින්ම ප්‍රවේශ වීමෙන් නිර්වචනය නොකළ නියතයක් ලැබෙනු ඇත .

මන්දගාමී සහ විශ්වසනීය දී සමාගම සහ hasOwnProperty ක්රමය

මිනිසුන් දැනටමත් මෙහි සඳහන් කර ඇති පරිදි, ඔබට “නිර්වචනය නොකළ” නියතයක් හා සම්බන්ධ දේපලක් සහිත වස්තුවක් තිබිය හැකිය.

 var bizzareObj = {valid_key:  undefined};

එවැනි අවස්ථාවක දී, ඔබ භාවිතා කිරීමට සිදු වනු ඇත hasOwnProperty හෝ දී ප්රධාන ඇත්තටම තිබේ නම් දැන ගැනීමට ක්රියාකරු. නමුත්, නමුත් කුමන මිලකටද?

ඉතින්, මම ඔබට කියමි ...

දී සමාගම සහ hasOwnProperty ජාවාස්ක්රිප්ට් භාවිතා ඉඩකඩම් Descriptor යාන්ත්රණයක් (ජාවා භාෂාවෙන් ජාවා පිළිබිඹු සමාන) ඒ 'ක්රම' වේ.

http://www.ecma-international.org/ecma-262/5.1/#sec-8.10

නම් කරන ලද දේපල ගුණාංග හැසිරවීම සහ ප්‍රතිසංස්කරණය කිරීම පැහැදිලි කිරීම සඳහා දේපල විස්තර වර්ගය භාවිතා කරයි. දේපල විස්තර කිරීමේ වර්ගයේ අගයන් නම් කර ඇති ක්ෂේත්‍ර වලින් සමන්විත වන අතර එහිදී එක් එක් ක්ෂේත්‍රයේ නම ගුණාංග නාමයක් වන අතර එහි අගය 8.6.1 හි නිශ්චිතව දක්වා ඇති අනුරූපී ගුණාංග අගයකි. ඊට අමතරව, ඕනෑම ක්ෂේත්‍රයක් පැවතිය හැකිය.

අනෙක් අතට, වස්තු ක්‍රමයක් හෝ යතුරක් ඇමතීමෙන් ජාවාස්ක්‍රිප්ට් [[ලබා ගන්න]] යාන්ත්‍රණය භාවිතා වේ. එය බොහෝ වේගවත් ය!

මිණුම් ලකුණ

http://jsperf.com/checking-if-a-key-exists-in-a-javascript-array

.

var result = "Impression" in array;

ප්රති result ලය විය

12,931,832 ±0.21% ops/sec      92% slower 

var result = array.hasOwnProperty("Impression")

ප්රති result ලය විය

16,021,758 ±0.45% ops/sec     91% slower

var result = array["Impression"] === undefined

ප්රති result ලය විය

168,270,439 ±0.13 ops/sec     0.02% slower 

var result = array.Impression  === undefined;

ප්රති result ලය විය

168,303,172 ±0.20%     fastest

සංස්කරණය කරන්න: දේපලකට undefinedවටිනාකම පැවරීමට හේතුව කුමක්ද?

එම ප්‍රශ්නය මට ප්‍රහේලිකාවක්. ජාවාස්ක්‍රිප්ට් හි, මෙවැනි ගැටළු වළක්වා ගැනීම සඳහා නොපැමිණෙන වස්තූන් සඳහා අවම වශයෙන් යොමු දෙකක් තිබේ: nullසහ undefined.

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

සසඳන්න:

var a = {1: null}; 
console.log(a[1] === undefined); // output: false. I know the value at position 1 of a[] is absent and this was by design, i.e.:  the value is defined. 
console.log(a[0] === undefined); // output: true. I cannot say anything about a[0] value. In this case, the key 0 was not in a[].

උපදෙස් දෙන්න

undefinedවටිනාකම් සහිත වස්තු වලින් වළකින්න . හැකි සෑම විටම කෙලින්ම පරීක්ෂා nullකර දේපල අගයන් ආරම්භ කිරීමට භාවිතා කරන්න. එසේ නොමැතිනම් මන්දගාමී inක්‍රියාකරු හෝ hasOwnProperty()ක්‍රමය භාවිතා කරන්න.

සංස්කරණය කරන්න: 12/04/2018 - කිසිසේත් අදාළ නොවේ

මිනිසුන් අදහස් දක්වා ඇති පරිදි, ජාවාස්ක්‍රිප්ට් එන්ජින් වල නවීන අනුවාදයන් (ෆයර්ෆොක්ස් හැර) ප්‍රවේශ ගුණාංග සඳහා ප්‍රවේශය වෙනස් කර ඇත. වර්තමාන ක්‍රියාත්මක කිරීම මෙම විශේෂිත අවස්ථාව සඳහා පෙර පැවති ක්‍රියාවලියට වඩා මන්දගාමී වන නමුත් ප්‍රවේශ යතුර සහ වස්තුව අතර වෙනස නොසලකා හැරිය හැකිය.

එය නැවත පැමිණේ undefined.

var aa = {hello: "world"};
alert( aa["hello"] );      // popup box with "world"
alert( aa["goodbye"] );    // popup box with "undefined"

undefinedවිශේෂ නියත අගයකි. එබැවින් ඔබට පැවසිය හැකිය, උදා

// note the three equal signs so that null won't be equal to undefined
if( aa["goodbye"] === undefined ) {
    // do something
}

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

// this works even if you have {"goodbye": undefined}
if( "goodbye" in aa ) {
    // do something
}

මෙම පිළිගත් පිළිතුර යොමු වස්තූන් . භාවිතා පරෙස්සම් වන්න inක්රියාකරු මත Array දත්ත වෙනුවට යතුරු සොයා ගැනීමට:

("true" in ["true", "false"])
// -> false (Because the keys of the above Array are actually 0 and 1)

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

"key" in obj

අරා යතුරු වලට වඩා බෙහෙවින් වෙනස් වස්තු ගුණාංග අගයන් පමණක් පරීක්ෂා කිරීම විය හැකිය

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

1. !!obj.theProperty
   අගය bool බවට පරිවර්තනය කරයි. වටිනාකම trueහැර අන් සියල්ලටම ප්‍රතිලාභfalse
2. ' theProperty' එය විවෘත දී
   දේපල පවතී නම් සැබෑ එන්නෙමි, කිසිදු එහි අගය ප්රශ්නයක් (පවා හිස්)
3. obj.hasOwnProperty('theProperty')
   මූලාකෘති දාමය පරීක්ෂා නොකරයි. (සියලු වස්තු ඇති බැවින් toStringක්රමය, 1 වන සහ 2 වන සැබෑ ඒ, ඒ අතර 3 එය මත බොරු ආපසු යා හැක හැරී යනු ඇත.)

යොමුව:

http://book.mixu.net/node/ch5.html

ඔබ underscore.js පුස්තකාලය භාවිතා කරන්නේ නම් වස්තු / අරාව මෙහෙයුම් සරල වේ.

ඔබේ නඩුවේ _.has ක්‍රමය භාවිතා කළ හැකිය. උදාහරණයක්:

yourArray = {age: "10"}

_.has(yourArray, "age")

නැවත සත්‍ය වේ

එහෙත්,

_.has(yourArray, "invalidKey")

වැරදි ලෙස ආපසු එයි

පිළිතුර:

if ("key" in myObj)
{
    console.log("key exists!");
}
else
{
    console.log("key doesn't exist!");
}

පැහැදිලි කිරීම:

මෙම inප්රධාන වස්තුව දී පවතී නම් ක්රියාකරු පරීක්ෂා කරනු ඇත. අගය නිර්වචනය කර නොමැතිදැයි ඔබ පරීක්ෂා කර බැලුවහොත්:, if (myObj["key"] === 'undefined')ඔබේ වස්තුවෙහි undefinedවටිනාකම සමඟ යතුරක් පැවතිය හැකි බැවින් ඔබට ගැටළු වලට මුහුණ දිය හැකිය .

එම හේතුව නිසා, මුලින්ම inක්‍රියාකරු භාවිතා කිරීම වඩා හොඳ පුරුද්දක් වන අතර එය පවතින බව ඔබ දැනගත් පසු යතුර තුළ ඇති අගය සංසන්දනය කරන්න.

මෙන්න මට බෙහෙවින් ප්‍රයෝජනවත් වන උපකාරක කාර්යයක්

keyExists(key, search)වස්තූන් හෝ අරා තුළ යතුරක් පහසුවෙන් බැලීමට මෙය භාවිතා කළ හැකිය!

ඔබට සොයා ගැනීමට අවශ්‍ය යතුර එය යවා ඔබට එය සොයා ගැනීමට අවශ්‍ය වස්තුව (වස්තුව හෝ අරාව) සොයන්න.

function keyExists(key, search) {
        if (!search || (search.constructor !== Array && search.constructor !== Object)) {
            return false;
        }
        for (var i = 0; i < search.length; i++) {
            if (search[i] === key) {
                return true;
            }
        }
        return key in search;
    }

// How to use it:
// Searching for keys in Arrays
console.log(keyExists('apple', ['apple', 'banana', 'orange'])); // true
console.log(keyExists('fruit', ['apple', 'banana', 'orange'])); // false

// Searching for keys in Objects
console.log(keyExists('age', {'name': 'Bill', 'age': 29 })); // true
console.log(keyExists('title', {'name': 'Jason', 'age': 29 })); // false

එය ඉතා විශ්වාසදායක වන අතර හරස් බ්‍රව්සරය හොඳින් ක්‍රියා කරයි.

වැනිලා ජේ

yourObjName.hasOwnProperty(key) : true ? false;

Es2015 හි අවම වශයෙන් එක් දේපලක් වත් තිබේදැයි පරීක්ෂා කිරීමට ඔබට අවශ්‍ය නම්

Object.keys(yourObjName).length : true ? false

ES6 විසඳුම

භාවිතා කිරීම Array#someසහ Object.keys. එය ආපසු ඇත සැබෑ ලබා ප්රධාන වස්තුව හෝ පවතී නම් බොරු නම් එය නො.

var obj = {foo: 'one', bar: 'two'};
    
function isKeyInObject(obj, key) {
    var res = Object.keys(obj).some(v => v == key);
    console.log(res);
}

isKeyInObject(obj, 'foo');
isKeyInObject(obj, 'something');

එක් පේළියේ උදාහරණයක්.

console.log(Object.keys({foo: 'one', bar: 'two'}).some(v => v == 'foo'));

අපට භාවිතා කළ හැකිය - hasOwnProperty.call(obj, key);

මෙම underscore.js මාර්ගය -

if(_.has(this.options, 'login')){
  //key 'login' exists in this.options 
}

_.has = function(obj, key) {
  return hasOwnProperty.call(obj, key);
};

පරීක්ෂා කිරීමට පහසුම ක්‍රමය නම්

"key" in object

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

var obj = {
  a: 1,
  b: 2,
}
"a" in obj // true
"c" in obj // false

ප්‍රතිලාභ අගය සත්‍ය ලෙස ඇඟවෙන්නේ වස්තුව තුළ යතුර පවතින බවයි.

lodashඔවුන්ගේ ව්‍යාපෘතියට ඇතුළත් කර ඇති අය සඳහා: "ගැඹුරු" යතුරු ලබා ගැනීමට උත්සාහ
කරන ලොඩාෂ් _.ජෙට් ක්‍රමයක් ඇත:

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

var object = { 'a': [{ 'b': { 'c': 3 } }] };

console.log(
  _.get(object, 'a[0].b.c'),           // => 3
  _.get(object, ['a', '0', 'b', 'c']), // => 3
  _.get(object, 'a.b.c'),              // => undefined 
  _.get(object, 'a.b.c', 'default')    // => 'default'
)

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>

එම යතුර කොතරම් ගැඹුරුද යන්න නිර්වචනය කර ඇත්දැයි මෙය effectively ලදායී ලෙස පරික්ෂා කරනු ඇති අතර එම යතුර නිර්වචනය කර නොමැති නම් ඔබේ වැඩසටහනේ ප්‍රවාහයට හානියක් විය හැකි දෝෂයක් නොපෙන්වයි.

යතුරක් තිබේදැයි මෙය අනිවාර්යයෙන්ම පරික්ෂා නොකරන අතර, එය අගයක සත්‍යතාව පරීක්ෂා කරයි. කුමන undefinedසහ nullයටට.

Boolean(obj.foo)

මම typescript භාවිතා කරන අතර, නූල් භාවිතා නිසා එසේ කැමති මේ විසඳුම මට හොඳින් ක්රියා 'foo' in objහෝ obj.hasOwnProperty('foo') ප්රධාන පවතී හෝ intellisense මට ලබා දෙන්නේ නැත නැද්ද යන්න පරීක්ෂා කිරීමට.

වස්තුවක ඕනෑම ගැඹුරකින් ඕනෑම යතුරක් පරික්ෂා කිරීමට ඔබට අවශ්‍ය නම් සහ ව්‍යාජ අගයන් සඳහා ගිණුමක් උපයෝගීතා ශ්‍රිතයක් සඳහා මෙම රේඛාව සලකා බලන්න:

var keyExistsOn = (o, k) => k.split(".").reduce((a, c) => a.hasOwnProperty(c) ? a[c] || 1 : false, Object.assign({}, o)) === false ? false : true;

ප්රතිපල

var obj = {
    test: "",
    locals: {
        test: "",
        test2: false,
        test3: NaN,
        test4: 0,
        test5: undefined,
        auth: {
            user: "hw"
        }
    }
}

keyExistsOn(obj, "")
> false
keyExistsOn(obj, "locals.test")
> true
keyExistsOn(obj, "locals.test2")
> true
keyExistsOn(obj, "locals.test3")
> true
keyExistsOn(obj, "locals.test4")
> true
keyExistsOn(obj, "locals.test5")
> true
keyExistsOn(obj, "sdsdf")
false
keyExistsOn(obj, "sdsdf.rtsd")
false
keyExistsOn(obj, "sdsdf.234d")
false
keyExistsOn(obj, "2134.sdsdf.234d")
false
keyExistsOn(obj, "locals")
true
keyExistsOn(obj, "locals.")
false
keyExistsOn(obj, "locals.auth")
true
keyExistsOn(obj, "locals.autht")
false
keyExistsOn(obj, "locals.auth.")
false
keyExistsOn(obj, "locals.auth.user")
true
keyExistsOn(obj, "locals.auth.userr")
false
keyExistsOn(obj, "locals.auth.user.")
false
keyExistsOn(obj, "locals.auth.user")
true

මෙම NPM පැකේජයද බලන්න: https://www.npmjs.com/package/has-deep-value

const object1 = {
  a: 'something',
  b: 'something',
  c: 'something'
};

const key = 's';

// Object.keys(object1) will return array of the object keys ['a', 'b', 'c']

Object.keys(object1).indexOf(key) === -1 ? 'the key is not there' : 'yep the key is exist';

'අරාව' ලෝකයේ අපට යම් ආකාරයක යතුරු ලෙස දර්ශක දෙස බැලිය හැකිය. පුදුමයට කරුණක් වන්නේ inක්‍රියාකරු (වස්තුව සඳහා හොඳ තේරීමක් වන) අරා සමඟ ක්‍රියා කිරීමයි. නොපවතින යතුර සඳහා ආපසු ලබා දුන් අගය වේundefined

let arr = ["a","b","c"]; // we have indexes: 0,1,2
delete arr[1];           // set 'empty' at index 1
arr.pop();               // remove last item

console.log(0 in arr,  arr[0]);
console.log(1 in arr,  arr[1]);
console.log(2 in arr,  arr[2]);

yourArray.indexOf (yourArrayKeyName)> -1

fruit = ['apple', 'grapes', 'banana']

fruit.indexOf('apple') > -1

සැබෑ

fruit = ['apple', 'grapes', 'banana']

fruit.indexOf('apple1') > -1

බොරු

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

// Lets create object `a` using create function `A`
function A(){};
A.prototype.onProtDef=2;
A.prototype.onProtUndef=undefined;
var a=new A();
a.ownProp = 3;
a.ownPropUndef = undefined;

// Let's try different methods:

a.onProtDef; // 2
a.onProtUndef; // undefined
a.ownProp; // 3
a.ownPropUndef; // undefined
a.whatEver; // undefined
a.valueOf; // ƒ valueOf() { [native code] }

a.hasOwnProperty('onProtDef'); // false
a.hasOwnProperty('onProtUndef'); // false
a.hasOwnProperty('ownProp'); // true
a.hasOwnProperty('ownPropUndef'); // true
a.hasOwnProperty('whatEver'); // false
a.hasOwnProperty('valueOf'); // false

'onProtDef' in a; // true
'onProtUndef' in a; // true
'ownProp' in a; // true
'ownPropUndef' in a; // true
'whatEver' in a; // false
'valueOf' in a; // true (on the prototype chain - Object.valueOf)

Object.keys(a); // ["ownProp", "ownPropUndef"]

ජාවාස්ක්‍රිප්ට් විනාශ කිරීම සමඟ නව පුදුමාකාර විසඳුමක් :

let obj = {
    "key1": "value1",
    "key2": "value2",
    "key3": "value3",
};

let {key1, key2, key3, key4} = obj;

// key1 = "value1"
// key2 = "value2"
// key3 = "value3"
// key4 = undefined

// Can easily use `if` here on key4
if(!key4) { console.log("key not present"); } // Key not present

ජාවාස්ක්‍රිප්ට් විනාශ කිරීමේ වෙනත් භාවිතයන් පරීක්ෂා කරන්න