ಅನಾವಶ್ಯಕ ಶ್ರೇಣೀಬದ್ಧತೆ, ಕಾಮೆಂಟ್‌ಗಳು ಮತ್ತು ವ್ಯಾಕರಣವನ್ನು ಸುಧಾರಿಸುವ ಮೂಲಕ ಕೋಡ್ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಉಚಿತ ಆನ್‌ಲೈನ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫೈಯರ್ ಸಾಧನ. ಯಾವುದೇ ಸ್ಥಾಪನೆಯ ಅಗತ್ಯವಿಲ್ಲ.
ಈ ಸರಳ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫೈಯರ್ ಅನಾವಶ್ಯಕ ಖಾಲಿ ಸ್ಥಳ ಮತ್ತು ಕಾಮೆಂಟ್‌ಗಳನ್ನು ತೆಗೆದು ಹಾಕುತ್ತದೆ, ನಿಮ್ಮ ಕೋಡ್‌ನ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು. ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉಳಿಸುತ್ತ while, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಸಂಕೀರ್ಣಗೊಳಿಸುತ್ತದೆ.
ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫಿಕೇಶನ್ ಎಂದರೆ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್‌ನಿಂದ ಅಗತ್ಯವಿಲ್ಲದ ಅಕ್ಷರಗಳನ್ನು ತೆಗೆದು ಹಾಕುವ ಪ್ರಕ್ರಿಯೆ, ಆದರೆ ಇದರ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಬದಲಾಯಿಸುತ್ತಿಲ್ಲ. ನಮ್ಮ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫೈಯರ್ ಸಾಧನವು ನಿಮ್ಮ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್‌ನ ಫೈಲ್ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಇದು ಖಾಲಿ ಸ್ಥಳವನ್ನು ತೆಗೆದು ಹಾಕುವುದು, ಕಾಮೆಂಟ್‌ಗಳನ್ನು ತೆಗೆದು ಹಾಕುವುದು ಮತ್ತು ಸಾಧ್ಯವಾದಲ್ಲಿ ಚರದ ಹೆಸರುಗಳನ್ನು ಚಿಕ್ಕದಾಗಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನಿಮ್ಮ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಮಿನಿಫೈ ಮಾಡುವುದು ವೆಬ್ ಆಪ್ಟಿಮೈಸೇಶನ್‌ನಲ್ಲಿ ಪ್ರಮುಖ ಹಂತವಾಗಿದೆ, ಇದು ನಿಮ್ಮ ವೆಬ್‌ಸೈಟ್‌ನ ಲೋಡ್ ವೇಗ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮಹತ್ವಪೂರ್ಣವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ.
ನೀವು ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಮಿನಿಫೈ ಮಾಡಿದಾಗ, ನೀವು ನಿಮ್ಮ ಕೋಡ್‌ನ ಒಗ್ಗೂಡಿತ ಆವೃತ್ತಿಯನ್ನು ರಚಿಸುತ್ತಿದ್ದೀರಿ, ಇದು ಬ್ರೌಸರ್‌ಗಳಿಗೆ ಡೌನ್‌ಲೋಡ್ ಮತ್ತು ಪಾರ್ಸ್ ಮಾಡಲು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ. ಈ ಸರಳ ಆದರೆ ಶಕ್ತಿಯುತ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫೈಯರ್ ಸಾಧನವು ನಿಮ್ಮ ಕೋಡ್ ಗಾತ್ರವನ್ನು ಕೇವಲ ಕೆಲವು ಕ್ಲಿಕ್‌ಗಳಲ್ಲಿ ತಕ್ಷಣ ಕಡಿಮೆ ಮಾಡಲು ನಿಮಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ, ನಿರ್ಮಾಣ ಸಾಧನಗಳು ಅಥವಾ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ಹೊಂದಿಸುವ ಸಂಕೀರ್ಣತೆಯಿಲ್ಲದೆ.
ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫಿಕೇಶನ್ ನಿಮ್ಮ ಕೋಡ್‌ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉಳಿಸುವಾಗ ಹಲವಾರು ಪರಿವರ್ತನೆಗಳನ್ನು ಅನ್ವಯಿಸುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನಮ್ಮ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫೈಯರ್ ಈ ಕೆಳಗಿನ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ:
ಖಾಲಿ ಸ್ಥಳವನ್ನು ತೆಗೆದು ಹಾಕುವುದು: ಓದುಗರಿಗಾಗಿ ಬಳಸುವ ಅಗತ್ಯವಿಲ್ಲದ ಸ್ಥಳಗಳು, ಟ್ಯಾಬ್‌ಗಳು ಮತ್ತು ಸಾಲು ಮುರಿಯುವಿಕೆಗಳನ್ನು ತೆಗೆದು ಹಾಕುತ್ತದೆ ಆದರೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅಗತ್ಯವಿಲ್ಲ.
ಕಾಮೆಂಟ್‌ಗಳನ್ನು ತೆಗೆದು ಹಾಕುವುದು: ಅಭಿವೃದ್ಧಿಕಾರರಿಗೆ ಸಹಾಯಕವಾದ ಆದರೆ ಉತ್ಪಾದನಾ ಕೋಡ್‌ನಲ್ಲಿ ಯಾವುದೇ ಉದ್ದೇಶವಿಲ್ಲದ ಏಕ ಸಾಲು (//) ಮತ್ತು ಬಹು ಸಾಲು (/* */) ಕಾಮೆಂಟ್‌ಗಳನ್ನು ತೆಗೆದು ಹಾಕುತ್ತದೆ.
ಸಿಂಟ್ಯಾಕ್ಸ್ ಆಪ್ಟಿಮೈಸೇಶನ್: ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನುಮತಿಸುವಲ್ಲಿ ಅಗತ್ಯವಿಲ್ಲದ ಸೆಮಿಕೋಲನ್‌ಗಳನ್ನು ಮತ್ತು ಕೊಠಡಿಗಳನ್ನು ತೆಗೆದು ಹಾಕುವ ಮೂಲಕ ಕೋಡ್ ಅನ್ನು ಚಿಕ್ಕದಾಗಿಸುತ್ತದೆ.
ಕಾರ್ಯಕ್ಷಮತೆಯ ಉಳಿವು: ನಿಮ್ಮ ಕೋಡ್ ಮಿನಿಫಿಕೇಶನ್ ನಂತರ ಉದ್ದೇಶಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಅಗತ್ಯವಿರುವ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್‌ಗಳು, ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳು ಮತ್ತು ಇತರ ಪ್ರಮುಖ ಕೋಡ್ ಅಂಶಗಳನ್ನು ಜಾಗರೂಕತೆಯಿಂದ ಉಳಿಸುತ್ತದೆ.
ಮಿನಿಫಿಕೇಶನ್ ಪ್ರಕ್ರಿಯೆ ಸಂಪೂರ್ಣವಾಗಿ ಕ್ಲೈಂಟ್-ಪಕ್ಷೀಯವಾಗಿದೆ, ಅಂದರೆ ನಿಮ್ಮ ಕೋಡ್ ನಿಮ್ಮ ಬ್ರೌಸರ್‌ನಿಂದ ಹೊರ ಹೋಗುವುದಿಲ್ಲ, ನಿಮ್ಮ ಸ್ವಂತ ಕೋಡ್‌ಗೆ ಸಂಪೂರ್ಣ ಗೌಪ್ಯತೆ ಮತ್ತು ಭದ್ರತೆಯನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ.
ನಮ್ಮ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫೈಯರ್ ಸಾಧನವನ್ನು ಬಳಸುವುದು ಸುಲಭವಾಗಿದೆ ಮತ್ತು ಯಾವುದೇ ತಾಂತ್ರಿಕ ಸೆಟಪ್ ಅಗತ್ಯವಿಲ್ಲ:
ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ನಮೂದಿಸಿ: ನಿಮ್ಮ ಅಮಿನಿಫೈ ಮಾಡಿದ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಇನ್ಪುಟ್ ಪಠ್ಯ ಪ್ರದೇಶದಲ್ಲಿ ಪೇಸ್ಟ್ ಮಾಡಿ. ನೀವು ಕಾಮೆಂಟ್‌ಗಳು, ಖಾಲಿ ಸ್ಥಳ ಮತ್ತು ಯಾವುದೇ ಮಾನ್ಯ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಒಳಗೊಂಡಿರಬಹುದು.
"ಮಿನಿಫೈ" ಕ್ಲಿಕ್ ಮಾಡಿ: ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಮಿನಿಫೈ ಬಟನ್ ಅನ್ನು ಒತ್ತಿ. ಸಾಧನವು ತಕ್ಷಣವೇ ಮಿನಿಫಿಕೇಶನ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.
ಫಲಿತಾಂಶಗಳನ್ನು ವೀಕ್ಷಿಸಿ: ನಿಮ್ಮ ಕೋಡ್‌ನ ಮಿನಿಫೈ ಮಾಡಿದ ಆವೃತ್ತಿ ಕೆಳಗಿನ ಔಟ್‌ಪುಟ್ ಪ್ರದೇಶದಲ್ಲಿ ತೋರಿಸಲಾಗುತ್ತದೆ. ನೀವು ಮೂಲ ಗಾತ್ರ, ಮಿನಿಫೈ ಮಾಡಿದ ಗಾತ್ರ ಮತ್ತು ಸಾಧಿಸಿದ ಶೇಕಡಾವಾರು ಕಡಿತವನ್ನು ತೋರಿಸುತ್ತಿರುವ ಅಂಕಿಅಂಶಗಳನ್ನು ಸಹ ಕಾಣುತ್ತೀರಿ.
ಮಿನಿಫೈ ಮಾಡಿದ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸಿ: "ಕಾಪಿ" ಬಟನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಕ್ಲಿಪ್‌ಬೋರ್ಡ್‌ಗೆ ಮಿನಿಫೈ ಮಾಡಿದ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸಿ, ನಿಮ್ಮ ವೆಬ್ ಯೋಜನೆಗಳಲ್ಲಿ ಬಳಸಲು ಸಿದ್ಧವಾಗಿದೆ.
ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಖಚಿತಪಡಿಸಿ: ನಿಮ್ಮ ಮಿನಿಫೈ ಮಾಡಿದ ಕೋಡ್ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ನಿರೀಕ್ಷಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಲು ಯಾವಾಗಲೂ ಪರೀಕ್ಷಿಸಿ.
ಈ ಸರಳ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಕಾರ್ಯಪ್ರವೃತ್ತಿಯಲ್ಲಿ ಬೇಕಾದಷ್ಟು ಬಾರಿ ಪುನರಾವೃತ್ತ ಮಾಡಬಹುದು, ನಿಮ್ಮ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್‌ಗಳನ್ನು ನಿಯೋಜನೆಯ ಮೊದಲು ತ್ವರಿತವಾಗಿ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ.
ನಿಮ್ಮ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಮಿನಿಫೈ ಮಾಡುವುದು ಹಲವಾರು ಪ್ರಮುಖ ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತದೆ:
ಚಿಕ್ಕ ಫೈಲ್ ಗಾತ್ರಗಳು ವೇಗವಾದ ಡೌನ್‌ಲೋಡ್ ಅನ್ನು ಅರ್ಥವಂತವಾಗಿಸುತ್ತವೆ, ವಿಶೇಷವಾಗಿ ಮೊಬೈಲ್ ಸಾಧನಗಳು ಅಥವಾ ನಿರ್ಬಂಧಿತ ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್ ಹೊಂದಿರುವ ಬಳಕೆದಾರರಿಗೆ. ಲೋಡ್ ಸಮಯದಲ್ಲಿ 100ms ಸುಧಾರಣೆ ಮಾಡಿದಾಗ 1% ವರೆಗೆ ಪರಿವರ್ತನೆ ದರವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ ಎಂದು ಸಂಶೋಧನೆ ತೋರಿಸುತ್ತದೆ.
ಮಿನಿಫೈ ಮಾಡಿದ ಫೈಲ್‌ಗಳು ವರ್ಗಾಯಿಸಲು ಕಡಿಮೆ ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್ ಅನ್ನು ಅಗತ್ಯವಿದೆ, ಹೋಸ್ಟಿಂಗ್ ವೆಚ್ಚಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಿರ್ಬಂಧಿತ ಇಂಟರ್‌ನೆಟ್ ಮೂಲಸೌಕರ್ಯಗಳಲ್ಲಿ ಉತ್ತಮ ಬಳಕೆದಾರ ಅನುಭವವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
ಪುಟದ ವೇಗವು ಗೂಗಲ್‌ನಂತಹ ಶೋಧ ಎಂಜಿನ್‌ಗಳಿಗೆ ಶ್ರೇಣೀಬದ್ಧಗೊಳಿಸುವ ಅಂಶವಾಗಿದೆ. ಮಿನಿಫೈ ಮಾಡಿದ ಸಂಪತ್ತುಗಳೊಂದಿಗೆ ವೇಗವಾಗಿ ಲೋಡ್ ಆಗುವ ವೆಬ್‌ಸೈಟ್‌ಗಳು ಶೋಧ ಫಲಿತಾಂಶಗಳಲ್ಲಿ ಹೆಚ್ಚು ಶ್ರೇಣೀಬದ್ಧವಾಗುತ್ತವೆ, ನಿಮ್ಮ ವೆಬ್‌ಸೈಟ್‌ನ ದೃಶ್ಯತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
ವೇಗವಾದ ಪುಟದ ಲೋಡ್‌ಗಳು ಉತ್ತಮ ಬಳಕೆದಾರ ನಿರ್ವಹಣೆಗೆ ಮತ್ತು ಕಡಿಮೆ ಬೌನ್ಸ್ ದರಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತವೆ. ಅಧ್ಯಯನಗಳು 53% ಮೊಬೈಲ್ ಬಳಕೆದಾರರು 3 ಸೆಕೆಂಡುಗಳ ಹೆಚ್ಚು ಲೋಡ್ ಮಾಡಲು ತಕ್ಷಣವೇ ತಿರಸ್ಕಾರಿಸುತ್ತಾರೆ ಎಂದು ತೋರಿಸುತ್ತವೆ.
ಚಿಕ್ಕ ಫೈಲ್‌ಗಳು ಡೌನ್‌ಲೋಡ್ ಮತ್ತು ಪಾರ್ಸ್ ಮಾಡಲು ಕಡಿಮೆ ಪ್ರಕ್ರಿಯಾತ್ಮಕ ಶಕ್ತಿಯನ್ನು ಅಗತ್ಯವಿದೆ, ಇದು ಸರ್ವರ್ ಮತ್ತು ಕ್ಲೈಂಟ್ ಎರಡರ ಕಡೆ ಶಕ್ತಿ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫಿಕೇಶನ್ ಅನೇಕ ದೃಷ್ಟಿಕೋನಗಳಲ್ಲಿ ಪ್ರಯೋಜನಕಾರಿ:
ಉತ್ಪಾದನಾ ಪರಿಸರಗಳಿಗೆ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿಯೋಜಿಸುವ ಮೊದಲು, ಅಭಿವೃದ್ಧಿಕಾರರು ಅಂತಿಮ ಬಳಕೆದಾರರ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್‌ಗಳನ್ನು ಮಿನಿಫೈ ಮಾಡುತ್ತಾರೆ.
ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್‌ಗಳನ್ನು CDN ಮೂಲಕ ಸೇವಿಸುವಾಗ, ಮಿನಿಫೈ ಮಾಡಿದ ಫೈಲ್‌ಗಳು ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್ ವೆಚ್ಚಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತವೆ ಮತ್ತು ಜಾಗತಿಕ ಜಾಲಗಳಲ್ಲಿ ವಿತರಣಾ ವೇಗವನ್ನು ಸುಧಾರಿಸುತ್ತವೆ.
ಮೊಬೈಲ್ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್ ಮತ್ತು ಪ್ರಕ್ರಿಯಾತ್ಮಕ ಶಕ್ತಿ ನಿರ್ಬಂಧಿತವಾಗಿರುವಾಗ, ಮಿನಿಫೈ ಮಾಡಿದ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಮುಖ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
SPAs ಸಾಮಾನ್ಯವಾಗಿ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಹೆಚ್ಚು ಅವಲಂಬಿತವಾಗಿರುತ್ತವೆ, ಇದು ಪ್ರಾರಂಭದ ಲೋಡ್ ಸಮಯಗಳು ಮತ್ತು ಒಟ್ಟು ಕಾರ್ಯಕ್ಷಮತೆಯು ಮಿನಿಫಿಕೇಶನಿಗೆ ವಿಶೇಷವಾಗಿ ಪ್ರಮುಖವಾಗಿಸುತ್ತದೆ.
ವಿಷಯ ನಿರ್ವಹಣಾ ವ್ಯವಸ್ಥೆಗಳು, ಉದಾಹರಣೆಗೆ ವರ್ಡ್‌ಪ್ರೆಸ್, ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಮಿನಿಫೈ ಮಾಡಿದಾಗ ವೆಬ್‌ಸೈಟ್ ವೇಗ ಮತ್ತು ಬಳಕೆದಾರ ಅನುಭವವನ್ನು ಸುಧಾರಿಸುತ್ತವೆ.
ಆನ್‌ಲೈನ್ ಅಂಗಡಿಗಳಿಗೆ ವೇಗವಾದ ಪುಟದ ಲೋಡ್‌ಗಳು ಕಾರ್ಟ್ ತಿರಸ್ಕಾರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮತ್ತು ಪರಿವರ್ತನೆ ದರವನ್ನು ಸುಧಾರಿಸಲು ಅಗತ್ಯವಿದೆ, ಇದರಿಂದ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫಿಕೇಶನ್ ಅತ್ಯಂತ ಪ್ರಮುಖವಾಗಿದೆ.
ನಮ್ಮ ಸಾಧನವು ಸರಳ ಮಿನಿಫಿಕೇಶನನ್ನು ಒದಗಿಸುತ್ತಿರುವಾಗ, ಪರಿಗಣಿಸಲು ಇತರ ವಿಧಾನಗಳಿವೆ:
Webpack, Rollup ಅಥವಾ Parcelಂತಹ ಸಾಧನಗಳು ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಯ ಭಾಗವಾಗಿ ಹೆಚ್ಚು ಸುಧಾರಿತ ಮಿನಿಫಿಕೇಶನನ್ನು ಒದಗಿಸುತ್ತವೆ, ಸಾಮಾನ್ಯವಾಗಿ Terser ಅಥವಾ UglifyJS ಅನ್ನು ಹಿಂಡಿಸುವ ಮೂಲಕ.
ಮೂಲಕ ಮಿನಿಫಿಕೇಶನನ್ನು ಮೀರಿಸುವಂತೆ, Google Closure Compilerಂತಹ ಸಾಧನಗಳು ಮೃತ ಕೋಡ್ ಉಲ್ಲೇಖ ಮತ್ತು ಕಾರ್ಯವನ್ನು ಒಳಗೊಂಡಂತೆ ಸುಧಾರಿತ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತವೆ.
ಮಿನಿಫಿಕೇಶನನ್ನು GZIP ಅಥವಾ Brotli ಒತ್ತಣೆ ಜೊತೆಗೆ ಸೇವಕ ಮಟ್ಟದಲ್ಲಿ ಒಟ್ಟಾಗಿ ಬಳಸುವುದು ಹೆಚ್ಚಿನ ಫೈಲ್ ಗಾತ್ರದ ಕಡಿತವನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಒಂದು ದೊಡ್ಡ ಫೈಲ್ ಅನ್ನು ಮಿನಿಫೈ ಮಾಡುವ ಬದಲು, ಬೇಡಿಕೆಯ ಸಮಯದಲ್ಲಿ ಲೋಡ್ ಆಗುವ ಚಿಕ್ಕ ಚುಟುಕುಗಳಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ವಿಭಜಿಸುವುದು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಇನ್ನಷ್ಟು ಸುಧಾರಿಸುತ್ತದೆ.
HTTP/2 ಯ ಮಲ್ಟಿಪ್ಲೆಕ್ಸಿಂಗ್ ಸಾಮರ್ಥ್ಯಗಳೊಂದಿಗೆ, ಬಹಳಷ್ಟು ಚಿಕ್ಕ ಫೈಲ್‌ಗಳು ಕೆಲವೊಂದು ದೊಡ್ಡದಾದ ಫೈಲ್‌ಗಳಿಗೆ ಹೋಲಿಸುತ್ತವೆ, ಇದು ಮಿನಿಫಿಕೇಶನ್ ತಂತ್ರವನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ.
ಇಲ್ಲಿ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಮಿನಿಫಿಕೇಶನ್ ಮುನ್ನ ಮತ್ತು ನಂತರ ತೋರಿಸುತ್ತಿರುವ ಕೆಲವು ಉದಾಹರಣೆಗಳು:
ಮಿನಿಫಿಕೇಶನ್ ಮುನ್ನ:
1// ಎರಡು ಸಂಖ್ಯೆಗಳ ಮೊತ್ತವನ್ನು ಲೆಕ್ಕಹಾಕಿ
2function addNumbers(a, b) {
3 // ಮೊತ್ತವನ್ನು ಹಿಂತಿರುಗಿಸಿ
4 return a + b;
5}
6
7// 5 ಮತ್ತು 10 ರೊಂದಿಗೆ ಕಾರ್ಯವನ್ನು ಕರೆ ಮಾಡಿ
8const result = addNumbers(5, 10);
9console.log("ಮೊತ್ತ: " + result);
10ಮಿನಿಫಿಕೇಶನ್ ನಂತರ:
1function addNumbers(a,b){return a+b}const result=addNumbers(5,10);console.log("ಮೊತ್ತ: "+result);
2ಮಿನಿಫಿಕೇಶನ್ ಮುನ್ನ:
1/**
2 * ಒಂದು ಸರಳ ಕೌಂಟರ್ ವರ್ಗ
3 * ಇದು ಒಂದು ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ ಮತ್ತು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ
4 */
5class Counter {
6 constructor(initialValue = 0) {
7 this.count = initialValue;
8 }
9
10 increment() {
11 return ++this.count;
12 }
13
14 decrement() {
15 return --this.count;
16 }
17
18 getValue() {
19 return this.count;
20 }
21}
22
23// ಹೊಸ ಕೌಂಟರ್ ಅನ್ನು ರಚಿಸಿ
24const myCounter = new Counter(10);
25console.log(myCounter.increment()); // 11
26console.log(myCounter.increment()); // 12
27console.log(myCounter.decrement()); // 11
28ಮಿನಿಫಿಕೇಶನ್ ನಂತರ:
1class Counter{constructor(initialValue=0){this.count=initialValue}increment(){return++this.count}decrement(){return--this.count}getValue(){return this.count}}const myCounter=new Counter(10);console.log(myCounter.increment());console.log(myCounter.increment());console.log(myCounter.decrement());
2ಮಿನಿಫಿಕೇಶನ್ ಮುನ್ನ:
1// DOM ಸಂಪೂರ್ಣವಾಗಿ ಲೋಡ್ ಆಗುವವರೆಗೆ ಕಾಯಿರಿ
2document.addEventListener('DOMContentLoaded', function() {
3 // ಬಟನ್ ಅಂಶವನ್ನು ಪಡೆಯಿರಿ
4 const button = document.getElementById('myButton');
5
6 // ಕ್ಲಿಕ್ ಘಟನೆ ಶ್ರೋತವನ್ನು ಸೇರಿಸಿ
7 button.addEventListener('click', function() {
8 // ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ಪಠ್ಯವನ್ನು ಬದಲಾಯಿಸಿ
9 this.textContent = 'ಕ್ಲಿಕ್ ಮಾಡಲಾಗಿದೆ!';
10
11 // CSS ವರ್ಗವನ್ನು ಸೇರಿಸಿ
12 this.classList.add('active');
13
14 // ಕನ್ಸೋಲ್‌ಗೆ ಲಾಗ್ ಮಾಡಿ
15 console.log('ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಲಾಯಿತು: ' + new Date().toLocaleTimeString());
16 });
17});
18ಮಿನಿಫಿಕೇಶನ್ ನಂತರ:
1document.addEventListener('DOMContentLoaded',function(){const button=document.getElementById('myButton');button.addEventListener('click',function(){this.textContent='ಕ್ಲಿಕ್ ಮಾಡಲಾಗಿದೆ!';this.classList.add('active');console.log('ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಲಾಯಿತು: '+new Date().toLocaleTimeString());});});
2ನಮ್ಮ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫೈಯರ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉಳಿಸುವಾಗ ಕೋಡ್ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಹಲವಾರು ತಂತ್ರಗಳನ್ನು ಬಳಸುತ್ತದೆ:
ಮಿನಿಫೈಯರ್ ತೆಗೆದು ಹಾಕುತ್ತದೆ:
ಎಲ್ಲಾ ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಕೋಡ್‌ನಿಂದ ತೆಗೆದು ಹಾಕಲಾಗುತ್ತದೆ:
// ಕಾಮೆಂಟ್)/* ಕಾಮೆಂಟ್ */)/** ಡಾಕ್ಯುಮೆಂಟೇಶನ್ */)ಮಿನಿಫೈಯರ್ ಜಾಗರೂಕತೆಯಿಂದ ಉಳಿಸುತ್ತದೆ:
"ಉದಾಹರಣೆ")'ಉದಾಹರಣೆ')`ಉದಾಹರಣೆ ${ಚರ`}`)\n, \", ಇತ್ಯಾದಿ)ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಉಳಿಸಲಾಗಿದೆ, ಇದರಲ್ಲಿ:
/ಪ್ಯಾಟರ್ನ್/ಫ್ಲಾಗ್‌ಗಳು)ಮಿನಿಫೈಯರ್ ಸೆಮಿಕೋಲನ್‌ಗಳನ್ನು ಜಾಗರೂಕತೆಯಿಂದ ನಿರ್ವಹಿಸುತ್ತದೆ:
ನಮ್ಮ ಸರಳ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫೈಯರ್ ಕೆಲವು ಮಿತಿಗಳನ್ನು ಹೊಂದಿದೆ:
ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫಿಕೇಶನ್ ಎಂದರೆ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್‌ನಿಂದ ಅಗತ್ಯವಿಲ್ಲದ ಅಕ್ಷರಗಳನ್ನು (ಖಾಲಿ ಸ್ಥಳ, ಕಾಮೆಂಟ್‌ಗಳು, ಇತ್ಯಾದಿ) ತೆಗೆದು ಹಾಕುವ ಪ್ರಕ್ರಿಯೆ, ಆದರೆ ಇದರ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಬದಲಾಯಿಸುತ್ತಿಲ್ಲ. ಗುರಿ ಫೈಲ್ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು, ಇದು ಲೋಡ್ ಸಮಯವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ ಮತ್ತು ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ಮಿನಿಫೈ ಮಾಡಿದ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಓದುಗರಿಗೆ ಓದಲು ಕಷ್ಟಕರವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ಓದುವಿಕೆಯ ಮೇಲೆ ಫೈಲ್ ಗಾತ್ರವನ್ನು ಆದ್ಯತೆಯಾಗಿದೆ. ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಡಿಬಗಿಂಗ್‌ಗಾಗಿ, ನಿಮ್ಮ ಕೋಡ್‌ನ ಅಮಿನಿಫೈ ಮಾಡಿದ ಆವೃತ್ತಿಯನ್ನು ಯಾವಾಗಲೂ ಇಟ್ಟುಕೊಳ್ಳಬೇಕು.
ಸರಿಯಾಗಿ ಮಾಡಿದಾಗ, ಮಿನಿಫಿಕೇಶನ್ ನಿಮ್ಮ ಕೋಡ್ ಕಾರ್ಯನಿರ್ವಹಣೆಯನ್ನು ಬದಲಾಯಿಸಬಾರದು. ಮಿನಿಫೈ ಮಾಡಿದ ಕೋಡ್ ಮೂಲ ಕೋಡ್‌ನಂತೆ ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ಆದರೆ ಚಿಕ್ಕ ಫೈಲ್ ಗಾತ್ರವನ್ನು ಹೊಂದಿದೆ.
ಕೋಡ್ ಶೈಲಿಯ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿ ಗಾತ್ರದ ಕಡಿತವು ಬದಲಾಗುತ್ತದೆ, ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ ನೀವು 30-60% ಗಾತ್ರದ ಕಡಿತವನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು. ಕಾಮೆಂಟ್‌ಗಳು ಮತ್ತು ವ್ಯಾಪಕ ಖಾಲಿ ಸ್ಥಳವನ್ನು ಹೊಂದಿರುವ ಕೋಡ್‌ಗಳು ದೊಡ್ಡ ಕಡಿತಗಳನ್ನು ಕಾಣುತ್ತವೆ.
ಇಲ್ಲ. ಮಿನಿಫಿಕೇಶನ್ ಕೋಡ್‌ನಲ್ಲಿನ ಅಗತ್ಯವಿಲ್ಲದ ಅಕ್ಷರಗಳನ್ನು ತೆಗೆದು ಹಾಕುತ್ತದೆ, ಆದರೆ ಒತ್ತಣೆ (GZIP ಹೋಲಿಸುವಂತೆ) ಫೈಲ್ ಅನ್ನು ಪ್ರಸಾರಕ್ಕಾಗಿ ಎನ್‌ಕೋಡ್ ಮಾಡಲು ಆಲ್ಗೋರಿθಮ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಎರಡನ್ನು ಒಟ್ಟಾಗಿ ಬಳಸುವುದು ಗರಿಷ್ಠ ಗಾತ್ರದ ಕಡಿತಕ್ಕಾಗಿ.
ಉತ್ತಮ ಅಭ್ಯಾಸವೆಂದರೆ, ಉತ್ತಮ ಡಿಬಗಿಂಗ್ ಮತ್ತು ಓದುವಿಕೆಗೆ ಅಮಿನಿಫೈ ಮಾಡಿದ ಕೋಡ್‌ಗಳನ್ನು ಬಳಸುವುದು, ನಂತರ ಉತ್ಪಾದನೆಯಲ್ಲಿ ನಿಯೋಜಿಸುವಾಗ ನಿಮ್ಮ ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಯ ಭಾಗವಾಗಿ ಮಿನಿಫೈ ಮಾಡುವುದು.
ನೀವು ಮಿನಿಫೈ ಮಾಡಿದ ಕೋಡ್ ಅನ್ನು ಓದಲು ಹೆಚ್ಚುReadable ಮಾಡಲು (ಪ್ರೀಟಿಫೈಯಿಂಗ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ) ಫಾರ್ಮಾಟ್ ಮಾಡಬಹುದು, ಆದರೆ ಮೂಲ ಕಾಮೆಂಟ್‌ಗಳು ಮತ್ತು ಚರದ ಹೆಸರುಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪುನಃಸ್ಥಾಪಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ನಿಮ್ಮ ಮೂಲ ಮೂಲ ಕೋಡ್‌ನ ಬ್ಯಾಕ್‌ಅಪ್ ಅನ್ನು ಯಾವಾಗಲೂ ಇಟ್ಟುಕೊಳ್ಳಿ.
ಹೌದು. ನಮ್ಮ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಮಿನಿಫೈಯರ್ ಸಂಪೂರ್ಣವಾಗಿ ನಿಮ್ಮ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ. ನಿಮ್ಮ ಕೋಡ್ ಯಾವುದೇ ಸರ್ವರ್‌ಗೆ ಕಳುಹಿಸಲಾಗುವುದಿಲ್ಲ, ಸಂಪೂರ್ಣ ಗೌಪ್ಯತೆ ಮತ್ತು ಭದ್ರತೆಯನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ.
ಹೌದು, ನಮ್ಮ ಮಿನಿಫೈಯರ್ ಆಧುನಿಕ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಇದರಲ್ಲಿ ES6+ ವೈಶಿಷ್ಟ್ಯಗಳು, ಅರೆ ಫಂಕ್ಶನ್‌ಗಳು, ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್‌ಗಳು ಮತ್ತು ವರ್ಗಗಳು ಸೇರಿವೆ.
ಮಿನಿಫಿಕೇಶನ್ ಫೈಲ್ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುವುದರಲ್ಲಿ ಕೇಂದ್ರೀಕೃತವಾಗಿದೆ, ಆದರೆ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉಳಿಸುತ್ತದೆ. ಒಬ್ಬ್ಫಸ್ಕೇಶನ್ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಷ್ಟಕರವಾಗಿಸುತ್ತದೆ, ಬುದ್ಧಿವಂತಿಕೆಯ ಆಸ್ತಿ ರಕ್ಷಿಸಲು, ಸಾಮಾನ್ಯವಾಗಿ ಕೆಲವು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ತ್ಯಜಿಸುವ ಮೂಲಕ.
ನಿಮ್ಮ ಜಾವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಲು ಸಿದ್ಧವಾಗಿದ್ದೀರಾ? ನಮ್ಮ ಮಿನಿಫೈಯರ್ ಅನ್ನು ಈಗ ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್ ಎಷ್ಟು ಚಿಕ್ಕದಾಗಬಹುದು ಎಂದು ನೋಡಿ. ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪೇಸ್ಟ್ ಮಾಡಿ, "ಮಿನಿಫೈ" ಕ್ಲಿಕ್ ಮಾಡಿ, ಮತ್ತು ಮಾಯಾಜಾಲವನ್ನು ನೋಡಿ!
ನಿಮ್ಮ ಕೆಲಸದ ಹಂತಕ್ಕೆ ಉಪಯೋಗಿಸಬಹುದಾದ ಹೆಚ್ಚು ಉಪಕರಣಗಳನ್ನು ಹುಡುಕಿ ಹೊಸ ಉಪಕರಣಗಳನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ