ශුන්‍ය වස්තුවක් වන්නේ ඇයි සහ ශුන්‍ය හා නිර්වචනය නොකළ වෙනස කුමක්ද?

ජාවාස්ක්‍රිප්ට් හි nullසලකන්නේ ඇයි object?

පරික්ෂා කරයි

if ( object == null )
      Do something

සමාන වේ

if ( !object )
      Do something

?

තවද:

nullසහ අතර ඇති වෙනස undefinedකුමක්ද?

(name is undefined)

ඔබ: මොකක්ද name? ^(*)
ජාවාස්ක්‍රිප්ට් : name ? මොකක්ද name? මම දන්නේ නැහැ ඔයා මොනවා ගැනද කතා කරන්නේ කියලා. ඔබ මීට nameපෙර කිසිවක් සඳහන් කර නැත . (සේවාදායකයා) පැත්තේ වෙනත් ස්ක්‍රිප්ටින් භාෂාවක් ඔබ දකින්නේද?

name = null;

ඔබ: කුමක්ද name?
ජාවාස්ක්‍රිප්ට්: මම දන්නේ නැහැ.

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

මතක තබා ගත යුතු එක් දෙයක් nullනම්, එය සංකල්පමය වශයෙන් සමාන falseහෝ ""එසේ නොවේ, ඒවා වර්ග වාත්තු කිරීමෙන් පසුව සමාන කළත්, එනම්

name = false;

ඔබ: මොකක්ද name?
ජාවාස්ක්‍රිප්ට්: බූලියන් අසත්‍යය.

name = '';

ඔබ: මොකක්ද name?
JavaScript: හිස් නූල

^{*: nameමෙම සන්දර්භය තුළ කිසි විටෙකත් අර්ථ දක්වා නැති විචල්‍යයක් ලෙස අදහස් කෙරේ. එය කිසියම් නිර්වචනය නොකළ විචල්‍යයක් විය හැකිය, කෙසේ වෙතත් නම යනු ඕනෑම HTML ආකෘති මූලද්‍රව්‍යයක දේපලකි. එය හැඳුනුම්පතට පෙර හොඳින් ආරම්භ කරන ලදී. අයිඩී අද්විතීය විය යුතු නමුත් නම් තිබිය යුතු නැති නිසා එය ප්‍රයෝජනවත් වේ.}

වෙනස මෙම ස්නිපටයට සාරාංශගත කළ හැකිය:

alert(typeof(null));      // object
alert(typeof(undefined)); // undefined

alert(null !== undefined) //true
alert(null == undefined)  //true

පරීක්ෂා කිරීම

object == nullපරීක්ෂා කිරීමට වෙනස් වේ if ( !object ).

දෙවැන්න සමාන වේ ! Boolean(object), මන්ද යත්, ඒකීය !ක්‍රියාකරු ස්වයංක්‍රීයව නිවැරදි ක්‍රියාකාරිත්වය බූලියන් තුළට දමයි.

Boolean(null)එකල අසත්‍යය සමාන බැවින් !false === true.

එසේ ඔබේ වස්තුව නම් ශූන්ය නොවන , නමුත් බොරු හෝ 0 හෝ "" , චෙක්පත සමත් වනු ඇත නිසා:

alert(Boolean(null)) //false
alert(Boolean(0))    //false
alert(Boolean(""))   //false

nullවන වස්තුවක් නොවේ එය වන අතර, ප්රාථමික අගය . උදාහරණයක් ලෙස, ඔබට එයට ගුණාංග එකතු කළ නොහැක. සමහර වෙලාවට මිනිස්සු නිසා, එය යම් වස්තුවක් බව වැරදි සහගත ලෙස උපකල්පනය typeof nullප්රතිලාභ "object". නමුත් එය ඇත්ත වශයෙන්ම දෝෂයකි (එය ECMAScript 6 හි පවා නිවැරදි කළ හැකිය).

අතර වෙනස nullසහ undefinedපහත සඳහන් පරිදි වේ:

• undefined: ජාවාස්ක්‍රිප්ට් විසින් භාවිතා කරන අතර එහි තේරුම “වටිනාකමක් නැත” යන්නයි. ආරම්භ නොකළ විචල්‍යයන්, නැතිවූ පරාමිතීන් සහ නොදන්නා විචල්‍යයන්ට එම අගය ඇත.

  > var noValueYet;
  > console.log(noValueYet);
  undefined
  
  > function foo(x) { console.log(x) }
  > foo()
  undefined
  
  > var obj = {};
  > console.log(obj.unknownProperty)
  undefined
  

  කෙසේ වෙතත්, නොදන්නා විචල්‍යයන්ට ප්‍රවේශ වීම ව්‍යතිරේකයක් ඇති කරයි:

  > unknownVariable
  ReferenceError: unknownVariable is not defined
  

• null: “වටිනාකමක් නැත” යන්න දැක්වීමට ක්‍රමලේඛකයින් විසින් භාවිතා කරයි, උදා: ශ්‍රිතයක පරාමිතියක් ලෙස.

විචල්යයක් පරීක්ෂා කිරීම:

console.log(typeof unknownVariable === "undefined"); // true

var foo;
console.log(typeof foo === "undefined"); // true
console.log(foo === undefined); // true

var bar = null;
console.log(bar === null); // true

සාමාන්‍ය රීතියක් ලෙස, ඔබ සැමවිටම ජාවාස්ක්‍රිප්ට් හි === සහ කිසි විටෙකත් == භාවිතා කළ යුතුය (== අනපේක්ෂිත ප්‍රති .ල ලබා දිය හැකි සියලු ආකාරයේ පරිවර්තනයන් සිදු කරයි ). චෙක්පත x == nullදාර නඩුවකි, මන්ද එය දෙකටම ක්‍රියා කරන නිසා nullසහ undefined:

> null == null
true
> undefined == null
true

විචල්‍යයකට වටිනාකමක් තිබේදැයි පරීක්ෂා කිරීමේ පොදු ක්‍රමයක් නම් එය බූලියන් බවට පරිවර්තනය කර එය දැයි බැලීමයි true. එම පරිවර්තනය සිදු කරනු ලබන්නේ ifප්‍රකාශය සහ බූලියන් ක්‍රියාකරු විසිනි! ("නැහැ").

function foo(param) {
    if (param) {
        // ...
    }
}
function foo(param) {
    if (! param) param = "abc";
}
function foo(param) {
    // || returns first operand that can't be converted to false
    param = param || "abc";
}

මෙම ප්රවේශය මත්ෂ්ය: පහත සඳහන් අගයන් සියලු කිරීමට ඇගයීමට falseඔබ පරෙස්සම් (උදා: ඉහත චෙක්පත් අතර වෙනස හඳුනා නො හැකි විය යුතු නිසා, undefinedසහ 0).

• undefined, null
• බූලියන්ස්: false
• අංක: +0, -0,NaN
• නූල්: ""

Booleanශ්‍රිතයක් ලෙස භාවිතා කිරීමෙන් ඔබට බූලියන් බවට පරිවර්තනය කිරීම පරීක්ෂා කළ හැකිය (සාමාන්‍යයෙන් එය ඉදිකිරීම්කරුවෙකි, භාවිතා කිරීමට new):

> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true

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

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

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

 undefined == null
 null == undefined

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

ඔබගේ නව සංස්කරණය සමඟ ඔව්

if (object == null)  does mean the same  if(!object)

වස්තුව අසත්‍ය දැයි පරීක්ෂා කිරීමේදී, ඔවුන් දෙදෙනාම කොන්දේසිය සපුරාලන්නේ අසත්‍ය නම් පරීක්ෂා කිරීමේදී පමණි , නමුත් සත්‍ය වූ විට නොවේ

මෙහි පරීක්ෂා කරන්න: ජාවාස්ක්‍රිප්ට් ගොචා

ප්රශ්නයේ පළමු කොටස:

ජාවාස්ක්‍රිප්ට් හි ශුන්‍ය වස්තුවක් ලෙස සලකන්නේ ඇයි?

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

ප්රශ්නයේ දෙවන කොටස:

පරික්ෂා


if (object == null)
Do something

කිරීම සමාන වේ

if (!object)
Do something

චෙක්පත් දෙක හැරුණු විට සෑම විටම අසත්‍ය වේ:

• වස්තුව නිර්වචනය නොකළ හෝ ශුන්‍ය ය: දෙකම සත්‍ය ය.

• වස්තුව ප්‍රාථමික වන අතර 0, ""හෝ අසත්‍යය: පළමුව පරීක්ෂා කරන්න අසත්‍යය, දෙවන සත්‍යය.

වස්තුව ප්රාථමික, නමුත් සැබෑ වස්තූන් නොවේ නම්, වැනි new Number(0), new String("")හෝ new Boolean(false), එසේ නම් චෙක්පත් දෙකම බොරු.

එබැවින් 'වස්තුව' යන්න සැබෑ වස්තුවක් ලෙස අර්ථ දැක්වුවහොත් චෙක්පත් දෙකම සැමවිටම එක හා සමාන වේ. ප්‍රාථමිකයන්ට ඉඩ දී ඇත්නම්, චෙක්පත් 0 සඳහා වෙනස් ""වන අතර අසත්‍ය වේ.

වැනි අවස්ථා වලදී object==null, අවිශ්වාස ප්‍රති results ල දෝෂ ප්‍රභවයක් විය හැකිය. භාවිතය ==කිසි විටෙකත් නිර්දේශ නොකරයි, ===ඒ වෙනුවට භාවිතා කරන්න.

ප්රශ්නයේ තුන්වන කොටස:

තවද:

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

ජාවාස්ක්‍රිප්ට් හි, එක් වෙනසක් නම්, ශුන්‍යය වර්ගයේ වස්තුවක් වන අතර නිර්වචනය නොකළ ආකාරයේ ය.

ජාවාස්ක්‍රිප්ට් හි, null==undefinedසත්‍ය වන අතර වර්ගය නොසලකා හරිනු ලැබුවහොත් එය සමාන යැයි සැලකේ. ඔවුන් එය තීරණය කළේ ඇයි, නමුත් 0 ""සහ අසත්‍යය සමාන නොවේ, මම නොදනිමි. එය අත්තනෝමතික මතයක් බව පෙනේ.

ජාවාස්ක්‍රිප්ට් හි, null===undefinedසත්‍ය නොවේ, මන්ද වර්ගය සමාන විය යුතුය ===.

යථාර්ථයේ දී, ශුන්‍ය හා නිර්වචනය නොකළ ඒවා සමාන ය, මන්ද ඒවා දෙකම නොපවතින බැවිනි. එබැවින් 0 කරන්න, ""ඒ සඳහාද, සමහර විට හිස් බහාලුම් []සහ {}. එකම කිසිවක් නැති බොහෝ දේ දෝෂ සඳහා වට්ටෝරුවකි. එක් වර්ගයක් හෝ කිසිවක් වඩා හොඳ නැත. මම හැකි තරම් භාවිතා කිරීමට උත්සාහ කරමි.

'අසත්‍ය', 'සත්‍ය' සහ '!' උදාහරණයක් ලෙස, සරල බව හැකි විය, පණුවන් තවත් මල්ලක් වේ if(!x)හා if(x)පමණක් ප්රමාණවත් වේ, ඔබ සත්ය හා අසත්ය අවශ්ය නැත.

ප්‍රකාශයක් var xයනු කිසිදු අගයක් ලබා නොදුනහොත් නිර්වචනය නොකළ වර්ගයකි, නමුත් එය x කිසිසේත් ප්‍රකාශයට පත් නොකළ ආකාරයටම විය යුතුය. තවත් දෝෂ ප්‍රභවයක් වන්නේ හිස් කිසිවක් නැති බහාලුමකි. එබැවින් එය එකට ප්‍රකාශ කිරීම හා නිර්වචනය කිරීම වඩාත් සුදුසුය var x=1.

මේ විවිධ වර්ගයේ කිසිවක් සොයා ගැනීමට මිනිසුන් උත්සාහ කරමින් රවුමක සැරිසරති, නමුත් සංකීර්ණ විවිධ ඇඳුම් වලින් සියල්ලම එකම දෙයකි. යථාර්ථය නම්

undefined===undeclared===null===0===""===[]==={}===nothing

සමහර විට සියල්ලන්ම ව්යතිරේක විසි කළ යුතුය.

var x = null;

x යනු ශුන්‍ය ලෙස අර්ථ දැක්වේ

y යන්න අර්ථ දක්වා නැත; // මම එය නිර්වචනය නොකළ නිසා

if (!x)

ශුන්‍යය අසත්‍යයක් ලෙස තක්සේරු කෙරේ

ශුන්‍ය හා නිර්වචනය නොකළ හැඟීමක් ඇති කළ හැකි එක් ක්‍රමයක් නම්, ඒවා සිදු වන්නේ කොතැනද යන්න තේරුම් ගැනීමයි.

පහත දැක්වෙන අවස්ථා වලදී ශුන්‍ය ප්‍රතිලාභ අගයක් බලාපොරොත්තු වන්න:

• DOM විමසන ක්‍රම

  console.log(window.document.getElementById("nonExistentElement"));
  //Prints: null

• අජැක්ස් ඉල්ලීමකින් JSON ප්‍රතිචාර ලැබුණි

    {
      name: "Bob",
      address: null
    }

• RegEx.exec .

• ප්‍රවාහයේ පවතින නව ක්‍රියාකාරිත්වය. පහත දැක්වෙන ප්‍රතිලාභ අහෝසි වේ:

        var proto = Object.getPrototypeOf(Object.getPrototypeOf({}));

       // But this returns undefined:

        Object.getOwnPropertyDescriptor({}, "a");

නොපවතින අනෙක් සියලුම අවස්ථා නිර්වචනය නොකෙරේ (@ ඇක්සෙල් විසින් සටහන් කර ඇති පරිදි). පහත සඳහන් සෑම මුද්‍රණයක්ම “නිර්වචනය නොකළ”:

    var uninitalised;
    console.log(uninitalised);

    var obj = {};
    console.log(obj.nonExistent);

    function missingParam(missing){
        console.log(missing);
    }

    missingParam();

    var arr = [];
    console.log(arr.pop());        

ඇත්ත වශයෙන්ම ඔබ ලිවීමට තීරණය කරන්නේ නම් var unitialised = null; හෝ ඔබ විසින්ම ක්‍රමයකින් ශුන්‍යව ආපසු යන්න, එවිට ඔබට වෙනත් අවස්ථාවන්හිදී ශුන්‍ය වේ. නමුත් එය පැහැදිලිව පෙනෙන්නට තිබිය යුතුය.

තුන්වන අවස්ථාව නම් ඔබට විචල්‍යයකට ප්‍රවේශ වීමට අවශ්‍ය වූ නමුත් එය ප්‍රකාශයට පත් කර ඇත්දැයි ඔබ නොදනී. එවැනි අවස්ථාවක විමර්ශන දෝෂයක් වළක්වා ගැනීම සඳහා typeof භාවිතා කරන්න:

if(typeof unknown !== "undefined"){
    //use unknown
}

සාරාංශයක් ලෙස ඔබ DOM හසුරුවන විට, අජැක්ස් සමඟ ගනුදෙනු කරන විට හෝ සමහර ECMAScript 5 විශේෂාංග භාවිතා කරන විට ශුන්‍යදැයි පරීක්ෂා කරන්න. අනෙක් සියලුම අවස්ථාවන් සඳහා දැඩි සමානාත්මතාවයකින් නිර්වචනය කර නොමැතිදැයි පරීක්ෂා කිරීම ආරක්ෂිත ය:

if(value === undefined){
  // stuff
}

ජාවාස්ක්‍රිප්ට් හි විවිධ ශුන්‍ය චෙක්පත් සංසන්දනය කිරීම:

http://jsfiddle.net/aaronhoffman/DdRHB/5/

// Variables to test
var myNull = null;
var myObject = {};
var myStringEmpty = "";
var myStringWhiteSpace = " ";
var myStringHello = "hello";
var myIntZero = 0;
var myIntOne = 1;
var myBoolTrue = true;
var myBoolFalse = false;
var myUndefined;

...trim...

http://aaron-hoffman.blogspot.com/2013/04/javascript-null-checking-undefined-and.html

අගය සමානාත්මතාවය සඳහා ශුන්‍ය සහ නිර්වචනය නොකළ දෙකම අසත්‍යය (ශුන්‍ය == නිර්වචනය නොකළ): ඒවා දෙකම බූලියන් අසත්‍යයට කඩා වැටේ. ඒවා එකම වස්තුවක් නොවේ (ශූන්‍ය! == නිර්වචනය නොකළ).

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

null යනු වස්තුවේ නිදසුනකි. හිස් ප්‍රති result ලයක් දැක්වීමට එකතු කිරීමේ වස්තු ආපසු ලබා දෙන DOM ක්‍රම සඳහා null භාවිතා කරයි, එය දෝෂයක් දක්වන්නේ නැතිව ව්‍යාජ අගයක් සපයයි.

පිළිතුර එකතු කිරීමට කුමක්ද අතර differrence වේ undefinedහාnull , සිට JavaScript මාර්ගෝපදේශනය 6 සංස්කරණය, මෙම පිටුවේ p.41 :

undefinedපද්ධති මට්ටමේ, අනපේක්ෂිත හෝ දෝෂ වැනි වටිනාකමේ අගය nullනිරූපණය කිරීමට සහ වැඩසටහන් මට්ටමේ, සාමාන්‍ය හෝ අපේක්ෂිත අගය නොමැතිවීම නියෝජනය කිරීමට ඔබට සලකා බැලිය හැකිය . ඔබට මෙම අගයන්ගෙන් එකක් විචල්‍යයකට හෝ දේපලකට පැවරීමට හෝ මෙම අගයන්ගෙන් එකක් ශ්‍රිතයකට යැවීමට අවශ්‍ය නම්, nullසෑම විටම පාහේ නිවැරදි තේරීම වේ.

සමහර නිරවද්‍යතා:

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

ifපහත දැක්වෙන පරිදි සිදුවන්නේ කුමක්ද if( o ):

වරහන් තුළ ඇති ප්‍රකාශනය ඇගයීමට ලක් කරනු ලැබේ, පසුව ifවරහන් තුළ ඇති ප්‍රකාශනයේ වටිනාකම ටයිප්-බලහත්කාරයෙන් ආරම්භ කිරීම - අපගේ නඩුවේදී o.

ජාවාස්ක්‍රිප්ට් හි ව්‍යාජ (එය සාවද්‍ය බවට බල කෙරෙනු ඇත) අගයන් වනුයේ: '', ශුන්‍ය, නිර්වචනය නොකළ, 0 සහ අසත්‍යය .

nullවස්තුවකි. එහි වර්ගය ශුන්‍යයි. undefinedවස්තුවක් නොවේ; එහි වර්ගය නිර්වචනය කර නැත.

පහත දැක්වෙන ශ්‍රිතය මඟින් වෙනස හඳුනා ගැනීමට හේතුව සහ හැකියාව පෙන්වයි:

function test() {
        var myObj = {};
        console.log(myObj.myProperty);
        myObj.myProperty = null;
        console.log(myObj.myProperty);
}

ඔබ අමතන්නේ නම්

test();

ඔබට ලැබෙනවා

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

ශුන්‍යයි

පළමු console.log(...)ලබා ගැනීමට උත්සාහක දිනුම් myPropertyසිට myObjඑය ආපසු "නිර්වචනය නොකළ" ලැබෙන නිසා - එය තවම අර්ථ දක්වා නැත අතර. එයට ශුන්‍යය පැවරීමෙන් පසුව, දෙවැන්න console.log(...)පැහැදිලිවම "ශූන්‍ය" ලෙස නැවත පැමිණේ myProperty, මන්ද එය පවතින නමුත් එයට එයට පවරා ඇති අගය nullඇත.

මෙම වෙනස විමසීමට හැකිවීම සඳහා, ජාවාස්ක්‍රිප්ට් සතුව ඇත්තේ nullසහ undefined: nullඅනෙක් භාෂාවන්හි මෙන්ම වස්තුවක් ද වස්තුවක් undefinedවිය නොහැක්කේ නිදසුනක් නොමැති නිසා (නිදසුනක් පවා නැත null).

උදාහරණයක් ලෙස window.someWeirdPropertyනිර්වචනය කර නැත

"window.someWeirdProperty === null" ව්‍යාජ ලෙස තක්සේරු කරයි

"window.someWeirdProperty === undefined" සත්‍ය ලෙස ඇගයීමට ලක් කරයි.

එපමනක් නොව checkif if (!o)පරීක්ෂා සමාන නොවේ if (o == null)සඳහා oවීම false.

නිර්වචනය නොකළ අනෙක් විනෝදජනක දෙය නම්, නිර්වචනය නොකළ හා සසඳන විට එය වැඩි කළ හැකි වීමයි.

x = undefined
x++
y = null
y++
console.log(x) // NaN
console.log(y) // 0

කවුන්ටර සඳහා පෙරනිමි සංඛ්‍යාත්මක අගයන් සැකසීමට මෙය ප්‍රයෝජනවත් වේ. එහි ප්‍රකාශනයේ දී ඔබ විචල්‍යයක් -1 ට කී වතාවක් සකසා තිබේද?

දී ජාවාස්ක්රිප්ට් null නිසා නොවේ objectඑය කිරීමට වර්ගය primitaveවර්ගය.

මොකක්ද වෙනස? නිර්වචනය නොකෙරේ, සකසා නැති දර්ශකයක්. ශූන්ය උදාහරණයක් දෙයක් අතින් වර්ගයේ වීමට විචල්ය නියම කර තිබේ සඳහා ශූන්ය හේතුවම සඳහන්null

මේ දෙස බලන්න:

   <script>
function f(a){
  alert(typeof(a));
  if (a==null) alert('null');
  a?alert(true):alert(false);
}
</script>
                                          //return:
<button onclick="f()">nothing</button>    //undefined    null    false
<button onclick="f(null)">null</button>   //object       null    false
<button onclick="f('')">empty</button>    //string               false
<button onclick="f(0)">zero</button>      //number               false
<button onclick="f(1)">int</button>       //number               true
<button onclick="f('x')">str</button>     //string               true

නිකලස් සී. සකාස් විසින් රචිත "වස්තු-දිශානත ජාවාස්ක්‍රිප්ට් හි මූලධර්ම" වෙතින්

වර්ගය ශුන්‍ය වන විට වස්තුවක් ඇයි? .

සකාස්, නිකලස් සී. (2014-02-07). වස්තු-දිශානත ජාවාස්ක්‍රිප්ට් හි මූලධර්ම (Kindle Locations 226-227). ස්ටාර්ච් ප්‍රෙස් නැත. Kindle සංස්කරණය.

එය මෙසේ පැවසීය:

var game = null; //typeof(game) is "object"

game.score = 100;//null is not an object, what the heck!?
game instanceof Object; //false, so it's not an instance but it's type is object
//let's make this primitive variable an object;
game = {}; 
typeof(game);//it is an object
game instanceof Object; //true, yay!!!
game.score = 100;

නිර්වචනය නොකළ නඩුව:

var score; //at this point 'score' is undefined
typeof(score); //'undefined'
var score.player = "felix"; //'undefined' is not an object
score instanceof Object; //false, oh I already knew that.

'ශූන්‍යය' ගැන සිතීමට ඇති හොඳම ක්‍රමය නම්, සමාන සංකල්පයක් දත්ත සමුදායන්හි භාවිතා කරන ආකාරය සිහිපත් කිරීමයි, එහිදී ඇඟවෙන්නේ ක්ෂේත්‍රයක “කිසිසේත්ම වටිනාකමක් නැති” බවයි.

• ඔව්, අයිතමයේ වටිනාකම දනී; එය ඇත 'අර්ථ.' එය ආරම්භ කර ඇත.
• අයිතමයේ වටිනාකම: "වටිනාකමක් නැත."

වඩාත් පහසුවෙන් නිදොස්කරණය කළ වැඩසටහන් ලිවීම සඳහා මෙය ඉතා ප්‍රයෝජනවත් තාක්‍ෂණයකි. ක විචල්ය දෝෂය ප්රතිඵලයක් ... විය හැකි '' නිර්වචනය නොකළ ' (කොහොමද ඔයා දන්නේ කොහොමද?) ඔබ කෙනෙකුට, මෙම වැඩසටහන සඳහා කොහේ හරි, "බව දැන ... නමුත් විචල්ය අගය අඩංගු නම්' ශූන්ය ' සකස් කිරීමට 'null.' 'එබැවින්, මම යෝජනා කරන්නේ, ඔබට විචල්‍යයක වටිනාකම ඉවත් කිරීමට අවශ්‍ය වූ විට, "මකන්න" එපා ... එය' ශුන්‍ය 'ලෙස සකසන්න. පැරණි වටිනාකම අනාථ වන අතර ඉක්මනින් කසළ එකතු කරනු ලැබේ; නව අගය නම්, "කිසිදු වටිනාකමක් නැත (දැන්)." අවස්ථා දෙකේදීම, විචල්යයේ තත්වය ස්ථිරයි: "එය පැහැදිලිවම, හිතාමතාම, එම මාර්ගය ලබා ගත්තේය."

1. නිර්වචනය නොකිරීම යනු විචල්‍යයක් ප්‍රකාශයට පත් කර ඇති නමුත් එයට කිසිදු වටිනාකමක් ලබා දී නොමැති අතර ශුන්‍යයට “වටිනාකමක් නැත” යන්න නිරූපණය කරන විචල්‍යයකට පැවරිය හැකිය. (ශුන්‍ය යනු පැවරුම් ක්‍රියාකරු)

2. නිර්වචනය යනු වර්ගයක් වන අතර ශුන්‍ය වස්තුවකි.

3. ජාවාස්ක්‍රිප්ට් විසින්ම නියම නොකළ විචල්‍යයක් නිර්වචනය නොකළ ලෙස ආරම්භ කළ හැකි නමුත් එයට කිසි විටෙකත් විචල්‍යයක අගය ශුන්‍යයට සැකසිය නොහැක. මෙය ක්‍රමානුකූලව කළ යුතුය.