ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ಪುನರಾವರ್ತನೆಯನ್ನು ಅನ್ವೇಷಿಸಲಾಗುತ್ತಿದೆ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಸ್ತುಗಳು ಪ್ರಮುಖ-ಮೌಲ್ಯದ ಜೋಡಿಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಮೂಲಭೂತವಾಗಿವೆ. ಈ ವಸ್ತುಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಕೀಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಅವುಗಳ ಗುಣಲಕ್ಷಣಗಳ ಮೂಲಕ ಲೂಪ್ ಮಾಡುವ ಅವಶ್ಯಕತೆಯಿದೆ.
ಈ ಟ್ಯುಟೋರಿಯಲ್ JavaScript ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಎಣಿಸುವ ವಿವಿಧ ವಿಧಾನಗಳ ಮೂಲಕ ನಿಮಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ. ನೀವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಹೊಸಬರೇ ಅಥವಾ ನಿಮ್ಮ ಕೌಶಲ್ಯಗಳನ್ನು ಪರಿಷ್ಕರಿಸಲು ನೋಡುತ್ತಿರಲಿ, ಪರಿಣಾಮಕಾರಿ ಕೋಡಿಂಗ್‌ಗಾಗಿ ಈ ತಂತ್ರಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ.
| ಆಜ್ಞೆ | ವಿವರಣೆ |
|---|---|
| for...in | ವಸ್ತುವಿನ ಎಣಿಕೆ ಮಾಡಬಹುದಾದ ಗುಣಲಕ್ಷಣಗಳ ಮೂಲಕ ಲೂಪ್ ಮಾಡುತ್ತದೆ. |
| hasOwnProperty() | ಆಬ್ಜೆಕ್ಟ್ ತನ್ನ ಸ್ವಂತ ಆಸ್ತಿಯಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಆಸ್ತಿಯನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. |
| Object.keys() | ಕೊಟ್ಟಿರುವ ವಸ್ತುವಿನ ಸ್ವಂತ ಎಣಿಕೆ ಮಾಡಬಹುದಾದ ಆಸ್ತಿ ಹೆಸರುಗಳ ಶ್ರೇಣಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. |
| forEach() | ಪ್ರತಿ ರಚನೆಯ ಅಂಶಕ್ಕೆ ಒಮ್ಮೆ ಒದಗಿಸಿದ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. |
| Object.entries() | ಕೊಟ್ಟಿರುವ ವಸ್ತುವಿನ ಸ್ವಂತ ಎಣಿಕೆ ಮಾಡಬಹುದಾದ ಸ್ಟ್ರಿಂಗ್-ಕೀ ಆಸ್ತಿ [ಕೀ, ಮೌಲ್ಯ] ಜೋಡಿಗಳ ಸರಣಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. |
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ಪುನರಾವರ್ತನೆ ತಂತ್ರಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ಒದಗಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು JavaScript ಆಬ್ಜೆಕ್ಟ್‌ನ ಗುಣಲಕ್ಷಣಗಳ ಮೂಲಕ ಪುನರಾವರ್ತಿಸಲು ವಿಭಿನ್ನ ವಿಧಾನಗಳನ್ನು ನೀಡುತ್ತವೆ. ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್ ಎ ಅನ್ನು ಬಳಸುತ್ತದೆ for...in ಲೂಪ್, ಇದು ವಸ್ತುವಿನ ಎಲ್ಲಾ ಎಣಿಕೆಯ ಗುಣಲಕ್ಷಣಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ. ಈ ಲೂಪ್ ಒಳಗೆ, ದಿ hasOwnProperty() ವಸ್ತುವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಆಸ್ತಿಯನ್ನು ತನ್ನದೇ ಆದ ಆಸ್ತಿಯಾಗಿ ಹೊಂದಿದ್ದರೆ ವಿಧಾನ ಪರಿಶೀಲಿಸುತ್ತದೆ, ಆನುವಂಶಿಕ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಸೇರಿಸಲಾಗಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಲಾಗಿಂಗ್ ಅಥವಾ ಮೌಲ್ಯಗಳನ್ನು ಮಾರ್ಪಡಿಸುವಂತಹ ವಸ್ತುವಿನ ಪ್ರತಿಯೊಂದು ಆಸ್ತಿಯ ಮೇಲೆ ನೀವು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕಾದಾಗ ಈ ವಿಧಾನವು ಉಪಯುಕ್ತವಾಗಿದೆ.
ಎರಡನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಹತೋಟಿ Object.keys() ವಿಧಾನ, ಇದು ವಸ್ತುವಿನ ಸ್ವಂತ ಎಣಿಕೆ ಮಾಡಬಹುದಾದ ಆಸ್ತಿ ಹೆಸರುಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ದಿ forEach() ವಿಧಾನವನ್ನು ನಂತರ ಈ ರಚನೆಯ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ, ಗೆ ಹೋಲಿಸಿದರೆ ಸರಳವಾದ ಮತ್ತು ಹೆಚ್ಚು ಓದಬಹುದಾದ ವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ for...in ಲೂಪ್. ಮೂರನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುತ್ತದೆ Object.entries(), ಇದು ವಸ್ತುವಿನ ಸ್ವಂತ ಎಣಿಕೆ ಮಾಡಬಹುದಾದ ಸ್ಟ್ರಿಂಗ್-ಕೀಡ್ ಆಸ್ತಿ [ಕೀ, ಮೌಲ್ಯ] ಜೋಡಿಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಎ for...of ಲೂಪ್ ಅನ್ನು ಈ ಜೋಡಿಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ, ಕೀಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪ್ರವೇಶಿಸಲು ಸಂಕ್ಷಿಪ್ತ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಾಪರ್ಟೀಸ್ ಮೂಲಕ ಲೂಪ್ ಮಾಡುವುದು
JavaScript ES6 ವಿಧಾನಗಳನ್ನು ಬಳಸುವುದು
const p = {"p1": "value1", "p2": "value2", "p3": "value3"};for (const key in p) {if (p.hasOwnProperty(key)) {console.log(key + ": " + p[key]);}}
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್ ಕೀಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ವಿಧಾನಗಳನ್ನು ಬಳಸುವುದು
const p = {"p1": "value1", "p2": "value2", "p3": "value3"};Object.keys(p).forEach(key => {console.log(key + ": " + p[key]);});
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್ ಕೀಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳನ್ನು ಹೊರತೆಗೆಯುವುದು
JavaScript Object.entries() ವಿಧಾನವನ್ನು ಬಳಸುವುದು
const p = {"p1": "value1", "p2": "value2", "p3": "value3"};for (const [key, value] of Object.entries(p)) {console.log(key + ": " + value);}
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆಗಾಗಿ ಸುಧಾರಿತ ತಂತ್ರಗಳು
ಹಿಂದೆ ವಿವರಿಸಿದ ವಿಧಾನಗಳ ಜೊತೆಗೆ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ಮತ್ತೊಂದು ಉಪಯುಕ್ತ ತಂತ್ರವನ್ನು ಬಳಸುತ್ತಿದೆ Object.values() ವಿಧಾನ. ಈ ವಿಧಾನವು ವಸ್ತುವಿನ ಸ್ವಂತ ಎಣಿಕೆ ಮಾಡಬಹುದಾದ ಆಸ್ತಿ ಮೌಲ್ಯಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ನಿಮಗೆ ಮೌಲ್ಯಗಳು ಮಾತ್ರ ಅಗತ್ಯವಿರುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ ಮತ್ತು ಕೀಗಳಲ್ಲ. ನಂತರ ನೀವು ಬಳಸಬಹುದು forEach() ಅಥವಾ ಈ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಇತರ ರಚನೆಯ ವಿಧಾನಗಳು. ಈ ವಿಧಾನವು ಕೈಯಲ್ಲಿರುವ ಕಾರ್ಯಕ್ಕೆ ಕೀಲಿಗಳು ಅಪ್ರಸ್ತುತವಾಗಿರುವ ಸನ್ನಿವೇಶಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.
ಮತ್ತೊಂದು ಸುಧಾರಿತ ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತಿದೆ Reflect.ownKeys(), ಇದು ಎಣಿಸಲಾಗದ ಮತ್ತು ಸಂಕೇತ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಹೆಚ್ಚು ಸಮಗ್ರವಾಗಿದೆ Object.keys() ಮತ್ತು Object.getOwnPropertyNames(). ಜೊತೆಗೂಡಿದಾಗ for...of, ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ವಸ್ತುವಿನ ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಏಕೀಕೃತ ರೀತಿಯಲ್ಲಿ ಪುನರಾವರ್ತಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಈ ಸುಧಾರಿತ ವಿಧಾನಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸಂಕೀರ್ಣ ವಸ್ತುಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸಲು ನಿಮ್ಮ ಟೂಲ್ಕಿಟ್ ಅನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆ ಮತ್ತು ನೀವು ವ್ಯಾಪಕವಾದ ಪುನರಾವರ್ತನೆಯ ಸನ್ನಿವೇಶಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿಭಾಯಿಸಬಹುದು ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ಪುನರಾವರ್ತನೆಯ ಬಗ್ಗೆ ಸಾಮಾನ್ಯ ಪ್ರಶ್ನೆಗಳು
- ವಸ್ತುವಿನ ಗುಣಲಕ್ಷಣಗಳ ಮೂಲಕ ನಾನು ಹೇಗೆ ಲೂಪ್ ಮಾಡುವುದು?
- ನೀವು ಬಳಸಬಹುದು a for...in ಲೂಪ್ ಅಥವಾ Object.keys() ಜೊತೆಗೆ forEach().
- ಎರಡರ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು Object.keys() ಮತ್ತು Object.values()?
- Object.keys() ಆಸ್ತಿ ಹೆಸರುಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ Object.values() ಆಸ್ತಿ ಮೌಲ್ಯಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
- ವಸ್ತುವಿನ ಕೀಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳನ್ನು ನಾನು ಹೇಗೆ ಪಡೆಯುವುದು?
- ಬಳಸಿ Object.entries() [ಕೀ, ಮೌಲ್ಯ] ಜೋಡಿಗಳ ಶ್ರೇಣಿಯನ್ನು ಪಡೆಯಲು, ನಂತರ ಅದರೊಂದಿಗೆ ಪುನರಾವರ್ತಿಸಿ for...of.
- ಎಣಿಸಲಾಗದ ಗುಣಲಕ್ಷಣಗಳ ಮೇಲೆ ನಾನು ಪುನರಾವರ್ತಿಸಬಹುದೇ?
- ಹೌದು, ಬಳಸಿ Object.getOwnPropertyNames() ಅಥವಾ Reflect.ownKeys() ಎಣಿಸಲಾಗದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಸೇರಿಸಲು.
- ಆಸ್ತಿಯು ವಸ್ತುವಿನ ಸ್ವಂತ ಆಸ್ತಿಯೇ ಎಂದು ನಾನು ಹೇಗೆ ಪರಿಶೀಲಿಸುವುದು?
- ಬಳಸಿ hasOwnProperty() ಆಸ್ತಿಯು ಆನುವಂಶಿಕವಾಗಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಒಂದು ಲೂಪ್ ಒಳಗೆ.
- ವಸ್ತುವಿನ ಚಿಹ್ನೆಗಳ ಮೇಲೆ ನಾನು ಹೇಗೆ ಪುನರಾವರ್ತಿಸುವುದು?
- ಬಳಸಿ Object.getOwnPropertySymbols() ಸಂಕೇತ ಗುಣಲಕ್ಷಣಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಪಡೆಯಲು.
- ವಸ್ತುವಿನ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ಉತ್ತಮ ವಿಧಾನ ಯಾವುದು?
- ಇದು ನಿಮ್ಮ ಅಗತ್ಯಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಬಳಸಿ for...in ಸರಳತೆಗಾಗಿ, Object.keys() ನಿರ್ದಿಷ್ಟ ಆಸ್ತಿ ಹೆಸರುಗಳಿಗಾಗಿ, ಮತ್ತು Object.entries() ಕೀಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳೆರಡಕ್ಕೂ.
JavaScript ಆಬ್ಜೆಕ್ಟ್ ಪುನರಾವರ್ತನೆಯನ್ನು ಸುತ್ತಿಕೊಳ್ಳಲಾಗುತ್ತಿದೆ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಮೂಲಕ ಪುನರಾವರ್ತನೆಯು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ವಿಭಿನ್ನ ವಿಧಾನಗಳು ಮತ್ತು ಅವುಗಳ ಸೂಕ್ತ ಬಳಕೆಯ ಸಂದರ್ಭಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಅಗತ್ಯವಿದೆ. ಸರಳದಿಂದ for...in ಬಳಸಿಕೊಂಡು ಹೆಚ್ಚು ಸುಧಾರಿತ ತಂತ್ರಗಳಿಗೆ ಕುಣಿಕೆಗಳು Object.entries() ಮತ್ತು Reflect.ownKeys(), ಪ್ರತಿಯೊಂದು ವಿಧಾನವು ಅದರ ಪ್ರಯೋಜನಗಳನ್ನು ಹೊಂದಿದೆ. ಈ ವಿಧಾನಗಳನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡುವುದರಿಂದ ವೈವಿಧ್ಯಮಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸನ್ನಿವೇಶಗಳನ್ನು ನಿರ್ವಹಿಸುವ ನಿಮ್ಮ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ನೀವು ವಸ್ತುವಿನ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಬಹುದು ಮತ್ತು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಬಹುದು.