JavaScript ਵਿੱਚ let ਅਤੇ var ਵਿਚਕਾਰ

Arthur Petit

ਵੀਰਵਾਰ, 6 ਜੂਨ 2024 12:25:38 ਪੂ.ਦੁ.

JavaScript ਵਿੱਚ ਵੇਰੀਏਬਲ ਘੋਸ਼ਣਾਵਾਂ ਨੂੰ ਸਮਝਣਾ

JavaScript ਦੀ ਦੁਨੀਆ ਵਿੱਚ, ਸਾਫ਼ ਅਤੇ ਕੁਸ਼ਲ ਕੋਡ ਲਿਖਣ ਲਈ let ਅਤੇ var ਵਿਚਕਾਰ ਅੰਤਰ ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। ECMAScript 6 ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ, let ਸਟੇਟਮੈਂਟ ਨੇ ਵੇਰੀਏਬਲ ਘੋਸ਼ਣਾ ਵਿੱਚ ਇੱਕ ਨਵਾਂ ਆਯਾਮ ਜੋੜਿਆ ਹੈ, ਅਕਸਰ ਵੇਰੀਏਬਲ ਦੇ ਦਾਇਰੇ ਉੱਤੇ ਵਧੇਰੇ ਨਿਯੰਤਰਣ ਪ੍ਰਦਾਨ ਕਰਨ ਵਜੋਂ ਦਰਸਾਇਆ ਗਿਆ ਹੈ।

ਜਦੋਂ ਕਿ ਦੋਵੇਂ ਚਲੋ ਅਤੇ 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" ਵਿਚਕਾਰ ਫਰਕ ਕਰਨਾ

ਫਰੰਟਐਂਡ JavaScript ਉਦਾਹਰਨ

// 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 ਦਾ ਵਿਵਹਾਰ ਹੈ। ਨਾਲ var, ਵੇਰੀਏਬਲ ਨੂੰ ਲਹਿਰਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਨਾਲ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ undefined, ਜਿਸ ਨਾਲ ਅਣਕਿਆਸੇ ਨਤੀਜੇ ਨਿਕਲ ਸਕਦੇ ਹਨ ਜੇਕਰ ਵੇਰੀਏਬਲ ਨੂੰ ਇਸਦੀ ਘੋਸ਼ਣਾ ਤੋਂ ਪਹਿਲਾਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਟਾਕਰੇ ਵਿੱਚ, let ਨੂੰ ਵੀ ਲਹਿਰਾਇਆ ਜਾਂਦਾ ਹੈ, ਪਰ ਇਹ ਸ਼ੁਰੂ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ ਏ let ਇਸਦੀ ਘੋਸ਼ਣਾ ਤੋਂ ਪਹਿਲਾਂ ਵੇਰੀਏਬਲ ਦੇ ਨਤੀਜੇ ਵਜੋਂ a ReferenceError.

ਇਸ ਤੋਂ ਇਲਾਵਾ, let ਲੂਪਸ ਵਿੱਚ ਬੰਦ ਹੋਣ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ var ਇੱਕ ਲੂਪ ਵਿੱਚ, ਸਾਰੇ ਦੁਹਰਾਓ ਇੱਕੋ ਵੇਰੀਏਬਲ ਦਾ ਹਵਾਲਾ ਦਿੰਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਬੱਗ ਹੋ ਸਕਦੇ ਹਨ। ਹਾਲਾਂਕਿ, let ਹਰੇਕ ਦੁਹਰਾਅ ਲਈ ਇੱਕ ਨਵੀਂ ਬਾਈਡਿੰਗ ਬਣਾਉਂਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਹਰੇਕ ਲੂਪ ਦੁਹਰਾਅ ਦਾ ਆਪਣਾ ਦਾਇਰਾ ਹੈ। ਇਹ ਵਿਵਹਾਰ ਕਰਦਾ ਹੈ let ਲੂਪਸ ਦੇ ਅੰਦਰ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ ਇੱਕ ਸੁਰੱਖਿਅਤ ਅਤੇ ਵਧੇਰੇ ਅਨੁਮਾਨ ਲਗਾਉਣ ਯੋਗ ਵਿਕਲਪ।

JavaScript ਵਿੱਚ 'let' ਅਤੇ 'var' ਬਾਰੇ ਆਮ ਸਵਾਲ

JavaScript ਵਿੱਚ ਲਹਿਰਾਉਣਾ ਕੀ ਹੈ?
ਘੋਸ਼ਣਾ ਨੂੰ ਮੌਜੂਦਾ ਦਾਇਰੇ ਦੇ ਸਿਖਰ 'ਤੇ ਲਿਜਾਣ ਦਾ JavaScript ਦਾ ਡਿਫਾਲਟ ਵਿਵਹਾਰ ਹੈ। var ਘੋਸ਼ਣਾਵਾਂ ਨੂੰ ਲਹਿਰਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਨਾਲ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ undefined, ਜਦਕਿ let ਘੋਸ਼ਣਾਵਾਂ ਲਹਿਰਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ ਪਰ ਸ਼ੁਰੂ ਨਹੀਂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ।
ਕੀ ਹੁੰਦਾ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਏ let ਇਸਦੀ ਘੋਸ਼ਣਾ ਤੋਂ ਪਹਿਲਾਂ ਵੇਰੀਏਬਲ?
ਪਹੁੰਚਣਾ ਏ 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 ਨੇ ਡਿਵੈਲਪਰਾਂ ਨੂੰ JavaScript ਵਿੱਚ ਵੇਰੀਏਬਲ ਘੋਸ਼ਣਾ ਲਈ ਇੱਕ ਵਧੇਰੇ ਮਜ਼ਬੂਤ ਟੂਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਹੈ। ਵਿਚਕਾਰ ਅੰਤਰ ਨੂੰ ਸਮਝਣਾ let ਅਤੇ var ਕਲੀਨਰ, ਵਧੇਰੇ ਰੱਖ-ਰਖਾਅ ਯੋਗ ਕੋਡ ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ। ਜਦਕਿ var ਕੁਝ ਸਥਿਤੀਆਂ ਵਿੱਚ ਅਜੇ ਵੀ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ, let ਸਕੋਪ ਅਤੇ ਲਹਿਰਾਉਣ 'ਤੇ ਬਿਹਤਰ ਨਿਯੰਤਰਣ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ, ਬੱਗ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ।

ਚੁਣ ਕੇ let ਵੱਧ var ਢੁਕਵੇਂ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ, ਡਿਵੈਲਪਰ ਬਲਾਕ-ਸਕੋਪਿੰਗ ਦਾ ਫਾਇਦਾ ਉਠਾ ਸਕਦੇ ਹਨ ਅਤੇ ਵੇਰੀਏਬਲ ਘੋਸ਼ਣਾ ਅਤੇ ਲਹਿਰਾਉਣ ਨਾਲ ਜੁੜੀਆਂ ਆਮ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚ ਸਕਦੇ ਹਨ। ਇਹ ਗਿਆਨ ਆਧੁਨਿਕ JavaScript ਵਿਕਾਸ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨ ਵਾਲੇ ਕਿਸੇ ਵੀ ਵਿਅਕਤੀ ਲਈ ਬੁਨਿਆਦੀ ਹੈ।

JavaScript ਵਿੱਚ "let" ਅਤੇ "var" ਵਿਚਕਾਰ ਅੰਤਰ ਨੂੰ ਸਮਝਣਾ