විචල්‍යයක් ආරම්භ කර ඇත්දැයි පරීක්ෂා කිරීමේ ක්‍රමය වඩා හොඳ / නිවැරදිද? (විචල්‍යයට ඕනෑම දෙයක් රඳවා ගත හැකි යැයි උපකල්පනය කළහොත් (string, int, object, function, etc.))

if (elem) { // or !elem

හෝ

if (typeof(elem) !== 'undefined') {

හෝ

if (elem != null) {

ඔබට අවශ්ය වන typeofක්රියාකරු . විශේෂයෙන්:

if (typeof variable !== 'undefined') {
    // the variable is defined
}

මෙම typeofවිචල්ය ඇත්තටම නිර්වචනය නොකළ නම් ක්රියාකරු පරීක්ෂා කරනු ඇත.

if (typeof variable === 'undefined') {
    // variable is undefined
}

මෙම typeofක්රියාකරු, අනෙක් සමාගම් මෙන් නොව, එය විසි කරන්නේ නැත ReferenceError ක අප්රසිද්ධ විචල්ය භාවිත කරන විට හැර.

කෙසේ වෙතත්, එය typeof nullනැවත පැමිණෙන බව සලකන්න "object". වෙත විචල්‍යයක් ආරම්භ කිරීමේ වැරැද්ද වළක්වා ගැනීමට අප පරෙස්සම් විය යුතුය null. ආරක්ෂිත වීමට, ඒ වෙනුවට අපට භාවිතා කළ හැක්කේ මෙයයි:

if (typeof variable === 'undefined' || variable === null) {
    // variable is undefined or null
}

===සරල සමානාත්මතාවය වෙනුවට දැඩි සංසන්දනයක් භාවිතා කිරීම පිළිබඳ වැඩි විස්තර සඳහා ==, බලන්න:
ජාවාස්ක්‍රිප්ට් සැසඳීම් වලදී භාවිතා කළ යුතු සමාන ක්‍රියාකරු (== vs ===)?

බොහෝ අවස්ථාවලදී, භාවිතා කිරීම:

if (elem) { // or !elem

ඔබ වෙනුවෙන් එම කාර්යය කරනු ඇත! ... මෙය පහත සඳහන් අවස්ථා පරීක්ෂා කරනු ඇත:

1. නිර්වචනය නොකළ : අගය අර්ථ දක්වා නොමැති නම් සහ එයundefined
2. null : එය ශුන්‍ය නම්, උදාහරණයක් ලෙස, DOM අංගයක් නොපවතී නම් ...
3. හිස් නූල :''
4. 0 : අංක ශුන්‍යය
5. NaN : අංකයක් නොවේ
6. බොරු

එබැවින් එය සියලු ආකාරයේ අවස්ථාවන් ආවරණය කරනු ඇත, නමුත් සෑම විටම අප ආවරණය කිරීමට කැමති අමුතු අවස්ථා තිබේ, නිදසුනක් ලෙස, මේ හා සමාන අවකාශයක් සහිත නූලක් ' ', මෙය ජාවාස්ක්‍රිප්ට් වලින් අර්ථ දක්වනු ඇත. ... උදාහරණයක් ලෙස මෙම අවස්ථාවේදී ඔබ ටිම් () භාවිතා කරමින් තවත් එක් චෙක්පතක් එක් කරයි, වැනි:

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

එසේම, මෙම චෙක්පත් අගයන් සඳහා පමණක් වන අතර, ජාවාස්ක්‍රිප්ට් හි වස්තු සහ අරා වෙනස් ලෙස ක්‍රියා කරන බැවින් හිස් අරාව []සහ හිස් වස්තුව {}සැමවිටම සත්‍ය වේ.

පිළිතුරේ කෙටි විස්තරයක් පෙන්වීමට මම පහත රූපය නිර්මාණය කරමි:

ජාවාස්ක්‍රිප්ට් හි, විචල්‍යයක් අර්ථ දැක්විය හැකි නමුත් අගය රඳවා තබා ගන්න undefined, එබැවින් වඩාත් පොදු පිළිතුර තාක්‍ෂණිකව නිවැරදි නොවන අතර ඒ වෙනුවට පහත සඳහන් දෑ සිදු කරයි:

if (typeof v === "undefined") {
   // no variable "v" is defined in the current scope
   // *or* some variable v exists and has been assigned the value undefined
} else {
   // some variable (global or local) "v" is defined in the current scope
   // *and* it contains a value other than undefined
}

එය ඔබගේ අරමුණු සඳහා ප්‍රමාණවත් විය හැකිය. පහත දැක්වෙන පරීක්ෂණයට සරල අර්ථකථන ඇත, එමඟින් ඔබේ කේතයේ හැසිරීම නිවැරදිව විස්තර කිරීම සහ එය ඔබම තේරුම් ගැනීම පහසු කරයි (ඔබ එවැනි දේ ගැන සැලකිලිමත් නම්):

if ("v" in window) {
   // global variable v is defined
} else {
   // global variable v is not defined
}

ඇත්ත වශයෙන්ම, මෙය ඔබ බ්‍රව්සරයක ධාවනය වන බව උපකල්පනය කරයි ( windowගෝලීය වස්තුව සඳහා නමක් ඇති තැන). නමුත් ඔබ මේ වගේ ග්ලෝබල් සමඟ විනෝද වන්නේ නම් ඔබ බොහෝ විට බ්‍රව්සරයක සිටී. භාවිතා තේමාව, 'name' in windowභාවිතා සමග ශෛලිය අතින් අනුරූප ය window.nameglobals වෙත යොමු කිරීමට. windowවිචල්‍යයන්ට වඩා ගුණාංග ලෙස ග්ලෝබල් වෙත ප්‍රවේශ වීම මඟින් ඔබේ කේතයේ ඔබ සඳහන් කර ඇති ප්‍රකාශයට පත් නොකළ විචල්‍යයන් ගණන අවම කර ගැනීමට ඉඩ සලසයි (ලින්ටින් කිරීමේ ප්‍රයෝජනය සඳහා), සහ දේශීය විචල්‍යයක් මඟින් ඔබේ ගෝලීය සෙවනැලි වීමේ හැකියාව වළක්වයි. එසේම, ග්ලෝබල් ඔබේ සමට බඩගා ගියහොත් ඔබට ඒවා ස්පර්ශ කිරීමට වඩාත් පහසුවක් දැනෙන්නේ මෙම සාපේක්ෂව දිගු සැරයටියකින් පමණි.

ඔබ භාවිතා කරන බොහෝ අවස්ථාවන්හිදී:

elem != null

සරල මෙන් නොව if (elem), එය ඉඩ 0, false, NaNහා '', නමුත් ප්රතික්ෂේප කරයි nullහෝ undefined, එය හොඳ, තර්කයක් ඉදිරියේ සඳහා පොදු පරීක්ෂණය, හෝ වස්තුවක දේපල කරමින්.

අනෙක් චෙක්පත් ද වැරදි නැත, ඒවාට වෙනස් භාවිතයන් ඇත:

• if (elem): නම් භාවිතා කළ හැක elemවස්තුවක් විය සහතික කර ඇත, හෝ නම් false, 0ආදිය "පෙරනිමි" අගයන් (කිරීමට ඒ නිසා සමාන ලෙස සලකනු ලැබේ undefinedහෝ null).

• typeof elem == 'undefined'nullනිශ්චිත නොවන ආරම්භක විචල්‍යයකට හෝ දේපලකට පැහැදිලි අර්ථයක් ඇති අවස්ථාවන්හිදී භාවිතා කළ හැකිය .

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

ඊට සාපේක්ෂව දැඩි සංසන්දනයක් ද ප්‍රයෝජනවත් වේ undefined:

if (elem === undefined) ...

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

var undefined; // really undefined
if (elem === undefined) ...

හෝ:

(function (undefined) {
    if (elem === undefined) ...
})();

මෙම ක්‍රමයේ ද්විතියික වාසියක් නම්, JS මිනිෆයර් මඟින් undefinedවිචල්‍යය තනි අක්ෂරයකට අඩු කළ හැකි අතර, සෑම අවස්ථාවකදීම ඔබට බයිට් කිහිපයක් ඉතිරි වේ.

තිබේදැයි පරීක්ෂා කරන්න window. hasOwnProperty( " varname" )

typeofපිළිතුරු රාශියකට විකල්පයක් ;

ගෝලීය විචල්‍යයන් var varname = value;ගෝලීය විෂය පථයේ ප්‍රකාශයක් සමඟ ප්‍රකාශයට පත් කෙරේ

කවුළු වස්තුවේ ගුණාංග ලෙස ප්‍රවේශ විය හැකිය.

එනිසා, hasOwnProperty()ක්රමය, කුමන

වස්තුවට නිශ්චිත දේපලක් එහි දේපලක් ලෙස තිබේද යන්න දක්වමින් බූලියන් ලබා දෙයි (එය උරුම කර ගැනීමට වඩා වෙනස්ව)

යන්න තීරණය කිරීමට භාවිතා කළ හැකිය

එය varක "varname" ගෝලීය ප්රකාශයට පත් කර තිබේ එනම් එම ක දේපළක් window.

// Globally established, therefore, properties of window
var foo = "whatever", // string
    bar = false,      // bool
    baz;              // undefined
//  window.qux does not exist

console.log( [
    window.hasOwnProperty( "foo" ), // true
    window.hasOwnProperty( "bar" ), // true
    window.hasOwnProperty( "baz" ), // true
    window.hasOwnProperty( "qux" )  // false
] );

මෙහි ඇති වැදගත් hasOwnProperty()දෙය නම්, එය ඇමතීමේදී, අපි තවමත් ප්‍රකාශයට පත් නොකළ විචල්‍යයක් භාවිතා නොකිරීමයි - ඇත්ත වශයෙන්ම කුමන ගැටලුව මුලින් අඩක් ද?

නැති වුණත් හැම විටම එම පරිපූර්ණ හෝ පරිපූර්ණ විසඳුමක්, යම් යම් අවස්ථාවල දී, එය හුදෙක් රස්සාව!

සටහන්

භාවිතා කරන විට ඉහත සැබෑ ය varවිචල්ය නිර්වචනය කිරීමට විරුද්ධ ලෙස, letඇති:

බ්ලොක් විෂය පථය දේශීය විචල්‍යය ප්‍රකාශ කරයි, විකල්පයක් ලෙස එය අගයකට ආරම්භ කරයි.

වාර්‍තා varවිෂය පථය නොසලකා ගෝලීය වශයෙන් හෝ දේශීයව සමස්ත ශ්‍රිතයක් සඳහා විචල්‍යයක් නිර්වචනය කරන යතුරු පදයට වඩා වෙනස් වේ.

ඉහළ මට්ටමේ වැඩසටහන් සහ කාර්යයන් let, මෙන් නොව var, ගෝලීය වස්තුව මත දේපලක් නිර්මාණය නොකරයි.

සම්පූර්ණත්වය සඳහා: const නියතයන් අර්ථ දැක්වීම අනුව සත්‍ය වශයෙන්ම විචල්‍ය නොවේ (ඒවායේ අන්තර්ගතය විය හැකි වුවද); වඩාත් අදාළ:

varවිචල්‍යයන් මෙන් නොව ගෝලීය නියතයන් කවුළු වස්තුවේ ගුණාංග බවට පත් නොවේ . නියතයක් සඳහා ආරම්භකයක් අවශ්‍ය වේ; එනම්, ඔබ ප්‍රකාශ කළ ප්‍රකාශයේම එහි වටිනාකම සඳහන් කළ යුතුය.

නියතයක අගය නැවත පැවරීමෙන් වෙනස් කළ නොහැකි අතර එය නැවත ප්‍රකාශ කළ නොහැක.

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

සිට letවිචල්ය හෝ constනියත උරුම වූ ඕනෑම වස්තුවක ගුණ කිසි hasOwnProperty()ක්රමය, එය ඔවුන්ගේ පැවැත්ම සඳහා පරීක්ෂා කිරීම සඳහා භාවිතා කළ නොහැක.

ලබා ගත හැකි සහ භාවිතා කිරීම සම්බන්ධයෙන් hasOwnProperty():

සෑම වස්තුවකට පැවත වස්තූන් ද අනුන hasOwnProperty()ක්රමය. [...] inක්‍රියාකරු මෙන් නොව , මෙම ක්‍රමය මඟින් වස්තුවේ මූලාකෘති දාමය පරීක්ෂා නොකරයි.

විචල්යයක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද

විචල්‍යයක් පවතින අතර එය ආරම්භ කර ඇත්දැයි පරීක්ෂා කිරීම සඳහා මෙය ලස්සන වෙඩි නොවදින විසඳුමකි:

var setOrNot = typeof variable !== typeof undefined;

කිසියම් විචල්‍යයක් ආරම්භ කර නොමැති විට පෙරනිමිය සැකසීම සඳහා එය ත්‍රිමාණ ක්‍රියාකරු සමඟ සංයෝජිතව බහුලව භාවිතා වේ:

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

සංසරණය වීමේ ගැටළු

අවාසනාවකට, ඔබට ශ්‍රිතයක් තුළ ඔබගේ චෙක්පත සරලව වටහා ගත නොහැක.

මේ වගේ දෙයක් කිරීම ගැන ඔබට සිතිය හැකිය:

function isset(variable) {
    return typeof variable !== typeof undefined;
}

කෙසේ වෙතත්, ඔබ උදා අමතන්නේ නම් මෙය යොමු දෝෂයක් ඇති කරයි. isset(foo)සහ විචල්‍යය fooනිර්වචනය කර නැත, මන්ද ඔබට පවතින විචල්‍යයක් ශ්‍රිතයකට යැවිය නොහැකි බැවිනි:

හඳුනා නොගත් යොමු දෝෂය: foo යන්න අර්ථ දක්වා නැත

ක්‍රියාකාරී පරාමිතීන් නිර්වචනය කර නොමැතිදැයි පරීක්ෂා කිරීම

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

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

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

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

var values = typeof variable !== 'undefined' ? variable : '';

සමුද්දේශ විචල්‍යය නිදර්ශන පැවරීම සමඟ ගෝලීය විචල්‍යය ප්‍රකාශ කිරීමට ඔබ උත්සාහ කරන විට මෙයද ප්‍රයෝජනවත් වනු ඇත.

ඔබට විචල්යය පරීක්ෂා කිරීමට අවශ්ය නම් undefinedහෝ නොවිය යුතුය null. ඉන්පසු පහත චෙක්පත සිදු කරන්න.

විචල්‍යය ප්‍රකාශයට පත් කළ විට, සහ ඔබට අගය පරීක්ෂා කිරීමට අවශ්‍ය නම්, මෙය පවා සරල ය: එය ක්‍රියාත්මක වන undefinedඅතර nullඑකට පරීක්ෂා කරයි.

var values = variable ? variable : '';

විචල්යයක් පරීක්ෂා කිරීම සඳහා කෙටි ක්රමය ප්රකාශයට පත් නොකෙරේ (නිර්වචනය කර නැත)

if (typeof variable === "undefined") {
  ...
}

බ්‍රව්සරයෙන් පිටත ධාවනය වන ස්ක්‍රිප්ට් හඳුනා ගැනීමට එය ප්‍රයෝජනවත් බව මට පෙනී windowගියේය (ප්‍රකාශිත විචල්‍යයක් නොතිබීම ).

එය රඳා පවතින්නේ විචල්‍යය නිර්වචනය කර ඇති බවට හෝ එය අර්ථවත් අගයක් ලබා ගැනීමට ඔබට අවශ්‍ය නම් පමණි.

වර්ගය නිර්වචනය කර නොමැතිදැයි පරීක්ෂා කිරීමෙන් විචල්‍යය තවම අර්ථ දක්වා ඇත්දැයි පරීක්ෂා කරයි.

=== nullහෝ !== nullවිචල්‍යයේ අගය හරියටම දැයි පරික්ෂා කරයි null.

== nullහෝ != nullවටිනාකම නම් පරීක්ෂා කරනු ඇත undefinedහෝ null.

if(value)විචල්ය නම් පරීක්ෂා කරනු ඇත undefined, null, 0, හෝ හිස් අගයක්.

ඉහළම පිළිතුර නිවැරදි ය, typeof භාවිතා කරන්න.

කෙසේ වෙතත්, මට පෙන්වා දීමට අවශ්‍ය වූයේ ජාවාස්ක්‍රිප්ට් undefinedහි විකෘති වීමයි (කිසියම් අභක්තික හේතුවක් නිසා). එබැවින් හුදෙක් පරීක්‍ෂණයක් කිරීමෙන් varName !== undefinedඔබ බලාපොරොත්තු වන පරිදි සෑම විටම ආපසු නොයාමට හැකියාවක් ඇත, මන්ද වෙනත් ලිබ්ස් නිර්වචනය කර නොතිබිය හැකි බැවිනි. පිළිතුරු කිහිපයක් (@ ස්කලීස්, එකක් සඳහා), භාවිතා නොකිරීමට වැඩි කැමැත්තක් දක්වන අතර typeof, එයින් එකක් කරදරයකට පත්විය හැකිය.

මෙය හැසිරවිය හැකි “පැරණි” ක්‍රමය නම්, විභව විකෘති / අධික ලෙස ධාවනය කිරීම වළක්වා ගැනීම සඳහා නිර්වචනය නොකළ විචල්‍යයක් ලෙස ප්‍රකාශ කිරීමයි undefined. කෙසේ වෙතත්, හොඳම ක්‍රමය තවමත් භාවිතා කිරීම typeofනිසා එය undefinedවෙනත් කේත වලින් ඉක්මවා යාම නොසලකා හරිනු ඇත . විශේෂයෙන් ඔබ වනාන්තරයේ භාවිතා කිරීම සඳහා කේතයක් ලියන්නේ නම්, පිටුවේ ක්‍රියාත්මක විය හැකි වෙනත් දේ දන්නේ කවුද ...

if (typeof console != "undefined") {    
   ...
}

නැත්නම් වඩා හොඳයි

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

සියලුම බ්‍රව්සර් වල ක්‍රියා කරයි

විවාදයට දායක වීම සඳහා, විචල්‍යය මා නිතරම කැමති නූලක් හෝ වස්තුවක් විය යුතු බව මා දන්නේ if (!variable)නම්, එහි ව්‍යාජදැයි පරීක්ෂා කරන්න. මෙය වඩාත් පිරිසිදු කේතයක් ගෙන ඒමට හැකි වන පරිදි, උදාහරණයක් ලෙස:

if (typeof data !== "undefined" && typeof data.url === "undefined") {
    var message = 'Error receiving response';
    if (typeof data.error !== "undefined") {
        message = data.error;
    } else if (typeof data.message !== "undefined") {
        message = data.message;
    }
    alert(message); 
}

පහත පරිදි අඩු කළ හැකිය:

if (data && !data.url) {
  var message = data.error || data.message || 'Error receiving response';
  alert(message)
} 

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

var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);

Null යනු ජාවාස්ක්‍රිප්ට් හි අගයකි typeof null ප්රතිලාභ"object"

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

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}

වඩාත්ම ශක්තිමත් 'එය අර්ථ දක්වා ඇත්තේ' චෙක්පත ටයිප් ඔෆ් සමඟ ය

if (typeof elem === 'undefined')

පෙරනිමිය පැවරීම සඳහා ඔබ නිර්වචනය කළ විචල්‍යයක් සොයන්නේ නම්, එක් ලයිනර් කියවීම පහසු කිරීම සඳහා ඔබට බොහෝ විට මෙය කළ හැකිය:

elem = elem || defaultElem;

එය භාවිතා කිරීම බොහෝ විට හොඳයි, බලන්න: ජාවාස්ක්‍රිප්ට් හි පෙරනිමි අගය සැකසීමට මුග්ධ ක්‍රමය

යතුරු ලියනය යතුරු පදය භාවිතා කරමින් මෙම එක් ලයිනර් එකක් ද ඇත :

elem = (typeof elem === 'undefined') ? defaultElem : elem;

ඔබට භාවිතා කළ හැකිය typeof ක්‍රියාකරු .

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

var dataSet;

alert("Variable dataSet is : " + typeof dataSet);

ඉහත කේත ස්නිපටය වැනි ප්‍රතිදානය නැවත ලබා දෙනු ඇත

විචල්ය දත්ත කට්ටලය: නිර්වචනය නොකළ.

විචල්යයක් ප්රකාශයට පත් කර තිබේද / පරීක්ෂා කර ඇත්දැයි පරීක්ෂා කිරීම සඳහා මම මෙම අපිරිසිදු උපක්රමය කළෙමි.

ශ්‍රිතයකට කේතය උකහා ගැනීමට මට ක්‍රමයක් සොයාගෙන නැත eval.

"use strict";

// var someVar;

var declared;
try {
  someVar;
  declared = true;
} catch(e) {
  declared = false;
}

if (declared) {
  console.log("someVar is declared; now has the value: " + someVar);
} else {
  console.log("someVar is not declared");
}

මෙම පිළිතුරු (ෆ්‍රෙඩ් ගාන්ඩ් විසඳුම හැර) සියල්ලම වැරදි හෝ අසම්පූර්ණයි.

මට වටිනාකමක් variableName;ගෙනයාමට අවශ්‍ය යැයි සිතමු undefined, එබැවින් එය var variableName;දැනටමත් ආරම්භ කර ඇති බවක් අදහස් වන ආකාරයට ප්‍රකාශයට පත් කර ඇත ; - එය දැනටමත් ප්‍රකාශයට පත් කර ඇත්දැයි පරීක්ෂා කරන්නේ කෙසේද?

හෝ ඊටත් වඩා හොඳයි - "Book1.chapter22.paragraph37" එක ඇමතුමකින් තිබේද, නමුත් යොමු දෝෂයක් මතු නොවන්නේදැයි මම වහාම පරීක්ෂා කරන්නේ කෙසේද?

අපි ඉතා බලගතු JasvaScript ක්රියාකරු, භාවිතා කරමින් එය කරන්න තුළ ක්රියාකරු .:

"[variable||property]" in [context||root] 
>> true||false

AJAX ජනප්‍රියත්වයේ කාලවලදී මම "Book1.chapter22.paragraph37" වැනි දේපල නම් සඳහා ගැඹුරු පරීක්ෂණ සහ තවත් බොහෝ දේ ඇතුළුව නාම අවකාශය තිබේද යන්න තීරණය කළ හැකි (පසුව නම් කරන ලද) isNS () ක්‍රමයක් ලියා ඇත.

නමුත් එය කලින් ප්‍රකාශයට පත් කර ඇති හෙයින් සහ එහි ඇති වැදගත්කම නිසා එය වෙනම ත්‍රෙඩ් එකක පළ කිරීමට සුදුසු බැවින් මම එය මෙහි පළ නොකරමි, නමුත් මූල කේත ( javascript + isNS ) ලබා දෙන්නෙමි. අවශ්‍ය පැහැදිලි කිරීම්.

ප්රශ්නයේ දක්වා ඇති විශේෂිත තත්වය තුළ,

typeof window.console === "undefined"

ට සමාන වේ

window.console === undefined

එය කෙටි බැවින් මම දෙවැන්නට කැමැත්තෙමි.

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

Rian බ්‍රයන්කෙලි සිය විශිෂ්ට පිළිතුරෙන් තාක්ෂණික විස්තර පැහැදිලි කරයි. මම නිගමනයකට එළඹීම පමණක් එකතු කර එය කියවීමට පහසු දෙයකට ජීර්ණය කර ඇත්තෙමි.

වස්තුව අනුව මම වෙනස් ක්‍රම දෙකක් භාවිතා කරමි.

if( !variable ){
  // variable is either
  // 1. '';
  // 2. 0;
  // 3. undefined;
  // 4. null;
  // 5. false;
}

සමහර විට හිස් නූලක් ව්‍යාජ ලෙස තක්සේරු කිරීමට මට අවශ්‍ය නැත, එබැවින් මම මෙම නඩුව භාවිතා කරමි

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

ඔබට ප්‍රතිවිරුද්ධ දේ අවශ්‍ය නම්, පළමු අවස්ථාවේදී! විචල්‍යය !! විචල්ය බවට පත්වන අතර අවලංගු ශ්‍රිතයේ === බවට පත්වේ! = සහ ශ්‍රිත නාම වෙනස් නොවන බවට වෙනස් වේ.

මගේ මනාපය typeof(elem) != 'undefined' && elem != null.

කෙසේ වෙතත් ඔබ තෝරා ගත්තද, චෙක්පත එවැනි ශ්‍රිතයකට දැමීම ගැන සලකා බලන්න

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

විචල්‍යය ප්‍රකාශයට පත් කර ඇති බව ඔබ නොදන්නේ නම් ඉදිරියට යන්න typeof (x) != 'undefined' && x != null;

විචල්‍යය ප්‍රකාශයට පත් කර ඇති නමුත් නොපවතින තැන ඔබ භාවිතා කළ හැකිය

existy(elem) && doSomething(elem);

ඔබ පරික්ෂා කරන විචල්‍යය සමහර විට කැදැලි දේපලක් විය හැකිය. ඔබට මුක්කු භාවිතා කළ හැකිය || question question ප්‍රශ්නයට ලක්වූ දේපලෙහි පැවැත්ම පරීක්ෂා කර බැලීමට:

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

එක් එක් දේපල භාවිතයෙන් පසු (... '|| {}'). ඊළඟ ප්‍රොපර් මඟින් නැතිවූ දේපලක් දෝෂයක් ඇති නොවන පරිදි.

නැතහොත් ඔබට වැනි පැවැත්මක් භාවිතා කළ හැකිය existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

උත්සාහ කරන්න

විචල්‍යය කිසිසේත් නිර්වචනය කර නොමැති නම්, ඔබට පහත දැක්වෙන පරිදි ට්‍රයිච්-කැච් බ්ලොක් භාවිතා කරමින් බ්‍රේක් කේත ක්‍රියාත්මක කිරීමකින් තොරව මෙය පරීක්ෂා කළ හැකිය (ඔබට use strictප්‍රකාරය කිරීමට අවශ්‍ය නැත )

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

බෝනස්: (වෙනත් පිළිතුරු වෙත යොමු කරමින්) ( මූලාශ්‍රයට=== වඩා පැහැදිලි වන්නේ ඇයි?== )

if (a == b)

if (a === b)

එය තත්වය මත රඳා පවතී. ඔබගේ කේතයෙන් පිටත ගෝලීයව අර්ථ දක්වා ඇති හෝ නොවිය හැකි යමක් ඔබ පරික්ෂා කරන්නේ නම් (සමහර විට jQuery වැනි) ඔබට අවශ්‍ය:

if (typeof(jQuery) != "undefined")

.

function sayHello(name) {
    if (name) return "Hello, " + name;
    else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"

මට පුදුමයි මේක තවම සඳහන් නොවීම ...

භාවිතා කරමින් අමතර වෙනස්කම් කිහිපයක් මෙන්න this['var_name']

විචල්‍යයක් නිර්වචනය කිරීමට පෙර එය භාවිතා කළ හැකි මෙම ක්‍රමය භාවිතා කිරීමේ වාසිය.

if (this['elem']) {...}; // less safe than the res but works as long as you're note expecting a falsy value
if (this['elem'] !== undefined) {...}; // check if it's been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it's not null, you can use just elem for the second part

// these will work even if you have an improper variable definition declared here
elem = null; // <-- no var here!! BAD!

ඔබට පහත දැක්වෙන පරිදි උත්සාහ කර බලන්න ...

var status = 'Variable exists'

try {
    myVar
} catch (ReferenceError) {
    status = 'Variable does not exist'
}

console.log(status)

අවාසියක් නම් ඔබට එය ශ්‍රිතයක් තුළට යොමු කළ නොහැකි බැවින් එය යොමු දෝෂයක් විසි කරයි

function variableExists(x) {
  var status = true
  try {
      x
  } catch (ReferenceError) {
      status = false
  }
  
  return status
}

console.log(variableExists(x))

සංස්කරණය කරන්න:

ඔබ ඉදිරිපස ජාවාස්ක්‍රිප්ට් හි වැඩ කරමින් සිටියේ නම් සහ විචල්‍යයක් ආරම්භ කර නොමැතිදැයි පරීක්ෂා කිරීමට ඔබට අවශ්‍ය නම් ( var x = undefinedආරම්භ නොකළ ලෙස ගණන් ගනු ඇත), ඔබට මෙය භාවිතා කළ හැකිය:

function globalVariableExists(variable) {
  if (window[variable] != undefined) {
    return true
  }
  
  return false
}

var x = undefined

console.log(globalVariableExists("x"))

console.log(globalVariableExists("y"))

var z = 123

console.log(globalVariableExists("z"))