ജാവാസ്ക്രിപ്റ്റിൽ അസാധുവായതും നിർവചിക്കാത്തതും തമ്മിലുള്ള വ്യത്യാസം
റഫറൻസ്
JavaScriptശൂന്യമായ സാധാരണ ഉപയോഗം
ഒരു ഫംഗ്ഷൻ പാരാമീറ്റർ എന്ന നിലയിൽ, ഫംഗ്ഷൻ പാരാമീറ്റർ ഒരു ഒബ്ജക്റ്റ് അല്ല എന്നാണ് ഇതിനർത്ഥം
function myFn(obj) {
if(null == obj) {
// code
}
}
ഒബ്ജക്റ്റ് പ്രോട്ടോടൈപ്പ് ശൃംഖലയുടെ അവസാനം
Object.getPrototypeOf(Object.prototype);
വേരിയബിൾ റിലീസ് ചെയ്യുമ്പോൾ, വേരിയബിളിന് നൾ നൽകുക
let o={
code:'abc'
};
o = null;
നിർവചിച്ചിട്ടില്ലാത്ത സാധാരണ ഉപയോഗം
വേരിയബിൾ പ്രഖ്യാപിച്ചു, പക്ഷേ നൽകിയിട്ടില്ല, വേരിയബിളിന്റെ മൂല്യം നിർവചിക്കപ്പെട്ടിട്ടില്ല
let o;
console.log(o); //undefined
വിളിക്കുമ്പോൾ ഫംഗ്ഷൻ നൽകേണ്ട പാരാമീറ്റർ നൽകിയിട്ടില്ല, തുടർന്ന് നൽകാത്ത പാരാമീറ്ററിന്റെ മൂല്യം നിർവചിക്കപ്പെട്ടിട്ടില്ല
function myFn(o) {
console.log(o);
}
myFn(); //undefined
ഒബ്ജക്റ്റിൽ അടങ്ങിയിട്ടില്ലാത്ത പ്രോപ്പർട്ടികൾ, മൂല്യം നിർവചിക്കപ്പെട്ടിട്ടില്ല
let o={
code:'abc'
};
console.log(o.name); //undefined
ഫംഗ്ഷൻ ഒരു മൂല്യം നൽകാത്തപ്പോൾ, അത് സ്ഥിരസ്ഥിതിയായി നിർവചിക്കപ്പെടാതെ മടങ്ങുന്നു
function myFn(obj) {
obj = 'a';
}
console.log(myFn()); //undefined
അസാധുവായതും നിർവചിക്കാത്തതും തമ്മിലുള്ള സമാനതകൾ
ബൂലിയനിലേക്ക് പരിവർത്തനം ചെയ്യുമ്പോൾ തെറ്റ്
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
അസാധുവായതും നിർവചിക്കാത്തതും തമ്മിലുള്ള വ്യത്യാസം
ഒരു സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുമ്പോൾ ഫലം വ്യത്യസ്തമായിരിക്കും. അസാധുവായ പരിവർത്തനത്തിന്റെ ഫലം 0 എന്ന സാധുവായ സംഖ്യ മൂല്യമാണ്, നിർവചിക്കപ്പെടാത്ത പരിവർത്തനത്തിന്റെ ഫലം NaN ആണ്.
console.log(Number(null)); // 0
console.log(Number(undefined)); // NaN
രണ്ട് തരങ്ങൾ വ്യത്യസ്തമാണ്, ശൂന്യമായ തരം ഒബ്ജക്റ്റ്, നിർവചിക്കാത്ത തരം നിർവചിക്കപ്പെട്ടിട്ടില്ല.
console.log(typeof null); //object
console.log(typeof undefined); //undefined
അസാധുവായതും നിർവചിക്കാത്തതും താരതമ്യം ചെയ്യുക
ശൂന്യവും നിർവചിക്കപ്പെടാത്തതും തമ്മിൽ വേർതിരിച്ചറിയാൻ, സാമാന്യത മാത്രമേ ഉപയോഗിക്കാനാകൂ.സംഗമത്തിൽ, രണ്ട് തരങ്ങളും തുല്യമാണോ എന്ന് ഇത് കർശനമായി താരതമ്യം ചെയ്യും.
console.log(Boolean(null == undefined)); // true
console.log(Boolean(null === undefined)); // false
സംഗ്രഹിക്കാനായി
മുകളിലുള്ള താരതമ്യത്തിന് ശേഷം, ഈ രണ്ട് തരങ്ങളെക്കുറിച്ച് ഞങ്ങൾക്ക് വ്യക്തമായ ധാരണയുണ്ട്. സാധാരണയായി കോഡ് എഴുതുമ്പോൾ വേരിയബിളിന് സാധുവായ ഒരു മൂല്യമുണ്ടോ എന്ന് ഞങ്ങൾ തീരുമാനിക്കുമ്പോൾ, ഇവ രണ്ടും തമ്മിൽ വേർതിരിച്ചറിയേണ്ടതില്ല, അത് ഒരു ബൂളിയൻ തരമായി ഉപയോഗിക്കുക. പ്രോപ്പർട്ടി നിലവിലുണ്ടോ എന്ന് ഞങ്ങൾ തീരുമാനിക്കേണ്ടിവരുമ്പോൾ, നിർവചിക്കപ്പെടാത്ത വിധിക്കാൻ ഞങ്ങൾ കർശനമായി തരം ഉപയോഗിക്കണം. അവസാനമായി, ഞങ്ങൾ ഒരു സംഖ്യാ മൂല്യം കൈമാറുകയാണെങ്കിൽ, ഞങ്ങൾ ആദ്യം ഒരു വിധി പറയണം, കൂടാതെ നേരിട്ട് ഒരു സംഖ്യാ തരത്തിലേക്ക് കാസ്റ്റുചെയ്യാൻ കഴിയില്ല, അല്ലാത്തപക്ഷം അസാധുവായ ഫലങ്ങൾ ഞങ്ങൾക്ക് ലഭിക്കും, കൂടാതെ നിർവചിക്കപ്പെടാത്തത് അസാധുവായ ഫലം NaN നേരിട്ട് കണക്കാക്കും.