புரிந்துகொள்வது !!

Arthur Petit

வியாழன், 20 ஜூன், 2024 ’அன்று’ முற்பகல் 2:03:13

டபுள் நாட் ஆபரேட்டருக்கு அறிமுகம்

தி !! (இரட்டை இல்லை) ஜாவாஸ்கிரிப்டில் ஆபரேட்டர் முதல் பார்வையில் அசாதாரணமாகத் தோன்றலாம். இது ஒரு மதிப்பை அதனுடன் தொடர்புடைய பூலியன் பிரதிநிதித்துவத்திற்கு மாற்ற பயன்படுகிறது, அந்த மதிப்பு உண்மையா அல்லது தவறானதா என்பதை உறுதிப்படுத்துகிறது. பூலியன் விளைவுக்கு உத்தரவாதம் அளிப்பதன் மூலம் தர்க்கத்தை எளிமைப்படுத்த இந்த நுட்பம் பெரும்பாலும் நிபந்தனை வெளிப்பாடுகளில் பயன்படுத்தப்படுகிறது.

உதாரணமாக, குறியீடு துணுக்கில் இது. செங்குத்து = செங்குத்து !== வரையறுக்கப்படவில்லை ? !!செங்குத்து : this.vertical;, டபுள் நாட் ஆபரேட்டர் என்பதை உறுதி செய்வதற்காகப் பயன்படுத்தப்படுகிறார் செங்குத்து மாறி வரையறுக்கப்பட்டால் பூலியன் மதிப்பாக மாற்றப்படும். இந்த கட்டுரையில் அது எப்படி என்பது பற்றிய விவரங்களை ஆராயும் !! ஆபரேட்டர் வேலை செய்கிறது மற்றும் ஜாவாஸ்கிரிப்ட் மேம்பாட்டில் இது ஏன் பயனுள்ளதாக இருக்கும்.

கட்டளை	விளக்கம்
!!value	மதிப்பை பூலியனாக மாற்றுகிறது. மதிப்பு உண்மையாக இருந்தால், அது உண்மையாக இருக்கும்; பொய்யானால், அது பொய்யாகத் திரும்பும்.
value !== undefined	மதிப்பு வரையறுக்கப்படவில்லை என்பதைச் சரிபார்த்து, மதிப்பு வெளிப்படையாக அமைக்கப்பட்டிருப்பதை உறுதிசெய்கிறது.
console.log()	பிழைத்திருத்த நோக்கங்களுக்காக வலை கன்சோலுக்கு ஒரு செய்தியை வெளியிடுகிறது.
require('http')	HTTP தொகுதியை உள்ளடக்கியது, இது Node.js ஐ HTTP வழியாக தரவை மாற்ற அனுமதிக்கிறது.
http.createServer()	ஒரு குறிப்பிட்ட போர்ட்டில் கோரிக்கைகளைக் கேட்கும் HTTP சேவையகத்தை உருவாக்குகிறது.
server.listen()	HTTP சேவையகத்தைத் தொடங்கி, குறிப்பிட்ட போர்ட்டில் உள்வரும் கோரிக்கைகளைக் கேட்கத் தொடங்குகிறது.

ஸ்கிரிப்ட்களில் டபுள் நாட் ஆபரேட்டரின் பயன்பாட்டைப் புரிந்துகொள்வது

முன்பக்கம் ஸ்கிரிப்ட் உதாரணம் எப்படி என்பதை நிரூபிக்கிறது double not operator ( !! ) எந்த மதிப்பையும் பூலியனாக மாற்ற ஜாவாஸ்கிரிப்ட்டில் பயன்படுத்தப்படுகிறது. விழாவில் 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 செயல்பாடு. இந்த அமைப்பானது, சர்வர் பக்க சூழலில் மதிப்புகளை பூலியன்களாக மாற்றுவதன் நடைமுறைப் பயன்பாட்டைக் காட்டுகிறது, மாறி கையாளுதலில் உறுதியையும் தெளிவையும் வழங்குகிறது.

ஜாவாஸ்கிரிப்டில் டபுள் நாட் ஆபரேட்டரை (!!) ஆராய்கிறது

ஜாவாஸ்கிரிப்ட் ஃப்ரண்டெண்ட் ஸ்கிரிப்ட் உதாரணம்

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

ஜாவாஸ்கிரிப்டில் டபுள் நாட் ஆபரேட்டரில் ஆழமாக மூழ்கவும்

தி double not operator (!!) ஜாவாஸ்கிரிப்டில் எந்த மதிப்பையும் அதன் பூலியன் சமமானதாக மாற்றுவதற்கான ஒரு சுருக்கமான வழி. ஒரு மதிப்பு கண்டிப்பாக பூலியன் என்பதை உறுதி செய்ய வேண்டிய போது இந்த ஆபரேட்டர் மிகவும் பயனுள்ளதாக இருக்கும். ஒரு இயக்குனராக இல்லாத போது (!) ஒரு மதிப்பின் உண்மைத்தன்மையை மாற்றுகிறது (உண்மையான மதிப்புகளை மாற்றுகிறது false மற்றும் தவறான மதிப்புகள் true), செகண்ட் அல்லாத ஆபரேட்டரைப் பயன்படுத்துதல் (!!) மதிப்பை அதன் அசல் உண்மைக்கு மீண்டும் மாற்றுகிறது ஆனால் பூலியன். குறியீடு தர்க்கத்திற்கு ஒரு உறுதியான தேவை இருக்கும் சூழ்நிலைகளில் இது மிகவும் பயனுள்ளதாக இருக்கும் true அல்லது false தெளிவின்மை இல்லாமல். பொதுவான பயன்பாட்டு நிகழ்வுகளில் நிபந்தனை அறிக்கைகள் மற்றும் வகை சரிபார்ப்பு ஆகியவை அடங்கும்.

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

டபுள் நாட் ஆபரேட்டர் பற்றி அடிக்கடி கேட்கப்படும் கேள்விகள்

என்ன செய்கிறது !! ஆபரேட்டர் ஜாவாஸ்கிரிப்டில் செய்யலாமா?
தி !! ஆபரேட்டர் ஒரு மதிப்பை அதன் பூலியன் சமமானதாக மாற்றுகிறது, திரும்பும் true உண்மை மதிப்புகள் மற்றும் false தவறான மதிப்புகளுக்கு.
ஏன் பயன்படுத்த வேண்டும் !! பூலியன்()க்குப் பதிலாக ஆபரேட்டர்
தி !! ஆபரேட்டர் குறுகியது மற்றும் ஜாவாஸ்கிரிப்ட் டெவலப்பர்களுக்கு மிகவும் படிக்கக்கூடிய மற்றும் முட்டாள்தனமாக கருதப்படுகிறது.
முடியும் !! எந்த தரவு வகையிலும் பயன்படுத்தப்படுமா?
ஆம், தி !! ஆபரேட்டரை ஜாவாஸ்கிரிப்டில் எந்த தரவு வகையிலும் பயன்படுத்தலாம், அதை பூலியனாக மாற்றலாம்.
எப்படி செய்கிறது !! பூஜ்ய மற்றும் வரையறுக்கப்படாத மதிப்புகளைக் கையாளவா?
இரண்டும் null மற்றும் undefined என மாற்றப்படுகின்றன false பயன்படுத்தும் போது !! இயக்குபவர்.
பயன்படுத்துவதில் செயல்திறன் நன்மை உள்ளதா !!?
பயன்படுத்தி !! சிக்கலான சோதனைகள் மற்றும் மாற்றங்களைத் தவிர்ப்பதன் மூலம் தூய்மையான மற்றும் வேகமான குறியீட்டிற்கு வழிவகுக்கும்.
சில பொதுவான பயன்பாட்டு வழக்குகள் எவை !!?
உள்ளீடு சரிபார்ப்பு, நிபந்தனை சரிபார்ப்புகள் மற்றும் தருக்க வெளிப்பாடுகளில் பூலியன் மதிப்புகளை உறுதி செய்தல் ஆகியவை பொதுவான பயன்பாட்டு நிகழ்வுகளில் அடங்கும்.
முடியும் !! மற்ற ஆபரேட்டர்களுடன் இணைந்து பயன்படுத்தப்படுமா?
ஆம், குறியீட்டில் உள்ள தருக்க நிலைமைகளை எளிமைப்படுத்தவும் தெளிவுபடுத்தவும் மற்ற ஆபரேட்டர்களுடன் இதைப் பயன்படுத்தலாம்.
இருக்கிறது !! ஜாவாஸ்கிரிப்டில் நல்ல பயிற்சியாக கருதப்படுகிறதா?
ஆம், பயன்படுத்தி !! மதிப்புகளை பூலியன்களாக மாற்றுவதற்கான ஒரு நல்ல நடைமுறையாகக் கருதப்படுகிறது, குறியீட்டை மேலும் படிக்கக்கூடியதாகவும் சுருக்கமாகவும் ஆக்குகிறது.
பயன்படுத்துவதற்கு ஏதேனும் மாற்று வழிகள் உள்ளதா !!?
மாற்றுகளில் பயன்படுத்துவது அடங்கும் Boolean() செயல்பாடு, ஆனால் !! பெரும்பாலும் அதன் சுருக்கத்திற்காக விரும்பப்படுகிறது.

டபுள் நாட் ஆபரேட்டர் விவாதத்தை முடித்தல்

டபுள் நாட் ஆபரேட்டர் (!!) என்பது ஜாவாஸ்கிரிப்டில் மதிப்புகளை பூலியன்களாக மாற்றுவதற்கான சக்திவாய்ந்த கருவியாகும். அதன் முதன்மை நோக்கம் பூலியன் செயல்பாடுகளில் தெளிவு மற்றும் துல்லியத்தை உறுதி செய்வதாகும், மேலும் குறியீட்டை மேலும் படிக்கக்கூடியதாகவும் பிழைத்திருத்தத்தை எளிதாக்கவும் செய்கிறது. புரிந்து செயல்படுத்துவதன் மூலம் !! ஆபரேட்டர், டெவலப்பர்கள் மிகவும் திறமையான மற்றும் சுருக்கமான குறியீட்டை எழுத முடியும், இது தருக்க பிழைகள் சாத்தியத்தை குறைக்கிறது. பூலியன் மதிப்புகள் தேவைப்படும் சூழ்நிலைகளில் இந்த ஆபரேட்டர் மிகவும் பயனுள்ளதாக இருக்கும், பூலியன் சூழலில் பல்வேறு வகையான தரவைக் கையாள ஒரு நேரடியான முறையை வழங்குகிறது.

புரிந்துகொள்வது !! (இரட்டை இல்லை) ஜாவாஸ்கிரிப்டில் ஆபரேட்டர்