జావాస్క్రిప్ట్‌లో

Arthur Petit

6, జూన్ 2024, గురువారం 12:45:19 AMకి

జావాస్క్రిప్ట్‌లో వేరియబుల్ డిక్లరేషన్‌లను గ్రహించడం

జావాస్క్రిప్ట్ ప్రపంచంలో, క్లీన్ మరియు ఎఫెక్టివ్ కోడ్ రాయడానికి లెట్ మరియు వర్ మధ్య వ్యత్యాసాన్ని అర్థం చేసుకోవడం చాలా ముఖ్యం. 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 వాస్తవ-ప్రపంచ దృశ్యాలలో.

జావాస్క్రిప్ట్‌లో "లెట్" మరియు "వర్" మధ్య తేడా

ఫ్రంటెండ్ జావాస్క్రిప్ట్ ఉదాహరణ

// 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();

"లెట్" మరియు "వర్"తో స్కోపింగ్‌ని అర్థం చేసుకోవడం

బ్యాకెండ్ 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 ఎగురవేస్తోంది. Hoisting అనేది ప్రస్తుత స్కోప్‌లో పైకి డిక్లరేషన్‌లను తరలించే JavaScript యొక్క ప్రవర్తన. తో var, వేరియబుల్స్ పైకి లేపబడతాయి మరియు ప్రారంభించబడతాయి undefined, వేరియబుల్ దాని ప్రకటనకు ముందు ఉపయోగించినట్లయితే ఇది ఊహించని ఫలితాలకు దారి తీస్తుంది. దీనికి విరుద్ధంగా, let ఎగురవేయబడింది, కానీ అది ప్రారంభించబడలేదు. దీని అర్థం a యాక్సెస్ చేయడం let దాని డిక్లరేషన్ ముందు వేరియబుల్ ఫలితంగా a ReferenceError.

అదనంగా, let లూప్‌లలో మూసివేతతో సమస్యలను నివారించడంలో సహాయపడుతుంది. ఉపయోగిస్తున్నప్పుడు var లూప్‌లో, అన్ని పునరావృత్తులు ఒకే వేరియబుల్‌ను సూచిస్తాయి, ఇది బగ్‌లకు దారి తీస్తుంది. అయితే, let ప్రతి పునరావృతం కోసం ఒక కొత్త బైండింగ్‌ను సృష్టిస్తుంది, ప్రతి లూప్ పునరావృతం దాని స్వంత పరిధిని కలిగి ఉండేలా చేస్తుంది. ఈ ప్రవర్తన చేస్తుంది let లూప్‌లలో వేరియబుల్‌లను ప్రకటించడానికి సురక్షితమైన మరియు మరింత ఊహాజనిత ఎంపిక.

జావాస్క్రిప్ట్‌లో 'లెట్' మరియు 'వర్' గురించి సాధారణ ప్రశ్నలు

జావాస్క్రిప్ట్‌లో హాయిస్టింగ్ అంటే ఏమిటి?
Hoisting అనేది ప్రస్తుత స్కోప్‌లో డిక్లరేషన్‌లను తరలించే JavaScript యొక్క డిఫాల్ట్ ప్రవర్తన. var డిక్లరేషన్‌లు ఎగురవేయబడతాయి మరియు ప్రారంభించబడతాయి undefined, అయితే let ప్రకటనలు ఊపందుకున్నాయి కానీ ప్రారంభించబడలేదు.
మీరు a ఉపయోగిస్తే ఏమి జరుగుతుంది let దాని ప్రకటనకు ముందు వేరియబుల్?
యాక్సెస్ చేస్తోంది a let దాని డిక్లరేషన్ ఫలితాలకు ముందు వేరియబుల్ a ReferenceError.
చెయ్యవచ్చు let మరియు var అదే పరిధిలో మళ్లీ ప్రకటించాలా?
లేదు, let అదే పరిధిలో తిరిగి ప్రకటించలేము, అయితే var అదే పరిధిలో తిరిగి ప్రకటించవచ్చు.
ఎందుకు let లూప్‌లలో ఉత్తమం?
let లూప్ యొక్క ప్రతి పునరావృతానికి కొత్త బైండింగ్‌ను సృష్టిస్తుంది, ప్రతి లూప్ పునరావృతం దాని స్వంత పరిధిని కలిగి ఉందని నిర్ధారిస్తుంది. ఇది మూసివేతలకు సంబంధించిన సాధారణ బగ్‌లను నివారిస్తుంది.
చేస్తుంది var బ్లాక్ పరిధిని గౌరవిస్తారా?
లేదు, var బ్లాక్ పరిధిని గౌరవించదు; ఇది ఫంక్షన్-స్కోప్డ్ లేదా గ్లోబల్-స్కోప్డ్.
టెంపోరల్ డెడ్ జోన్ అంటే ఏమిటి?
టెంపోరల్ డెడ్ జోన్ అనేది స్కోప్‌లోకి ప్రవేశించడం మరియు వేరియబుల్ యొక్క వాస్తవ ప్రకటన మధ్య సమయం, ఈ సమయంలో ఒక let వేరియబుల్ త్రో చేస్తుంది a ReferenceError.
చెయ్యవచ్చు const అదేవిధంగా ఉపయోగించబడుతుంది let?
అవును, const బ్లాక్-స్కోప్డ్ లాగా ఉంటుంది let, కానీ ఇది తిరిగి కేటాయించకూడని వేరియబుల్స్ డిక్లేర్ చేయడానికి ఉపయోగించబడుతుంది.
ఎప్పుడు ఉండాలి let పైగా ఉపయోగించబడుతుంది var?
let పైగా వాడాలి var మీకు బ్లాక్ స్కోప్ అవసరమైనప్పుడు మరియు వేరియబుల్ హోస్టింగ్ మరియు మూసివేతలతో సమస్యలను నివారించడానికి.

వేరియబుల్ డిక్లరేషన్‌లపై తుది ఆలోచనలు

ముగింపులో, పరిచయం let ECMAScript 6 జావాస్క్రిప్ట్‌లో వేరియబుల్ డిక్లరేషన్ కోసం డెవలపర్‌లకు మరింత బలమైన సాధనాన్ని అందించింది. మధ్య తేడాలను అర్థం చేసుకోవడం let మరియు var క్లీనర్, మరింత మెయింటెనబుల్ కోడ్ రాయడానికి ఇది అవసరం. కాగా var కొన్ని సందర్భాల్లో ఇప్పటికీ ఉపయోగకరంగా ఉండవచ్చు, let స్కోప్ మరియు హోస్టింగ్‌పై మెరుగైన నియంత్రణను అందిస్తుంది, బగ్‌ల సంభావ్యతను తగ్గిస్తుంది.

ఎంచుకోవడం ద్వారా let పైగా var తగిన సందర్భాలలో, డెవలపర్లు బ్లాక్-స్కోపింగ్ ప్రయోజనాన్ని పొందవచ్చు మరియు వేరియబుల్ డిక్లరేషన్ మరియు హాయిస్టింగ్‌తో అనుబంధించబడిన సాధారణ ఆపదలను నివారించవచ్చు. ఆధునిక జావాస్క్రిప్ట్ డెవలప్‌మెంట్‌లో నైపుణ్యం సాధించాలని చూస్తున్న ఎవరికైనా ఈ జ్ఞానం ప్రాథమికమైనది.

జావాస్క్రిప్ట్‌లో "లెట్" మరియు "వర్" మధ్య వ్యత్యాసాన్ని అర్థం చేసుకోవడం