ජාවාස්ක්‍රිප්ට් හි ශුන්‍ය සහ නිර්වචනය නොකළ අතර වෙනස කුමක්ද?

ජාවාස්ක්‍රිප්ට් අතර nullසහ වෙනස කුමක්දැයි දැන ගැනීමට මට අවශ්‍යය undefined.

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

var TestVar;
alert(TestVar); //shows undefined
alert(typeof TestVar); //shows undefined

nullපැවරුම් අගයකි. කිසිදු අගයක නිරූපණයක් ලෙස එය විචල්‍යයකට පැවරිය හැකිය:

var TestVar = null;
alert(TestVar); //shows null
alert(typeof TestVar); //shows object

පූර්ව උදාහරණ වලින් පැහැදිලි වන undefinedඅතර එය nullඑකිනෙකට වෙනස් වර්ග දෙකකි: undefinedවර්ගයක් යනු (නිර්වචනය නොකළ) nullවස්තුවකි.

null === undefined // false
null == undefined // true
null === null // true

සහ

null = 'value' // ReferenceError
undefined = 'value' // 'value'

(අක්ෂර නොමැතිකම නිසා අක්ෂර එකතු කිරීම, එබැවින් මට මෙය පළ කිරීමට අවසර ඇත.)

මම මේක මෙතනින් ගත්තා

නිර්වචනය නොකළ අගය යනු විචල්‍යයකට අගයක් පවරා නොමැති විට භාවිතා කරන ප්‍රාථමික අගයකි.

ශුන්‍ය අගය යනු ශුන්‍ය, හිස් හෝ නොපවතින යොමු දැක්වීමක් නියෝජනය කරන ප්‍රාථමික අගයකි.

ඔබ var හරහා විචල්‍යයක් ප්‍රකාශ කර එයට අගයක් ලබා නොදෙන විට, එහි අගය නිර්වචනය නොකෙරේ. ඔබ විසින්ම WScript.Echo () හෝ මෙම අගය දැනුම් දීමට උත්සාහ කළහොත් ඔබට කිසිවක් නොපෙනේ. කෙසේ වෙතත්, ඔබ එයට හිස් නූලක් එකතු කළහොත් හදිසියේම එය දිස්වනු ඇත:

var s;
WScript.Echo(s);
WScript.Echo("" + s);

ඔබට විචල්‍යයක් ප්‍රකාශ කළ හැකිය, එය ශුන්‍ය ලෙස සකසන්න, සහ හැසිරීම අනන්‍ය වන්නේ “ශුන්‍ය” මුද්‍රණය කර “නිර්වචනය නොකළ” ලෙසට ය. මෙය ඇත්ත වශයෙන්ම කුඩා වෙනසක්.

ඔබට නිර්වචනය නොකළ විචල්‍යයක් ශුන්‍ය හෝ අනෙක් අතට සංසන්දනය කළ හැකි අතර තත්වය සත්‍ය වනු ඇත:

undefined == null
null == undefined

කෙසේ වෙතත් ඒවා විවිධ වර්ග දෙකක් ලෙස සැලකේ. නිර්වචනය නොකළ සියල්ලම තමාටම ආවේණික වූවක් වුවද, ශුන්‍යය විශේෂ වස්තු අගයක් ලෙස සැලකේ. ටයිප් ඔෆ් () භාවිතා කිරීමෙන් ඔබට මෙය දැකිය හැකි අතර එය විචල්‍යයක සාමාන්‍ය වර්ගය නියෝජනය කරන නූලක් ලබා දෙයි:

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

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

undefined
object

ඔවුන් විවිධ වර්ගයන් නොතකා, ඔබ එක් සාමාජිකයෙකු වෙත ප්‍රවේශ වීමට උත්සාහ කළහොත් ඒවා තවමත් ක්‍රියාත්මක වේ, උදා: ඔවුන් ව්‍යතිරේකයක් දමනු ඇතැයි කියනු ලැබේ. WSH සමඟ භයානක "" නම "ශුන්‍ය හෝ වස්තුවක් නොවන බව ඔබට පෙනෙනු ඇති අතර එය ඔබ වාසනාවන්ත නම් (නමුත් එය වෙනත් ලිපියකට මාතෘකාවක් වේ).

ඔබට විචල්‍යයක් නිර්වචනය කළ නොහැකි ලෙස සැකසිය හැකිය, නමුත් මම එයට එරෙහිව දැඩි ලෙස උපදෙස් දෙමි. මම ඔබට නිර්දේශ කරන්නේ විචල්‍යයන් ශුන්‍ය කිරීමට සහ ඔබට සැකසීමට අමතක වූ දේවල් සඳහා වටිනාකම නිර්වචනය නොකිරීමට පමණි. ඒ අතරම, සෑම විචල්‍යයක්ම සෑම විටම සැකසීමට මම ඔබව දිරිමත් කරමි. ජාවාස්ක්‍රිප්ට් හි සී-ශෛලීය භාෂාවන්ට වඩා වෙනස් විෂය පථයක් ඇති අතර, ප්‍රවීණ ක්‍රමලේඛකයින් පවා පහසුවෙන් ව්‍යාකූල කරයි, සහ විචල්‍යයන් ශුන්‍යයට සැකසීම එය මත පදනම් වූ දෝෂ වළක්වා ගත හැකි හොඳම ක්‍රමයයි.

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

var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);

ඉහත පිටපතෙහි ප්‍රති result ලය:

0.) a
1.) undefined
2.) c

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

ශුන්‍ය හා නිර්වචනය නොකළ වෙනස නම්: ජාවාස්ක්‍රිප්ට් කිසි විටෙකත් ශුන්‍ය කිරීමට කිසිවක් සකසන්නේ නැත, සාමාන්‍යයෙන් අප කරන්නේ එයයි. අපට විචල්‍යයන් නිර්වචනය නොකළ ලෙස සැකසිය හැකි නමුත්, අපි ශුන්‍යයට වැඩි කැමැත්තක් දක්වන්නේ එය අප වෙනුවෙන් මෙතෙක් කර ඇති දෙයක් නොවන බැවිනි. ඔබ නිදොස්කරණය කරන විට මෙයින් අදහස් වන්නේ ශුන්‍ය කිරීමට සකසා ඇති ඕනෑම දෙයක් ඔබගේම ක්‍රියාවකින් මිස ජාවාස්ක්‍රිප්ට් වලින් නොවන බවයි. ඉන් ඔබ්බට, මෙම විශේෂ අගයන් දෙක ආසන්න වශයෙන් සමාන වේ.

null යනු වටිනාකමක් නොමැති බව අඟවන විශේෂ මූල පදයකි.

එය වටිනාකමක් ලෙස සිතන්න, වැනි:

• "foo" යනු නූල්,
• ඇත්ත බූලියන්,
• 1234 යනු අංකය,
• ශුන්‍යය නිර්වචනය කර නැත.

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

var foo;

අර්ථ දක්වා ඇති හිස් විචල්‍යය nullදත්ත සමුදායකිundefined

මේ දෙකම නිරූපණය කරන්නේ කිසිදු වටිනාකමක් නැති විචල්‍යයක අගයයි

තවද වටිනාකමක් නැති නූලක්null නියෝජනය නොකරයි - හිස් නූල-

මෙන්

var a = ''; 
console.log(typeof a); // string 
console.log(a == null); //false 
console.log(a == undefined); // false 

දැන් නම්

var a;
console.log(a == null); //true
console.log(a == undefined); //true 

ඒත්

var a; 
console.log(a === null); //false 
console.log(a === undefined); // true

SO සෑම කෙනෙකුම භාවිතා කිරීමට තමන්ගේම ක්‍රමයක් ඇත

විචල්ය දත්ත වර්ගය සංසන්දනය කිරීමට නිර්වචනය නොකළ එය භාවිතා කරන්න

විචල්‍යයක අගය හිස් කිරීම සඳහා එය ශුන්‍ය කරන්න

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

null : විචල්‍යයක් සඳහා අගය නොමැති වීම; undefined : විචල්‍යය නොමැති වීම;

.. කොතැනක විචල්‍යය යනු අගය සමඟ සම්බන්ධිත සංකේතාත්මක නමකි.

අළුත් ප්‍රකාශිත විචල්‍යයන් ශුන්‍ය ලෙස ව්‍යංගයෙන් ආරම්භ කිරීමට JS කාරුණික විය හැකි නමුත් එය එසේ නොවේ.

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

ජාවාස්ක්‍රිප්ට් හි අපට පහත දැක්වෙන විචල්‍යයන් තිබිය හැකිය.

1. ප්‍රකාශයට පත් නොකළ විචල්‍යයන්
2. ප්‍රකාශිත නමුත් නියම නොකළ විචල්‍යයන්
3. වචනාර්ථයෙන් නිර්වචනය කර නොමැති විචල්‍යයන්
4. විචල්‍යයන් වචනාර්ථයෙන් ශුන්‍ය කර ඇත
5. නිර්වචනය නොකළ හෝ ශුන්‍ය හැර වෙනත් ඕනෑම දෙයක් සමඟ පවරා ඇති විචල්‍යතා

පහත දැක්වෙන්නේ මෙම එක් එක් සිද්ධිය එකින් එක පැහැදිලි කිරීමයි

1. ප්‍රකාශයට පත් නොකළ විචල්‍යයන්: ප්‍රකාශයට පත් නොකළ විචල්‍යයන් සඳහා පහත දැක්වේ

   • පරීක්ෂා කළ හැක්කේ 'නිර්වචනය නොකළ' නූලක් ලබා දෙන typeof () මගින් පමණි
   • සමග පරීක්ෂා කළ නොහැකි == හෝ === හෝ නම් හෝ කොන්දේසි ක්රියාකරු ? (යොමු දෝෂය විසි කරයි)

2. ප්‍රකාශිත නමුත් නියම නොකළ විචල්‍යයන්

   • typeof return string 'undefined'
   • == සමග චෙක් ශූන්ය ප්රතිලාභ සැබෑ
   • == සමග චෙක් නිර්වචනය නොකළ ප්රතිලාභ සැබෑ
   • === ශුන්‍ය ප්‍රතිලාභ සාවද්‍ය ලෙස පරික්ෂා කරන්න
   • === සමග චෙක් නිර්වචනය නොකළ ප්රතිලාභ සැබෑ
   • නම් හෝ, කොන්දේසි ක්රියාකරු ? වැරදි ලෙස ආපසු එයි

3. වචනයේ පරිසමාප්ත අර්ථයෙන්ම පවරා ඇති විචල්‍යයන්: මෙම විචල්‍යයන් ප්‍රකාශිත නමුත් නියම නොකළ විචල්‍යයන් ලෙස සලකනු ලැබේ .

4. විචල්‍යයන් වචනාර්ථයෙන් ශුන්‍ය කර ඇත

   • typeof return string 'object'
   • == සමග චෙක් ශූන්ය ප්රතිලාභ සැබෑ
   • == සමග චෙක් නිර්වචනය නොකළ ප්රතිලාභ සැබෑ
   • === ශුන්‍ය ප්‍රතිලාභ සමඟ පරීක්ෂා කිරීම සත්‍ය වේ
   • === සමග චෙක් නිර්වචනය නොකළ ප්රතිලාභ බොරු
   • නම් හෝ, කොන්දේසි ක්රියාකරු ? වැරදි ලෙස ආපසු එයි

5. නිර්වචනය නොකළ හෝ ශුන්‍ය හැර වෙනත් ඕනෑම දෙයක් සමඟ පවරා ඇති විචල්‍යතා

   • typeof පහත දැක්වෙන නූල් වලින් එකක් ලබා දෙයි: 'string' , 'number' , 'boolean' , 'function' , 'object' , 'symbol'

පහත දැක්වෙන්නේ විචල්‍යයක නිවැරදි වර්ග පරීක්ෂා කිරීම සඳහා ඇල්ගොරිතම සපයයි:

1. සඳහා පරීක්ෂා කරන්න අප්රසිද්ධ / චිත්රපට / පවරා නිර්වචනය නොකළ භාවිතා typeof . 'නිර්වචනය නොකළ' නූල නැවත ලබා දෙන්නේ නම් ආපසු යන්න.
2. සඳහා පරීක්ෂා කරන්න ශූන්ය භාවිතා === . සත්‍ය නම් 'ශුන්‍ය' ආපසු එවන්න .
3. Typeof භාවිතයෙන් සත්‍ය වර්ගය සඳහා පරීක්ෂා කරන්න . 'වස්තුව' ට සමාන නොවේ නම් ආපසු වර්ගය
4. සත්‍ය වස්තු වර්ගය තීරණය කිරීම සඳහා Object.prototype.toString.call (o) අමතන්න . එය වර්ගය වැලක් ආපසු දිය යුතු ය '' [වස්තුව ObjectType] ' කරුණාකර Javascript හෝ සියලු ඉදි කිරීම සඳහා DOM වස්තූන් අර්ථ. පරිශීලක අර්ථ දක්වන ලද වස්තු සඳහා එය '[වස්තු වස්තුව]' ලබා දෙයි

වර්ග තීරණය කිරීම සඳහා ඔබට පහත උපයෝගීතා ශ්‍රිතය භාවිතා කළ හැකිය. එය දැනට සියලුම ECMA 262 2017 වර්ග සඳහා සහය දක්වයි.

function TypeOf(o,bReturnConstructor)
 {
   if(typeof o==='undefined') return 'undefined'
   if(o===null) return 'null'   
   if(typeof o!=='object') return typeof o

   var type=Object.prototype.toString.call(o)
  switch(type)
  {
     //Value types:4
     case '[object Number]': type='number';break;
     case '[object String]': type='string';break;
     case '[object Boolean]': type='boolean';break;
     case '[object Date]': type='date';break;


   //Error Types:7
     case '[object Error]': type='error';break;
     case '[object EvalError]': type='evalerror';break;
     case '[object RangeError]': type='rangeerror';break;
     case '[object ReferenceError]': type='referenceerror';break;
     case '[object SyntaxError]': type='syntaxerror';break;
     case '[object TypeError]': type='typeerror';break;
     case '[object URIError]': type='urierror';break;


    //Indexed Collection and Helper Types:13
     case '[object Array]': type='array';break;
     case '[object Int8Array]': type='int8array';break;
     case '[object Uint8Array]': type='uint8array';break;
     case '[object Uint8ClampedArray]': type='uint8clampedarray';break;
     case '[object Int16Array]': type='int16array';break;
     case '[object Uint16Array]': type='uint16array';break;
     case '[object Int32Array]': type='int32array';break;
     case '[object Uint32Array]': type='uint32array';break;
     case '[object Float32Array]': type='float32array';break;
     case '[object Float64Array]': type='float64array';break;
     case '[object ArrayBuffer]': type='arraybuffer';break;
     case '[object SharedArrayBuffer]': type='sharedarraybuffer';break;
     case '[object DataView]': type='dataview';break;

    //Keyed Collection Types:2
     case '[object Map]': type='map';break;
     case '[object WeakMap]': type='weakmap';break;

    //Set Types:2
     case '[object Set]': type='set';break;
     case '[object WeakSet]': type='weakset';break;

    //Operation Types
    case '[object RegExp]': type='regexp';break;
    case '[object Proxy]': type='proxy';break;
    case '[object Promise]': type='promise';break;

    case '[object Object]': type='object';
             if(bReturnConstructor && o.constructor) type=o.constructor.toString().match(/^function\s*([^\s(]+)/)[1];
         break;
    default:
        type=type.split(' ')[1]
        type=type.substr(0,type.length-1)   

   }
    return type 
}

පද්ධති මට්ටමක්, අනපේක්ෂිත හෝ දෝෂයක් වැනි වටිනාකමක් නොමැති වීම සහ වැඩසටහන් මට්ටම, සාමාන්‍ය හෝ අපේක්ෂිත අගය නොමැතිවීම නිරූපණය කිරීම සඳහා ඔබ නිර්වචනය කර නැත.

ජාවාස්ක්‍රිප්ට් හරහා: නියත මාර්ගෝපදේශය

මම පැහැදිලි කරන්නම් undefined, nullසහ Uncaught ReferenceError:

1 - Uncaught ReferenceError: විචල්‍යය ඔබේ ස්ක්‍රිප්ටයේ ප්‍රකාශයට පත් කර නොමැත, මෙම විචල්‍ය
2 ගැන සඳහනක් නොමැත undefined: විචල්‍යය ප්‍රකාශයට පත් කළ නමුත් ආරම්භ නොකෙරේ
3 - null: විචල්‍යය ප්‍රකාශ කළ අතර එය හිස් අගයකි

නිර්වචනය නොකළ යන්නෙන් විචල්‍යයක් ප්‍රකාශයට පත් කර ඇති නමුත් එහි කිසිදු වටිනාකමක් නැත:

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

ශුන්‍යය යනු පැවරුමකි:

var var2= null;
alert(var2); //null
alert(typeof var2); //object

ශුන්‍ය හා නිර්වචනය නොකළ පහත දැක්වෙන පොදු වස්තු වර්ග දෙකකි:

• දෙකම තබා ගත හැක්කේ පිළිවෙලින් ශුන්‍ය හා නිර්වචනය නොකළ තනි අගයක් පමණි ;
• දෙකටම ගුණාංග හෝ ක්‍රම නොමැති අතර ඕනෑම ගුණාංගයක් කියවීමට උත්සාහ කිරීමෙන් ධාවන කාල දෝෂයක් ඇති වේ (අනෙක් සියලුම වස්තූන් සඳහා, ඔබ නොපවතින දේපලක් කියවීමට උත්සාහ කළහොත් ඔබට වටිනාකම නිර්වචනය නොකෙරේ);
• වටිනාකම් ශූන්ය හා නිර්වචනය නොකළ එකිනෙකට විසින් වෙන කිසිවක් සමාන ලෙස සලකනු ලැබේ ==සහ !=ක්රියාකරුවන්.

කෙසේ වෙතත් සමානකම් මෙතැනින් අවසන් වේ. එක් වරක්, ශුන්‍ය සහ නිර්වචනය නොකළ වචන ක්‍රියාත්මක වන ආකාරයෙහි මූලික වෙනසක් ඇත . මෙය පැහැදිලි නැත, නමුත් පහත උදාහරණය සලකා බලන්න:

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

නිර්වචනය නොකළ , NaN සහ Infinity යනු පූර්ව ආරම්භක "සුපිරි ග්ලෝබල්" විචල්‍යයන්ගේ නම් පමණි - ඒවා ක්‍රියාත්මක වන වේලාවේදී ආරම්භ කර ඇති අතර සාමාන්‍ය ගෝලීය හෝ දේශීය විචල්‍යයන් එකම නම් වලින් අභිබවා යා හැකිය.

දැන්, අපි එකම දේ ශුන්‍යයෙන් උත්සාහ කරමු :

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

අපොයි! ශුන්‍ය , සත්‍ය සහ අසත්‍ය වෙන් කර ඇති මූල පද - ඒවා විචල්‍ය හෝ දේපල නාම ලෙස භාවිතා කිරීමට සම්පාදකයා ඔබට ඉඩ නොදේ

තවත් වෙනසක් නම්, නිර්වචනය නොකළ ප්‍රාථමික වර්ගයක් වන අතර, ශුන්‍යය යනු වස්තු වර්ගයකි (වස්තු යොමුකිරීමේ අරුත පෙන්නුම් කරයි). පහත සඳහන් කරුණු සලකා බලන්න:

WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object

එසේම, සංඛ්‍යාත්මක සන්දර්භය තුළ ශුන්‍ය හා නිර්වචනය නොකළ ආකාරයෙන් වැදගත් වෙනසක් ඇත :

var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1

var b = null; // the value null must be explicitly assigned 
WScript.Echo(b === null); // Prints: -1

WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)

WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)

WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)

WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)

ශූන්ය බවට පත් 0 අංක ගණිතමය ප්රකාශන හෝ සංඛ්යා සැසඳීම් භාවිතා කළ විට - එලෙස කිරීමට බොරු , එය මූලික වශයෙන් "ශුන්ය" හුදෙක් විශේෂ ආකාරයේ. නිර්වචනය නොකළ , සත්‍ය “කිසිවක් ” නොවන අතර ඔබ එය සංඛ්‍යාත්මක සන්දර්භය තුළ භාවිතා කිරීමට උත්සාහ කරන විට NaN (“අංකයක් නොවේ”) බවට පත්වේ .

ශුන්‍ය හා නිර්වචනය නොකළ== සහ !=ක්‍රියාකරුවන්ගෙන් විශේෂ ප්‍රතිකාරයක් ලැබෙන බව සලකන්න , නමුත් ප්‍රකාශනය සමඟ ඔබට a සහ b වල සත්‍ය සංඛ්‍යාත්මක සමානාත්මතාවය පරීක්ෂා කළ හැකිය (a >= b && a <= b).

tl; dr

nullඑය වස්තුවක් බව ඔබ දන්නා විචල්‍යයක් සැකසීමට භාවිතා කරන්න .

undefinedවර්ගය මිශ්‍ර කර ඇති විචල්‍යයක් සැකසීමට භාවිතා කරන්න .

මෙය ප්‍රාථමික 5 සහ වස්තු වර්ගය යන දෙකෙහිම මගේ භාවිතය වන අතර, එය «භාවිත නඩුව between undefinedහෝ අතර වෙනස පැහැදිලි කරයි null.

නූල්

සම්මුතිය අනුව, සියලු ජීවන චක්‍රය, ආරම්භයක් ලෙස, පහත දැක්වෙන පරිදි, විචල්‍යයක් යනු නූලක් පමණක් බව ඔබ දන්නේ නම් "":

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

අංකය

විචල්‍යයක් යනු සංඛ්‍යාවක් පමණක් බව ඔබ දන්නේ නම්, සියලු ජීවන චක්‍රය, සම්මුතිය අනුව, ඔබට එය ආරම්භ කළ හැකිය, 0(හෝ ඔබේ භාවිතයේ වැදගත් අගයක් NaNනම් 0):

(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"

හෝ

(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"

බූලියන්

සම්මුතිය අනුව සියලු ජීවන චක්‍රය, විචල්‍යයක් යනු බූලියන් එකක් පමණක් බව ඔබ දන්නේ නම් false:

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

වස්තුව

ඔබ විචල්ය සියලු ජීව චක්රය අතර වස්තුවක් පමණක් දන්නේ නම්, සමුළුව විසින්, ඔබ එය වෙත ආරම්භනය හැකි null:

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

සටහන: වස්තුවක් සැමවිටම පවතින නිසාත්, නැවත පැමිණීම නිසාත්, ස්මාර්ට් භාවිතය අහෝසි කිරීම වස්තුවක ව්‍යාජ අනුවාදය විය යුතුය . එයින් අදහස් වන්නේ වස්තුව සහ ශුන්‍ය වර්ගය සඳහා ස්ථාවර අගය නැවත ලබා දීමයි.truetypeof nullobjecttypeof myVarObject

සියලුම

සම්මුතිය අනුව විචල්‍යයකට මිශ්‍ර වර්ගයක් (ඕනෑම ජීවන චක්‍රයක් අතර ඕනෑම වර්ගයක්) ඇති බව ඔබ දන්නේ නම්, ඔබට එය ආරම්භ කළ හැකිය undefined.

nullවිශේෂ අගයක් යනු "වටිනාකමක් නැත" යන්නයි. 'වස්තුව' ආපසු ලබා දෙන nullනිසා විශේෂ වස්තුවකි typeof null.

අනෙක් අතට, undefinedවිචල්‍යය ප්‍රකාශයට පත් කර හෝ වටිනාකමක් ලබා දී නොමැති බව අදහස් වේ.

වෙනස තේරුම් ගැනීමට ඇති හොඳම ක්‍රමය නම්, පළමුව ජාවාස්ක්‍රිප්ට්හි අභ්‍යන්තර ක්‍රියාකාරකම් පිළිබඳ ඔබේ මනස නිරවුල් කර ඒවා අතර අර්ථයේ වෙනස්කම් තේරුම් ගැනීමයි:

let supervisor = "None"
    // I have a supervisor named "None"

let supervisor = null
    // I do NOT have a supervisor. It is a FACT that I do not.

let supervisor = undefined
    // I may or may not have a supervisor. I either don't know
    // if I do or not, or I am choosing not to tell you. It is
    // irrelevant or none of your business.

මෙම අවස්ථා තුන අතර අර්ථයේ වෙනසක් ඇති අතර, ජාවාස්ක්‍රිප්ට් දෙවන අවස්ථා දෙක එකිනෙකට වෙනස් අගයන් දෙකකින් වෙන් කරයි, nullසහ undefined. එම අර්ථයන් පැහැදිලිව ප්‍රකාශ කිරීම සඳහා එම අගයන් පැහැදිලිව භාවිතා කිරීමට ඔබට නිදහස තිබේ.

ඉතින් මෙම දාර්ශනික පදනම නිසා පැන නගින ජාවාස්ක්‍රිප්ට් විශේෂිත ගැටළු මොනවාද?

1. ආරම්භකයකු නොමැතිව ප්‍රකාශිත විචල්‍යයකට වටිනාකම ලැබෙන්නේ undefinedඅපේක්ෂිත අගය කුමක් දැයි ඔබ කිසි විටෙකත් නොකියූ බැවිනි.

   let supervisor;
   assert(supervisor === undefined);

2. කිසි විටෙකත් සකසා නැති වස්තුවක දේපලක් තක්සේරු undefinedකරන්නේ එම දේපල ගැන කිසිවෙකු කිසිවක් නොකියූ බැවිනි.

   const dog = { name: 'Sparky', age: 2 };
   assert(dog.breed === undefined);

3. nullහා undefinedබ්රෙන්ඩන් Eich මේ බව සඳහන් කළේය නිසා එකිනෙකාට "සමාන" වේ. නමුත් ඒවා එකිනෙකට සමාන නොවේ.

   assert(null == undefined);
   assert(null !== undefined);

4. nullහා undefined, දැන්නම්, විවිධ වර්ගයේ ඇත. nullවර්ගය අයිති Nullසහ undefinedවර්ගය කිරීමට Undefined. මෙය පිරිවිතරයේ ඇත, නමුත් typeofමා මෙහි නැවත නොකිරීමට ඇති අමුතුකම නිසා ඔබ මෙය කිසි විටෙකත් නොදැන සිටියි.

5. පැහැදිලි ප්‍රතිලාභ ප්‍රකාශයක් නොමැතිව එහි සිරුරේ අවසානය කරා ළඟා වන ශ්‍රිතයක්, undefinedඑය ආපසු ලබා දුන් දේ ගැන ඔබ කිසිවක් නොදන්නා බැවින් නැවත පැමිණේ .

මාර්ගය වන විට, ජාවාස්ක්‍රිප්ට් හි වෙනත් "කිසිවක් නැති" ආකාර තිබේ (දර්ශනය හැදෑරීම සතුටක් ....)

• NaN
• කිසි විටෙක ප්‍රකාශයට පත් නොකළ විචල්‍යයක් භාවිතා කිරීම සහ ලැබීම a ReferenceError
• එහි තාවකාලික මළ කලාපයේ letහෝ constඅර්ථ දක්වා ඇති දේශීය විචල්‍යයක් භාවිතා කිරීම සහ ලැබීම aReferenceError

• විරල අරා වල හිස් සෛල. ඔව්, මේවා නිර්වචනය නොකළ undefinedඒවා සමඟ ===සැසඳුවද ඒවා නොවේ .

  $ node
  > const a = [1, undefined, 2]
  > const b = [1, , 2]
  > a
  [ 1, undefined, 2 ]
  > b
  [ 1, <1 empty item>, 2 ]

ජාවාස්ක්‍රිප්ට් හි ප්‍රාථමික දත්ත වර්ග 5 ක් ඇත, නූල්, අංකය, බූලියන්, ශූන්‍ය සහ නිර්වචනය නොකළ. මම සරල උදාහරණයකින් පැහැදිලි කිරීමට උත්සාහ කරමි

අපට සරල ශ්‍රිතයක් ඇති බව කියමු

 function test(a) {

     if(a == null){
        alert("a is null");
     } else {
        alert("The value of a is " + a);
     }
  }

(a == null) (! a) ට සමාන නම් ඉහත ශ්‍රිතයේ ද

දැන් අපි පරාමිතිය පසු නොකර මෙම ශ්‍රිතය අමතන විට a

   test(); it will alert "a is null";
   test(4); it will alert "The value of a is " + 4;

තවද

var a;
alert(typeof a); 

මෙය නිර්වචනය නොකෙරේ; අපි විචල්යයක් ප්රකාශ කර ඇති නමුත් අපි මෙම විචල්යයට කිසිදු අගයක් නියම කර නැත; නමුත් අපි ලියන්නේ නම්

var a = null;
alert(typeof a); will give alert as object

එබැවින් ශූන්‍යය වස්තුවකි. යම් ආකාරයකින් අපි 'අ' සඳහා ශුන්‍ය අගයක් ලබා දී ඇත

ඔබ ජාවාස්ක්‍රිප්ට් හි විචල්‍යයක් ප්‍රකාශ කරන විට, එය අගය පවරනු ලැබේ undefined. මෙයින් අදහස් කරන්නේ විචල්‍යය ස්පර්ශ නොවූ අතර අනාගතයේදී ඕනෑම වටිනාකමක් ලබා දිය හැකි බවයි. ප්‍රකාශ කිරීමේ අවස්ථාවේදී මෙම විචල්‍යය රඳවා තබා ගැනීමට යන වටිනාකම ඔබ නොදන්නා බව ද එයින් ගම්‍ය වේ.

දැන් ඔබට පැහැදිලිවම විචල්‍යයක් පැවරිය හැකිය null. එයින් අදහස් වන්නේ විචල්යයට කිසිදු වටිනාකමක් නොමැති බවයි. උදාහරණයක් ලෙස - සමහර අයට මැද නමක් නොමැත. එබැවින් එවැනි අවස්ථාවකදී පුද්ගල වස්තුවක මිඩ්ල්නේම් විචල්‍යයට ශුන්‍ය අගය පැවරීම වඩා හොඳය.

දැන් යමෙක් ඔබේ පුද්ගල වස්තුවේ මිඩ්ල්නේම් විචල්‍යයට ප්‍රවේශ වන අතර එයට වටිනාකමක් ඇතැයි සිතමු undefined. මෙම විචල්‍යය ආරම්භ කිරීමට සංවර්ධකයාට අමතක වී ඇත්ද නැතිනම් එහි කිසිදු වටිනාකමක් නොමැතිදැයි ඔහු නොදනී. එහි අගය තිබේ nullනම්, පරිශීලකයාට මිඩ්ල් නමට කිසිදු වටිනාකමක් නොමැති බවත් එය ස්පර්ශ නොකළ විචල්‍යයක් නොවන බවත් පහසුවෙන් අනුමාන කළ හැකිය.

සඳහා undefinedවර්ගය, ඇත්තේ එක ම එක අගය ඇත: undefined.

සඳහා nullවර්ගය, ඇත්තේ එක ම එක අගය ඇත: null.

එබැවින් ඔවුන් දෙදෙනාටම ලේබලය එහි වර්ගය සහ වටිනාකම යන දෙකම වේ.

ඔවුන් අතර වෙනස. උදාහරණයක් වශයෙන්:

• null හිස් අගයක්
• undefined නැතිවූ අගයකි

හෝ:

• undefined තවම වටිනාකමක් නැත
• null වටිනාකමක් ඇති අතර තවදුරටත් නැත

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

කෙසේ වෙතත්, undefinedයනු හඳුනාගැනීමේ . කෙසේ වෙතත්, non-strictමාදිලිය සහ strictමාදිලිය යන දෙකෙහිම , ඔබට නිර්වචනය නොකළ නාමයේ දේශීය විචල්‍යයක් නිර්මාණය කළ හැකිය. නමුත් මෙය එක් භයානක අදහසකි!

function foo() {
    undefined = 2; // bad idea!
}

foo();

function foo() {
    "use strict";
    undefined = 2; // TypeError!
}

foo();

කිසියම් අගයක් නොමැතිවීම නිරූපණය කිරීම සඳහා ශුන්‍ය සහ නිර්වචනය නොකළ දෙකම භාවිතා වේ.

var a = null;

a ආරම්භ කර අර්ථ දක්වා ඇත.

typeof(a)
//object

null යනු ජාවාස්ක්‍රිප්ට් හි ඇති වස්තුවකි

Object.prototype.toString.call(a) // [object Object]

var b;

b නිර්වචනය කර නොමැති අතර ආරම්භ නොකෙරේ

නිර්වචනය නොකළ වස්තු ගුණාංග ද නිර්වචනය කර නැත. උදාහරණයක් ලෙස "x" වස්තුව මත අර්ථ දක්වා නොමැති අතර ඔබ cx වෙත ප්‍රවේශ වීමට උත්සාහ කළහොත් එය නිර්වචනය නොකෙරේ.

සාමාන්‍යයෙන් අපි නිර්වචනය නොකළ විචල්‍යයන්ට ශුන්‍යය පවරන්නෙමු.

රයන් මෝර්ගේ මෙම විෂය පිළිබඳ ගැඹුරු ලිපියක් අනුව ...

"සාමාන්‍යයෙන්, ඔබට විචල්‍යයකට හෝ දේපලකට වටිනාකමක් ලබා නොදීමට, එය ශ්‍රිතයකට යොමු කිරීමට හෝ ශ්‍රිතයකින් ආපසු ලබා දීමට අවශ්‍ය නම්, ශුන්‍යය සෑම විටම පාහේ හොඳම විකල්පය වේ. සරලව කිවහොත්, ජාවාස්ක්‍රිප්ට් නිර්වචනය නොකළ අතර ක්‍රමලේඛකයින් කළ යුතුය ශුන්‍ය භාවිතා කරන්න.

ශුන්‍ය හා නිර්වචනය නොකළ සදාකාලික අගාධය ගවේෂණය කිරීම බලන්න

ජාවාස්ක්‍රිප්ට් හි ශුන්‍ය හා නිර්වචනය නොකළ දෙකම පෙන්නුම් කරන්නේ වටිනාකමක් නොමැති බවයි.

var a = null; //variable assigned null value
var b;  // undefined

සත්‍යය තිබියදීත් දෙකම පවතින්නේ වටිනාකමක් නොමැති නමුත්: නිර්වචනය නොකළ යන්නෙන් අදහස් කරන්නේ විචල්‍යය ආරම්භ කර නොමැති බවයි. කිසිවක් ලබා නොදෙන කාර්යයන් සහ කිසිදු වටිනාකමක් ලබා නොදෙන ක්‍රියාකාරී පරාමිතීන්, නිර්වචනය නොකළ අගය ආපසු ලබා දෙනු ලැබේ. ශුන්‍ය හා නිර්වචනය නොකළ අතර වෙනස හඳුනා ගැනීමට දැඩි සමානාත්මතා ක්‍රියාකරු === භාවිතා කරන්න.

යොමුව: http://www.thesstech.com/javascript/null-and-undefined

හරි, අපි ගැන ආරංචි වන විට අපි ව්යාකූල වෙන්න පුළුවන් nullහා undefined, නමුත් ඉඩ ඒක සරල ආරම්භ ඔවුන් දෙදෙනාම falsy හා බොහෝ ක්රම සමාන, නමුත් JavaScript පිළිබඳ අමුතු කොටසක්, ඔවුන් සැලකිය යුතු වෙනස්කම් කිහිපයක් කරන්න, උදාහරණයක් ලෙස, typeof null වේ 'object'ඇති අතර typeof undefined වේ 'undefined'.

typeof null; //"object"
typeof undefined; //"undefined";

නමුත් ඔබ ඒවා ==පහත පරිදි පරීක්ෂා කළහොත් , ඒවා දෙකම ව්‍යාජ ඒවා බව ඔබට පෙනේ :

null==undefined; //true

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

බැලූ බැල්මට ඔබ වෙනුවෙන් වෙනස්කම් පෙන්වීමට මම ඉක්මන් රූපයක් නිර්මාණය කරමි.

යතුරු ලියනය නැවත නිර්වචනය කර ඇති පරිදි, නිර්වචනය නොකිරීම යනු ආරම්භකය ශුන්‍ය බැවින් විචල්‍ය ලක්ෂ්‍යයන් කිසිදු වස්තුවකට යොමු නොකරයි (ජාවාස්ක්‍රිප්ට් හි ඇති සෑම දෙයක්ම පාහේ වස්තුවකි).

ජාවාස්ක්‍රිප්ට් හි සියලුම විචල්‍යයන් යතුරු අගය යුගල ලෙස ගබඩා කර ඇත. සෑම විචල්‍යයක්ම variable_name: variable_value / යොමු ලෙස ගබඩා කර ඇත .

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

එවැනි අවස්ථාවකදී කේතයේ පසු අවස්ථාවක විචල්‍යයක් වටිනාකමක් නොමැතිව තිබිය යුතු යැයි දක්වන්නේ කෙසේද? ඔබට ශුන්‍ය වර්ගය භාවිතා කළ හැකිය , එය එකම දෙය නිර්වචනය කිරීමට භාවිතා කරන වර්ගයකි , අගයක් නොමැතිකම, නමුත් එය නිර්වචනය නොකළ ආකාරයටම නොවේ, මේ අවස්ථාවේ දී ඔබට ඇත්ත වශයෙන්ම මතකයේ අගය ඇත. එම අගය ශුන්‍යයි

දෙකම සමාන නමුත් භාවිතය සහ අර්ථය වෙනස් වේ.

මම අතර ඉතා සියුම් වෙනසක් එකතු කිරීමට අවශ්ය nullහා undefinedඔබ බිම් මට්ටමේ සිට සාමාන්ය වැනිලා JavaScript (JS) ඉගෙන ගැනීමට උත්සාහ කරන විට දැනගැනීමට හොඳ වන:

• nullJS හි වෙන් කර ඇති මූල පදයක් වන අතර undefinedඔබ සිටින ධාවන කාල පරිසරයේ ගෝලීය වස්තුවෙහි විචල්‍යයකි.

කේතය ලිවීමේදී, මේ වෙනස ලෙස ද හඳුනාගත නොවේ nullහා undefinedසැමවිටම JavaScript ප්රකාශය ආර් තුළ භාවිතා වේ. නමුත් ඔබ ඒවා ප්‍රකාශනයක LHS හි භාවිතා කරන විට ඔබට මෙම වෙනස පහසුවෙන් නිරීක්ෂණය කළ හැකිය. එබැවින් JS පරිවර්තකයා පහත කේතය දෝෂයක් ලෙස අර්ථ නිරූපණය කරයි:

var null = 'foo'

එය පහත දෝෂයක් ලබා දෙයි:

හඳුනා නොගත් සින්ටැක්ස් දෝෂය: අනපේක්ෂිත ටෝකන ශුන්‍යය

පහත දැක්වෙන කේතය සාර්ථකව ක්‍රියාත්මක වන අතර සැබෑ ජීවිතයේ දී එසේ කිරීමට මම නිර්දේශ නොකරමි:

var undefined = 'bar'

මෙය ක්‍රියාත්මක undefinedවන්නේ ගෝලීය වස්තුවෙහි විචල්‍යයක් වන නිසාය (ග්‍රාහක පැත්තේ ජේඑස් නම් බ්‍රව්සර් කවුළු වස්තුව)

අතර වෙනස undefinedහා nullඅවම වේ, නමුත් වෙනසක් ඇත. අගය undefinedකිසි විටෙකත් ආරම්භ කර නොමැති විචල්‍යයකි . විචල්යයක අගය nullපැහැදිලිවම ලබා දී ඇති nullඅතර එයින් අදහස් වන්නේ විචල්යයට කිසිදු වටිනාකමක් නොමැති බව පැහැදිලිවම සකසා ඇති බවයි. ඔබ සංසන්දනය නම් undefinedසහ nullභාවිතයෙන් null==undefinedප්රකාශනය, ඔවුන් සමාන වනු ඇත.

මූලික වශයෙන්, අනිශ්චිත පලා අවස්ථාවේ කිසිදු අගය (ඇත්තටම ශූන්ය ම වස්තුවක්) විචල්ය පවරා ඇති බව යන්න ශූන්ය මාර්ගයෙන් නිර්මාණය JavaScript ඇති ගෝලීය විචල්ය වේ.

අපි උදාහරණයක් ගනිමු:

        var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

නිර්වචනය නොකළ එය ඔබට ප්‍රතිදානය ලෙස ලැබෙනු ඇත.

දැන්,

        x=5;
        y=null;
        z=x+y;

එවිට ඔබට ප්‍රතිදානය ලෙස 5 ක් ලැබෙනු ඇත. ඒ අතර ප්රධාන වෙනස අනිශ්චිත හා ශූන්ය

null - එය පැවරුම් අගයක් වන අතර එය කිසිදු අගයක් නිරූපණය කිරීම සඳහා විචල්‍යය සමඟ භාවිතා කරයි (එය වස්තුවකි).

undefined - එය විචල්‍යයක් වන අතර එයට කිසිදු වටිනාකමක් පවරා නොමැත, එබැවින් ජාවාස්ක්‍රිප්ට් එයට නිර්වචනය නොකළ (එය දත්ත වර්ගයකි).

ප්‍රකාශයට පත් නොකල - විචල්‍යයක් කිසිසේත් නිර්මාණය නොකළේ නම් එය ප්‍රකාශයට පත් නොකෙරේ.

මෙය පරීක්ෂා කරන්න. ප්‍රතිදානය වචන දහසක් වටී.

var b1 = document.getElementById("b1");

checkif("1, no argument"                        );
checkif("2, undefined explicitly",     undefined);
checkif("3, null explicitly",               null);
checkif("4, the 0",                            0);
checkif("5, empty string",                    '');
checkif("6, string",                    "string");
checkif("7, number",                      123456);

function checkif (a1, a2) {
	print("\ncheckif(), " + a1 + ":");
	if (a2 == undefined) {
		print("==undefined:    YES");
	} else {
		print("==undefined:    NO");
	}
	if (a2 === undefined) {
		print("===undefined:   YES");
	} else {
		print("===undefined:   NO");
	}
	if (a2 == null) {
		print("==null:         YES");
	} else {
		print("==null:         NO");
	}
	if (a2 === null) {
		print("===null:        YES");
	} else {
		print("===null:        NO");
	}
	if (a2 == '') {
		print("=='':           YES");
	} else {
		print("=='':           NO");
	}
	if (a2 === '') {
		print("==='':          YES");
	} else {
		print("==='':          NO");
	}
	if (isNaN(a2)) {
		print("isNaN():        YES");
	} else {
		print("isNaN():        NO");
	}
	if (a2) {
		print("if-?:           YES");
	} else {
		print("if-?:           NO");
	}
		print("typeof():       " + typeof(a2));
}

function print(v) {
	b1.innerHTML += v + "\n";
}

<!DOCTYPE html>
<html>
<body>
<pre id="b1"></pre>
</body>
</html>

මෙයද බලන්න:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators

චියර්ස්!

විශේෂ අගයන් දෙකම හිස් තත්වයක් අදහස් කරයි.

ප්‍රධාන වෙනස නම් නිර්වචනය නොකිරීම තවමත් ආරම්භ කර නොමැති විචල්‍යයක වටිනාකම වන අතර ශුන්‍යය නිරූපණය කරන්නේ වස්තුවක් හිතාමතාම නොපැවතීමයි.

විචල්ය අංකය අර්ථ දක්වා ඇත, කෙසේ වෙතත්, ආරම්භක අගය සමඟ පවරා නොමැත:

let number;
number; // => undefined

සංඛ්‍යා විචල්‍යය නිර්වචනය කර නැති අතර එය පැහැදිලිවම පෙන්නුම් කරන්නේ ආරම්භක නොවන විචල්‍යයකි

නොපවතින වස්තු දේපලකට ප්‍රවේශ වූ විට එකම ආරම්භක සංකල්පය සිදු වේ:

const obj = { firstName: 'Dmitri' };
obj.lastName; // => undefined

LastName දේපල obj හි නොපවතින හෙයින්, JavaScript විසින් obj.lastName නිර්වචනය කර නොමැති ලෙස නිවැරදිව තක්සේරු කරයි.

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

උදාහරණයක් ලෙස, ක්ලෝන () යනු සරල ජාවාස්ක්‍රිප්ට් වස්තුවක් ක්ලෝන කරන ශ්‍රිතයකි. ශ්‍රිතය වස්තුවක් ආපසු ලබා දෙනු ඇතැයි අපේක්ෂා කෙරේ:

function clone(obj) {
  if (typeof obj === 'object' && obj !== null) {
    return Object.assign({}, obj);
  }
  return null;
}
clone({name: 'John'}); // => {name: 'John'}
clone(15);             // => null
clone(null);           // => null

කෙසේ වෙතත්, ක්ලෝන () වස්තු නොවන තර්කයක් සමඟ ආයාචනා කළ හැකිය: 15 හෝ ශුන්‍ය (හෝ සාමාන්‍යයෙන් ප්‍රාථමික අගයක්, ශුන්‍ය හෝ නිර්වචනය නොකළ). එවැනි අවස්ථාවකදී, ශ්‍රිතයට ක්ලෝනයක් සෑදිය නොහැක, එබැවින් එය ශුන්‍ය වේ - නැතිවූ වස්තුවක දර්ශකය.

typeof ක්‍රියාකරු විසින් අගයන් දෙක අතර වෙනස හඳුනා ගනී:

typeof undefined; // => 'undefined'
typeof null;      // => 'object'

දැඩි තත්ත්වයේ ක්‍රියාකරු === නිවැරදිව නිර්වචනය නොකෙරේ.

let nothing = undefined;
let missingObject = null;
nothing === missingObject; // => false

වෙනත් අර්ථයකට අමතරව වෙනත් වෙනස්කම් තිබේ:

1. වස්තු විනාශ කිරීම මෙම අගයන් දෙක සඳහා වෙනස් ලෙස ක්‍රියා කරයි:

   const { a = "default" } = { a: undefined }; // a is "default"
   const { b = "default" } = { b: null };      // b is null

2. JSON.stringify () තබා ඇති nullනමුත් මඟ හැරේundefined

   const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
   console.log(json); // prints {"nullValue":null}

3. typeof operator

   console.log(typeof undefined); // "undefined"
   console.log(typeof null);      // "object" instead of "null"

මරිජ් හැවර්බෙක් විසින් රචිත "එලොකෙන්ට් ජාවාස්ක්‍රිප්ට්" 3 වන සංස්කරණයෙන් උපුටා ගැනීම:

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

අවංකවම, මුලදී, මම මෙම උපදෙස් ගැන ටිකක් සැක කරමි. කෙසේ වෙතත්, මගේම අර්ථ නිරූපණය අනුව, එය ඔවුන්ගේ වෙනස්කම් සමඟ කටයුතු කිරීමට lazy(එදිරිව eager) ක්රමයකි. සමහර විට, අපට කිසිසේත්ම වෙනස්කම් සමඟ කටයුතු කිරීමට අවශ්‍ය නැත. අපට එසේ කිරීමට අවශ්‍ය නම්, අපගේ කේතය හරහා hyperactively/defensivelyඑම අගයන් ( nullසහ undefined) ගලා යන බැවින් අපට අපගේ සැලකිල්ල ප්‍රමාද කළ හැකිය (අපට කළ යුතු ප්‍රයෝජනය) සහ සෑම පියවරකදීම ඒ ගැන කරදර නොවන්න .

PS: මෙය ඔබේ ප්‍රශ්නයට answer ජු පිළිතුරක් නොවේ. මෙය අදාළ මතයක් පමණි.