ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ವೇರಿಯಬಲ್ ಘೋಷಣೆಗಳನ್ನು ಗ್ರಹಿಸುವುದು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಜಗತ್ತಿನಲ್ಲಿ, ಕ್ಲೀನ್ ಮತ್ತು ದಕ್ಷ ಕೋಡ್ ಬರೆಯಲು ಲೆಟ್ ಮತ್ತು ವರ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ECMAScript 6 ರಲ್ಲಿ ಪರಿಚಯಿಸಲಾಗಿದೆ, ಅವಕಾಶ ಹೇಳಿಕೆಯು ವೇರಿಯಬಲ್ ಘೋಷಣೆಗೆ ಹೊಸ ಆಯಾಮವನ್ನು ಸೇರಿಸಿದೆ, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ವೇರಿಯೇಬಲ್ ವ್ಯಾಪ್ತಿಯ ಮೇಲೆ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣವನ್ನು ಒದಗಿಸುತ್ತದೆ ಎಂದು ವಿವರಿಸಲಾಗಿದೆ.
ಎರಡೂ ಸಂದರ್ಭದಲ್ಲಿ ಅವಕಾಶ ಮತ್ತು var ಅಸ್ಥಿರಗಳನ್ನು ಘೋಷಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ, ಅವು ವಿಭಿನ್ನ ನಡವಳಿಕೆಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತವೆ ಅದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಪರಿಣಾಮ ಬೀರಬಹುದು. ಈ ಲೇಖನದಲ್ಲಿ, ನಾವು ಈ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ ಮತ್ತು ಯಾವಾಗ ಬಳಸಬೇಕೆಂದು ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತೇವೆ ಅವಕಾಶ ಬದಲಾಗಿ var.
| ಆಜ್ಞೆ | ವಿವರಣೆ |
|---|---|
| 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 ನಲ್ಲಿ "ಲೆಟ್" ಮತ್ತು "var" ನಡುವೆ ವ್ಯತ್ಯಾಸ
ಮುಂಭಾಗದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಉದಾಹರಣೆ
// Example demonstrating the difference between 'var' and 'let'function varTest() {var x = 1;if (true) {var x = 2; // same variableconsole.log(x); // 2}console.log(x); // 2}function letTest() {let y = 1;if (true) {let y = 2; // different variableconsole.log(y); // 2}console.log(y); // 1}varTest();letTest();
"ಲೆಟ್" ಮತ್ತು "ವರ್" ನೊಂದಿಗೆ ಸ್ಕೋಪಿಂಗ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ಬ್ಯಾಕೆಂಡ್ 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 overwrittenlet message = "New count is: "; // block-scopedres.write(message + count); // New count is: 20}res.write(message + count); // The count is: 20res.end();}).listen(8080);console.log('Server running at http://127.0.0.1:8080/');
ಸ್ಕೋಪ್ ಮತ್ತು ಹೋಸ್ಟಿಂಗ್‌ಗೆ ಆಳವಾಗಿ ಧುಮುಕುವುದು
ಹೋಲಿಸುವಾಗ ಪರಿಗಣಿಸಬೇಕಾದ ಮತ್ತೊಂದು ಪ್ರಮುಖ ಅಂಶ ಮತ್ತು ಎತ್ತುತ್ತಿದೆ. Hoisting ಎನ್ನುವುದು ಪ್ರಸ್ತುತ ವ್ಯಾಪ್ತಿಯ ಮೇಲಕ್ಕೆ ಘೋಷಣೆಗಳನ್ನು ಚಲಿಸುವ JavaScript ನ ನಡವಳಿಕೆಯಾಗಿದೆ. ಜೊತೆಗೆ , ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಹಾರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಇದರೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ undefined, ವೇರಿಯಬಲ್ ಅನ್ನು ಅದರ ಘೋಷಣೆಯ ಮೊದಲು ಬಳಸಿದರೆ ಇದು ಅನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಸಹ ಹಾರಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ಅದನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿಲ್ಲ. ಇದರರ್ಥ a ಪ್ರವೇಶಿಸುವುದು ಅದರ ಘೋಷಣೆಯ ಮೊದಲು ವೇರಿಯೇಬಲ್ a ಗೆ ಕಾರಣವಾಗುತ್ತದೆ .
ಹೆಚ್ಚುವರಿಯಾಗಿ, ಲೂಪ್‌ಗಳಲ್ಲಿ ಮುಚ್ಚುವಿಕೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಬಳಸುವಾಗ ಲೂಪ್‌ನಲ್ಲಿ, ಎಲ್ಲಾ ಪುನರಾವರ್ತನೆಗಳು ಒಂದೇ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತವೆ, ಇದು ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಆದಾಗ್ಯೂ, ಪ್ರತಿ ಪುನರಾವರ್ತನೆಗೆ ಹೊಸ ಬೈಂಡಿಂಗ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಪ್ರತಿ ಲೂಪ್ ಪುನರಾವರ್ತನೆಯು ತನ್ನದೇ ಆದ ವ್ಯಾಪ್ತಿಯನ್ನು ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ನಡವಳಿಕೆಯು ಮಾಡುತ್ತದೆ let ಲೂಪ್‌ಗಳಲ್ಲಿ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಘೋಷಿಸಲು ಸುರಕ್ಷಿತ ಮತ್ತು ಹೆಚ್ಚು ಊಹಿಸಬಹುದಾದ ಆಯ್ಕೆ.
- ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಎತ್ತುವುದು ಎಂದರೇನು?
- Hoisting ಎನ್ನುವುದು ಪ್ರಸ್ತುತ ವ್ಯಾಪ್ತಿಯ ಮೇಲಕ್ಕೆ ಘೋಷಣೆಗಳನ್ನು ಚಲಿಸುವ JavaScript ನ ಡೀಫಾಲ್ಟ್ ನಡವಳಿಕೆಯಾಗಿದೆ. ಘೋಷಣೆಗಳನ್ನು ಹಾರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ , ಹಾಗೆಯೇ ಘೋಷಣೆಗಳನ್ನು ಹಾರಿಸಲಾಗುತ್ತದೆ ಆದರೆ ಪ್ರಾರಂಭಿಸಲಾಗಿಲ್ಲ.
- ನೀವು ಎ ಬಳಸಿದರೆ ಏನಾಗುತ್ತದೆ ಅದರ ಘೋಷಣೆಯ ಮೊದಲು ವೇರಿಯಬಲ್?
- ಪ್ರವೇಶಿಸಲಾಗುತ್ತಿದೆ a ವೇರಿಯಬಲ್ ಅದರ ಘೋಷಣೆಯ ಮೊದಲು ಫಲಿತಾಂಶವು a .
- ಮಾಡಬಹುದು ಮತ್ತು ಅದೇ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಮರು ಘೋಷಣೆ ಮಾಡಬೇಕೆ?
- ಇಲ್ಲ, ಅದೇ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಮರು-ಘೋಷಣೆ ಮಾಡಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ಅದೇ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಮರು ಘೋಷಣೆ ಮಾಡಬಹುದು.
- ಏಕೆ ಆಗಿದೆ ಲೂಪ್‌ಗಳಲ್ಲಿ ಆದ್ಯತೆ?
- ಲೂಪ್‌ನ ಪ್ರತಿ ಪುನರಾವರ್ತನೆಗೆ ಹೊಸ ಬೈಂಡಿಂಗ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಪ್ರತಿ ಲೂಪ್ ಪುನರಾವರ್ತನೆಯು ತನ್ನದೇ ಆದ ವ್ಯಾಪ್ತಿಯನ್ನು ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಮುಚ್ಚುವಿಕೆಗೆ ಸಂಬಂಧಿಸಿದ ಸಾಮಾನ್ಯ ದೋಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ.
- ಮಾಡುತ್ತದೆ ಬ್ಲಾಕ್ ವ್ಯಾಪ್ತಿಯನ್ನು ಗೌರವಿಸುವುದೇ?
- ಇಲ್ಲ, ಬ್ಲಾಕ್ ವ್ಯಾಪ್ತಿಯನ್ನು ಗೌರವಿಸುವುದಿಲ್ಲ; ಇದು ಕಾರ್ಯ-ವ್ಯಾಪ್ತಿ ಅಥವಾ ಜಾಗತಿಕವಾಗಿ-ವ್ಯಾಪ್ತಿ ಹೊಂದಿದೆ.
- ಟೆಂಪೊರಲ್ ಡೆಡ್ ಝೋನ್ ಎಂದರೇನು?
- ಟೆಂಪೊರಲ್ ಡೆಡ್ ಝೋನ್ ವ್ಯಾಪ್ತಿ ಮತ್ತು ವೇರಿಯೇಬಲ್‌ನ ನಿಜವಾದ ಘೋಷಣೆಯ ನಡುವಿನ ಸಮಯವಾಗಿದೆ, ಈ ಸಮಯದಲ್ಲಿ ಒಂದು ವೇರಿಯೇಬಲ್ ಎ ಎಸೆಯುತ್ತದೆ .
- ಮಾಡಬಹುದು ಅದೇ ರೀತಿ ಬಳಸಬಹುದು ?
- ಹೌದು, ಹಾಗೆ ಬ್ಲಾಕ್ ಸ್ಕೋಪ್ಡ್ ಆಗಿದೆ , ಆದರೆ ಮರುಹಂಚಿಕೆ ಮಾಡಬಾರದೆಂದು ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಘೋಷಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
- ಯಾವಾಗ ಬೇಕು ಮೇಲೆ ಬಳಸಬಹುದು ?
- ಮೇಲೆ ಬಳಸಬೇಕು ನಿಮಗೆ ಬ್ಲಾಕ್ ಸ್ಕೋಪ್ ಅಗತ್ಯವಿರುವಾಗ ಮತ್ತು ವೇರಿಯಬಲ್ ಹೋಸ್ಟಿಂಗ್ ಮತ್ತು ಮುಚ್ಚುವಿಕೆಯೊಂದಿಗೆ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಲು.
ವೇರಿಯಬಲ್ ಘೋಷಣೆಗಳ ಅಂತಿಮ ಆಲೋಚನೆಗಳು
ಕೊನೆಯಲ್ಲಿ, ಪರಿಚಯ ECMAScript 6 ರಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ವೇರಿಯಬಲ್ ಘೋಷಣೆಗಾಗಿ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಹೆಚ್ಚು ದೃಢವಾದ ಸಾಧನವನ್ನು ಒದಗಿಸಿದೆ. ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಕ್ಲೀನರ್, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಬರೆಯಲು ಅತ್ಯಗತ್ಯ. ಹಾಗೆಯೇ var ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಇನ್ನೂ ಉಪಯುಕ್ತವಾಗಬಹುದು, ವ್ಯಾಪ್ತಿ ಮತ್ತು ಎತ್ತುವಿಕೆಯ ಮೇಲೆ ಉತ್ತಮ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತದೆ, ದೋಷಗಳ ಸಾಧ್ಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ಆಯ್ಕೆ ಮಾಡುವ ಮೂಲಕ ಮುಗಿದಿದೆ ಸೂಕ್ತವಾದ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ, ಡೆವಲಪರ್‌ಗಳು ಬ್ಲಾಕ್-ಸ್ಕೋಪಿಂಗ್‌ನ ಲಾಭವನ್ನು ಪಡೆಯಬಹುದು ಮತ್ತು ವೇರಿಯಬಲ್ ಡಿಕ್ಲರೇಶನ್ ಮತ್ತು ಹೈಸ್ಟಿಂಗ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಸಾಮಾನ್ಯ ಮೋಸಗಳನ್ನು ತಪ್ಪಿಸಬಹುದು. ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಲು ಬಯಸುವ ಯಾರಿಗಾದರೂ ಈ ಜ್ಞಾನವು ಮೂಲಭೂತವಾಗಿದೆ.