ಕಾರ್ಯಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಡೆವಲಪರ್ಗೆ ಇದು ಅಗತ್ಯವಿಲ್ಲ, ಆದರೆ ಕಾರ್ಯಗಳನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡುವುದು ಸಹ ಅಗತ್ಯವಾಗಿದೆ. ಇಂದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಹಲವಾರು ಲೈಬ್ರರಿಗಳು ಲಭ್ಯವಿದೆ, ಅದು ಡೆವಲಪರ್ಗಳಿಗೆ ವೇರಿಯೇಬಲ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ. ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ಲೋಡಾಶ್ ಲೈಬ್ರರಿಯ ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದ ಕಾರ್ಯಗಳನ್ನು ಹೇಗೆ ಬಳಸಿಕೊಳ್ಳಬೇಕು ಎಂಬುದನ್ನು ನಾವು ಕಲಿಯುತ್ತೇವೆ.
ನೀವು ಇನ್ನೂ ಲೋಡಾಶ್ ಅನ್ನು ಪ್ರಯತ್ನಿಸದಿದ್ದರೆ, ಇದೀಗ ಕ್ಷಣವಾಗಿದೆ. Lodash ಒಂದು ಸಮಕಾಲೀನ JavaScript ಯುಟಿಲಿಟಿ ಪ್ಯಾಕೇಜ್ ಆಗಿದ್ದು ಅದು ಅರೇಗಳು, ಪೂರ್ಣಾಂಕಗಳು, ವಸ್ತುಗಳು, ಪಠ್ಯಗಳು ಮತ್ತು ಇತರ ಡೇಟಾ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.
ವಿವಿಧ ರೀತಿಯ ವಸ್ತುಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸಲು ಇದು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ ಮತ್ತು ಜೆನೆರಿಕ್ ವಿಧಾನಗಳನ್ನು ಕೋಡ್ ಮಾಡುವ ಅಗತ್ಯವನ್ನು ತೆಗೆದುಹಾಕುವ ಮೂಲಕ ನಿಮ್ಮ ಸಮಯವನ್ನು ಉಳಿಸುತ್ತದೆ. ನಿಮ್ಮ ಕೋಡ್ ಕಡಿಮೆ ಸಾಲುಗಳೊಂದಿಗೆ ಸ್ವಚ್ಛವಾಗಿರುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಾ ಬ್ರೌಸರ್ಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನೀವು ಈಗಾಗಲೇ ಅದನ್ನು ಬಳಸದಿದ್ದರೆ, ನೀವು ಅದನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಗಣಿಸಬೇಕು.
Lodash ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳದಿರುವುದು ನಮ್ಮ JavaScript ಕೋಡ್ಬೇಸ್ಗಳಿಗೆ ದೊಡ್ಡ ನಷ್ಟವಾಗಿದೆ. ಕೆಲಸದಲ್ಲಿ ನಾವು ಹೊಂದಿರುವ ಸಾಮಾನ್ಯ ಸವಾಲುಗಳಿಗೆ ಇದು ದೋಷ-ಮುಕ್ತ ಮತ್ತು ಸೊಗಸಾದ ಪರಿಹಾರವಾಗಿದೆ ಮತ್ತು ಅದನ್ನು ಬಳಸುವುದರಿಂದ ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ನಿರ್ವಹಿಸುವಂತೆ ಮಾಡುತ್ತದೆ.
ಕೆಲವು ಹೆಚ್ಚು ಜನಪ್ರಿಯವಾದ (ಅಥವಾ ಇಲ್ಲವೇ!) ಲೋಡಾಶ್ ಕಾರ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸೋಣ ಮತ್ತು ಈ ಲೈಬ್ರರಿಯು ಎಷ್ಟು ಉಪಯುಕ್ತ ಮತ್ತು ಸುಂದರವಾಗಿದೆ ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯೋಣ.
1. _.sortedUniq
ಎಲ್ಲಾ ನಕಲು ಮೌಲ್ಯಗಳನ್ನು ಇದರೊಂದಿಗೆ ಹಿಂತಿರುಗಿಸಲಾಗುವುದಿಲ್ಲ. ಏಕೆಂದರೆ ಇದು ಕೇವಲ ವಿಂಗಡಿಸಲಾದ ಅರೇಗಳಿಗೆ, ಇದನ್ನು ಮುಖ್ಯವಾಗಿ ವೇಗದ ಕಾರಣಗಳಿಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ನೀವು ದೊಡ್ಡ ಶ್ರೇಣಿಯೊಂದಿಗೆ ವ್ಯವಹರಿಸುತ್ತಿದ್ದರೆ ಮಾತ್ರ ಇದು ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ. ನೀವು ವೇಗವನ್ನು ಸುಧಾರಿಸಲು ಬಯಸಿದರೆ, ನಿಮ್ಮ ರಚನೆಯನ್ನು ವಿಂಗಡಿಸಿ ಮತ್ತು ವಿಂಗಡಿಸಲಾದ ಅರೇಗಳೊಂದಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವಿಧಾನಗಳನ್ನು ಬಳಸಿ.
ಲೋಡಾಶ್ ಇದರಂತೆಯೇ ಇರುವ ಹಲವಾರು ಇತರ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದೆ. ನೀವು .sortedIndex, .sortedIndexBy, .sortedIndexOf, .sortedLastIndex, .sortedLastIndexBy, .sortedLastIndexOf, .sortedUniq, .sortedUniqBy, .sortedUniqBy.
2. _.ಕಡಿಮೆ ಮಾಡಿ
_.reduce ಒಂದು ಫಿಲ್ಟರ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಹೋಲುತ್ತದೆ. ಒಂದೇ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಹಿಂತಿರುಗಿದ ವಸ್ತುವಿನ ರೂಪವನ್ನು ಆಯ್ಕೆ ಮಾಡುವ ಆಯ್ಕೆಯನ್ನು ನೀವು ಹೊಂದಿರುವಿರಿ. ನಾನು ಹೇಳುತ್ತಿರುವುದನ್ನು ನೀವು ಗ್ರಹಿಸದಿದ್ದರೆ ಇದು ಸಾಮಾನ್ಯವಾಗಿದೆ; ಅದಕ್ಕೆ ಒಂದು ಉದಾಹರಣೆ ಇದೆ.
ಮೂಲಭೂತವಾಗಿ, ನಾವು ವಯಸ್ಸಿನ ಪ್ರಕಾರ ವರ್ಗೀಕರಿಸಿದ ಬಳಕೆದಾರರನ್ನು ಹೊಂದಿರುವ ಹೊಸ ವಸ್ತುವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ, ಆದರೆ 18 ರಿಂದ 59 ವರ್ಷ ವಯಸ್ಸಿನವರಿಗೆ ಮಾತ್ರ. ಈ ಲೋಡಾಶ್ ಸಹಾಯಕ ಕಾರ್ಯವು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲಾಗುವ ಒಂದಾಗಿದೆ. ಇದು ES6 ನಲ್ಲಿಯೂ ಸೇರಿದೆ. ನಾನು ಎರಡು ವಿಶಿಷ್ಟ ಪ್ರಮಾದಗಳನ್ನು ಸಹ ಸೂಚಿಸಲು ಬಯಸುತ್ತೇನೆ: ಕ್ರಿಯೆಯ ಕೊನೆಯಲ್ಲಿ ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸಲು ಮರೆಯದಿರಿ ಮತ್ತು ಫಲಿತಾಂಶಕ್ಕಾಗಿ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಮೂರನೇ ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿ (ಇಲ್ಲಿ) ಒದಗಿಸಿ.
3. _.ಗೆಟ್ ಮತ್ತು ._ಸೆಟ್
ಇದಕ್ಕಾಗಿ, ಬಹುತೇಕ ಒಂದೇ ವಿಷಯವನ್ನು ನಿರ್ವಹಿಸುವ ಎರಡು ಕಾರ್ಯಗಳನ್ನು ತೋರಿಸುವ ಮೂಲಕ ನಾನು ನಿಮ್ಮನ್ನು ಸ್ವಲ್ಪ ಮೋಸಗೊಳಿಸುತ್ತೇನೆ. _.ಆಬ್ಜೆಕ್ಟ್ನಿಂದ ಆಸ್ತಿ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಮತ್ತು _.ಸೆಟ್ ಮಾಡಿ, ನೀವು ಊಹಿಸಿದಂತೆ ಮೌಲ್ಯದೊಂದಿಗೆ ಆಸ್ತಿಯನ್ನು ಹೊಂದಿಸಿ. ನೀವು ಆಸ್ತಿಯನ್ನು ಅದರ ಮಾರ್ಗದ ಮೂಲಕ ಪ್ರವೇಶಿಸುವುದನ್ನು ಹೊರತುಪಡಿಸಿ ಅನನ್ಯವಾದ ಏನೂ ಇಲ್ಲ.
ನಾವು ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.
_.set ಗೆ ಕರೆ ಮಾಡುವಾಗ ಮಾರ್ಗವು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ, ಅದನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ. ಇನ್ನು ಮುಂದೆ "ಅನಿರ್ದಿಷ್ಟವಾದ ಆಸ್ತಿ 'ಐಟಂಗಳನ್ನು' ಹೊಂದಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ" ದೋಷಗಳು ಇರುವುದಿಲ್ಲ. ಮಾರ್ಗವು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ, _.get ದೋಷದ ಬದಲಿಗೆ ವ್ಯಾಖ್ಯಾನಿಸದೆ ಹಿಂತಿರುಗುತ್ತದೆ. ಮಾರ್ಗವು ಅನಿರ್ದಿಷ್ಟವಾಗಿ ಪರಿಹರಿಸಿದರೆ, ನೀವು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಸಹ ಒದಗಿಸಬಹುದು (ಮೂರನೇ ನಿಯತಾಂಕ).
4. _.ಹುಡುಕಿ
ಒಂದೇ ವಸ್ತುವನ್ನು ಹುಡುಕಲು ರಚನೆಯ ಮೂಲಕ ಲೂಪ್ ಮಾಡುವ ಬದಲು, ನಾವು _.find ಅನ್ನು ಬಳಸಬಹುದು. ಅದು ಒಳ್ಳೆಯದು, ಆದರೆ ಇದು _.ಫೈಂಡ್ ಮಾಡಬಹುದಾದ ಏಕೈಕ ವಿಷಯವಲ್ಲ. ಒಂದೇ ಸಾಲಿನ ಕೋಡ್ನೊಂದಿಗೆ, ನೀವು ಹಲವಾರು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬಳಸಿಕೊಂಡು ವಸ್ತುವನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು. ಇದನ್ನು ಪರಿಶೀಲಿಸಿ!
5. _.ಕೀಬೈ
ನನ್ನ ಮೆಚ್ಚಿನವುಗಳಲ್ಲಿ ಒಂದು _.keyBy. ಒಂದು ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣದೊಂದಿಗೆ ವಸ್ತುವನ್ನು ಪಡೆಯಲು ಪ್ರಯತ್ನಿಸುವಾಗ ಇದು ಸಾಕಷ್ಟು ಉಪಯುಕ್ತವಾಗಿದೆ. ನಾವು 100 ಬ್ಲಾಗ್ ನಮೂದುಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು "34abc" ಐಡಿಯೊಂದಿಗೆ ಒಂದನ್ನು ಪಡೆದುಕೊಳ್ಳಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಊಹಿಸಿ. ನಾವು ಅದನ್ನು ಹೇಗೆ ಮಾಡಲಿದ್ದೇವೆ? ಏನಾಗುತ್ತದೆ ಎಂದು ನೋಡೋಣ! ಸರ್ವರ್ ಅದನ್ನು ಅರೇಯಾಗಿ ಒದಗಿಸಿದರೆ ವಸ್ತು ಸಂಗ್ರಹಣೆಯನ್ನು ವ್ಯವಸ್ಥೆಗೊಳಿಸಲು ಈ ವಿಧಾನವು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಕಾರ್ಯವನ್ನು ಎರಡನೇ ವಾದವಾಗಿಯೂ ಬಳಸಬಹುದು.
6. _.ಪ್ರತಿಯೊಂದಕ್ಕೂ
ಈ ವಿಧಾನವು ಒಂದೊಂದಾಗಿ ವಸ್ತುಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತದೆ, ನಿಮಗೆ ಬೇಕಾದ ಯಾವುದೇ ತರ್ಕವನ್ನು ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಈ ಮೊದಲ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾನು ಬಳಕೆದಾರರ ವಸ್ತುಗಳ ಪಟ್ಟಿಯನ್ನು ಲೂಪ್ ಮಾಡುತ್ತೇನೆ, ಪೂರ್ಣಹೆಸರು ಎಂಬ ಹೊಸ ಆಸ್ತಿಯನ್ನು ರಚಿಸಲು ಅವರ ಮೊದಲ ಮತ್ತು ಕೊನೆಯ ಹೆಸರುಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುತ್ತೇನೆ.
ಇವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದೂ ಎರಡು ನಿಯತಾಂಕಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ನಾವು ಲೂಪ್ ಮಾಡುತ್ತಿರುವ ಅರೇ ಮೊದಲ ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿದೆ. ಎರಡನೆಯ ವಾದವು ಪುನರಾವರ್ತಿತ ಕಾರ್ಯವಾಗಿದೆ, ಮೊದಲ ಪ್ಯಾರಾಮೀಟರ್ ವೈಯಕ್ತಿಕ ಐಟಂ ಉಲ್ಲೇಖವಾಗಿದೆ ಮತ್ತು ಎರಡನೆಯದು ಪುನರಾವರ್ತನೆಯ ಪ್ರಸ್ತುತ ಸೂಚ್ಯಂಕವಾಗಿದೆ.
7. _.ನಕ್ಷೆ
ಪ್ರತಿಯೊಂದರಂತೆಯೇ ನಕ್ಷೆಯು ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯಾದ್ಯಂತ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ. ಮತ್ತೊಂದೆಡೆ, ನಕ್ಷೆ ಕಾರ್ಯವು ಪುನರಾವರ್ತಿತ ಕಾರ್ಯದಿಂದ ಒದಗಿಸಲಾದ ಮೌಲ್ಯಗಳ ಹೊಸ ಶ್ರೇಣಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಇಲ್ಲಿ ನಮ್ಮ forEach ಉದಾಹರಣೆಯಲ್ಲಿರುವಂತೆ ನಾವು ಅದೇ ಬಳಕೆದಾರರ ಸಂಗ್ರಹವನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ. ಎಲ್ಲಾ ಬಳಕೆದಾರರ ಸಂಪೂರ್ಣ ಹೆಸರುಗಳ ಸಮತಟ್ಟಾದ ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುವ ಹೊಸ ವೇರಿಯೇಬಲ್ ಅನ್ನು ರಚಿಸಲು ನಾವು _.map ಅನ್ನು ಬಳಸಬಹುದು.
8. _.ವ್ಯತ್ಯಾಸ
ವ್ಯತ್ಯಾಸ ಕಾರ್ಯವು ಮೊದಲ ಮತ್ತು ಎರಡನೆಯ ಸರಣಿಗಳ ನಡುವೆ ಭಿನ್ನವಾಗಿರುವ ಮೌಲ್ಯಗಳ ಹೊಸ ಶ್ರೇಣಿಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ವಾದಗಳ ಸ್ಥಳವು ಫಲಿತಾಂಶಗಳ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಅತ್ಯಗತ್ಯ.
9. _.ಪಡೆಯಿರಿ
_.get() ಕಾರ್ಯವು ವಸ್ತುವಿನೊಳಗಿನ ಅಂಶವನ್ನು ಪತ್ತೆಹಚ್ಚಲು ನಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಸರಬರಾಜು ಮಾಡಿದ ಮಾರ್ಗದಲ್ಲಿ ಒಂದು ಅಂಶ ಕಂಡುಬಂದಿಲ್ಲವಾದರೆ ಹಿಂತಿರುಗಲು ನಾವು _.get() ಕಾರ್ಯಕ್ಕಾಗಿ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಬಹುದು. _.get() ಕಾರ್ಯವು ಮೂರು ನಿಯತಾಂಕಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಅದರಲ್ಲಿ ಮೊದಲನೆಯದು ನಾವು ಒಂದು ಅಂಶವನ್ನು ಪಡೆಯಲು ಬಯಸುವ ವಸ್ತುವಾಗಿದೆ. ಮಾರ್ಗವು ಎರಡನೆಯದು. ಮೂರನೇ ಮೌಲ್ಯವು ಒಂದು ಅಂಶವನ್ನು ಕಂಡುಹಿಡಿಯಲಾಗದಿದ್ದರೆ ನಾವು ಹಿಂತಿರುಗಿಸಲು ಬಯಸುವ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವಾಗಿದೆ.
10. _.ಹುಡುಕಿ
_find() ಕಾರ್ಯವು _.get() ವಿಧಾನಕ್ಕೆ ಹೋಲುವಂತೆ ಕಾಣಿಸಬಹುದು. _.ಗೆಟ್() ವಿಧಾನದಂತೆ _.find() ಕಾರ್ಯವು ಮೂರು ನಿಯತಾಂಕಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, _.get() ವಿಧಾನಕ್ಕಿಂತ ಭಿನ್ನವಾಗಿ, ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಒಂದು ಅರೇ ಅಥವಾ ಆಬ್ಜೆಕ್ಟ್ ಆಗಿರಬಹುದು. ಎರಡನೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್ ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯ ಮೇಲೆ ಕರೆಯಲಾಗುವ ಕಾರ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಮೂರನೇ ಇನ್ಪುಟ್ ಸಂಗ್ರಹದ ಪ್ರಾರಂಭದ ಸೂಚ್ಯಂಕವಾಗಿದೆ. ಏಕೆಂದರೆ _.find() ಕಾರ್ಯವು ಸಂಗ್ರಹದಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಅಂಶದ ಮೇಲೆ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ.
11. _.groupBy
ಒಂದು ಕಾರ್ಯದ ಫಲಿತಾಂಶದಿಂದ (ಅಥವಾ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಆಯ್ಕೆಮಾಡಿದ ಆಸ್ತಿ ಹೆಸರು) ಹೆಸರಿನ ವಸ್ತುವನ್ನು ರಚಿಸಿ, ಪ್ರತಿ ಮೌಲ್ಯವು ಒಂದೇ ಕೀಲಿಯೊಂದಿಗೆ ವಸ್ತುಗಳ ಒಂದು ಶ್ರೇಣಿಯಾಗಿದೆ.
12. _.ಸೆಟ್
_.set() ವಿಧಾನವು _.get() ವಿಧಾನದ ವಿಲೋಮವಾಗಿದೆ. ಇದು ನಿರ್ದಿಷ್ಟ ಪಥದಲ್ಲಿ ಅಂಶದ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ. ವಸ್ತು ಅಥವಾ ರಚನೆಯು ಮೊದಲ ನಿಯತಾಂಕವಾಗಿದೆ, ಮಾರ್ಗವು ಎರಡನೆಯದು ಮತ್ತು ನೀವು ಹೊಂದಿಸಲು ಬಯಸುವ ಮೌಲ್ಯವು ಮೂರನೆಯದು.
13. _.ವಿಲೀನ
ಇದು Object.assign ನಂತೆಯೇ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಆದರೆ ಇದು ಆಳವಾದ ವಸ್ತುಗಳನ್ನು ಬದಲಿಸುವ ಬದಲು ಅವುಗಳನ್ನು ನವೀಕರಿಸಲು ಆಧಾರವಾಗಿರುವ ರಚನೆಯ ಆಳಕ್ಕೆ ಮರುಕಳಿಸುತ್ತದೆ.
14. ._ಡೆಬರ್
ಇದು ಸಾಕಷ್ಟು ನೇರ ಉದಾಹರಣೆಯಾಗಿದೆ. ಎಲ್ಲಾ "ಸಂಯೋಜಿತ ಡಯಾಕ್ರಿಟಿಕಲ್ ಗುರುತುಗಳನ್ನು" ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ. ಹೀಗಾಗಿ "é" "e" ಆಗುತ್ತದೆ. ಅಂತರರಾಷ್ಟ್ರೀಕರಣ ಮತ್ತು ಸ್ಥಳೀಕರಣವು ಇದ್ದಾಗ, ಹುಡುಕಾಟ ಕಾರ್ಯಗಳಿಗಾಗಿ ಪಠ್ಯವನ್ನು ಡಿಬರ್ರ್ ಮಾಡುವುದು ಉತ್ತಮ ಅಭ್ಯಾಸವಾಗಿದೆ.
15. _.ಡಿಬೌನ್ಸ್
ಇದು ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ಲೋಡಾಶ್ ತಂತ್ರಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಅದು ಏನು ಮಾಡುತ್ತದೆ ಮತ್ತು ನೀವು ಅದನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು ಎಂಬುದನ್ನು ಗ್ರಹಿಸಲು ಕಷ್ಟವಾಗಬಹುದು. _.debounce() ವಿಧಾನವು ಕಾರ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. _.debounce() ವಿಧಾನದ ಕಾರ್ಯವು ಕಾರ್ಯವನ್ನು ಕೊನೆಯದಾಗಿ ಆಹ್ವಾನಿಸಿದಾಗಿನಿಂದ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಮಿಲಿಸೆಕೆಂಡ್ಗಳು ಹಾದುಹೋಗುವವರೆಗೆ ಆಹ್ವಾನವನ್ನು ವಿಳಂಬಗೊಳಿಸುತ್ತದೆ.
ತೀರ್ಮಾನ
ಲೋಡಾಶ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಭಾಷೆಯ ಪ್ರಬಲ ವಿಸ್ತರಣೆಯಾಗಿದೆ. ಕನಿಷ್ಠ ಪ್ರಯತ್ನದಿಂದ, ಒಬ್ಬರು ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಕೋಡ್ ಅನ್ನು ನಿರ್ಮಿಸಬಹುದು. ಲೋಡಾಶ್ ಕೂಡ ಸಂಪೂರ್ಣವಾಗಿ ಮಾಡ್ಯುಲರ್ ಆಗಿದೆ. ಅದರ ಕೆಲವು ಕಾರ್ಯಚಟುವಟಿಕೆಗಳನ್ನು ಅಂತಿಮವಾಗಿ ಅಸಮ್ಮತಿಸಬಹುದಾದರೂ, JS ಭಾಷೆಯ ವಿಕಾಸವನ್ನು ಚಾಲನೆ ಮಾಡುವಾಗ ಡೆವಲಪರ್ಗಳಿಗೆ ಇದು ಇನ್ನೂ ಹಲವಾರು ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತದೆ ಎಂದು ನಾನು ನಂಬುತ್ತೇನೆ.
ಅರೇಗಳು, ಆಬ್ಜೆಕ್ಟ್ಗಳು ಮತ್ತು ಸಂಗ್ರಹಣೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಲೋಡಾಶ್ ಎಷ್ಟು ಶಕ್ತಿಯುತವಾಗಿರುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡಲು ಈ ಕೆಲವು ಲೋಡಾಶ್ ಸಾಮರ್ಥ್ಯಗಳು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತವೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ನೀವು ಭೇಟಿ ನೀಡಬಹುದು ದಸ್ತಾವೇಜನ್ನು ಇದು ನೀಡುವ ಇತರ ಆಯ್ಕೆಗಳ ಸಮೃದ್ಧಿಯನ್ನು ಅನ್ವೇಷಿಸಲು.
ಪ್ರತ್ಯುತ್ತರ ನೀಡಿ