ජාවාස්ක්රිප්ට් හි වස්තු දේපලක් තිබේදැයි පරීක්ෂා කිරීමට හොඳම ක්රමය undefined
කුමක්ද?
ජාවාස්ක්රිප්ට් හි වස්තු දේපලක් තිබේදැයි පරීක්ෂා කිරීමට හොඳම ක්රමය undefined
කුමක්ද?
Answers:
දේපලක වටිනාකම විශේෂ වටිනාකම දැයි පරීක්ෂා කිරීමට සුපුරුදු ක්රමය නම් 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`");
}
obj !== undefined
. සිත්ගන්නාසුලු undefined
ප්රති .ල ගෙන දෙන undefined = 1234
දේ මෙන් විකෘති වීමට භාවිතා කරයි . නමුත් Ecmascript 5 පසු එය තවදුරටත් ලිවිය නොහැක, එබැවින් අපට සරල අනුවාදය භාවිතා කළ හැකිය. codereadability.com/how-to-check-for-undefined-in-javascript
මෙම මාතෘකාවට වැරදි පිළිතුරු ගණනාවක් ඇති බව මම විශ්වාස කරමි. පොදු විශ්වාසයන්ට පටහැනිව, "නිර්වචනය නොකළ" යනු ජාවාස්ක්රිප්ට් හි මූල පදයක් නොවන අතර ඇත්ත වශයෙන්ම එයට වටිනාකමක් ලබා දිය හැකිය.
මෙම පරීක්ෂණය සිදු කිරීමට වඩාත්ම ශක්තිමත් ක්රමය නම්:
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 === undefined
myVar ප්රකාශයට පත් නොකල තත්වයේ දෝෂයක් මතු කරයි.
=== undefined
ව්යාකූලත්වය භාවිතා නොකිරීම සම්බන්ධයෙන් මෙහි දී ඇති පළමු සාධාරණීකරණය මට පෙනේ . ඔව්, ඔබට පැවරිය හැකිය undefined
, නමුත් එසේ කිරීමට නීත්යානුකූල හේතුවක් නොමැත, එසේ කිරීමෙන් ඔබේ කේතය බිඳ දැමිය හැකි යැයි පුරෝකථනය කළ හැකිය. සී හි ඔබට පුළුවන් #define true false
, සහ පයිතන්හි ඔබට පැවරිය හැකි True
සහ කළ හැකි False
නමුත් කේතයේ වෙනත් තැනක හිතාමතාම තමන්ගේ පරිසරය කඩාකප්පල් කිරීමේ හැකියාවෙන් ආරක්ෂා වන අයුරින් එම භාෂාවලින් ඔවුන්ගේ කේතය සැලසුම් කිරීමේ අවශ්යතාවය මිනිසුන්ට දැනෙන්නේ නැත. . ඇයි ද පවරා ඇති හැකියාව වේ undefined
මෙතන සලකා පවා වටිනා?
void 0
අගය ලබා ගැනීම සඳහා ඔබට සැමවිටම කළ හැකි බව මතක තබා ගන්න undefined
. එබැවින් ඔබට කළ හැකිය if (myVar === void 0)
. මෙම 0
විශේෂ නොවේ, ඔබ වචනාර්ථයෙන් එහි කිසිදු ප්රකාශනයක් කළ හැකි.
undefined
. MDN: undefined
මෙහි වෙනත් බොහෝ පිළිතුරු මගින් දැඩි ලෙස නිර්දේශ කර ඇතත්, 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
වෙනත් ආකාරයකින් ආදේශ කරන්න .
undefined
අතර පෙරනිමි එක සඟවයි. බොහෝ ප්රායෝගික අරමුණු සඳහා එය නැවත ලිවීමට සමාන බලපෑමක් ඇති කරයි.
void 0
නිර්වචනය නොකළ නමුත් නැවත සංසන්දනය කිරීමට භාවිතා කළ හැකිය - එය මෝඩ සහ අතිරික්තයකි.
typeof something === "undefined")
කේතයෙන් බැලීම නැවැත්වීමට අවශ්යයි .
void 0
සඳහා (එක් වරක්) කෙටි හා ආරක්ෂිත වේ! ඒක මගේ පොතේ ජයග්රහණයක්.
ජාවාස්ක්රිප්ට් හි ශුන්ය වන අතර නිර්වචනය කර නොමැත . ඔවුන්ට විවිධ අර්ථයන් ඇත.
මරිජ්න් හැවර්බෙක් සිය නිදහස්, මාර්ගගත පොතක් වන “ එලොකන්ට් ජාවාස්ක්රිප්ට් ” (අවධාරණය මගේ):
සමාන අගයක් ද ඇත, ශූන්යය, එහි අර්ථය 'මෙම අගය අර්ථ දක්වා ඇත, නමුත් එයට වටිනාකමක් නැත' යන්නයි. නිර්වචනය නොකළ සහ ශුන්ය අතර අර්ථයේ වෙනස බොහෝ දුරට ශාස්ත්රීය වන අතර සාමාන්යයෙන් එතරම් සිත්ගන්නා සුළු නොවේ. ප්රායෝගික වැඩසටහන් වලදී, යම් දෙයකට 'වටිනාකමක් තිබේද' යන්න පරීක්ෂා කිරීම බොහෝ විට අවශ්ය වේ. මෙම අවස්ථා වලදී, == නිර්වචනය නොකළ දෙයක් භාවිතා කළ හැකිය, මන්ද ඒවා හරියටම එකම අගයක් නොවුනත්, ශුන්ය == නිර්වචනය නොකළ සත්යය නිපදවනු ඇත.
එබැවින්, යමක් නිර්වචනය කර ඇත්දැයි පරීක්ෂා කිරීමට හොඳම ක්රමය වනු ඇතැයි මම සිතමි.
if (something == undefined)
මෙය උපකාරී වේ යැයි සිතමු!
සංස්කරණය කරන්න: ඔබගේ සංස්කරණයට ප්රතිචාර වශයෙන්, වස්තු ගුණාංග එකම ආකාරයකින් ක්රියා කළ යුතුය.
var person = {
name: "John",
age: 28,
sex: "male"
};
alert(person.name); // "John"
alert(person.fakeVariable); // undefined
undefined
පරිශීලකයාට නැවත පැවරිය හැකි විචල්යයක් පමණි: ලිවීම undefined = 'a';
මඟින් ඔබේ කේතය තවදුරටත් ඔබ සිතන දේ නොකරනු ඇත. භාවිතා typeof
කිරීම වඩා හොඳ වන අතර ප්රකාශ කර නොමැති විචල්යයන් සඳහා (ගුණාංග පමණක් නොවේ) ක්රියා කරයි.
මෙයින් අදහස් කරන්නේ කුමක්ද: “නිර්වචනය නොකළ වස්තු දේපල” ?
ඇත්ත වශයෙන්ම එය වෙනස් කරුණු දෙකක් අදහස් කළ හැකිය! පළමුව, එය කිසි විටෙකත් වස්තුවෙහි අර්ථ දක්වා නොමැති දේපල අදහස් කළ හැකි අතර, දෙවනුව, අර්ථ දැක්විය නොහැකි වටිනාකමක් ඇති දේපල අදහස් කළ හැකිය . මෙම කේතය දෙස බලමු:
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.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
(එය ද 'ගෝලීය' උපසර්ගය තොරව භාවිතා කළ හැක). සේවාදායක පැත්තේ ජාවාස්ක්රිප්ට් ක්රියාත්මක කිරීම ගැන මම නොදනිමි.
undefined
සාමාජිකයෙකු ලෙස කිසිවක් නොකියයි global
. ද වත් console.log(global);
හෝ for (var key in global) { ... }
වෙන්නේ නෑ නිර්වචනය නොකළ සාමාජිකයෙකු ලෙස ගෝලීය . නමුත් 'undefined' in global
ප්රතිවිරුද්ධ දේ පෙන්වන්න වගේ පරීක්ෂා කරන්න.
[[Enumerable]]
අසත්ය ය :-)
Minuses of typeof obj.prop == 'undefined'
, මෙය ලිවීමෙන් වළක්වා ගත හැකිය typeof obj.prop == typeof undefined
. මෙය ද ඉතා හොඳ සමමිතියක් ලබා දෙයි.
obj.prop === undefined
.
if ('foo' in o
) ... ඔබගේ පිළිතුර සැබැවින් ම පළමු නිවැරදි පිළිතුර මෙතැනින්. අනෙක් සියල්ලන්ම එම වාක්යයට පිළිතුරු සපයයි.
ගැටළුව අවස්ථා තුනකට තල්ලු වේ:
undefined
.undefined
.මෙය මා වැදගත් යැයි සලකන දෙයක් අපට කියයි:
නිර්වචනය නොකළ සාමාජිකයෙකු සහ නිර්වචනය නොකළ සාමාජිකයෙකු අතර වෙනසක් ඇත.
නමුත් අවාසනාවන්ත ලෙස 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 (!("x" in blob)) {}
ඇතුළත වරහන් සමඟ පැවසිය යුතුය, මන්ද! ක්රියාකරුට 'in' ට වඩා ප්රමුඛතාවයක් ඇත. යමෙකුට උපකාර කරන බලාපොරොත්තුව.
a = {b: undefined}
; පසුව typeof a.b === typeof a.c === 'undefined'
නොව 'b' in a
හා !('c' in a)
.
{ x : undefined }
හෝ අවම වශයෙන් එය වගුවේ (2.) ට වෙනත් විකල්පයක් ලෙස එක් කිරීමට මම යෝජනා කරමි - එම කරුණ (2.) ඇගයීමට ලක් කළත් undefined
(කෙසේ වෙතත්) ඔබ එය පසුව සඳහන් කරයි).
if ( typeof( something ) == "undefined")
මෙය මට වැඩ කළ අතර අනෙක් අය එසේ නොකළේය.
typeof (something == "undefined")
.
(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 ප්රකාශය කේත වාරණය ක්රියාත්මක නොකරයි. මෙය සාමාන්යයෙන් බොහෝ කේත වාරණ ප්රකාශ වල (ජාවාස්ක්රිප්ට් වල) අපේක්ෂිත හැසිරීමයි.
var x = obj && obj.prop || 'default';
ජාවාස්ක්රිප්ට් හි අබිස් ගවේෂණය කිරීම සහ නිර්වචනය නොකිරීම යන ලිපියෙන් මම කියවා ඇත්තේ Underscore.js වැනි රාමු මෙම ශ්රිතය භාවිතා කරන බවයි:
function isUndefined(obj){
return obj === void 0;
}
void 0
එය ලිවීමේ කෙටි ක්රමයක් පමණි undefined
( ඕනෑම ප්රකාශන ප්රතිලාභයක් අනුගමනය කිරීමෙන් එය අවලංගු වන බැවින් ), එය වර්ග 3 ක් ඉතිරි කරයි. එය ද කළ හැකි var a; return obj === a;
නමුත් එය තවත් එක් චරිතයකි. :-)
void
වෙන් කර ඇති වචනයක් වන අතර, undefined
එනම් පෙරනිමියෙන් undefined
සමාන වන void 0
අතර, ඔබට undefined
උදා undefined = 1234
.
isUndefined(obj)
: අක්ෂර 16 යි. obj === void 0
: අක්ෂර 14 යි. නෆ් කිව්වා.
හුදෙක් කිසිවක් ජාවාස්ක්රිප්ට් හි අර්ථ දක්වා නැත, නිර්වචනය කර නැත, එය වස්තුවක් / අරාවක් තුළ ඇති දේපලක් නම් කමක් නැත හෝ සරල විචල්යයක් ...
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)
. X ප්රකාශ කර නොමැති වුවද මෙම චෙක්පත ආරක්ෂිතයි ( var x;
) - බ්රව්සරය දෝෂයක් නොදක්වයි.
if (window.history) {
history.call_some_function();
}
කවුළුව යනු සියළුම ගෝලීය විචල්යයන් එහි සාමාජිකයන් ලෙස තබා ඇති වස්තුවක් වන අතර, නොපවතින සාමාජිකයෙකුට ප්රවේශ වීමට උත්සාහ කිරීම නීත්යානුකූල ය. නම් x ප්රකාශ කර නොමැති හෝ ඉන් නියම කර නැත window.x
ප්රතිලාභ නිර්වචනය නොකළ . නිර්වචනය නොකළ මඟ පෙන්වන බොරු විට නම් () එය පරීක්ෂා කර බැලීමයි.
typeof history != 'undefined'
ඇත්ත වශයෙන්ම පද්ධති දෙකෙහිම ක්රියාත්මක වේ.
මේ හරහා කියවන විට, මම මෙය නොදැකීම ගැන පුදුම වෙමි. මේ සඳහා වැඩ කරන බහු ඇල්ගොරිතම මා සොයාගෙන ඇත.
වස්තුවක වටිනාකම කිසි විටෙක නිර්වචනය කර 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");
}
if (!obj.prop)
var obj = {foo: undefined}; obj.foo === void 0
-> true
. එය “කිසි විටෙකත් අර්ථ දක්වා නැත undefined
”? මේක වැරදියි.
void 0
ආතතිය සඳහා සංසන්දනය කරන්න .
if (foo !== void 0)
එය තරම් වාචික නොවේ if (typeof foo !== 'undefined')
foo
නොකළ හොත් එය යොමු දෝෂයක් විසි කරයි .
විසඳුම වැරදිය. ජාවාස්ක්රිප්ට් හි,
null == undefined
ඒවා සත්යයක් බවට පත්වනු ඇත, මන්ද ඔවුන් දෙදෙනාම “බූලියන්” වෙතට තල්ලු කර ඇති අතර ඒවා අසත්යය. නිවැරදි ක්රමය වන්නේ පරීක්ෂා කිරීමයි
if (something === undefined)
අනන්යතා ක්රියාකරු ...
===
සමානාත්මතාවය + (ප්රාථමික සමානාත්මතාවය | වස්තු අනන්යතාවය), එහිදී ප්රාථමිකයන්ට නූල් ඇතුළත් වේ. අනන්යතා ක්රියාකරු ලෙස 'abab'.slice(0,2) === 'abab'.slice(2)
යමෙකු සලකන්නේ නම් බොහෝ දෙනා නොදැනුවත්වම සලකනු ඇතැයි මම සිතමි ===
.
පහත දැක්වෙන කේතය භාවිතා කර ඔබට මාර්ගය සමඟ නිර්වචනය කර ඇති අරාව ලබා ගත හැකිය.
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 සබැඳිය
getUndefiend
විය යුතුය getUndefined
.
මෙන්න මගේ තත්වය:
මම REST ඇමතුමක ප්රති result ලය භාවිතා කරමි. ප්රති result ලය JSON සිට JavaScript වස්තුවකට විග්රහ කළ යුතුය.
මට ආරක්ෂා කිරීමට අවශ්ය එක් දෝෂයක් තිබේ. පරිශීලකයා තර්ක විතර්ක සඳහන් කරන තාක් දුරට විවේක ඇමතුම සඳහා වන ආගන්තුක වැරදියි නම්, ඉතිරි ඇමතුම මූලික වශයෙන් හිස් වේ.
මෙයින් ආරක්ෂා වීමට මට මෙම ලිපිය භාවිතා කරන අතරේ, මම මෙය උත්සාහ කළෙමි.
if( typeof restResult.data[0] === "undefined" ) { throw "Some error"; }
මගේ තත්වය සඳහා, restResult.data [0] === "වස්තුව" නම්, මට ආරක්ෂිතව සෙසු සාමාජිකයන් පරීක්ෂා කිරීම ආරම්භ කළ හැකිය. නිර්වචනය නොකළහොත් ඉහත පරිදි දෝෂය විසි කරන්න.
මා පවසන දෙය නම් මගේ තත්වය සඳහා මෙම ලිපියේ ඉහත යෝජනා සියල්ලම ක්රියාත්මක නොවීමයි. මම කියන්නේ නැහැ මම හරි, හැමෝම වැරදියි කියලා. මම කිසිසේත් ජාවාස්ක්රිප්ට් මාස්ටර් නොවෙමි, නමුත් මෙය යමෙකුට උපකාරී වනු ඇතැයි බලාපොරොත්තු වෙමි.
typeof
ආරක්ෂකයා ඇත්ත වශයෙන්ම comp ජු සංසන්දනයකට මුහුණ දිය නොහැකි කිසිම දෙයකින් ආරක්ෂා නොවේ. restResult
නිර්වචනය නොකළ හෝ ප්රකාශයට පත් නොකළේ නම් , එය තවමත් විසි කරයි.
if(!restResult.data.length) { throw "Some error"; }
නිර්වචනය කරන ලද දේපලක් නව විචල්යයකට අර්ථ දැක්වුවහොත් එය පැවරීමට හොඳ හෝ අලංකාර ක්රමයක් ඇත.
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)
1
විචල්යයට මා එකතු කරන්නේ x
කෙසේද? මට අන්ඩර්ස්කෝර් හෝ jQuery අවශ්යද? ( typeof
චෙක්පතක් වැනි වඩාත් මූලික මෙහෙයුම් සඳහා පවා මිනිසුන් පුස්තකාල භාවිතා කිරීම පුදුම සහගතය )
if (this.variable)
එය නිර්වචනය කර ඇත්දැයි පරීක්ෂා කිරීමට මම භාවිතා කරමි . ඉහත නිර්දේශ කර ඇති සරල if (variable)
, මා අසමත් වේ. එය ක්රියාත්මක වන්නේ විචල්යය කිසියම් වස්තුවක ක්ෂේත්රයක් වූ විට පමණක් බව එය ශබ්ද කෝෂයේ අර්ථ දක්වා ඇත්දැයි පරීක්ෂා කරයි. නමුත් අපි භාවිත කළ හැක හෝ ඕනෑම විචල්ය, වර්තමාන කවුළුව තුළ ක්ෂේත්ර නිසා මම එය තේරුම් ලෙස ශබ්ද කෝෂය වස්තුව ලෙස. එබැවින් මෙන්න පරීක්ෂණයකිobj.someField
this
window
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);
ආදාන අගයේ දේපලක් ලබා ගැනීමට උත්සාහ කරන්න, දෝෂ පණිවිඩය තිබේදැයි පරීක්ෂා කරන්න. ආදාන අගය නිර්වචනය කර නොමැති නම්, දෝෂ පණිවිඩය වනු ඇත Uncought TypeError : නිර්වචනය නොකළ දේපල 'b' කියවිය නොහැක
සංසන්දනය කිරීම සඳහා ආදාන අගය නූල් බවට පරිවර්තනය කරන්න "undefined"
බවට පරිවර්තනය කර එය negative ණ අගයක් බව සහතික කරන්න.
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
}
typeof
වේ. පුද්ගලයන් 4 දෙනෙකු මෙය ඉහළට ඔසවා තැබීම පුදුම සහගතය. -1.
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
}