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

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	బ్లాక్-స్కోప్డ్ లోకల్ వేరియబుల్‌ని డిక్లేర్ చేస్తుంది, ఐచ్ఛికంగా దానిని విలువకు ప్రారంభిస్తుంది. అదే పరిధిలో మళ్లీ ప్రకటించలేం.
const	బ్లాక్-స్కోప్డ్, రీడ్-ఓన్లీ స్థిరాంకాన్ని ప్రకటిస్తుంది. ఇది డిక్లరేషన్ సమయంలో తప్పనిసరిగా ప్రారంభించబడాలి మరియు తిరిగి కేటాయించబడదు.
writeHead	Node.jsలో HTTP ప్రతిస్పందన కోసం స్థితి కోడ్ మరియు హెడర్‌లను సెట్ చేస్తుంది.
createServer	Node.jsలో HTTP సర్వర్‌ని సృష్టిస్తుంది, ఇది అభ్యర్థనలను వినగలదు మరియు ప్రతిస్పందించగలదు.
listen	పేర్కొన్న పోర్ట్‌లో ఇన్‌కమింగ్ కనెక్షన్‌ల కోసం వినడం ప్రారంభించడానికి సర్వర్‌ను సెటప్ చేస్తుంది.
console.log	కన్సోల్‌కు సందేశాలను ప్రింట్ చేస్తుంది, డీబగ్గింగ్ ప్రయోజనాల కోసం ఉపయోగపడుతుంది.

ఆచరణలో ఎలా "లెట్" మరియు "వర్" తేడా

ఫ్రంటెండ్ స్క్రిప్ట్ ఉదాహరణ మధ్య ఉన్న కీలక వ్యత్యాసాలను వివరిస్తుంది మరియు . లో ఫంక్షన్, వేరియబుల్ var x ఒక if బ్లాక్‌లో ప్రకటించబడింది మరియు మొత్తం ఫంక్షన్ పరిధిలో అదే వేరియబుల్‌ని మళ్లీ కేటాయిస్తుంది. దీని ఫలితంగా రెండు కన్సోల్ లాగ్‌లు 2 అవుట్‌పుట్ అవుతాయి, ఇది ఎలా ఉంటుందో చూపిస్తుంది బ్లాక్ పరిధిని గౌరవించదు. దీనికి విరుద్ధంగా, ది ఫంక్షన్ ప్రకటిస్తుంది if బ్లాక్ లోపల మరియు వెలుపల రెండూ. ది let బ్లాక్ లోపల డిక్లరేషన్ వేరే వేరియబుల్, కాబట్టి మొదటి కన్సోల్ లాగ్ అవుట్‌పుట్‌లు 2, మరియు రెండవ కన్సోల్ లాగ్ అవుట్‌పుట్‌లు 1, బ్లాక్ స్కోప్‌కు సంబంధించి.

బ్యాకెండ్ Node.js ఉదాహరణ ఈ వ్యత్యాసాలను మరింతగా ప్రదర్శించడానికి ఒక సాధారణ HTTP సర్వర్‌ను సెటప్ చేస్తుంది. ఉపయోగించి ఒక if బ్లాక్‌లో, మేము దానిని చూస్తాము బాహ్యాన్ని తిరిగి రాస్తుంది ఫంక్షన్ పరిధి కారణంగా వేరియబుల్. ది let message బ్లాక్ లోపల ఆ బ్లాక్‌కి స్థానికంగా ఉంటుంది, ప్రతి బ్లాక్‌కు వేర్వేరు సందేశాలను అవుట్‌పుట్ చేయడం ద్వారా బ్లాక్-స్కోపింగ్‌ని ప్రదర్శిస్తుంది. దాని యొక్క ఉపయోగం మరియు ఆదేశాలు సర్వర్‌ను ఏర్పాటు చేస్తాయి, ఇది క్లయింట్‌కు ప్రతిస్పందనలను వ్రాస్తుంది, యొక్క ఆచరణాత్మక అనువర్తనాలను ప్రదర్శిస్తుంది మరియు 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/');

స్కోప్ మరియు హాయిస్టింగ్‌లో లోతుగా డైవ్ చేయండి

పోల్చేటప్పుడు పరిగణించవలసిన మరో ముఖ్య అంశం మరియు ఎగురవేస్తోంది. Hoisting అనేది ప్రస్తుత స్కోప్‌లో పైకి డిక్లరేషన్‌లను తరలించే JavaScript యొక్క ప్రవర్తన. తో , వేరియబుల్స్ పైకి లేపబడతాయి మరియు ప్రారంభించబడతాయి undefined, వేరియబుల్ దాని ప్రకటనకు ముందు ఉపయోగించినట్లయితే ఇది ఊహించని ఫలితాలకు దారి తీస్తుంది. దీనికి విరుద్ధంగా, ఎగురవేయబడింది, కానీ అది ప్రారంభించబడలేదు. దీని అర్థం a యాక్సెస్ చేయడం దాని డిక్లరేషన్ ముందు వేరియబుల్ ఫలితంగా a .

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

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

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

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

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

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

ఆచరణలో ఎలా "లెట్" మరియు "వర్" తేడా

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

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

స్కోప్ మరియు హాయిస్టింగ్‌లో లోతుగా డైవ్ చేయండి

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