ಯಂತ್ರದ ಪ್ರಕಾರ, ಬ್ರೌಸರ್ ಕುಟುಂಬ ಮತ್ತು ಕಾರ್ಯಾಚರಣೆ ವ್ಯವಸ್ಥೆ ಮೂಲಕ ಶ್ರೇಣೀಬದ್ಧಿಸಲು ಆಯ್ಕೆಗಳು ಹೊಂದಿರುವ ವಾಸ್ತವಿಕ ಬ್ರೌಸರ್ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸಿ. ವೆಬ್ ಅಭಿವೃದ್ಧಿ ಪರೀಕ್ಷೆ ಮತ್ತು ಹೊಂದಾಣಿಕೆ ಪರಿಶೀಲನೆಗಾಗಿ ಪರಿಪೂರ್ಣ.
ವೆಬ್ ಅಭಿವೃದ್ಧಿ ಪರೀಕ್ಷೆಗೆ ಯಾದೃಚ್ಛಿಕ, ವಾಸ್ತವಿಕ ಬ್ರೌಸರ್ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸಿ.
ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್ ಎಂಬುದು ವೆಬ್ ಬ್ರೌಸರ್ಗಳು ಮತ್ತು ಇತರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ತಮ್ಮನ್ನು ವೆಬ್‌ಸೈಟ್‌ಗಳಿಗೆ ಗುರುತಿಸಲು ಕಳುಹಿಸುವ ನಿರ್ದಿಷ್ಟ ಪಠ್ಯ ಗುರುತಿಸುವಿಕೆ. ಈ ಸ್ಟ್ರಿಂಗ್ ಸಾಮಾನ್ಯವಾಗಿ ಬ್ರೌಸರ್, ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆ, ಸಾಧನದ ಪ್ರಕಾರ ಮತ್ತು ಬಳಸುವ ರೆಂಡರಿಂಗ್ ಎಂಜಿನ್ ಬಗ್ಗೆ ಮಾಹಿತಿ ಒಳಗೊಂಡಿರುತ್ತದೆ. ವೆಬ್ ಅಭಿವೃದ್ಧಿಕಾರರು ಮತ್ತು ಪರೀಕ್ಷಕರಿಗೆ, ವಿವಿಧ ವಾಸ್ತವಿಕ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗೆ ಪ್ರವೇಶ ಹೊಂದಿರುವುದು ವೆಬ್‌ಸೈಟ್‌ಗಳ ಹೊಂದಾಣಿಕೆ, ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕತೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ವಿವಿಧ ವೇದಿಕೆಗಳಲ್ಲಿ ಪರೀಕ್ಷಿಸಲು ಅಗತ್ಯವಿದೆ.
ಈ ಯಾದೃಚ್ಛಿಕ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಜನರೇಟರ್ ಸಾಧನವು ನಿಮ್ಮ ಆಯ್ಕೆಯ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಆಧರಿಸಿ ನಿಜವಾದಂತೆ ಕಾಣುವ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ರಚಿಸುತ್ತದೆ. ನೀವು ಸಾಧನದ ಪ್ರಕಾರ (ಡೆಸ್ಕ್‌ಟಾಪ್ ಅಥವಾ ಮೊಬೈಲ್), ಬ್ರೌಸರ್ ಕುಟುಂಬ (ಕ್ರೋಮ್, ಫೈರ್‌ಫಾಕ್ಸ್, ಸಾಫಾರಿ ಅಥವಾ ಎಡ್ಜ್) ಮತ್ತು ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆ ಮೂಲಕ ಫಿಲ್ಟರ್ ಮಾಡಬಹುದು, ನಿಮ್ಮ ಪರೀಕ್ಷಾ ಅಗತ್ಯಗಳಿಗೆ ಹೊಂದುವ ಬಳಕೆದಾರ ಏಜೆಂಟ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸಲು. ಈ ಸಾಧನವು ಒಬ್ಬ ಕ್ಲಿಕ್‌ನಲ್ಲಿ ಉತ್ಪಾದಿತ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನಕಲಿಸಲು ಆಯ್ಕೆಗಳು ಮತ್ತು ತಕ್ಷಣವೇ ಹೊಸ ಯಾದೃಚ್ಛಿಕ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಸರಳ ಇಂಟರ್ಫೇಸನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಬ್ರೌಸರ್ ಮತ್ತು ವೇದಿಕೆಯ ಆಧಾರದಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಮಾದರಿಗಳನ್ನು ಅನುಸರಿಸುತ್ತವೆ, ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ ಹಲವಾರು ಸಾಮಾನ್ಯ ಘಟಕಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ:
ಮೇಲಿನ ಪ್ರಮುಖ ಬ್ರೌಸರ್ಗಳಿಗೆ ಸಾಮಾನ್ಯ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ರಚನೆಗಳ ವಿವರ ಇಲ್ಲಿದೆ:
1Mozilla/5.0 (ಪ್ಲಾಟ್‌ಫಾರ್ಮ್; ವಿವರಗಳು) AppleWebKit/537.36 (KHTML, ಜೆಕ್ಕೋ ಹೋಲಿಸುವಂತೆ) Chrome/ಆವೃತ್ತಿ Safari/537.36
21Mozilla/5.0 (ಪ್ಲಾಟ್‌ಫಾರ್ಮ್; rv:geckoversion) Gecko/geckotrail Firefox/firefoxversion
21Mozilla/5.0 (ಪ್ಲಾಟ್‌ಫಾರ್ಮ್) AppleWebKit/webkitversion (KHTML, ಜೆಕ್ಕೋ ಹೋಲಿಸುವಂತೆ) Version/safariversion Safari/safariversion
21Mozilla/5.0 (ಪ್ಲಾಟ್‌ಫಾರ್ಮ್) AppleWebKit/537.36 (KHTML, ಜೆಕ್ಕೋ ಹೋಲಿಸುವಂತೆ) Chrome/chromiumversion Safari/537.36 Edg/edgeversion
2ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ವಿಭಾಗವು ಡೆಸ್ಕ್‌ಟಾಪ್ ಮತ್ತು ಮೊಬೈಲ್ ಸಾಧನಗಳ ನಡುವೆ ಬಹಳ ವ್ಯತ್ಯಾಸವಾಗುತ್ತದೆ:
ಡೆಸ್ಕ್‌ಟಾಪ್ ಉದಾಹರಣೆಗಳು:
Windows NT 10.0; Win64; x64Macintosh; Intel Mac OS X 10_15_7X11; Linux x86_64ಮೊಬೈಲ್ ಉದಾಹರಣೆಗಳು:
Linux; Android 12; SM-G998BiPhone; CPU iPhone OS 15_4 like Mac OS Xಡೆಸ್ಕ್‌ಟಾಪ್ ಬಳಕೆದಾರ ಏಜೆಂಟ್‌ಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯ ಮಾಹಿತಿಯನ್ನು, ವಾಸ್ತವಿಕತೆಯ ವಿವರಗಳನ್ನು (x86_64 ಅಥವಾ Win64) ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ಭಾಷಾ ಆದ್ಯತೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ. ಇವು ಮೊಬೈಲ್ ಬಳಕೆದಾರ ಏಜೆಂಟ್‌ಗಳ ಹೋಲಿಸಿದರೆ ಹೆಚ್ಚು ಸಮ್ಮಿಲಿತವಾಗಿರುತ್ತವೆ.
ಮೊಬೈಲ್ ಬಳಕೆದಾರ ಏಜೆಂಟ್‌ಗಳಲ್ಲಿ ಸಾಧನ ಮಾದರಿಯ ಮಾಹಿತಿಯನ್ನು, ಮೊಬೈಲ್ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯ ಆವೃತ್ತಿಗಳನ್ನು ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಕೊನೆಯಲ್ಲಿ "ಮೊಬೈಲ್" ಶಬ್ದವನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ. ಐಒಎಸ್ ಸಾಧನಗಳ ಮೇಲೆ ಮೊಬೈಲ್ ಸಾಫಾರಿಗೆ "iPhone" ಅಥವಾ "iPad" ಗುರುತಿಸುವಿಕೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ, ಆದರೆ ಆಂಡ್ರಾಯ್ಡ್ ಸಾಧನಗಳು ತಯಾರಕರ ಮತ್ತು ಮಾದರಿಯ ಸಂಖ್ಯೆಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ.
ಪ್ರತಿ ಬ್ರೌಸರ್ ವಿಭಿನ್ನ ಆವೃತ್ತಿ ಮಾದರಿಗಳನ್ನು ಅನುಸರಿಸುತ್ತವೆ:
ಯಾದೃಚ್ಛಿಕ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಉತ್ಪಾದನೆಯು ವೆಬ್ ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಪರೀಕ್ಷೆಯಲ್ಲಿ ಹಲವಾರು ಪ್ರಮುಖ ಅನ್ವಯಗಳನ್ನು ಹೊಂದಿದೆ:
ಕ್ರಾಸ್-ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆ ಪರೀಕ್ಷೆ: ನಿಮ್ಮ ವೆಬ್‌ಸೈಟ್‌ವು ವಿವಿಧ ಬ್ರೌಸರ್‌ಗಳಲ್ಲಿ ಹೇಗೆ ಪ್ರದರ್ಶಿಸುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಪರೀಕ್ಷಿಸಲು, ಹಲವಾರು ಬ್ರೌಸರ್‌ಗಳನ್ನು ಅಥವಾ ಸಾಧನಗಳನ್ನು ಸ್ಥಾಪಿಸಲು ಅಗತ್ಯವಿಲ್ಲ.
ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ವಿನ್ಯಾಸ ಪರೀಕ್ಷೆ: ನಿಮ್ಮ ವೆಬ್‌ಸೈಟ್ ಮೊಬೈಲ್ ಮತ್ತು ಡೆಸ್ಕ್‌ಟಾಪ್ ಸಾಧನಗಳನ್ನು ಸರಿಯಾಗಿ ಗುರುತಿಸುತ್ತೆ ಮತ್ತು ಸೂಕ್ತ ವಿನ್ಯಾಸವನ್ನು ಒದಗಿಸುತ್ತೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
ಫೀಚರ್ ಡಿಟೆಕ್ಷನ್ ದೃಢೀಕರಣ: ವಿಭಿನ್ನ ಬ್ರೌಸರ್ ಸಾಮರ್ಥ್ಯಗಳಿಗಾಗಿ ನಿಮ್ಮ ವೆಬ್‌ಸೈಟ್‌ನ ಫೀಚರ್ ಡಿಟೆಕ್ಷನ್ ಯಂತ್ರಣಗಳು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
QA ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ ಪರೀಕ್ಷೆ: ನಿಮ್ಮ ಸ್ವಯಂಚಾಲಿತ ಪರೀಕ್ಷಾ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ವಿಭಿನ್ನ ಬಳಕೆದಾರ ಏಜೆಂಟ್‌ಗಳನ್ನು ಸೇರಿಸಿ, ವಿವಿಧ ಬಳಕೆದಾರ ಪರಿಸರಗಳನ್ನು ಅನುಕರಿಸಲು.
ಕಾರ್ಯಕ್ಷಮತೆ ಪರೀಕ್ಷೆ: ನಿಮ್ಮ ವೆಬ್‌ಸೈಟ್ ವಿಭಿನ್ನ ಬ್ರೌಸರ್ ಪರಿಸರಗಳಿಂದ ಪ್ರವೇಶಿಸಿದಾಗ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ವಿಶ್ಲೇಷಿಸಿ.
ಬ್ರೌಸರ್-ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಗಳನ್ನು ಡಿಬಗ್ ಮಾಡುವುದು: ನಿರ್ದಿಷ್ಟ ಬ್ರೌಸರ್‌ಗಳಲ್ಲಿ ಅಥವಾ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಮಾತ್ರ ಸಂಭವಿಸುವ ದೋಷಗಳನ್ನು ಪುನರಾವೃತ್ತಗೊಳಿಸಲು ಮತ್ತು ಸರಿಪಡಿಸಲು.
API ಪರೀಕ್ಷೆ: ವಿಭಿನ್ನ ಕ್ಲೈಂಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಂದ ಬರುವ ವಿನಂತಿಗಳನ್ನು ನಿಮ್ಮ API ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಪರೀಕ್ಷಿಸಿ.
ನಮ್ಮ ಯಾದೃಚ್ಛಿಕ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಜನರೇಟರ್ ಹಲವಾರು ಪರೀಕ್ಷಾ ದೃಶ್ಯಗಳಲ್ಲಿ ಉಪಯುಕ್ತವಾಗಿದ್ದರೂ, ಪರ್ಯಾಯ ವಿಧಾನಗಳಿವೆ:
ಬ್ರೌಸರ್ ಪರೀಕ್ಷಾ ಸೇವೆಗಳು: BrowserStack, Sauce Labs ಅಥವಾ LambdaTest ಎಂಬ ವೇದಿಕೆಗಳು, ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಅನ್ನು ಕೇವಲ ಅನುಕರಿಸುವುದರ ಬದಲು, ಪರೀಕ್ಷೆಗಾಗಿ ವಾಸ್ತವ ಬ್ರೌಸರ್ ಉದಾಹರಣೆಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ.
ಬ್ರೌಸರ್ ಅಭಿವೃದ್ಧಿ ಸಾಧನಗಳು: ಬಹುತೇಕ ಆಧುನಿಕ ಬ್ರೌಸರ್ಗಳು ತಮ್ಮ ಅಭಿವೃದ್ಧಿ ಸಾಧನಗಳ ಮೂಲಕ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಅನ್ನು ಮರುಪೂರಣ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತವೆ, ಇದು ತ್ವರಿತ ಪರೀಕ್ಷೆಗಳಿಗೆ ಉಪಯುಕ್ತವಾಗಬಹುದು.
ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ವಿಚರ್ ವಿಸ್ತರಣೆಗಳು: ಬ್ರೌಸರ್ ವಿಸ್ತರಣೆಗಳು, ಬ್ರೌಸಿಂಗ್ ಮಾಡುವಾಗ ಪೂರ್ವನಿಯೋಜಿತ ಬಳಕೆದಾರ ಏಜೆಂಟ್‌ಗಳನ್ನು ಸ್ವಿಚ್ ಮಾಡಲು ನಿಮಗೆ ಅವಕಾಶ ನೀಡುತ್ತವೆ.
ವರ್ಚುಯಲ್ ಯಂತ್ರಗಳು ಅಥವಾ ಕಂಟೈನರ್‌ಗಳು: ವಿಭಿನ್ನ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಗಳ ಮತ್ತು ಬ್ರೌಸರ್‌ಗಳ ವಾಸ್ತವ ಉದಾಹರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಅತ್ಯಂತ ಖಚಿತವಾದ ಪರೀಕ್ಷೆಗಾಗಿ.
ಹೆಡ್‌ಲೆಸ್ ಬ್ರೌಸರ್ ಪರೀಕ್ಷೆ: Puppeteer ಅಥವಾ Selenium ಎಂಬ ಸಾಧನಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ವಿಭಿನ್ನ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸೆಟಿಂಗ್‌ಗಳೊಂದಿಗೆ ಬ್ರೌಸರ್ನ್ನು ಪ್ರೋಗ್ರಾಮatically ನಿಯಂತ್ರಿಸುವುದು.
ಪ್ರತಿ ಪರ್ಯಾಯವು ತನ್ನದೇ ಆದ ಲಾಭಗಳನ್ನು ಹೊಂದಿದ್ದು, ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಪರೀಕ್ಷಾ ಅಗತ್ಯಗಳು ಮತ್ತು ಸಂಪತ್ತುಗಳನ್ನು ಆಧರಿಸಿ ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿರಬಹುದು.
ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಪರಿಕಲ್ಪನೆಯು ವಿಶ್ವದ ವೆಬ್‌ನ ಆರಂಭದ ದಿನಗಳಿಂದಲೂ ಇದೆ. "ಬಳಕೆದಾರ ಏಜೆಂಟ್" ಎಂಬ ಶಬ್ದವು HTTP ನಿರ್ದೇಶನದಿಂದ ಬಂದಿದೆ, ಇದು ವೆಬ್ ಸರ್ವರ್‌ಗೆ ವಿನಂತಿಯನ್ನು ಮಾಡುವ ಕ್ಲೈಂಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ.
ಪ್ರಥಮವಾಗಿ ವ್ಯಾಪಕವಾಗಿ ಬಳಸುವ ಬ್ರೌಸರ್, NCSA Mosaic, ಬ್ರೌಸರ್ ಹೆಸರು ಮತ್ತು ಆವೃತ್ತಿಯನ್ನು ಗುರುತಿಸುವುದು ಒಳಗೊಂಡ ಸರಳ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಒಳಗೊಂಡಿತ್ತು. Netscape Navigator ಬಿಡುಗಡೆ ಆದಾಗ, ಇದು ಸಮಾನ ಮಾದರಿಯನ್ನು ಬಳಸಿತು. ಆದರೆ, ವೆಬ್ ಸರ್ವರ್‌ಗಳು ಬ್ರೌಸರ್ ಆಧಾರದಲ್ಲಿ ವಿಭಿನ್ನ ವಿಷಯವನ್ನು ಒದಗಿಸಲು ಆರಂಭಿಸಿದಾಗ, "ಬ್ರೌಸರ್ ಸ್ನಿಫಿಂಗ್" ಎಂದು ಕರೆಯುವ ಅಭ್ಯಾಸವು ಉದ್ಭವಿಸಿತು.
Netscape ಮತ್ತು Internet Explorer ನಡುವಿನ ಬ್ರೌಸರ್ ಯುದ್ಧಗಳ ಸಮಯದಲ್ಲಿ, ವೆಬ್‌ಸೈಟ್‌ಗಳು ನಿರ್ದಿಷ್ಟ ಬ್ರೌಸರ್ಗಳಿಗೆ ಮಾತ್ರ ಸುಧಾರಿತ ವಿಷಯವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಹೊಂದಾಣಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸಲು, ಬ್ರೌಸರ್ಗಳು ತಮ್ಮನ್ನು ಇತರ ಬ್ರೌಸರ್ಗಳಂತೆ ಗುರುತಿಸಲು ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಸೇರಿಸಲು ಆರಂಭಿಸಿದರು. ಇದು ಅಂದಿನಿಂದ, ಬಹುತೇಕ ಆಧುನಿಕ ಬ್ರೌಸರ್ಗಳು ತಮ್ಮ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳಲ್ಲಿ "Mozilla" ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಇದು Netscape Navigator ನ ಕೋಡ್ ಹೆಸರಿನ ಉಲ್ಲೇಖವಾಗಿದೆ.
ಮೊಬೈಲ್ ಸಾಧನಗಳ ಏರಿಕೆಯಿಂದ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗೆ ಹೊಸ ಸಂಕೀರ್ಣತೆ ಸೇರಿತು. ಮೊಬೈಲ್ ಬ್ರೌಸರ್ಗಳಿಗೆ ತಮ್ಮನ್ನು ಮೊಬೈಲ್ ಎಂದು ಗುರುತಿಸಲು ಅಗತ್ಯವಿತ್ತು, ಇದರಿಂದ ಸಾಧನ ಗುರುತಿಸುವಿಕೆಗಳು ಮತ್ತು ಮೊಬೈಲ್-ನಿರ್ದಿಷ್ಟ ಟೋಕನ್‌ಗಳನ್ನು ಸೇರಿಸಲು ಕಾರಣವಾಯಿತು.
ವೆಬ್ ಪರಿಸರವು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿರುವಂತೆ, ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಹೆಚ್ಚು ಗೊಂದಲಗೊಂಡವು. ಇವು ಈಗ ಬಹಳಷ್ಟು ಬ್ರೌಸರ್ ಎಂಜಿನ್‌ಗಳಿಗೆ (ಹಾಗೆ "AppleWebKit" ಮತ್ತು "Gecko") ಉಲ್ಲೇಖಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ, ಆದರೆ ಆ ಎಂಜಿನ್‌ಗಳನ್ನು ವಾಸ್ತವವಾಗಿ ಬಳಸುವುದಿಲ್ಲ.
ಈ ಸಂಕೀರ್ಣತೆ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಖಚಿತವಾಗಿ ಪಾರ್ಸ್ ಮಾಡಲು ಸವಾಲುಗಳನ್ನು ಉಂಟುಮಾಡಿದೆ, ಮತ್ತು ಕೆಲವು ವೆಬ್ ಪ್ರಮಾಣಿತ ಗುಂಪುಗಳು ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಹೀನಾಯಗೊಳಿಸಲು ಅಥವಾ ಸರಳಗೊಳಿಸಲು ಶಿಫಾರಸು ಮಾಡಿದ್ದಾರೆ. ಆದರೆ, ಹಿಂದಿನ ಹೊಂದಾಣಿಕೆ ಕಾರಣಕ್ಕಾಗಿ, ಪರಂಪರাগত ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್ ವೆಬ್ ಬ್ರೌಸಿಂಗ್‌ನ ಪ್ರಮುಖ ಭಾಗವಾಗಿದೆ.
ಇಲ್ಲಿ ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳಿವೆ:
1// ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್: ಬಳಕೆದಾರ ಏಜೆಂಟ್‌ನಿಂದ ಬ್ರೌಸರ್ ಪ್ರಕಾರವನ್ನು ಗುರುತಿಸುವುದು
2function detectBrowser() {
3 const userAgent = navigator.userAgent;
4
5 if (userAgent.indexOf("Firefox") > -1) {
6 return "ಫೈರ್‌ಫಾಕ್ಸ್";
7 } else if (userAgent.indexOf("SamsungBrowser") > -1) {
8 return "ಸ್ಯಾಮ್‌ಸಂಗ್ ಬ್ರೌಸರ್";
9 } else if (userAgent.indexOf("Opera") > -1 || userAgent.indexOf("OPR") > -1) {
10 return "ಓಪೆರಾ";
11 } else if (userAgent.indexOf("Trident") > -1) {
12 return "ಇಂಟರ್ನೆಟ್ ಎಕ್ಸ್‌ಪ್ಲೋರ್";
13 } else if (userAgent.indexOf("Edge") > -1) {
14 return "ಎಡ್ಜ್";
15 } else if (userAgent.indexOf("Chrome") > -1) {
16 return "ಕ್ರೋಮ್";
17 } else if (userAgent.indexOf("Safari") > -1) {
18 return "ಸಾಫಾರಿ";
19 } else {
20 return "ಅಜ್ಞಾತ";
21 }
22}
23
24// ಬಳಸುವುದು
25console.log("ನೀವು ಬಳಸುತ್ತಿದ್ದೀರಿ: " + detectBrowser());
261# ಪೈಥಾನ್: ವಿನಂತಿಗಳನ್ನು ನಿಗದಿತ ಬಳಕೆದಾರ ಏಜೆಂಟ್‌ನಲ್ಲಿ ಹೊಂದಿಸುವುದು
2import requests
3
4def fetch_with_user_agent(url, user_agent):
5 headers = {
6 'User-Agent': user_agent
7 }
8 response = requests.get(url, headers=headers)
9 return response.text
10
11# ಉದಾಹರಣೆ ಬಳಸುವುದು
12chrome_ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36'
13content = fetch_with_user_agent('https://example.com', chrome_ua)
14print(content[:100]) # ಪ್ರತಿಕ್ರಿಯೆಯ ಮೊದಲ 100 ಅಕ್ಷರಗಳನ್ನು ಮುದ್ರಣ ಮಾಡುವುದು
151<?php
2// PHP: ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಅನ್ನು ಗುರುತಿಸುವುದು
3function isMobileDevice() {
4 $userAgent = $_SERVER['HTTP_USER_AGENT'];
5 $mobileKeywords = array('Mobile', 'Android', 'iPhone', 'iPad', 'Windows Phone');
6
7 foreach ($mobileKeywords as $keyword) {
8 if (stripos($userAgent, $keyword) !== false) {
9 return true;
10 }
11 }
12 return false;
13}
14
15// ಬಳಸುವುದು
16if (isMobileDevice()) {
17 echo "ನೀವು ಮೊಬೈಲ್ ಸಾಧನವನ್ನು ಬಳಸುತ್ತಿದ್ದೀರಿ.";
18} else {
19 echo "ನೀವು ಡೆಸ್ಕ್‌ಟಾಪ್ ಸಾಧನವನ್ನು ಬಳಸುತ್ತಿದ್ದೀರಿ.";
20}
21?>
221// ಜಾವಾ: ಯಾದೃಚ್ಛಿಕ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಅನ್ನು ಉತ್ಪಾದಿಸುವುದು
2import java.util.Random;
3
4public class UserAgentGenerator {
5 private static final String[] CHROME_VERSIONS = {"96.0.4664.110", "95.0.4638.69", "94.0.4606.81"};
6 private static final String[] OS_VERSIONS = {"Windows NT 10.0; Win64; x64",
7 "Macintosh; Intel Mac OS X 10_15_7",
8 "X11; Linux x86_64"};
9
10 public static String generateRandomChromeUserAgent() {
11 Random random = new Random();
12 String osVersion = OS_VERSIONS[random.nextInt(OS_VERSIONS.length)];
13 String chromeVersion = CHROME_VERSIONS[random.nextInt(CHROME_VERSIONS.length)];
14
15 return "Mozilla/5.0 (" + osVersion + ") AppleWebKit/537.36 (KHTML, like Gecko) " +
16 "Chrome/" + chromeVersion + " Safari/537.36";
17 }
18
19 public static void main(String[] args) {
20 System.out.println(generateRandomChromeUserAgent());
21 }
22}
231# ರೂಬಿ: ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುವುದು
2require 'user_agent_parser'
3
4def parse_user_agent(user_agent_string)
5 parser = UserAgentParser::Parser.new
6 client = parser.parse(user_agent_string)
7
8 {
9 browser_name: client.family,
10 browser_version: client.version.to_s,
11 os_name: client.os.family,
12 os_version: client.os.version.to_s,
13 device: client.device.family
14 }
15end
16
17# ಉದಾಹರಣೆ ಬಳಸುವುದು
18ua = 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.3 Mobile/15E148 Safari/604.1'
19info = parse_user_agent(ua)
20puts info
211// C#: HttpClient ನಲ್ಲಿ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಅನ್ನು ಹೊಂದಿಸುವುದು
2using System;
3using System.Net.Http;
4using System.Threading.Tasks;
5
6class Program
7{
8 static async Task Main()
9 {
10 // ಕಸ್ಟಮ್ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಹೊಂದಿರುವ HttpClient ಅನ್ನು ರಚಿಸುವುದು
11 using (var httpClient = new HttpClient())
12 {
13 string userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36";
14 httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
15
16 try
17 {
18 // ಕಸ್ಟಮ್ ಬಳಕೆದಾರ ಏಜೆಂಟ್‌ನೊಂದಿಗೆ ವಿನಂತಿಯನ್ನು ಮಾಡಲು
19 HttpResponseMessage response = await httpClient.GetAsync("https://example.com");
20 response.EnsureSuccessStatusCode();
21 string responseBody = await response.Content.ReadAsStringAsync();
22
23 Console.WriteLine($"ಪ್ರತಿಕ್ರಿಯೆ ಸ್ಥಿತಿಗತಿ ಕೋಡ್: {response.StatusCode}");
24 Console.WriteLine(responseBody.Substring(0, 100) + "..."); // ಮೊದಲ 100 ಅಕ್ಷರಗಳನ್ನು
25 }
26 catch (HttpRequestException e)
27 {
28 Console.WriteLine($"ವಿನಂತಿ ದೋಷ: {e.Message}");
29 }
30 }
31 }
32}
331// ಗೋ: ಕಸ್ಟಮ್ ಬಳಕೆದಾರ ಏಜೆಂಟ್‌ಗಳೊಂದಿಗೆ HTTP ವಿನಂತಿಗಳನ್ನು ರಚಿಸುವುದು
2package main
3
4import (
5 "fmt"
6 "io/ioutil"
7 "net/http"
8)
9
10func main() {
11 // ಹೊಸ ವಿನಂತಿಯನ್ನು ರಚಿಸುವುದು
12 req, err := http.NewRequest("GET", "https://example.com", nil)
13 if err != nil {
14 fmt.Printf("ವಿನಂತಿ ರಚಿಸುವಾಗ ದೋಷ: %s\n", err)
15 return
16 }
17
18 // ಕಸ್ಟಮ್ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಅನ್ನು ಹೊಂದಿಸುವುದು
19 req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36")
20
21 // ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸುವುದು
22 client := &http.Client{}
23 resp, err := client.Do(req)
24 if err != nil {
25 fmt.Printf("ವಿನಂತಿ ಕಳುಹಿಸುವಾಗ ದೋಷ: %s\n", err)
26 return
27 }
28 defer resp.Body.Close()
29
30 // ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಓದುವುದು
31 body, err := ioutil.ReadAll(resp.Body)
32 if err != nil {
33 fmt.Printf("ಪ್ರತಿಕ್ರಿಯೆ ಓದುವಾಗ ದೋಷ: %s\n", err)
34 return
35 }
36
37 fmt.Printf("ಪ್ರತಿಕ್ರಿಯೆ ಸ್ಥಿತಿಗತಿ: %s\n", resp.Status)
38 fmt.Printf("ಪ್ರತಿಕ್ರಿಯೆ ಶರೀರದ ಪೂರ್ವಾವಲೋಕನ: %s\n", body[:100])
39}
40ಇಲ್ಲಿ ವಿವಿಧ ಬ್ರೌಸರ್ ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಿಗೆ ನಿಜವಾದ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಕೆಲವು ಉದಾಹರಣೆಗಳಿವೆ:
ಕ್ರೋಮ್ ವಿಂಡೋಸ್‌ನಲ್ಲಿ:
1Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36
2ಫೈರ್‌ಫಾಕ್ಸ್ ಮ್ಯಾಕ್‌ಒಸ್‌ನಲ್ಲಿ:
1Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:95.0) Gecko/20100101 Firefox/95.0
2ಸಾಫಾರಿ ಮ್ಯಾಕ್‌ಒಸ್‌ನಲ್ಲಿ:
1Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.2 Safari/605.1.15
2ಎಡ್ಜ್ ವಿಂಡೋಸ್‌ನಲ್ಲಿ:
1Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36 Edg/96.0.1054.62
2ಕ್ರೋಮ್ ಆಂಡ್ರಾಯ್ಡ್‌ನಲ್ಲಿ:
1Mozilla/5.0 (Linux; Android 12; SM-G998B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.104 Mobile Safari/537.36
2ಸಾಫಾರಿ ಐಫೋನ್‌ನಲ್ಲಿ:
1Mozilla/5.0 (iPhone; CPU iPhone OS 15_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.2 Mobile/15E148 Safari/604.1
2ಫೈರ್‌ಫಾಕ್ಸ್ ಆಂಡ್ರಾಯ್ಡ್‌ನಲ್ಲಿ:
1Mozilla/5.0 (Android 12; Mobile; rv:95.0) Gecko/95.0 Firefox/95.0
2ಸ್ಯಾಮ್‌ಸಂಗ್ ಇಂಟರ್ನೆಟ್ ಗ್ಯಾಲಕ್ಸಿಯಲ್ಲಿ:
1Mozilla/5.0 (Linux; Android 12; SM-G998B) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/16.0 Chrome/92.0.4515.166 Mobile Safari/537.36
2"ಬಳಕೆದಾರ ಏಜೆಂಟ್." MDN ವೆಬ್ ಡಾಕ್ಸ್, ಮೋಜಿಲ್ಲಾ, https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
"ಬ್ರೌಸರ್ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳು." WhatIsMyBrowser.com, https://www.whatismybrowser.com/guides/the-latest-user-agent/
"HTTP ಬಳಕೆದಾರ-ಏಜೆಂಟ್ ಹೆಡರ್ ವಿವರಿಸಲಾಗಿದೆ." KeyCDN, https://www.keycdn.com/support/user-agent
"ಕ್ಲೈಂಟ್ ಹಿಂಟ್ಸ್." MDN ವೆಬ್ ಡಾಕ್ಸ್, ಮೋಜಿಲ್ಲಾ, https://developer.mozilla.org/en-US/docs/Web/HTTP/Client_hints
"ಬ್ರೌಸರ್ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಇತಿಹಾಸ." WebAIM, https://webaim.org/blog/user-agent-string-history/
"ಬ್ರೌಸರ್ ಡಿಟೆಕ್ಷನ್ ಬಳಕೆದಾರ ಏಜೆಂಟ್ ಬಳಸುವುದು." Google Developers, https://developer.chrome.com/docs/multidevice/user-agent/
ನಿಮ್ಮ ಕೆಲಸದ ಹಂತಕ್ಕೆ ಉಪಯೋಗಿಸಬಹುದಾದ ಹೆಚ್ಚು ಉಪಕರಣಗಳನ್ನು ಹುಡುಕಿ ಹೊಸ ಉಪಕರಣಗಳನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ