ਦੀ ਸਮਝ !! (ਡਬਲ ਨਹੀਂ) JavaScript

Arthur Petit

ਵੀਰਵਾਰ, 20 ਜੂਨ 2024 1:41:02 ਪੂ.ਦੁ.

ਡਬਲ ਨਾਟ ਆਪਰੇਟਰ ਨਾਲ ਜਾਣ-ਪਛਾਣ

ਦੀ !! (ਡਬਲ ਨਹੀਂ) JavaScript ਵਿੱਚ ਓਪਰੇਟਰ ਪਹਿਲੀ ਨਜ਼ਰ ਵਿੱਚ ਅਸਾਧਾਰਨ ਲੱਗ ਸਕਦਾ ਹੈ। ਇਹ ਇੱਕ ਮੁੱਲ ਨੂੰ ਇਸਦੇ ਅਨੁਸਾਰੀ ਬੂਲੀਅਨ ਪ੍ਰਤੀਨਿਧਤਾ ਵਿੱਚ ਬਦਲਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਮੁੱਲ ਸਹੀ ਜਾਂ ਗਲਤ ਹੈ। ਇਹ ਤਕਨੀਕ ਅਕਸਰ ਬੂਲੀਅਨ ਨਤੀਜੇ ਦੀ ਗਰੰਟੀ ਦੇ ਕੇ ਤਰਕ ਨੂੰ ਸਰਲ ਬਣਾਉਣ ਲਈ ਸ਼ਰਤੀਆ ਸਮੀਕਰਨਾਂ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।

ਉਦਾਹਰਨ ਲਈ, ਕੋਡ ਸਨਿੱਪਟ ਵਿੱਚ this.vertical = ਲੰਬਕਾਰੀ !== ਪਰਿਭਾਸ਼ਿਤ? !!ਵਰਟੀਕਲ: this.vertical;, ਡਬਲ ਨਾਟ ਓਪਰੇਟਰ ਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਨਿਯੁਕਤ ਕੀਤਾ ਗਿਆ ਹੈ ਕਿ ਲੰਬਕਾਰੀ ਵੇਰੀਏਬਲ ਨੂੰ ਬੂਲੀਅਨ ਮੁੱਲ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ ਜੇਕਰ ਇਸਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਲੇਖ ਇਸ ਬਾਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਜਾਣੂ ਹੋਵੇਗਾ ਕਿ ਕਿਵੇਂ !! ਆਪਰੇਟਰ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਇਹ JavaScript ਵਿਕਾਸ ਵਿੱਚ ਉਪਯੋਗੀ ਕਿਉਂ ਹੈ।

ਹੁਕਮ	ਵਰਣਨ
!!value	ਮੁੱਲ ਨੂੰ ਬੂਲੀਅਨ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। ਜੇਕਰ ਮੁੱਲ ਸੱਚਾ ਹੈ, ਤਾਂ ਇਹ ਸੱਚ ਵਾਪਸ ਆਉਂਦਾ ਹੈ; ਜੇਕਰ ਗਲਤ ਹੈ, ਤਾਂ ਇਹ ਗਲਤ ਵਾਪਸ ਆਉਂਦਾ ਹੈ।
value !== undefined	ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਮੁੱਲ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਮੁੱਲ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ।
console.log()	ਵੈੱਬ ਕੰਸੋਲ ਲਈ ਇੱਕ ਸੁਨੇਹਾ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ, ਡੀਬੱਗਿੰਗ ਉਦੇਸ਼ਾਂ ਲਈ ਉਪਯੋਗੀ।
require('http')	HTTP ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ, ਜੋ Node.js ਨੂੰ HTTP 'ਤੇ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।
http.createServer()	ਇੱਕ HTTP ਸਰਵਰ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਇੱਕ ਖਾਸ ਪੋਰਟ 'ਤੇ ਬੇਨਤੀਆਂ ਨੂੰ ਸੁਣਦਾ ਹੈ।
server.listen()	HTTP ਸਰਵਰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਖਾਸ ਪੋਰਟ 'ਤੇ ਆਉਣ ਵਾਲੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਸੁਣਨਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ।

ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਡਬਲ ਨਾਟ ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਨੂੰ ਸਮਝਣਾ

ਫਰੰਟਐਂਡ ਸਕ੍ਰਿਪਟ ਉਦਾਹਰਨ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਕਿਵੇਂ double not operator ( !! ) ਕਿਸੇ ਵੀ ਮੁੱਲ ਨੂੰ ਬੁਲੀਅਨ ਵਿੱਚ ਬਦਲਣ ਲਈ JavaScript ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਸਮਾਗਮ ਵਿੱਚ ਸ setVertical, ਪੈਰਾਮੀਟਰ value ਇਹ ਵੇਖਣ ਲਈ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਕੀ ਇਹ ਨਹੀਂ ਹੈ undefined ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ value !== undefined. ਜੇਕਰ ਇਹ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ double not operator 'ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ value, ਇਸ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਬਦਲਣਾ true ਜਾਂ false. ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ vertical ਵੇਰੀਏਬਲ ਨੂੰ ਹਮੇਸ਼ਾ ਇੱਕ ਬੂਲੀਅਨ ਮੁੱਲ 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜੋ ਕੋਡ ਵਿੱਚ ਹੋਰ ਲਾਜ਼ੀਕਲ ਕਾਰਵਾਈਆਂ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ। ਸਕ੍ਰਿਪਟ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਵੀ ਲੌਗ ਕਰਦੀ ਹੈ vertical ਕੰਸੋਲ ਨੂੰ ਸਪਸ਼ਟ ਸਮਝ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਕਿ ਵੇਰੀਏਬਲ ਨੂੰ ਕਿਵੇਂ ਸੈੱਟ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।

Node.js ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਬੈਕਐਂਡ ਸਕ੍ਰਿਪਟ ਉਦਾਹਰਨ ਵਿੱਚ, ਉਹੀ ਤਰਕ HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਸਕ੍ਰਿਪਟ ਆਯਾਤ ਕਰਕੇ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ HTTP module ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ require('http'). ਇੱਕ ਸਰਵਰ ਫਿਰ ਨਾਲ ਬਣਾਇਆ ਗਿਆ ਹੈ http.createServer ਜੋ ਬੇਨਤੀਆਂ ਸੁਣਦਾ ਹੈ। ਬੇਨਤੀ ਹੈਂਡਲਰ ਦੇ ਅੰਦਰ, setVertical ਫੰਕਸ਼ਨ ਨੂੰ ਇਹ ਦਿਖਾਉਣ ਲਈ ਵੱਖ-ਵੱਖ ਮੁੱਲਾਂ ਨਾਲ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ ਕਿ ਕਿਵੇਂ double not operator ਇੱਕ ਬੈਕਐਂਡ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ। ਦ server.listen ਵਿਧੀ ਪੋਰਟ 3000 'ਤੇ ਸਰਵਰ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ, ਅਤੇ ਕਿਸੇ ਵੀ ਬੇਨਤੀ ਨੂੰ /set-vertical ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਟਰਿੱਗਰ ਕਰੋ setVertical ਫੰਕਸ਼ਨ. ਇਹ ਸੈੱਟਅੱਪ ਸਰਵਰ-ਸਾਈਡ ਸੰਦਰਭ ਵਿੱਚ ਮੁੱਲਾਂ ਨੂੰ ਬੁਲੀਅਨਾਂ ਵਿੱਚ ਬਦਲਣ ਦੀ ਵਿਹਾਰਕ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਵੇਰੀਏਬਲ ਹੈਂਡਲਿੰਗ ਵਿੱਚ ਮਜ਼ਬੂਤੀ ਅਤੇ ਸਪਸ਼ਟਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

JavaScript ਵਿੱਚ ਡਬਲ ਨਾਟ ਆਪਰੇਟਰ (!!) ਦੀ ਪੜਚੋਲ ਕਰਨਾ

JavaScript ਫਰੰਟਐਂਡ ਸਕ੍ਰਿਪਟ ਉਦਾਹਰਨ

// HTML part
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Double Not Operator Example</title>
</head>
<body>
    <script>
        let vertical;
        function setVertical(value) {
            vertical = value !== undefined ? !!value : vertical;
            console.log("Vertical is set to:", vertical);
        }
        setVertical(true);  // Vertical is set to: true
        setVertical(0);     // Vertical is set to: false
        setVertical(undefined); // Vertical remains unchanged
    </script>
</body>
</html>

Node.js ਵਿੱਚ ਡਬਲ ਨਾਟ ਆਪਰੇਟਰ (!!) ਦਾ ਬੈਕਐਂਡ ਲਾਗੂ ਕਰਨਾ

Node.js ਬੈਕਐਂਡ ਸਕ੍ਰਿਪਟ ਉਦਾਹਰਨ

// Node.js script
const http = require('http');

let vertical;
function setVertical(value) {
    vertical = value !== undefined ? !!value : vertical;
    console.log("Vertical is set to:", vertical);
}

const server = http.createServer((req, res) => {
    if (req.url === '/set-vertical') {
        setVertical(true);  // Vertical is set to: true
        setVertical(0);     // Vertical is set to: false
        setVertical(undefined); // Vertical remains unchanged
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end('Check console for vertical values.');
    } else {
        res.writeHead(404, { 'Content-Type': 'text/plain' });
        res.end('Not Found');
    }
});

server.listen(3000, () => {
    console.log('Server running at http://localhost:3000/');
});

JavaScript ਵਿੱਚ ਡਬਲ ਨਾਟ ਆਪਰੇਟਰ ਵਿੱਚ ਡੂੰਘੀ ਡੁਬਕੀ ਕਰੋ

ਦ double not operator (!!) JavaScript ਵਿੱਚ ਕਿਸੇ ਵੀ ਮੁੱਲ ਨੂੰ ਇਸਦੇ ਬੂਲੀਅਨ ਬਰਾਬਰ ਵਿੱਚ ਬਦਲਣ ਦਾ ਇੱਕ ਸੰਖੇਪ ਤਰੀਕਾ ਹੈ। ਇਹ ਓਪਰੇਟਰ ਖਾਸ ਤੌਰ 'ਤੇ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਤੁਹਾਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਕਿ ਇੱਕ ਮੁੱਲ ਸਖਤੀ ਨਾਲ ਬੁਲੀਅਨ ਹੈ। ਜਦੋਂ ਕਿ ਇੱਕ ਸਿੰਗਲ ਨਹੀਂ ਓਪਰੇਟਰ (!) ਇੱਕ ਮੁੱਲ ਦੀ ਸੱਚਾਈ ਨੂੰ ਉਲਟਾਉਂਦਾ ਹੈ (ਸੱਚਾਈ ਮੁੱਲਾਂ ਨੂੰ ਬਦਲਦਾ ਹੈ false ਅਤੇ ਝੂਠੇ ਮੁੱਲ true), ਇੱਕ ਦੂਜਾ ਨਾਟ ਆਪਰੇਟਰ ਲਾਗੂ ਕਰਨਾ (!!) ਮੁੱਲ ਨੂੰ ਇਸਦੀ ਅਸਲ ਸੱਚਾਈ ਵਿੱਚ ਮੁੜ-ਉਲਟਾ ਦਿੰਦਾ ਹੈ ਪਰ ਇੱਕ ਬੁਲੀਅਨ ਵਜੋਂ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ ਜਿੱਥੇ ਕੋਡ ਤਰਕ ਨੂੰ ਇੱਕ ਨਿਸ਼ਚਿਤ ਲੋੜ ਹੁੰਦੀ ਹੈ true ਜਾਂ false ਅਸਪਸ਼ਟਤਾ ਦੇ ਬਿਨਾਂ. ਆਮ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਸ਼ਰਤੀਆ ਬਿਆਨ ਅਤੇ ਕਿਸਮ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ।

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

Double Not Operator ਬਾਰੇ ਅਕਸਰ ਪੁੱਛੇ ਜਾਂਦੇ ਸਵਾਲ

ਕੀ ਕਰਦਾ ਹੈ !! ਓਪਰੇਟਰ JavaScript ਵਿੱਚ ਕਰਦੇ ਹਨ?
ਦ !! ਓਪਰੇਟਰ ਇੱਕ ਮੁੱਲ ਨੂੰ ਇਸਦੇ ਬੂਲੀਅਨ ਬਰਾਬਰ ਵਿੱਚ ਬਦਲਦਾ ਹੈ, ਵਾਪਸੀ ਕਰਦਾ ਹੈ true ਸੱਚੇ ਮੁੱਲਾਂ ਲਈ ਅਤੇ false ਝੂਠੇ ਮੁੱਲ ਲਈ.
ਦੀ ਵਰਤੋਂ ਕਿਉਂ ਕਰੋ !! ਬੁਲੀਅਨ () ਦੀ ਬਜਾਏ ਆਪਰੇਟਰ
ਦ !! ਓਪਰੇਟਰ ਛੋਟਾ ਹੁੰਦਾ ਹੈ ਅਤੇ ਅਕਸਰ JavaScript ਡਿਵੈਲਪਰਾਂ ਲਈ ਵਧੇਰੇ ਪੜ੍ਹਨਯੋਗ ਅਤੇ ਮੁਹਾਵਰੇ ਵਾਲਾ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।
ਸਕਦਾ ਹੈ !! ਕਿਸੇ ਵੀ ਡਾਟਾ ਕਿਸਮ ਨਾਲ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ?
ਹਾਂ, ਦ !! ਓਪਰੇਟਰ ਨੂੰ JavaScript ਵਿੱਚ ਕਿਸੇ ਵੀ ਡੇਟਾ ਕਿਸਮ ਦੇ ਨਾਲ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਇਸਨੂੰ ਬੁਲੀਅਨ ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਕਿਵੇਂ ਕਰਦਾ ਹੈ !! ਨਲ ਅਤੇ ਪਰਿਭਾਸ਼ਿਤ ਮੁੱਲਾਂ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ?
ਦੋਵੇਂ null ਅਤੇ undefined ਵਿੱਚ ਤਬਦੀਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ false ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ !! ਆਪਰੇਟਰ
ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਕੋਈ ਪ੍ਰਦਰਸ਼ਨ ਲਾਭ ਹੈ !!?
ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ !! ਗੁੰਝਲਦਾਰ ਜਾਂਚਾਂ ਅਤੇ ਪਰਿਵਰਤਨ ਤੋਂ ਬਚ ਕੇ ਕਲੀਨਰ ਅਤੇ ਸੰਭਾਵੀ ਤੌਰ 'ਤੇ ਤੇਜ਼ ਕੋਡ ਦੀ ਅਗਵਾਈ ਕਰ ਸਕਦਾ ਹੈ।
ਕੁਝ ਆਮ ਵਰਤੋਂ ਦੇ ਕੇਸ ਕੀ ਹਨ !!?
ਆਮ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਇਨਪੁਟ ਪ੍ਰਮਾਣਿਕਤਾ, ਸ਼ਰਤੀਆ ਜਾਂਚਾਂ, ਅਤੇ ਲਾਜ਼ੀਕਲ ਸਮੀਕਰਨਾਂ ਵਿੱਚ ਬੂਲੀਅਨ ਮੁੱਲਾਂ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ ਸ਼ਾਮਲ ਹੈ।
ਸਕਦਾ ਹੈ !! ਹੋਰ ਓਪਰੇਟਰਾਂ ਦੇ ਨਾਲ ਜੋੜ ਕੇ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ?
ਹਾਂ, ਇਹ ਕੋਡ ਵਿੱਚ ਤਰਕਪੂਰਨ ਸਥਿਤੀਆਂ ਨੂੰ ਸਰਲ ਬਣਾਉਣ ਅਤੇ ਸਪਸ਼ਟ ਕਰਨ ਲਈ ਦੂਜੇ ਆਪਰੇਟਰਾਂ ਦੇ ਨਾਲ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਹੈ !! JavaScript ਵਿੱਚ ਚੰਗਾ ਅਭਿਆਸ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ?
ਹਾਂ, ਵਰਤ ਕੇ !! ਮੁੱਲਾਂ ਨੂੰ ਬੂਲੀਅਨ ਵਿੱਚ ਬਦਲਣ ਲਈ ਇੱਕ ਵਧੀਆ ਅਭਿਆਸ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ, ਕੋਡ ਨੂੰ ਵਧੇਰੇ ਪੜ੍ਹਨਯੋਗ ਅਤੇ ਸੰਖੇਪ ਬਣਾਉਣਾ।
ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਕੋਈ ਵਿਕਲਪ ਹਨ !!?
ਵਿਕਲਪਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ Boolean() ਫੰਕਸ਼ਨ, ਪਰ !! ਅਕਸਰ ਇਸਦੀ ਸੰਖੇਪਤਾ ਲਈ ਤਰਜੀਹ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ।

ਡਬਲ ਨਾਟ ਆਪਰੇਟਰ ਚਰਚਾ ਨੂੰ ਸਮੇਟਣਾ

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

ਦੀ ਸਮਝ !! (ਡਬਲ ਨਹੀਂ) JavaScript ਵਿੱਚ ਆਪਰੇਟਰ