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	ਇੱਕ ਬਲਾਕ-ਸਕੋਪਡ ਲੋਕਲ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਵਿਕਲਪਿਕ ਤੌਰ 'ਤੇ ਇਸਨੂੰ ਇੱਕ ਮੁੱਲ ਵਿੱਚ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ। ਇਸ ਨੂੰ ਉਸੇ ਦਾਇਰੇ ਵਿੱਚ ਦੁਬਾਰਾ ਘੋਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ।
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 ਅਸਲ-ਸੰਸਾਰ ਦੇ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ.

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

ਸਕੋਪ ਅਤੇ ਹੋਸਟਿੰਗ ਵਿੱਚ ਡੂੰਘੀ ਡੁਬਕੀ

ਤੁਲਨਾ ਕਰਨ ਵੇਲੇ ਵਿਚਾਰ ਕਰਨ ਲਈ ਇਕ ਹੋਰ ਮੁੱਖ ਪਹਿਲੂ ਅਤੇ ਲਹਿਰਾ ਰਿਹਾ ਹੈ। ਹੋਸਟਿੰਗ ਮੌਜੂਦਾ ਦਾਇਰੇ ਦੇ ਸਿਖਰ 'ਤੇ ਘੋਸ਼ਣਾਵਾਂ ਨੂੰ ਲਿਜਾਣ ਦਾ JavaScript ਦਾ ਵਿਵਹਾਰ ਹੈ। ਨਾਲ , ਵੇਰੀਏਬਲ ਨੂੰ ਲਹਿਰਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਨਾਲ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ undefined, ਜਿਸ ਨਾਲ ਅਣਕਿਆਸੇ ਨਤੀਜੇ ਨਿਕਲ ਸਕਦੇ ਹਨ ਜੇਕਰ ਵੇਰੀਏਬਲ ਨੂੰ ਇਸਦੀ ਘੋਸ਼ਣਾ ਤੋਂ ਪਹਿਲਾਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਟਾਕਰੇ ਵਿੱਚ, ਨੂੰ ਵੀ ਲਹਿਰਾਇਆ ਜਾਂਦਾ ਹੈ, ਪਰ ਇਹ ਸ਼ੁਰੂ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ ਏ ਇਸਦੀ ਘੋਸ਼ਣਾ ਤੋਂ ਪਹਿਲਾਂ ਵੇਰੀਏਬਲ ਦੇ ਨਤੀਜੇ ਵਜੋਂ a .

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

JavaScript ਵਿੱਚ ਲਹਿਰਾਉਣਾ ਕੀ ਹੈ?
ਘੋਸ਼ਣਾ ਨੂੰ ਮੌਜੂਦਾ ਦਾਇਰੇ ਦੇ ਸਿਖਰ 'ਤੇ ਲਿਜਾਣ ਦਾ JavaScript ਦਾ ਡਿਫਾਲਟ ਵਿਵਹਾਰ ਹੈ। ਘੋਸ਼ਣਾਵਾਂ ਨੂੰ ਲਹਿਰਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਨਾਲ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ , ਜਦਕਿ ਘੋਸ਼ਣਾਵਾਂ ਲਹਿਰਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ ਪਰ ਸ਼ੁਰੂ ਨਹੀਂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ।
ਕੀ ਹੁੰਦਾ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਏ ਇਸਦੀ ਘੋਸ਼ਣਾ ਤੋਂ ਪਹਿਲਾਂ ਵੇਰੀਏਬਲ?
ਪਹੁੰਚਣਾ ਏ ਇਸ ਦੇ ਘੋਸ਼ਣਾ ਤੋਂ ਪਹਿਲਾਂ ਵੇਰੀਏਬਲ ਨਤੀਜੇ ਵਜੋਂ a .
ਸਕਦਾ ਹੈ ਅਤੇ ਉਸੇ ਦਾਇਰੇ ਵਿੱਚ ਮੁੜ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇ?
ਨਹੀਂ, ਨੂੰ ਉਸੇ ਦਾਇਰੇ ਵਿੱਚ ਦੁਬਾਰਾ ਘੋਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਉਸੇ ਦਾਇਰੇ ਵਿੱਚ ਮੁੜ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
ਕਿਉਂ ਹੈ ਲੂਪਸ ਵਿੱਚ ਤਰਜੀਹ?
ਲੂਪ ਦੇ ਹਰੇਕ ਦੁਹਰਾਅ ਲਈ ਇੱਕ ਨਵੀਂ ਬਾਈਡਿੰਗ ਬਣਾਉਂਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਹਰੇਕ ਲੂਪ ਦੁਹਰਾਅ ਦਾ ਆਪਣਾ ਸਕੋਪ ਹੈ। ਇਹ ਬੰਦ ਹੋਣ ਨਾਲ ਜੁੜੇ ਆਮ ਬੱਗਾਂ ਨੂੰ ਰੋਕਦਾ ਹੈ।
ਕਰਦਾ ਹੈ ਆਦਰ ਬਲਾਕ ਸਕੋਪ?
ਨਹੀਂ, ਬਲਾਕ ਸਕੋਪ ਦਾ ਆਦਰ ਨਹੀਂ ਕਰਦਾ; ਇਹ ਫੰਕਸ਼ਨ-ਸਕੋਪਡ ਜਾਂ ਗਲੋਬਲੀ-ਸਕੋਪਡ ਹੈ।
ਟੈਂਪੋਰਲ ਡੈੱਡ ਜ਼ੋਨ ਕੀ ਹੈ?
ਟੈਂਪੋਰਲ ਡੈੱਡ ਜ਼ੋਨ ਸਕੋਪ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਅਤੇ ਵੇਰੀਏਬਲ ਦੀ ਅਸਲ ਘੋਸ਼ਣਾ ਦੇ ਵਿਚਕਾਰ ਦਾ ਸਮਾਂ ਹੈ, ਜਿਸ ਦੌਰਾਨ ਇੱਕ ਐਕਸੈਸ ਕਰਨਾ ਵੇਰੀਏਬਲ a ਸੁੱਟ ਦੇਵੇਗਾ .
ਸਕਦਾ ਹੈ ਦੇ ਸਮਾਨ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ?
ਹਾਂ, ਵਰਗਾ ਬਲਾਕ-ਸਕੋਪ ਹੈ , ਪਰ ਇਸਦੀ ਵਰਤੋਂ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਦੁਬਾਰਾ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
ਕਦੋਂ ਚਾਹੀਦਾ ਹੈ ਵੱਧ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ?
ਵੱਧ ਵਰਤਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਜਦੋਂ ਤੁਹਾਨੂੰ ਬਲਾਕ ਸਕੋਪ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਅਤੇ ਵੇਰੀਏਬਲ ਹੋਸਟਿੰਗ ਅਤੇ ਬੰਦ ਹੋਣ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚਣ ਲਈ।

ਵੇਰੀਏਬਲ ਘੋਸ਼ਣਾਵਾਂ 'ਤੇ ਅੰਤਿਮ ਵਿਚਾਰ

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

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

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

ਅਭਿਆਸ ਵਿੱਚ "ਲਓ" ਅਤੇ "ਵਰ" ਵਿੱਚ ਅੰਤਰ ਕਿਵੇਂ ਹੈ

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

"let" ਅਤੇ "var" ਨਾਲ ਸਕੋਪਿੰਗ ਨੂੰ ਸਮਝਣਾ

ਸਕੋਪ ਅਤੇ ਹੋਸਟਿੰਗ ਵਿੱਚ ਡੂੰਘੀ ਡੁਬਕੀ

ਵੇਰੀਏਬਲ ਘੋਸ਼ਣਾਵਾਂ 'ਤੇ ਅੰਤਿਮ ਵਿਚਾਰ