ಡಬಲ್ ನಾಟ್ ಆಪರೇಟರ್‌ಗೆ ಪರಿಚಯ
ದಿ !! (ಡಬಲ್ ಅಲ್ಲ) JavaScript ನಲ್ಲಿ ಆಪರೇಟರ್ ಮೊದಲ ನೋಟದಲ್ಲಿ ಅಸಾಮಾನ್ಯವಾಗಿ ಕಾಣಿಸಬಹುದು. ಮೌಲ್ಯವನ್ನು ಅದರ ಅನುಗುಣವಾದ ಬೂಲಿಯನ್ ಪ್ರಾತಿನಿಧ್ಯಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಮೌಲ್ಯವು ಸರಿ ಅಥವಾ ತಪ್ಪಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಬೂಲಿಯನ್ ಫಲಿತಾಂಶವನ್ನು ಖಾತರಿಪಡಿಸುವ ಮೂಲಕ ತರ್ಕವನ್ನು ಸರಳೀಕರಿಸಲು ಈ ತಂತ್ರವನ್ನು ಷರತ್ತುಬದ್ಧ ಅಭಿವ್ಯಕ್ತಿಗಳಲ್ಲಿ ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.
ಉದಾಹರಣೆಗೆ, ಕೋಡ್ ತುಣುಕಿನಲ್ಲಿ this.vertical = ಲಂಬ !== undefined ? !!ಲಂಬ : ಈ.ವರ್ಟಿಕಲ್;ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಡಬಲ್ ನಾಟ್ ಆಪರೇಟರ್ ಅನ್ನು ನೇಮಿಸಲಾಗಿದೆ ಲಂಬವಾದ ವೇರಿಯೇಬಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ ಅದನ್ನು ಬೂಲಿಯನ್ ಮೌಲ್ಯಕ್ಕೆ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ. ಈ ಲೇಖನವು ಹೇಗೆ ಎಂಬುದರ ನಿಶ್ಚಿತಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ !! ಆಪರೇಟರ್ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಇದು ಏಕೆ ಉಪಯುಕ್ತವಾಗಿದೆ.
| ಆಜ್ಞೆ | ವಿವರಣೆ |
|---|---|
| !!value | ಮೌಲ್ಯವನ್ನು ಬೂಲಿಯನ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಮೌಲ್ಯವು ಸತ್ಯವಾಗಿದ್ದರೆ, ಅದು ನಿಜವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ; ತಪ್ಪಾಗಿದ್ದರೆ, ಅದು ಸುಳ್ಳು ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. |
| value !== undefined | ಮೌಲ್ಯವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಮೌಲ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸದಿದ್ದರೆ ಪರಿಶೀಲಿಸುತ್ತದೆ. |
| console.log() | ವೆಬ್ ಕನ್ಸೋಲ್‌ಗೆ ಸಂದೇಶವನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ, ಡೀಬಗ್ ಮಾಡುವ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. |
| require('http') | HTTP ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ, ಇದು HTTP ಮೂಲಕ ಡೇಟಾವನ್ನು ವರ್ಗಾಯಿಸಲು Node.js ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ. |
| 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 ಕಾರ್ಯ. ಈ ಸೆಟಪ್ ಸರ್ವರ್-ಸೈಡ್ ಸನ್ನಿವೇಶದಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಬೂಲಿಯನ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸುವ ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಯನ್ನು ತೋರಿಸುತ್ತದೆ, ವೇರಿಯಬಲ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್‌ನಲ್ಲಿ ದೃಢತೆ ಮತ್ತು ಸ್ಪಷ್ಟತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಡಬಲ್ ನಾಟ್ ಆಪರೇಟರ್ (!!) ಎಕ್ಸ್‌ಪ್ಲೋರಿಂಗ್
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫ್ರಂಟೆಂಡ್ ಸ್ಕ್ರಿಪ್ಟ್ ಉದಾಹರಣೆ
// 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: truesetVertical(0); // Vertical is set to: falsesetVertical(undefined); // Vertical remains unchanged</script></body></html>
Node.js ನಲ್ಲಿ ಡಬಲ್ ನಾಟ್ ಆಪರೇಟರ್ (!!) ನ ಬ್ಯಾಕೆಂಡ್ ಇಂಪ್ಲಿಮೆಂಟೇಶನ್
Node.js ಬ್ಯಾಕೆಂಡ್ ಸ್ಕ್ರಿಪ್ಟ್ ಉದಾಹರಣೆ
// Node.js scriptconst 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: truesetVertical(0); // Vertical is set to: falsesetVertical(undefined); // Vertical remains unchangedres.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 ತಪ್ಪು ಮೌಲ್ಯಗಳಿಗಾಗಿ.
- ಏಕೆ ಬಳಸಬೇಕು !! ಬೂಲಿಯನ್ () ಬದಲಿಗೆ ಆಪರೇಟರ್
- ದಿ !! ಆಪರೇಟರ್ ಚಿಕ್ಕದಾಗಿದೆ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ಭಾಷಾವೈಶಿಷ್ಟ್ಯವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.
- ಮಾಡಬಹುದು !! ಯಾವುದೇ ಡೇಟಾ ಪ್ರಕಾರದೊಂದಿಗೆ ಬಳಸಬಹುದೇ?
- ಹೌದು, ದಿ !! ಆಪರೇಟರ್ ಅನ್ನು JavaScript ನಲ್ಲಿ ಯಾವುದೇ ಡೇಟಾ ಪ್ರಕಾರದೊಂದಿಗೆ ಬಳಸಬಹುದು, ಅದನ್ನು ಬೂಲಿಯನ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.
- ಹೇಗೆ ಮಾಡುತ್ತದೆ !! ಶೂನ್ಯ ಮತ್ತು ವ್ಯಾಖ್ಯಾನಿಸದ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುವುದೇ?
- ಎರಡೂ null ಮತ್ತು undefined ಆಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ false ಬಳಸುವಾಗ !! ಆಪರೇಟರ್.
- ಬಳಸುವುದರಿಂದ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪ್ರಯೋಜನವಿದೆಯೇ !!?
- ಬಳಸಿ !! ಸಂಕೀರ್ಣ ತಪಾಸಣೆ ಮತ್ತು ಪರಿವರ್ತನೆಗಳನ್ನು ತಪ್ಪಿಸುವ ಮೂಲಕ ಕ್ಲೀನರ್ ಮತ್ತು ಸಂಭಾವ್ಯ ವೇಗದ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗಬಹುದು.
- ಕೆಲವು ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು ಯಾವುವು !!?
- ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಪ್ರಕರಣಗಳಲ್ಲಿ ಇನ್‌ಪುಟ್ ಮೌಲ್ಯೀಕರಣ, ಷರತ್ತುಬದ್ಧ ಪರಿಶೀಲನೆಗಳು ಮತ್ತು ತಾರ್ಕಿಕ ಅಭಿವ್ಯಕ್ತಿಗಳಲ್ಲಿ ಬೂಲಿಯನ್ ಮೌಲ್ಯಗಳನ್ನು ಖಾತ್ರಿಪಡಿಸುವುದು ಸೇರಿವೆ.
- ಮಾಡಬಹುದು !! ಇತರ ನಿರ್ವಾಹಕರ ಜೊತೆಯಲ್ಲಿ ಬಳಸಬಹುದೇ?
- ಹೌದು, ಕೋಡ್‌ನಲ್ಲಿ ತಾರ್ಕಿಕ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ಸರಳೀಕರಿಸಲು ಮತ್ತು ಸ್ಪಷ್ಟಪಡಿಸಲು ಇತರ ಆಪರೇಟರ್‌ಗಳ ಜೊತೆಗೆ ಇದನ್ನು ಬಳಸಬಹುದು.
- ಇದೆ !! ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಉತ್ತಮ ಅಭ್ಯಾಸವೆಂದು ಪರಿಗಣಿಸಲಾಗಿದೆಯೇ?
- ಹೌದು, ಬಳಸುವುದು !! ಮೌಲ್ಯಗಳನ್ನು ಬೂಲಿಯನ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸವೆಂದು ಪರಿಗಣಿಸಲಾಗಿದೆ, ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸುತ್ತದೆ.
- ಬಳಸಲು ಯಾವುದೇ ಪರ್ಯಾಯಗಳಿವೆಯೇ !!?
- ಪರ್ಯಾಯಗಳು ಬಳಕೆಯನ್ನು ಒಳಗೊಂಡಿವೆ Boolean() ಕಾರ್ಯ, ಆದರೆ !! ಅದರ ಸಂಕ್ಷಿಪ್ತತೆಗಾಗಿ ಹೆಚ್ಚಾಗಿ ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ.
ಡಬಲ್ ನಾಟ್ ಆಪರೇಟರ್ ಚರ್ಚೆಯನ್ನು ಸುತ್ತಿಕೊಳ್ಳುವುದು
ಡಬಲ್ ನಾಟ್ ಆಪರೇಟರ್ (!!) ಮೌಲ್ಯಗಳನ್ನು ಬೂಲಿಯನ್‌ಗಳಿಗೆ ಪರಿವರ್ತಿಸಲು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಪ್ರಬಲ ಸಾಧನವಾಗಿದೆ. ಬೂಲಿಯನ್ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಸ್ಪಷ್ಟತೆ ಮತ್ತು ನಿಖರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಇದರ ಪ್ರಾಥಮಿಕ ಉದ್ದೇಶವಾಗಿದೆ, ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲದು ಮತ್ತು ಡೀಬಗ್ ಮಾಡಲು ಸುಲಭವಾಗುತ್ತದೆ. ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ !! ಆಪರೇಟರ್, ಡೆವಲಪರ್‌ಗಳು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ಕೋಡ್ ಅನ್ನು ಬರೆಯಬಹುದು, ಇದು ತಾರ್ಕಿಕ ದೋಷಗಳ ಸಂಭಾವ್ಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಬೂಲಿಯನ್ ಮೌಲ್ಯಗಳು ಅಗತ್ಯವಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಈ ಆಪರೇಟರ್ ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಬೂಲಿಯನ್ ಸಂದರ್ಭದಲ್ಲಿ ವಿವಿಧ ರೀತಿಯ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು ನೇರವಾದ ವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ.