JavaScript-ൽ let ഉം var ഉം

Arthur Petit

2024, ജൂൺ 6, വ്യാഴാഴ്‌ച 12:11:43 AM

JavaScript-ൽ വേരിയബിൾ ഡിക്ലറേഷനുകൾ മനസ്സിലാക്കുന്നു

ജാവാസ്ക്രിപ്റ്റിൻ്റെ ലോകത്ത്, ശുദ്ധവും കാര്യക്ഷമവുമായ കോഡ് എഴുതുന്നതിന് ലെറ്റും var ഉം തമ്മിലുള്ള വ്യത്യാസം മനസ്സിലാക്കുന്നത് നിർണായകമാണ്. ECMAScript 6-ൽ അവതരിപ്പിച്ച, ലെറ്റ് സ്റ്റേറ്റ്‌മെൻ്റ് വേരിയബിൾ ഡിക്ലറേഷന് ഒരു പുതിയ മാനം ചേർത്തിട്ടുണ്ട്, ഇത് പലപ്പോഴും വേരിയബിളിൻ്റെ വ്യാപ്തിയിൽ കൂടുതൽ നിയന്ത്രണം നൽകുന്നതായി വിവരിക്കപ്പെടുന്നു.

രണ്ട് സമയത്ത് അനുവദിക്കുക ഒപ്പം var വേരിയബിളുകൾ പ്രഖ്യാപിക്കാൻ ഉപയോഗിക്കുന്നു, നിങ്ങളുടെ കോഡിനെ സാരമായി ബാധിക്കുന്ന വ്യത്യസ്ത സ്വഭാവങ്ങൾ അവ പ്രദർശിപ്പിക്കുന്നു. ഈ ലേഖനത്തിൽ, ഞങ്ങൾ ഈ വ്യത്യാസങ്ങൾ പര്യവേക്ഷണം ചെയ്യുകയും എപ്പോൾ ഉപയോഗിക്കണം എന്നതിനെക്കുറിച്ചുള്ള മാർഗ്ഗനിർദ്ദേശം നൽകുകയും ചെയ്യും അനുവദിക്കുക ഇതിനുപകരമായി var.

കമാൻഡ്	വിവരണം
var	ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കുന്നു, ഓപ്ഷണലായി അതിനെ ഒരു മൂല്യത്തിലേക്ക് സമാരംഭിക്കുന്നു. ഇത് ഫംഗ്‌ഷൻ-സ്കോപ്പ്ഡ് അല്ലെങ്കിൽ ആഗോളതലത്തിൽ വ്യാപ്തിയുള്ളതാണ്, അത് വീണ്ടും പ്രഖ്യാപിക്കാനും അപ്‌ഡേറ്റ് ചെയ്യാനും കഴിയും.
let	ഒരു ബ്ലോക്ക്-സ്കോപ്പ്ഡ് ലോക്കൽ വേരിയബിൾ പ്രഖ്യാപിക്കുന്നു, ഓപ്ഷണലായി അതിനെ ഒരു മൂല്യത്തിലേക്ക് സമാരംഭിക്കുന്നു. അതേ പരിധിയിൽ അത് വീണ്ടും പ്രഖ്യാപിക്കാൻ കഴിയില്ല.
const	ബ്ലോക്ക്-സ്കോപ്പ്ഡ്, റീഡ്-ഒൺലി കോൺസ്റ്റൻ്റ് പ്രഖ്യാപിക്കുന്നു. ഡിക്ലറേഷൻ സമയത്ത് ഇത് സമാരംഭിച്ചിരിക്കണം, അത് വീണ്ടും അസൈൻ ചെയ്യാൻ കഴിയില്ല.
writeHead	Node.js-ൽ HTTP പ്രതികരണത്തിനായി സ്റ്റാറ്റസ് കോഡും തലക്കെട്ടുകളും സജ്ജമാക്കുന്നു.
createServer	Node.js-ൽ ഒരു HTTP സെർവർ സൃഷ്ടിക്കുന്നു, അതിന് അഭ്യർത്ഥനകൾ കേൾക്കാനും പ്രതികരിക്കാനും കഴിയും.
listen	ഒരു നിർദ്ദിഷ്‌ട പോർട്ടിൽ ഇൻകമിംഗ് കണക്ഷനുകൾ കേൾക്കാൻ ആരംഭിക്കുന്നതിന് സെർവർ സജ്ജീകരിക്കുന്നു.
console.log	ഡീബഗ്ഗിംഗ് ആവശ്യങ്ങൾക്ക് ഉപയോഗപ്രദമായ, കൺസോളിലേക്ക് സന്ദേശങ്ങൾ പ്രിൻ്റ് ചെയ്യുന്നു.

പ്രാക്ടീസിൽ "ലെറ്റ്", "വർ" എന്നിവ എങ്ങനെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു

ഫ്രണ്ട്എൻഡ് സ്ക്രിപ്റ്റ് ഉദാഹരണം തമ്മിലുള്ള പ്രധാന വ്യത്യാസങ്ങൾ വ്യക്തമാക്കുന്നു var ഒപ്പം let. ൽ varTest ഫംഗ്ഷൻ, വേരിയബിൾ var x ഒരു if ബ്ലോക്കിനുള്ളിൽ പ്രഖ്യാപിക്കുകയും മുഴുവൻ ഫംഗ്‌ഷൻ സ്കോപ്പിനുള്ളിൽ അതേ വേരിയബിൾ വീണ്ടും നൽകുകയും ചെയ്യുന്നു. ഇത് രണ്ട് കൺസോൾ ലോഗുകളും 2 ഔട്ട്പുട്ട് ചെയ്യുന്നു, ഇത് എങ്ങനെയെന്ന് കാണിക്കുന്നു var ബ്ലോക്ക് പരിധിയെ മാനിക്കുന്നില്ല. വിപരീതമായി, ദി letTest ഫംഗ്ഷൻ പ്രഖ്യാപിക്കുന്നു let y if ബ്ലോക്കിൻ്റെ അകത്തും പുറത്തും. ദി let ബ്ലോക്കിനുള്ളിലെ ഡിക്ലറേഷൻ മറ്റൊരു വേരിയബിളാണ്, അതിനാൽ ആദ്യത്തെ കൺസോൾ ലോഗ് ഔട്ട്പുട്ട് 2 ഉം രണ്ടാമത്തെ കൺസോൾ ലോഗ് ഔട്ട്പുട്ടുകൾ 1 ഉം നൽകുന്നു.

ഈ വ്യത്യാസങ്ങൾ കൂടുതൽ പ്രകടമാക്കാൻ ബാക്കെൻഡ് Node.js ഉദാഹരണം ഒരു ലളിതമായ HTTP സെർവർ സജ്ജമാക്കുന്നു. ഉപയോഗിക്കുന്നത് var count ഒരു if ബ്ലോക്കിനുള്ളിൽ, ഞങ്ങൾ അത് കാണുന്നു var പുറം തിരുത്തിയെഴുതുന്നു count പ്രവർത്തന വ്യാപ്തി കാരണം വേരിയബിൾ. ദി let message ബ്ലോക്കിനുള്ളിൽ ആ ബ്ലോക്കിൻ്റെ പ്രാദേശികമായി തുടരുന്നു, ഓരോ ബ്ലോക്കിനും വ്യത്യസ്ത സന്ദേശങ്ങൾ നൽകി ബ്ലോക്ക്-സ്കോപ്പിംഗ് പ്രദർശിപ്പിക്കുന്നു. ഉപയോഗം createServer ഒപ്പം listen കമാൻഡുകൾ സെർവർ സ്ഥാപിക്കുന്നു, അത് ക്ലയൻ്റിനുള്ള പ്രതികരണങ്ങൾ എഴുതുന്നു, ഇതിൻ്റെ പ്രായോഗിക പ്രയോഗങ്ങൾ പ്രദർശിപ്പിക്കുന്നു var ഒപ്പം let യഥാർത്ഥ ലോക സാഹചര്യങ്ങളിൽ.

JavaScript-ൽ "let" ഉം "var" ഉം തമ്മിൽ വേർതിരിച്ചറിയുന്നു

മുൻഭാഗം ജാവാസ്ക്രിപ്റ്റ് ഉദാഹരണം

// Example demonstrating the difference between 'var' and 'let'
function varTest() {
    var x = 1;
    if (true) {
        var x = 2;  // same variable
        console.log(x);  // 2
    }
    console.log(x);  // 2
}

function letTest() {
    let y = 1;
    if (true) {
        let y = 2;  // different variable
        console.log(y);  // 2
    }
    console.log(y);  // 1
}

varTest();
letTest();

"let", "var" എന്നിവ ഉപയോഗിച്ച് സ്കോപ്പിംഗ് മനസ്സിലാക്കുക

ബാക്കെൻഡ് Node.js ഉദാഹരണം

// Backend example using Node.js to demonstrate 'let' and 'var'
const http = require('http');

http.createServer((req, res) => {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    var count = 10;
    let message = "The count is: ";

    if (true) {
        var count = 20;  // 'count' is hoisted and overwritten
        let message = "New count is: ";  // block-scoped
        res.write(message + count);  // New count is: 20
    }
    res.write(message + count);  // The count is: 20
    res.end();
}).listen(8080);

console.log('Server running at http://127.0.0.1:8080/');

സ്കോപ്പിലേക്കും ഹോയിസ്റ്റിംഗിലേക്കും ആഴത്തിൽ മുങ്ങുക

താരതമ്യം ചെയ്യുമ്പോൾ പരിഗണിക്കേണ്ട മറ്റൊരു പ്രധാന വശം let ഒപ്പം var ഉയർത്തുകയാണ്. നിലവിലെ സ്കോപ്പിൻ്റെ മുകളിലേക്ക് പ്രഖ്യാപനങ്ങൾ നീക്കുന്നതിനുള്ള JavaScript-ൻ്റെ സ്വഭാവമാണ് Hoisting. കൂടെ var, വേരിയബിളുകൾ ഉയർത്തി തുടങ്ങുന്നു undefined, വേരിയബിൾ അതിൻ്റെ പ്രഖ്യാപനത്തിന് മുമ്പ് ഉപയോഗിച്ചാൽ അത് അപ്രതീക്ഷിത ഫലങ്ങളിലേക്ക് നയിച്ചേക്കാം. വിപരീതമായി, let ഉയർത്തിയിട്ടുണ്ട്, പക്ഷേ അത് ആരംഭിച്ചിട്ടില്ല. ഇതിനർത്ഥം a ആക്സസ് ചെയ്യുക എന്നാണ് let അതിൻ്റെ പ്രഖ്യാപനത്തിന് മുമ്പുള്ള വേരിയബിൾ a എന്നതിന് കാരണമാകും ReferenceError.

കൂടാതെ, let ലൂപ്പുകളിൽ അടയ്ക്കുന്നതിലെ പ്രശ്നങ്ങൾ തടയാൻ സഹായിക്കുന്നു. ഉപയോഗിക്കുമ്പോൾ var ഒരു ലൂപ്പിൽ, എല്ലാ ആവർത്തനങ്ങളും ഒരേ വേരിയബിളിനെ പരാമർശിക്കുന്നു, ഇത് ബഗുകളിലേക്ക് നയിച്ചേക്കാം. എന്നിരുന്നാലും, let ഓരോ ആവർത്തനത്തിനും ഒരു പുതിയ ബൈൻഡിംഗ് സൃഷ്ടിക്കുന്നു, ഓരോ ലൂപ്പ് ആവർത്തനത്തിനും അതിൻ്റേതായ സ്കോപ്പ് ഉണ്ടെന്ന് ഉറപ്പാക്കുന്നു. ഈ സ്വഭാവം ഉണ്ടാക്കുന്നു let ലൂപ്പിനുള്ളിൽ വേരിയബിളുകൾ പ്രഖ്യാപിക്കുന്നതിനുള്ള സുരക്ഷിതവും കൂടുതൽ പ്രവചിക്കാവുന്നതുമായ ഒരു തിരഞ്ഞെടുപ്പ്.

JavaScript-ലെ 'let', 'var' എന്നിവയെക്കുറിച്ചുള്ള പൊതുവായ ചോദ്യങ്ങൾ

JavaScript-ൽ എന്താണ് ഉയർത്തുന്നത്?
നിലവിലെ സ്കോപ്പിൻ്റെ മുകളിലേക്ക് പ്രഖ്യാപനങ്ങൾ നീക്കുന്നതിനുള്ള JavaScript-ൻ്റെ ഡിഫോൾട്ട് സ്വഭാവമാണ് Hoisting. var പ്രഖ്യാപനങ്ങൾ ഉയർത്തുകയും ആരംഭിക്കുകയും ചെയ്യുന്നു undefined, അതേസമയം let പ്രഖ്യാപനങ്ങൾ ഉയർത്തിയെങ്കിലും ആരംഭിച്ചിട്ടില്ല.
എ ഉപയോഗിച്ചാൽ എന്ത് സംഭവിക്കും let അതിൻ്റെ പ്രഖ്യാപനത്തിന് മുമ്പുള്ള വേരിയബിൾ?
ആക്സസ് ചെയ്യുന്നു എ let വേരിയബിൾ അതിൻ്റെ പ്രഖ്യാപനത്തിന് മുമ്പ് a ReferenceError.
കഴിയും let ഒപ്പം var അതേ പരിധിയിൽ വീണ്ടും പ്രഖ്യാപിക്കുമോ?
ഇല്ല, let അതേ പരിധിയിൽ വീണ്ടും പ്രഖ്യാപിക്കാൻ കഴിയില്ല, അതേസമയം var അതേ പരിധിയിൽ വീണ്ടും പ്രഖ്യാപിക്കാവുന്നതാണ്.
എന്ത് കൊണ്ടാണു let ലൂപ്പുകളിൽ അഭികാമ്യം?
let ലൂപ്പിൻ്റെ ഓരോ ആവർത്തനത്തിനും ഒരു പുതിയ ബൈൻഡിംഗ് സൃഷ്ടിക്കുന്നു, ഓരോ ലൂപ്പ് ആവർത്തനത്തിനും അതിൻ്റേതായ വ്യാപ്തി ഉണ്ടെന്ന് ഉറപ്പാക്കുന്നു. ഇത് അടച്ചുപൂട്ടലുമായി ബന്ധപ്പെട്ട സാധാരണ ബഗുകളെ തടയുന്നു.
ചെയ്യുന്നു var ബ്ലോക്ക് പരിധിയെ ബഹുമാനിക്കണോ?
ഇല്ല, var ബ്ലോക്ക് പരിധിയെ മാനിക്കുന്നില്ല; ഇത് ഫംഗ്‌ഷൻ സ്കോപ്പ് അല്ലെങ്കിൽ ആഗോളതലത്തിൽ വ്യാപ്തിയുള്ളതാണ്.
എന്താണ് ടെമ്പറൽ ഡെഡ് സോൺ?
വ്യാപ്തിയിലേക്ക് പ്രവേശിക്കുന്നതിനും വേരിയബിളിൻ്റെ യഥാർത്ഥ പ്രഖ്യാപനത്തിനും ഇടയിലുള്ള സമയമാണ് ടെമ്പറൽ ഡെഡ് സോൺ. let വേരിയബിൾ എ എറിയുന്നു ReferenceError.
കഴിയും const സമാനമായി ഉപയോഗിക്കും let?
അതെ, const ബ്ലോക്ക്-സ്കോപ്പ് പോലെയാണ് let, എന്നാൽ ഇത് വീണ്ടും അസൈൻ ചെയ്യാൻ പാടില്ലാത്ത വേരിയബിളുകൾ പ്രഖ്യാപിക്കാൻ ഉപയോഗിക്കുന്നു.
എപ്പോൾ വേണം let ഉപയോഗിക്കും var?
let മേൽ ഉപയോഗിക്കണം var നിങ്ങൾക്ക് ബ്ലോക്ക് സ്കോപ്പ് ആവശ്യമായി വരുമ്പോൾ വേരിയബിൾ ഹോയിസ്റ്റിംഗിലും ക്ലോഷറിലുമുള്ള പ്രശ്നങ്ങൾ ഒഴിവാക്കുക.

വേരിയബിൾ ഡിക്ലറേഷനുകളെക്കുറിച്ചുള്ള അന്തിമ ചിന്തകൾ

സമാപനത്തിൽ, ആമുഖം let ECMAScript 6-ൽ JavaScript-ൽ വേരിയബിൾ ഡിക്ലറേഷനായി ഡെവലപ്പർമാർക്ക് കൂടുതൽ കരുത്തുറ്റ ടൂൾ നൽകിയിട്ടുണ്ട്. തമ്മിലുള്ള വ്യത്യാസങ്ങൾ മനസ്സിലാക്കുന്നു let ഒപ്പം var വൃത്തിയുള്ളതും കൂടുതൽ പരിപാലിക്കാവുന്നതുമായ കോഡ് എഴുതുന്നതിന് അത്യാവശ്യമാണ്. അതേസമയം var ചില സാഹചര്യങ്ങളിൽ ഇപ്പോഴും ഉപയോഗപ്രദമായേക്കാം, let സ്കോപ്പിലും ഹോയിസ്റ്റിംഗിലും മികച്ച നിയന്ത്രണം വാഗ്ദാനം ചെയ്യുന്നു, ബഗുകളുടെ സാധ്യത കുറയ്ക്കുന്നു.

തിരഞ്ഞെടുക്കുന്നതിലൂടെ let കഴിഞ്ഞു var ഉചിതമായ സാഹചര്യങ്ങളിൽ, ഡെവലപ്പർമാർക്ക് ബ്ലോക്ക്-സ്കോപ്പിംഗ് പ്രയോജനപ്പെടുത്താനും വേരിയബിൾ ഡിക്ലറേഷനും ഹോയിസ്റ്റിംഗുമായി ബന്ധപ്പെട്ട പൊതുവായ അപകടങ്ങൾ ഒഴിവാക്കാനും കഴിയും. ആധുനിക ജാവാസ്ക്രിപ്റ്റ് വികസനം മാസ്റ്റർ ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ആർക്കും ഈ അറിവ് അടിസ്ഥാനപരമാണ്.

JavaScript-ൽ "let" ഉം "var" ഉം തമ്മിലുള്ള വ്യത്യാസം മനസ്സിലാക്കുന്നു