ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ದೇಶದ ಮೂಲಕ ನೆಸ್ಟೆಡ್ ಅರೇ ಅನ್ನು ವಿಂಗಡಿಸುವುದು

ಮಾಸ್ಟರಿಂಗ್ ಅರೇ ವಿಂಗಡಣೆ: ದೇಶದ ಪ್ರಕಾರ ನಗರಗಳನ್ನು ಗುಂಪು ಮಾಡುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಅರೇಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ, ಆದರೆ ನೀವು ಸಂಕೀರ್ಣ ಡೇಟಾವನ್ನು ಸಂಘಟಿಸಬೇಕಾದಾಗ ವಿಷಯಗಳು ಟ್ರಿಕಿ ಆಗಬಹುದು. ಉದಾಹರಣೆಗೆ, ನೀವು ದೇಶಗಳು, ನಗರಗಳು ಮತ್ತು ದಿನಾಂಕಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದ್ದರೆ, ಆ ಶ್ರೇಣಿಯನ್ನು ವಿಂಗಡಿಸುವುದು ಮತ್ತು ಪುನರ್ರಚಿಸುವುದು ಒಂದು ಸವಾಲಾಗಿದೆ. ಇಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಅರೇ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ ಸೂಕ್ತವಾಗಿ ಬರುತ್ತದೆ.

ನೀವು ದೇಶದ ಹೆಸರುಗಳು, ನಗರದ ಹೆಸರುಗಳು ಮತ್ತು ಅನುಗುಣವಾದ ದಿನಾಂಕಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುವಿರಿ ಎಂದು ಊಹಿಸಿ ಮತ್ತು ಆಯಾ ದೇಶದ ಅಡಿಯಲ್ಲಿ ಪ್ರತಿ ನಗರದ ಡೇಟಾವನ್ನು ಗುಂಪು ಮಾಡುವಾಗ ನೀವು ಈ ಶ್ರೇಣಿಯನ್ನು ದೇಶದಿಂದ ವಿಂಗಡಿಸಲು ಬಯಸುತ್ತೀರಿ. ಸ್ಪಷ್ಟವಾದ ಪ್ರಸ್ತುತಿಗಾಗಿ ಸಂಘಟಿಸಬೇಕಾದ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಇದು ಉಪಯುಕ್ತ ಕೌಶಲ್ಯವಾಗಿದೆ.

ಇದನ್ನು ಸಾಧಿಸಲು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೇಟಾವನ್ನು ಸುಲಭವಾಗಿ ವಿಂಗಡಿಸಲು ಮತ್ತು ಪುನರ್ರಚಿಸಲು ಅನುಮತಿಸುವ ಹಲವಾರು ವಿಧಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ನೀವು ಕಾರ್ಯಗಳನ್ನು ಬಳಸಬಹುದು ಮತ್ತು ಅಂಶಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಗುಂಪು ಮಾಡಲು, ಡೇಟಾ ಅರೇಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸ್ಪಷ್ಟ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಈ ಟ್ಯುಟೋರಿಯಲ್ ದೇಶ ಅಥವಾ ನಗರದ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡುವುದು ಅಥವಾ ದಿನಾಂಕ ಶ್ರೇಣಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವಂತಹ ವಿವಿಧ ಬಳಕೆದಾರ ಸಂವಹನಗಳಿಗೆ ಅಳವಡಿಸಿಕೊಳ್ಳಬಹುದಾದ, ನೆಸ್ಟೆಡ್ ಅರೇ ಅನ್ನು ದೇಶದ ಮೂಲಕ ವಿಂಗಡಿಸಲು ಮತ್ತು ಗುಂಪು ಮಾಡಲು ಸರಳವಾದ ವಿಧಾನದ ಮೂಲಕ ನಿಮಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ. ಹಂತಗಳಲ್ಲಿ ಧುಮುಕೋಣ!

ಆಜ್ಞೆ	ಬಳಕೆಯ ಉದಾಹರಣೆ
localeCompare()	ಲೊಕೇಲ್-ಸೆನ್ಸಿಟಿವ್ ಕ್ರಮದಲ್ಲಿ ಎರಡು ತಂತಿಗಳನ್ನು ಹೋಲಿಸಲು ಈ ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಶ್ರೇಣಿಯನ್ನು ವಿಂಗಡಿಸುವಾಗ ದೇಶದ ಹೆಸರುಗಳನ್ನು ವರ್ಣಮಾಲೆಯಂತೆ ಹೋಲಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ದೇಶದ ಹೆಸರುಗಳನ್ನು ಅವುಗಳ ಲೊಕೇಲ್-ನಿರ್ದಿಷ್ಟ ವಿಂಗಡಣೆ ನಿಯಮಗಳ ಪ್ರಕಾರ ಸರಿಯಾಗಿ ಆದೇಶಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
reduce()	ಕಡಿಮೆ () ವಿಧಾನವು ರಚನೆಯ ಮೂಲಕ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಇಲ್ಲಿ, ಪ್ರತಿ ದೇಶವನ್ನು ಅದರ ನಗರಗಳು ಮತ್ತು ದಿನಾಂಕಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವ ವಸ್ತುವನ್ನು ನಿರ್ಮಿಸುವ ಮೂಲಕ ಆಯಾ ದೇಶಗಳ ಅಡಿಯಲ್ಲಿ ನಗರಗಳನ್ನು ಗುಂಪು ಮಾಡಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
Object.entries()	ಈ ವಿಧಾನವು ಕೊಟ್ಟಿರುವ ವಸ್ತುವಿನ ಸ್ವಂತ ಎಣಿಕೆ ಮಾಡಬಹುದಾದ ಸ್ಟ್ರಿಂಗ್-ಕೀಡ್ ಆಸ್ತಿ ಜೋಡಿಗಳ ಶ್ರೇಣಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಗುಂಪು ಮಾಡಲಾದ ವಸ್ತುವನ್ನು ಮತ್ತೆ ಸುಲಭವಾಗಿ ಕುಶಲತೆಯಿಂದ ಮತ್ತು ಲಾಗ್ ಮಾಡಬಹುದಾದ ರಚನೆಯ ಸ್ವರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
sort()	ಶ್ರೇಣಿಯನ್ನು ಸ್ಥಳದಲ್ಲಿ ವಿಂಗಡಿಸಲು ವಿಂಗಡಣೆ () ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಸರಿಯಾದ ಕ್ರಮದಲ್ಲಿ ದೇಶದಿಂದ ಗುಂಪು ಮಾಡಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ನಿರ್ದಿಷ್ಟವಾಗಿ ಮೊದಲ ಐಟಂ (ದೇಶ) ಮೂಲಕ ಶ್ರೇಣಿಯನ್ನು ವಿಂಗಡಿಸುತ್ತದೆ.
console.log()	ಈ ಆಜ್ಞೆಯು ಡೀಬಗ್ ಮಾಡುವ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಕನ್ಸೋಲ್‌ಗೆ ಡೇಟಾವನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ. ಇಲ್ಲಿ, ರೂಪಾಂತರಗೊಂಡ ರಚನೆಯ ರಚನೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ಇದು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಡೆವಲಪರ್‌ಗಳಿಗೆ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ವಿವಿಧ ಹಂತಗಳಲ್ಲಿ ಫಲಿತಾಂಶವನ್ನು ನೋಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
if (!acc[country])	ರಚನೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುವಾಗ ಸಂಚಯಕ ವಸ್ತುವಿನಲ್ಲಿ ದೇಶವು ಇನ್ನೂ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲವೇ ಎಂದು ಈ ಸಾಲು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇದು ಇಲ್ಲದಿದ್ದರೆ ದೇಶಕ್ಕೆ ಖಾಲಿ ಶ್ರೇಣಿಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ, ನಗರಗಳ ಸರಿಯಾದ ಗುಂಪನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
push()	ಪುಶ್() ವಿಧಾನವು ರಚನೆಗೆ ಹೊಸ ಅಂಶಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ. ಇಲ್ಲಿ, ಗುಂಪು ಮಾಡುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಆಯಾ ದೇಶದ ಶ್ರೇಣಿಗೆ ನಗರಗಳು ಮತ್ತು ದಿನಾಂಕಗಳನ್ನು ಸೇರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
require()	ಜೆಸ್ಟ್ ಟೆಸ್ಟಿಂಗ್ ಉದಾಹರಣೆಯಲ್ಲಿ, ಜೆಸ್ಟ್ ಪರೀಕ್ಷಾ ಪರಿಸರವನ್ನು ಆಮದು ಮಾಡಲು ಅವಶ್ಯಕತೆ() ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಪರಿಹಾರದ ಕಾರ್ಯವನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ಅಗತ್ಯವಾದ ಪರೀಕ್ಷಾ ಸಾಧನಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಈ ಆಜ್ಞೆಯು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅರೇಗಳ ಸಮರ್ಥ ವಿಂಗಡಣೆ ಮತ್ತು ಗುಂಪುಗಾರಿಕೆ

ಮೇಲೆ ರಚಿಸಲಾದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ನೆಸ್ಟೆಡ್ ಅರೇ ಅನ್ನು ಮೊದಲ ಐಟಂ ಮೂಲಕ ವಿಂಗಡಿಸುವ ಮತ್ತು ಗುಂಪು ಮಾಡುವ ಸಮಸ್ಯೆಯನ್ನು ನಿಭಾಯಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅದು ದೇಶವಾಗಿದೆ. ಆಯಾ ದೇಶಗಳ ಅಡಿಯಲ್ಲಿ ನಗರಗಳು ಮತ್ತು ದಿನಾಂಕಗಳ ಕೋಷ್ಟಕವನ್ನು ಆಯೋಜಿಸುವುದು ಗುರಿಯಾಗಿದೆ. ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರಕ್ರಿಯೆಯು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ರಚನೆಯನ್ನು ಮರುಹೊಂದಿಸುವ ವಿಧಾನ. ಒಂದೇ ದೇಶಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ಸತತವಾಗಿ ಪಟ್ಟಿ ಮಾಡಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಈ ಕಾರ್ಯವು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಸನ್ನೆ ಮಾಡುವ ಮೂಲಕ , ವಿಂಗಡಣೆಯು ಲೊಕೇಲ್-ನಿರ್ದಿಷ್ಟ ನಿಯಮಗಳನ್ನು ಗೌರವಿಸುತ್ತದೆ ಎಂದು ಸ್ಕ್ರಿಪ್ಟ್ ಖಚಿತಪಡಿಸುತ್ತದೆ, ಇದು ವಿವಿಧ ದೇಶದ ಹೆಸರುಗಳು ಅಥವಾ ASCII ಅಲ್ಲದ ಅಕ್ಷರಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ.

ಡೇಟಾವನ್ನು ವಿಂಗಡಿಸಿದ ನಂತರ, ಮುಂದಿನ ಹಂತವು ದೇಶದ ಮೂಲಕ ನಗರಗಳನ್ನು ಗುಂಪು ಮಾಡುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಇದನ್ನು ಬಳಸಿಕೊಂಡು ಸಾಧಿಸಲಾಗುತ್ತದೆ ಫಂಕ್ಷನ್, ಫಲಿತಾಂಶಗಳ ಕ್ರೋಢೀಕರಣವನ್ನು ಸರಳಗೊಳಿಸುವ ಪ್ರಬಲ ರಚನೆಯ ವಿಧಾನ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವಿಧಾನವು ಪ್ರತಿ ಕೀಲಿಯು ಒಂದು ದೇಶವಾಗಿರುವ ವಸ್ತುವನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ ಮತ್ತು ಅನುಗುಣವಾದ ಮೌಲ್ಯವು ಅದರ ನಗರಗಳು ಮತ್ತು ದಿನಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯಾಗಿದೆ. ಈ ಹಂತವು ಪ್ರತಿ ದೇಶವು ಅದರ ಸಂಬಂಧಿತ ಡೇಟಾದೊಂದಿಗೆ ಸಂಯೋಜಿತವಾಗಿದೆ ಎಂಬುದನ್ನು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ, ಮುಂಭಾಗದ ಅಂತ್ಯದ ಇಂಟರ್ಫೇಸ್‌ನಲ್ಲಿ ಟೇಬಲ್‌ಗಳು ಅಥವಾ ಚಾರ್ಟ್‌ಗಳನ್ನು ರೆಂಡರಿಂಗ್ ಮಾಡುವಂತಹ ಭವಿಷ್ಯದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಪ್ರವೇಶಿಸಲು ಸುಲಭವಾಗುತ್ತದೆ.

ಗುಂಪು ಮಾಡಿದ ನಂತರ, ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ ಫಲಿತಾಂಶದ ವಸ್ತುವನ್ನು ಮತ್ತೆ ಸರಣಿಯಾಗಿ ಪರಿವರ್ತಿಸುವ ವಿಧಾನ. ಈ ರೂಪಾಂತರವು ಅವಶ್ಯಕವಾಗಿದೆ ಏಕೆಂದರೆ ವಸ್ತುಗಳು ಸುಲಭವಾಗಿ ಕುಶಲತೆಯಿಂದ ಅಥವಾ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅರೇಗಳಂತೆ ನಿರೂಪಿಸಲ್ಪಟ್ಟಿಲ್ಲ. ಡೇಟಾವನ್ನು ಮತ್ತೆ ರಚನೆಯ ಸ್ವರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುವ ಮೂಲಕ, ನಾವು ಅದರ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಬಹುದು ಅಥವಾ ಅದನ್ನು ಮನಬಂದಂತೆ ಇತರ ಕಾರ್ಯಗಳಿಗೆ ರವಾನಿಸಬಹುದು. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಅನೇಕ ಕಾರ್ಯಗಳಿಗೆ ಅರೇಗಳ ಬಳಕೆಯನ್ನು ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಹೆಚ್ಚಿನ ಕಾರ್ಯಗಳೊಂದಿಗೆ ಅವುಗಳ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಪ್ರಯಾಣದ ಸುಲಭತೆ.

ಅಂತಿಮ ಹಂತಗಳಲ್ಲಿ, ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕ್ರಿಯಾತ್ಮಕತೆಗಾಗಿ ಪರೀಕ್ಷಿಸಲಾಗುತ್ತದೆ. ಬ್ಯಾಕ್-ಎಂಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ , ವಿಂಗಡಣೆ ಮತ್ತು ಗುಂಪು ಮಾಡುವ ಕಾರ್ಯಗಳ ಸರಿಯಾದತೆಯನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ನಾವು ಜೆಸ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಬಳಸುತ್ತೇವೆ. ಪರೀಕ್ಷೆಗಳು ನಗರಗಳನ್ನು ತಮ್ಮ ದೇಶಗಳ ಅಡಿಯಲ್ಲಿ ಸರಿಯಾಗಿ ಗುಂಪು ಮಾಡಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಸ್ವರೂಪವು ನಿರೀಕ್ಷಿತ ರಚನೆಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಸರ್ವರ್‌ನಲ್ಲಿ ಅಥವಾ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಪರಿಹಾರವು ಬಹು ಪರಿಸರದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಾತರಿಪಡಿಸಲು ಪರೀಕ್ಷೆಗೆ ಈ ಗಮನವು ಮುಖ್ಯವಾಗಿದೆ. ಸಂಯೋಜನೆಯ ಮೂಲಕ ಮತ್ತು ಸರಿಯಾದ ಪರೀಕ್ಷೆ, ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸಂಕೀರ್ಣ ಡೇಟಾವನ್ನು ವಿಂಗಡಿಸುವ ಮತ್ತು ಗುಂಪು ಮಾಡುವ ಸಮಸ್ಯೆಗೆ ವಿಶ್ವಾಸಾರ್ಹ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತವೆ.

// Original array of country, city, and date data
const data = [
  ['Spain', 'Madrid', '10-12-2024'],
  ['Spain', 'Barcelona', '10-15-2024'],
  ['Suisse', 'Berne', '10-18-2024'],
  ['France', 'Paris', '10-22-2024'],
  ['France', 'Lyon', '10-24-2024']
];

// Step 1: Sort the array by country name (first item)
data.sort((a, b) => a[0].localeCompare(b[0]));

// Step 2: Group cities by their respective countries using reduce
const groupedData = data.reduce((result, item) => {
  const [country, city, date] = item;
  if (!result[country]) {
    result[country] = [];
  }
  result[country].push([city, date]);
  return result;
}, {});

// Step 3: Convert the grouped object back into an array format
const orderedArray = Object.entries(groupedData);
console.log(orderedArray);

const data = [
  ['Spain', 'Madrid', '10-12-2024'],
  ['Suisse', 'Berne', '10-18-2024'],
  ['France', 'Paris', '10-22-2024'],
  ['France', 'Lyon', '10-24-2024'],
  ['Spain', 'Barcelona', '10-15-2024']
];

// Step 1: Sort data by country (first column)
const sortedData = data.sort((a, b) => a[0].localeCompare(b[0]));

// Step 2: Group data by country using map and reduce functions
const groupedData = sortedData.reduce((acc, current) => {
  const [country, city, date] = current;
  if (!acc[country]) {
    acc[country] = [];
  }
  acc[country].push([city, date]);
  return acc;
}, {});

// Step 3: Return the formatted array
const resultArray = Object.entries(groupedData);
console.log(resultArray);

const { test, expect } = require('@jest/globals');

test('Should correctly group cities by country', () => {
  const data = [
    ['Spain', 'Madrid', '10-12-2024'],
    ['France', 'Paris', '10-22-2024']
  ];
  const groupedData = sortAndGroup(data);
  expect(groupedData).toEqual([
    ['Spain', [['Madrid', '10-12-2024']]],
    ['France', [['Paris', '10-22-2024']]]
  ]);
});

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅರೇಗಳನ್ನು ವಿಂಗಡಿಸಲು ಸುಧಾರಿತ ತಂತ್ರಗಳು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ವಿಶೇಷವಾಗಿ ಡೈನಾಮಿಕ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ವಿಂಗಡಣೆಯ ಸರಣಿಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಮತ್ತೊಂದು ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ಡೇಟಾ ನಿರಂತರವಾಗಿ ಬದಲಾಗುತ್ತಿರುವ ಸಂದರ್ಭಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು. ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರು ಬುಕಿಂಗ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಂತಹ ಲೈವ್ ಸಿಸ್ಟಮ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತಿರುವಾಗ, ಅಲ್ಲಿ ಅವರು ದೇಶಗಳು, ನಗರಗಳು ಮತ್ತು ದಿನಾಂಕಗಳನ್ನು ಆಯ್ಕೆಮಾಡುತ್ತಾರೆ, ಡೇಟಾದ ವಿಂಗಡಣೆಯು ನೈಜ ಸಮಯದಲ್ಲಿ ನಡೆಯುತ್ತದೆ. ಅಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಅಂತಹ ವಿಧಾನಗಳನ್ನು ಬಳಸುವುದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪ್ರಯೋಜನಕಾರಿಯಾಗಬಹುದು. ಪ್ರತಿ ಬಾರಿ ಬಳಕೆದಾರರು ಡೇಟಾವನ್ನು ಆಯ್ಕೆ ಮಾಡಿದಾಗ ಅಥವಾ ಮಾರ್ಪಡಿಸಿದಾಗ, ರಚನೆಯು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನವೀಕರಿಸಲ್ಪಡುತ್ತದೆ ಮತ್ತು ಮರು-ವಿಂಗಡಣೆಗೊಳ್ಳುತ್ತದೆ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ, ಬಳಕೆ ಕ್ರಮಾವಳಿಗಳನ್ನು ವಿಂಗಡಿಸುವಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಬಳಕೆದಾರರ ಅಗತ್ಯಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ವಿಂಗಡಣೆ ತರ್ಕವನ್ನು ಹೊಂದಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರ ಆದ್ಯತೆಗಳನ್ನು ಅವಲಂಬಿಸಿ ನೀವು ದೇಶದಿಂದ ಮಾತ್ರವಲ್ಲದೆ ನಗರ ಅಥವಾ ದಿನಾಂಕದ ಮೂಲಕವೂ ವಿಂಗಡಿಸಬೇಕಾಗಬಹುದು. ಒಳಗೆ ಒಂದು ಕಾಲ್ಬ್ಯಾಕ್ ಕಾರ್ಯ ವಿಧಾನವು ಡೆವಲಪರ್‌ಗೆ ವಿಂಗಡಣೆಯನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಹೇಗೆ ನಿರ್ವಹಿಸಬೇಕು ಎಂಬುದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಇದು ಬಳಕೆದಾರರ ಅನುಭವ ಮತ್ತು ಸಿಸ್ಟಮ್ ನಮ್ಯತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.

ಪರಿಗಣಿಸಬೇಕಾದ ಇನ್ನೊಂದು ಅಂಶವೆಂದರೆ ಬಳಕೆ ರಚನೆಯನ್ನು ವಿಂಗಡಿಸುವ ಮೊದಲು. ಈ ಹಂತವು ಯಾವುದೇ ಭ್ರಷ್ಟ ಅಥವಾ ಅಮಾನ್ಯವಾದ ಡೇಟಾ ರಚನೆಯೊಳಗೆ ಬರುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರು ಆಕಸ್ಮಿಕವಾಗಿ ಅಮಾನ್ಯ ದಿನಾಂಕವನ್ನು ನಮೂದಿಸಿದರೆ ಅಥವಾ ನಗರದ ಹೆಸರನ್ನು ಖಾಲಿ ಬಿಟ್ಟರೆ, ಡೇಟಾ ಮೌಲ್ಯೀಕರಣ ಪ್ರಕ್ರಿಯೆಯು ದೋಷವನ್ನು ಫ್ಲ್ಯಾಗ್ ಮಾಡಬಹುದು ಅಥವಾ ವಿಂಗಡಿಸುವ ತರ್ಕವನ್ನು ಅನ್ವಯಿಸುವ ಮೊದಲು ಅಮಾನ್ಯ ನಮೂದುಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಫಿಲ್ಟರ್ ಮಾಡಬಹುದು. ಸಿಸ್ಟಮ್ನ ಡೇಟಾದ ಸಮಗ್ರತೆ ಮತ್ತು ನಿಖರತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಈ ಹಂತವು ಮುಖ್ಯವಾಗಿದೆ.

1. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಮೊದಲ ಐಟಂ ಮೂಲಕ ನೀವು ಶ್ರೇಣಿಯನ್ನು ಹೇಗೆ ವಿಂಗಡಿಸುತ್ತೀರಿ?
2. ನೀವು ಬಳಸಬಹುದು ವಿಧಾನ ಮತ್ತು ಕಸ್ಟಮ್ ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಮೊದಲ ಐಟಂಗಳನ್ನು ಹೋಲಿಕೆ ಮಾಡಿ, ಉದಾಹರಣೆಗೆ .
3. ಏನಾಗಿದೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಬಳಸಲಾಗಿದೆಯೇ?
4. ದಿ ವಿಧಾನವು ರಚನೆಯ ಅಂಶಗಳನ್ನು ದೇಶದಿಂದ ಗುಂಪು ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಪ್ರತಿ ದೇಶವು ಅದರ ನಗರಗಳನ್ನು ಮೌಲ್ಯಗಳಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವಸ್ತುವನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ.
5. ವಿಂಗಡಿಸುವ ಮೊದಲು ಶ್ರೇಣಿಯಲ್ಲಿ ಅಮಾನ್ಯವಾದ ಡೇಟಾವನ್ನು ನಾನು ಹೇಗೆ ನಿರ್ವಹಿಸಬಹುದು?
6. ಕಾಣೆಯಾದ ನಗರದ ಹೆಸರುಗಳು ಅಥವಾ ಅಮಾನ್ಯ ದಿನಾಂಕಗಳಂತಹ ದೋಷಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಡೇಟಾ ಮೌಲ್ಯೀಕರಣ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಬಳಸಿ ಮತ್ತು ವಿಂಗಡಿಸುವ ಮೊದಲು ಈ ನಮೂದುಗಳನ್ನು ಫ್ಲ್ಯಾಗ್ ಮಾಡಿ ಅಥವಾ ತೆಗೆದುಹಾಕಿ.
7. ನಾನು ದೇಶ ಮತ್ತು ನಗರ ಎರಡರಿಂದಲೂ ವಿಂಗಡಿಸಲು ಬಯಸಿದರೆ ಏನು ಮಾಡಬೇಕು?
8. ನಲ್ಲಿ ಕಾಲ್‌ಬ್ಯಾಕ್ ಅನ್ನು ನೀವು ಮಾರ್ಪಡಿಸಬಹುದು ಮೊದಲು ದೇಶಗಳನ್ನು ಹೋಲಿಸುವ ವಿಧಾನ, ಮತ್ತು ಅವು ಒಂದೇ ಆಗಿದ್ದರೆ, ಅದೇ ದೇಶದೊಳಗಿನ ನಗರಗಳನ್ನು ಹೋಲಿಕೆ ಮಾಡಿ.
9. ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್‌ಗೆ ವಿಂಗಡಣೆಯನ್ನು ನಾನು ಹೇಗೆ ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಮಾಡಬಹುದು?
10. ಪ್ರಚೋದಿಸುವ ಈವೆಂಟ್ ಕೇಳುಗರನ್ನು ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಹೊಸ ನಗರ ಅಥವಾ ದಿನಾಂಕವನ್ನು ಆಯ್ಕೆ ಮಾಡುವಂತಹ ಬದಲಾವಣೆಯನ್ನು ಬಳಕೆದಾರರು ಮಾಡಿದಾಗಲೆಲ್ಲಾ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಇಲ್ಲಿ ವಿವರಿಸಿರುವ ತಂತ್ರಗಳು ದೇಶದ ಪ್ರಕಾರ ಶ್ರೇಣಿಗಳನ್ನು ವಿಂಗಡಿಸಲು ಮತ್ತು ಗುಂಪು ಮಾಡಲು ಸುವ್ಯವಸ್ಥಿತ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತವೆ, ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮತ್ತು ವಿಭಿನ್ನ ಬಳಕೆದಾರರ ಸಂವಹನಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳುವಂತೆ ಮಾಡುತ್ತದೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸುವುದು ಡೇಟಾವನ್ನು ಸುಲಭವಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಸರಿಯಾದ ಸ್ವರೂಪದಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಈವೆಂಟ್-ಚಾಲಿತ ನವೀಕರಣಗಳು, ಡೇಟಾ ಮೌಲ್ಯೀಕರಣ ಮತ್ತು ಡೈನಾಮಿಕ್ ವಿಂಗಡಣೆಯೊಂದಿಗೆ, ಡೆವಲಪರ್‌ಗಳು ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಸರಾಗವಾಗಿ ನಿರ್ವಹಿಸುವ ಹೆಚ್ಚು ದೃಢವಾದ ವ್ಯವಸ್ಥೆಗಳನ್ನು ರಚಿಸಬಹುದು. ಈ ವಿಧಾನಗಳು ಡೈನಾಮಿಕ್ ಡೇಟಾ ನಿರ್ವಹಣೆಯನ್ನು ಒಳಗೊಂಡ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳಿಗೆ ಸ್ಕೇಲೆಬಲ್ ಪರಿಹಾರಗಳನ್ನು ನೀಡುತ್ತವೆ, ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ವಿಂಗಡಣೆಯು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಉಳಿಯುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.