විචල්‍යයක් 'නිර්වචනය නොකළ' හෝ 'ශුන්‍ය' දැයි මා තීරණය කරන්නේ කෙසේද?

කොහොමද විචල්ය නම් මම තීරණය කරන්නේ undefinedහෝ null?

මගේ කේතය පහත පරිදි වේ:

var EmpName = $("div#esd-names div#name").attr('class');
if(EmpName == 'undefined'){
  // DO SOMETHING
};

<div id="esd-names">
  <div id="name"></div>
</div>

නමුත් මම මෙය කරන්නේ නම්, ජාවාස්ක්‍රිප්ට් පරිවර්තකය ක්‍රියාත්මක කිරීම නවත්වයි.

මෙය සිදු කිරීම සඳහා ඔබට වියුක්ත සමානාත්මතා ක්‍රියාකරුගේ ගුණාංග භාවිතා කළ හැකිය :

if (variable == null){
    // your code here.
}

නිසා null == undefinedසැබෑ වන අතර, ඉහත කේතය දෙකම අල්ලා ඇත nullහා undefined.

අල්ලා ගැනීමට nullහා undefinedඑකවර සම්මත ක්‍රමය මෙයයි:

if (variable == null) {
     // do something 
}

- වඩා පැහැදිලි නමුත් අඩු සංක්ෂිප්තයට 100% සමාන වේ:

if (variable === undefined || variable === null) {
     // do something 
}

වෘත්තීය ජේඑස් ලියන විට, එම වර්ගයේ සමානාත්මතාවය සහ ==එදිරිව හැසිරීම=== තේරුම් ගත හැකිය. එබැවින් අපි භාවිතා කරන්නේ ==හා සැසඳීම පමණි null.

නැවත සංස්කරණය කරන්න

භාවිතා කිරීම යෝජනා කරන අදහස් typeofහුදෙක් වැරදිය. ඔව්, ඉහත මගේ විසඳුම විචල්‍යය නොපවතින විට ReferenceError එකක් ඇති කරයි. මේක හොඳ දෙයක්. මෙම යොමු දෝෂය යෝග්‍ය වේ: එය වෙනත් භාෂාවල සම්පාදක දෝෂ මෙන් ඔබේ කේතය නැව්ගත කිරීමට පෙර ඔබේ වැරදි සොයා ගැනීමට සහ ඒවා නිවැරදි කිරීමට උපකාරී වේ. භාවිතා කරන්න try/ catchඔබ ආදානය සමඟ වැඩ කරන්නේ නම් ඔබට පාලනය කළ නොහැක.

ඔබේ කේතයේ ප්‍රකාශයට පත් නොකළ විචල්‍යයන් පිළිබඳව කිසිදු සඳහනක් නොතිබිය යුතුය.

ඉහත පිළිතුරු සමඟ සංයෝජනය කිරීමෙන් වඩාත්ම සම්පූර්ණ පිළිතුර වනු ඇත්තේ:

if( typeof variable === 'undefined' || variable === null ){
    // Do stuff
}

මෙය ප්‍රකාශයට පත් නොකළ හෝ ප්‍රකාශයට පත් කරන ලද සහ පැහැදිලිවම ශුන්‍ය හෝ නිර්වචනය නොකළ ඕනෑම විචල්‍යයක් සඳහා ක්‍රියා කළ යුතුය. තථ්‍ය ශුන්‍ය නොවන අගයක් ඇති ඕනෑම ප්‍රකාශිත විචල්‍යයක් සඳහා බූලියන් ප්‍රකාශනය අසත්‍ය ලෙස තක්සේරු කළ යුතුය.

if (variable == null) {
    // Do stuff, will only match null or undefined, this won't match false
}

if (typeof EmpName != 'undefined' && EmpName) {

අගය නොවේ නම් සත්‍ය ලෙස ඇගයීමට ලක් කරයි:

• ශුන්‍යයි

• නිර්වචනය නොකළ

• නා

• හිස් නූල ("")

• 0

• බොරු

jQuery attr()ශ්‍රිතය හිස් නූලක් හෝ සත්‍ය අගය ලබා දෙයි (සහ කිසි විටෙකත් nullහෝ නොවේ undefined). එය නැවත පැමිණෙන එකම අවස්ථාවundefined වන්නේ ඔබේ තේරීම්කරු කිසිදු අංගයක් ආපසු ලබා නොදුන් .

එබැවින් ඔබට හිස් නූලකට එරෙහිව පරීක්ෂා කිරීමට අවශ්‍ය විය හැකිය. විකල්පයක් ලෙස, හිස් නූල්, ශුන්‍ය සහ නිර්වචනය නොකළ ව්‍යාජ-වයි බැවින් ඔබට මෙය කළ හැකිය:

if (!EmpName) { //do something }

මම මේ සඳහා මගේම කාර්යයක් ලිවීමට පැමිණ සිටිමි. ජාවාස්ක්‍රිප්ට් අමුතුයි.

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

function empty(v) {
    let type = typeof v;
    if (type === 'undefined') {
        return true;
    }
    if (type === 'boolean') {
        return !v;
    }
    if (v === null) {
        return true;
    }
    if (v === undefined) {
        return true;
    }
    if (v instanceof Array) {
        if (v.length < 1) {
            return true;
        }
    } else if (type === 'string') {
        if (v.length < 1) {
            return true;
        }
        if (v === '0') {
            return true;
        }
    } else if (type === 'object') {
        if (Object.keys(v).length < 1) {
            return true;
        }
    } else if (type === 'number') {
        if (v === 0) {
            return true;
        }
    }
    return false;
}

TypeScript- අනුකූල වේ.

මෙම ක්රියාව කළ යුත්තේ හරියටම PHP හි මෙන් එකම දේ empty()කාර්යය (බලන්නRETURN VALUES )

සලකන undefined, null, false, 0, 0.0, "0" {}, [], හිස් ලෙස.

"0.0", NaN, " ", true, හිස්-නොවන ලෙස සලකනු ලැබේ.

කෙටිම හා පහසුම:

if(!EmpName ){
 // DO SOMETHING
}

EmpName නම් මෙය සත්‍ය ලෙස තක්සේරු කරනු ඇත:

• ශුන්‍යයි
• නිර්වචනය නොකළ
• නා
• හිස්
• string ("")
• 0
• බොරු

මෙය කිරීමට ඇති කෙටිම ක්‍රමය නම්:

if(EmpName == null) { /* DO SOMETHING */ };

මෙන්න සාක්ෂි:

function check(EmpName) {
  if(EmpName == null) { return true; };
  return false;
}

var log = (t,a) => console.log(`${t} -> ${check(a)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" 

==( මෙහි මූලාශ්‍රය ) පිළිබඳ වැඩි විස්තර මෙහි දැක්වේ

බෝනස් : හේතුව ===වඩා පැහැදිලි වීමට හේතුව ==( වයස්ගත පිළිතුර දෙස බලන්න )

ඔබට පරීක්ෂා කිරීමට අවශ්‍ය විචල්‍යය ගෝලීය නම්, කරන්න

if (window.yourVarName) {
    // Your code here
}

yourVarNameවිචල්‍යය නොපවතින නමුත් පරීක්ෂා කිරීමට මෙම ක්‍රමය දෝෂයක් ඇති නොකරයි.

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

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

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

windowසියලු ගෝලීය විචල්‍යයන් එහි ගුණාංග ලෙස රඳවා ඇති වස්තුවක් වන අතර, ජාවාස්ක්‍රිප්ට් හි නොපවතින වස්තු දේපලකට ප්‍රවේශ වීමට උත්සාහ කිරීම නීත්‍යානුකූල වේ. නම් historyඑවිට නොපවතියි window.historyප්රතිලාභ undefined. undefinedවැරදියි, එබැවින් if(undefined){}බ්ලොක් එකක කේතය ක්‍රියාත්මක නොවේ.

මට මේ ගැටලුව ඇති වී ඇත, එනම් වස්තුවක් ශුන්‍ය දැයි පරීක්ෂා කිරීම.
මම මෙය සරලවම භාවිතා කරමි:

if (object) {
    // Your code
}

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

if (document.getElementById("enterJob")) {
    document.getElementById("enterJob").className += ' current';
}

ඔබ jQuery භාවිතා කරන බැවින් , විචල්‍යයක් නිර්වචනය කර නොමැතිද නැතිනම් තනි ශ්‍රිතයක් භාවිතා කිරීමෙන් එහි අගය අහෝසි වේද යන්න ඔබට තීරණය කළ හැකිය.

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;

jQuery පිරික්සුම් අංගය ශුන්‍ය නොවේ:

var dvElement = $('#dvElement');

if (dvElement.length  > 0) {
    // Do something
}
else{
    // Else do something else
}

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

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

සියලුම කොන්දේසි පරීක්ෂා කරන්න:

if(variable === undefined || variable === null || variable === ''){
}

ඔබට සරලවම පහත සඳහන් දෑ භාවිතා කළ හැකිය (මෙය කිරීමට කෙටි ක්‍රම ඇති බව මම දනිමි, නමුත් මෙය දෘශ්‍යමය වශයෙන් නිරීක්ෂණය කිරීම පහසු කරයි, අවම වශයෙන් කේතය දෙස බලන අනෙක් අයට).

if (x === null || x === undefined) {
 // Add your response code here, etc.
}

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

if(!variable) {
  // If the variable is null or undefined then execution of code will enter here.
}

පහත විසඳුම සමඟ:

const getType = (val) => typeof val === 'undefined' || !val ? null : typeof val;
const isDeepEqual = (a, b) => getType(a) === getType(b);

console.log(isDeepEqual(1, 1)); // true
console.log(isDeepEqual(null, null)); // true
console.log(isDeepEqual([], [])); // true
console.log(isDeepEqual(1, "1")); // false
etc...

මට පහත සඳහන් දෑ පරීක්ෂා කළ හැකිය:

• ශුන්‍යයි
• නිර්වචනය නොකළ
• නා
• හිස්
• string ("")
• 0
• බොරු

විචල්යයක් ශුන්ය හෝ නිර්වචනය කර ඇත්දැයි පරීක්ෂා කිරීම සඳහා මම පහත කේතය භාවිතා කරමි.

    if(typeof sVal === 'undefined' || sVal === null || sVal === ''){
      console.log('variable is undefined or null');
    }

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

var c;
undefined
if (c === void 0) alert();
// output =  undefined
var c = 1;
// output =  undefined
if (c === void 0) alert();
// output =   undefined
// check c value  c
// output =  1
if (c === void 0) alert();
// output =  undefined
c = undefined;
// output =  undefined
if (c === void 0) alert();
// output =   undefined

අපි මේ දෙස බලමු,

1.  

   let apple; // Only declare the variable as apple
   alert(apple); // undefined

   ඉහත දැක්වෙන්නේ විචල්‍යය ලෙස ප්‍රකාශ වන්නේ පමණි apple. මෙම අවස්ථාවේදී, අපි ක්‍රමයට කතා කළහොත් alertඑය නිර්වචනය නොකෙරේ.

2.  

      let apple = null; /* Declare the variable as apple and initialized but the value is null */
      alert(apple); // null

appleවටිනාකමේ විචල්‍යය ශුන්‍ය බැවින් දෙවැන්නෙහි එය ශුන්‍ය වේ.

එබැවින් වටිනාකමක් නිර්වචනය කර නැතිද නැතිනම් ඔබට පරීක්ෂා කළ හැකිය.

if(apple !== undefined || apple !== null) {
    // Can use variable without any error
}

හොඳම ක්‍රමය:

if(typeof variable==='undefined' || variable===null) {

/* do your stuff */
}

(null == undefined)  // true

(null === undefined) // false

මොකද === වර්ගය සහ වටිනාකම යන දෙකම පරීක්ෂා කරයි. දෙකෙහිම වර්ගය වෙනස් නමුත් අගය සමාන වේ.

var i;

if (i === null || typeof i === 'undefined') {
    console.log(i, 'i is undefined or null')
}
else {
    console.log(i, 'i has some value')
}

මෙම foo == nullචෙක්පත උපාය කරන්න සහ කෙටිම ආකාරයෙන් "නිර්වචනය නොකළ හෝ ශූන්ය" නඩුව සමථයකට පත් කළ යුතු. ("Foo" ලෙස නොසැලකේ. එස්ලින්ට් සහ ට්ලින්ට් හි eqeqeq හෝ ත්‍රිත්ව-සමාන නීති දෙස බලන්න ...

විචල්යයක් undefinedහෝ nullවෙනම දැයි අප පරික්ෂා කරන විට පැහැදිලි ප්රවේශය මෙම අවස්ථාවේ දී යෙදිය යුතු අතර, මාතෘකාවට මගේ දායකත්වය (දැනට negative ණාත්මක නොවන පිළිතුරු 27 ක්!) void 0පරීක්ෂා කිරීම සඳහා කෙටි හා ආරක්ෂිත ක්රමයක් ලෙස භාවිතා කිරීම ය. සඳහාundefined .

foo === undefinedනිර්වචනය කිරීම වෙන් කර ඇති වචනයක් නොවන අතර සෙවනැලි කළ හැකි නිසා ( MDN ) භාවිතා කිරීම ආරක්ෂිත නොවේ . typeof === 'undefined'චෙක්පත භාවිතා කිරීම ආරක්ෂිතයි, නමුත් අප විසින් foo-is-ප්‍රකාශයට පත් නොකළ නඩුව ගැන සැලකිලිමත් නොවන්නේ නම් පහත සඳහන් ප්‍රවේශය භාවිතා කළ හැකිය:

if (foo === void 0 || foo === null) { ... }

ඔබ එය පරීක්ෂා කිරීම සඳහා ශ්‍රිතයක් නිර්මාණය කරන්නේ නම්:

export function isEmpty (v) {
 if (typeof v === "undefined") {
   return true;
 }
 if (v === null) {
   return true;
 }
 if (typeof v === "object" && Object.keys(v).length === 0) {
   return true;
 }

 if (Array.isArray(v) && v.length === 0) {
   return true;
 }

 if (typeof v === "string" && v.trim().length === 0) {
   return true;
 }

return false;
}

ටයිප් ඔෆ් ශුන්‍යය ඇමතීමෙන් “වස්තුව” හි අගය ලැබේ, විශේෂ අගය ශුන්‍යය හිස් වස්තු යොමු කිරීමක් ලෙස සැලකේ. 5 වන අනුවාදය හරහා සෆාරි සහ 7 වන අනුවාදය හරහා ක්‍රෝම් යන දෙඅංශයෙන්ම නිත්‍ය ප්‍රකාශනයක යතුරු ලියනය කිරීම “ශ්‍රිතය” ලබා දෙන අතර අනෙක් සියලුම බ්‍රව්සර් “වස්තුව” ආපසු ලබා දේ.

var x;
if (x === undefined) {
    alert ("only declared, but not defined.")
};
if (typeof y === "undefined") {
    alert ("not even declared.")
};

ඔබට භාවිතා කළ හැක්කේ දෙවැන්න පමණි: එය අර්ථ දැක්වීම සහ ප්‍රකාශනය යන දෙකම පරික්ෂා කරයි

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

var EmpName = $("div#esd-names div#name").attr('class');

// Undefined check
if (Object.prototype.toString.call(EmpName) === '[object Undefined]'){
    // Do something with your code
}

// Nullcheck
if (Object.prototype.toString.call(EmpName) === '[object Null]'){
    // Do something with your code
}

යතුරු ලියනය භාවිතා කිරීමෙන් අගය නිර්වචනය කර නොමැතිද නැතිනම් ඔබට පරීක්ෂා කළ හැකිය:

if(typeof value == 'undefined'){

if(x==null)ජාවාස්ක්‍රිප්ට් හි නරක අදහසකි. සමඟ විනිශ්චය කරන්න "=="- එය අනපේක්ෂිත ආකාරයේ බලහත්කාරයක් ඇති කළ හැකි අතර එය කෝපි ස්ක්‍රිප්ට් මඟින් කියවිය නොහැක, කොන්දේසි විනිශ්චය කිරීමේදී කිසි විටෙකත් "==" හෝ "! =" භාවිතා නොකරන්න!

if(x)වඩා හොඳ වනු ඇත, නමුත් 0 සහ "" සමඟ ප්‍රවේශම් වන්න . එය ලෙස සලකනු ලැබේ බොරු නොවේ සමග සමාන ක්රමයක් "!= null"වේ සැබෑ .

ජාවාස්ක්‍රිප්ට් හොඳම පිළිවෙත් බලන්න .