ஜாவாஸ்கிரிப்டில் let

Arthur Petit

வியாழன், 6 ஜூன், 2024 ’அன்று’ முற்பகல் 12:48:07

ஜாவாஸ்கிரிப்டில் மாறி அறிவிப்புகளைப் புரிந்துகொள்வது

ஜாவாஸ்கிரிப்ட் உலகில், சுத்தமான மற்றும் திறமையான குறியீட்டை எழுதுவதற்கு லெட் மற்றும் வார் இடையே உள்ள வித்தியாசத்தைப் புரிந்துகொள்வது முக்கியமானது. 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 நிஜ உலகக் காட்சிகளில்.

ஜாவாஸ்கிரிப்டில் "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();

"லெட்" மற்றும் "வார்" உடன் ஸ்கோப்பிங்கைப் புரிந்துகொள்வது

பின்முனை 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 என்பது ஜாவாஸ்கிரிப்ட்டின் தற்போதைய நோக்கத்தின் மேல் அறிவிப்புகளை நகர்த்துவதற்கான நடத்தை ஆகும். உடன் var, மாறிகள் ஏற்றப்பட்டு துவக்கப்படும் undefined, அதன் அறிவிப்புக்கு முன் மாறி பயன்படுத்தப்பட்டால் எதிர்பாராத முடிவுகளுக்கு வழிவகுக்கும். மாறாக, let உயர்த்தப்பட்டது, ஆனால் அது துவக்கப்படவில்லை. இதன் பொருள் a அணுகுதல் let அதன் அறிவிப்புக்கு முன் மாறி ஒரு ReferenceError.

கூடுதலாக, let லூப்களை மூடுவதில் சிக்கல்களைத் தடுக்க உதவுகிறது. பயன்படுத்தும் போது var ஒரு சுழற்சியில், அனைத்து மறு செய்கைகளும் ஒரே மாறியைக் குறிப்பிடுகின்றன, இது பிழைகளுக்கு வழிவகுக்கும். எனினும், let ஒவ்வொரு மறு செய்கைக்கும் ஒரு புதிய பிணைப்பை உருவாக்குகிறது, ஒவ்வொரு லூப் மறு செய்கைக்கும் அதன் சொந்த நோக்கம் இருப்பதை உறுதி செய்கிறது. இந்த நடத்தை செய்கிறது let சுழல்களுக்குள் மாறிகளை அறிவிப்பதற்கான பாதுகாப்பான மற்றும் கணிக்கக்கூடிய தேர்வு.

JavaScript இல் 'let' மற்றும் 'var' பற்றிய பொதுவான கேள்விகள்

ஜாவாஸ்கிரிப்ட்டில் ஏற்றுவது என்ன?
Hoisting என்பது ஜாவாஸ்கிரிப்ட்டின் இயல்புநிலை நடத்தை, அறிவிப்புகளை தற்போதைய நோக்கத்தின் மேல் நோக்கி நகர்த்துகிறது. var பிரகடனங்கள் ஏற்றப்பட்டு துவக்கப்படுகின்றன undefined, போது let பிரகடனங்கள் உயர்த்தப்படுகின்றன ஆனால் துவக்கப்படவில்லை.
நீங்கள் பயன்படுத்தினால் என்ன நடக்கும் let அதன் அறிவிப்புக்கு முன் மாறி?
அணுகல் a let அதன் பிரகடனத்திற்கு முன் மாறி ஒரு ReferenceError.
முடியும் let மற்றும் var அதே நோக்கத்தில் மீண்டும் அறிவிக்கப்படுமா?
இல்லை, let அதே நோக்கத்தில் மீண்டும் அறிவிக்க முடியாது, அதேசமயம் var அதே நோக்கத்தில் மீண்டும் அறிவிக்க முடியும்.
ஏன் let சுழல்களில் விரும்பத்தக்கதா?
let சுழற்சியின் ஒவ்வொரு மறு செய்கைக்கும் ஒரு புதிய பிணைப்பை உருவாக்குகிறது, ஒவ்வொரு லூப் மறு செய்கைக்கும் அதன் சொந்த நோக்கம் இருப்பதை உறுதி செய்கிறது. இது மூடல்களுடன் தொடர்புடைய பொதுவான பிழைகளைத் தடுக்கிறது.
செய்யும் var தொகுதி நோக்கம் மரியாதை?
இல்லை, var தொகுதி நோக்கத்தை மதிக்கவில்லை; இது செயல்பாட்டு நோக்குடையது அல்லது உலகளாவிய நோக்குடையது.
டெம்போரல் டெட் சோன் என்றால் என்ன?
டெம்போரல் டெட் சோன் என்பது ஸ்கோப்பிற்குள் நுழைவதற்கும் மாறியின் உண்மையான அறிவிப்புக்கும் இடைப்பட்ட நேரமாகும், இதன் போது ஒரு அணுகல் let மாறி ஒரு வீசும் ReferenceError.
முடியும் const இதேபோல் பயன்படுத்தப்படும் let?
ஆம், const தொகுதி-நோக்கம் போன்றது let, ஆனால் இது மறுஒதுக்கீடு செய்யக்கூடாத மாறிகளை அறிவிக்கப் பயன்படுகிறது.
எப்போது வேண்டும் let மேல் பயன்படுத்தப்படும் var?
let மேல் பயன்படுத்த வேண்டும் var உங்களுக்கு பிளாக் ஸ்கோப் தேவைப்படும்போது மற்றும் மாறி ஏற்றுதல் மற்றும் மூடுதல் போன்ற சிக்கல்களைத் தவிர்க்கவும்.

மாறி பிரகடனங்கள் பற்றிய இறுதி எண்ணங்கள்

முடிவில், அறிமுகம் let ECMAScript 6 இல், ஜாவாஸ்கிரிப்டில் மாறி அறிவிப்புக்கான மிகவும் வலுவான கருவியை டெவலப்பர்களுக்கு வழங்கியுள்ளது. இடையே உள்ள வேறுபாடுகளைப் புரிந்துகொள்வது let மற்றும் var தூய்மையான, மேலும் பராமரிக்கக்கூடிய குறியீட்டை எழுதுவதற்கு இது அவசியம். போது var சில சூழ்நிலைகளில் இன்னும் பயனுள்ளதாக இருக்கும், let நோக்கம் மற்றும் ஏற்றுதல் ஆகியவற்றின் மீது சிறந்த கட்டுப்பாட்டை வழங்குகிறது, பிழைகள் ஏற்படுவதற்கான வாய்ப்பைக் குறைக்கிறது.

தேர்ந்தெடுப்பதன் மூலம் let முடிந்துவிட்டது var பொருத்தமான சூழ்நிலைகளில், டெவலப்பர்கள் பிளாக்-ஸ்கோப்பிங்கைப் பயன்படுத்திக் கொள்ளலாம் மற்றும் மாறி அறிவிப்பு மற்றும் ஏற்றத்துடன் தொடர்புடைய பொதுவான ஆபத்துகளைத் தவிர்க்கலாம். நவீன ஜாவாஸ்கிரிப்ட் மேம்பாட்டில் தேர்ச்சி பெற விரும்பும் எவருக்கும் இந்த அறிவு அடிப்படையாகும்.

ஜாவாஸ்கிரிப்டில் "let" மற்றும் "var" இடையே உள்ள வித்தியாசத்தைப் புரிந்துகொள்வது