Juhuslik kasutajaagendi generaator veebiarenduse testimiseks

Juhuslik kasutajaagendi generaator

Sissejuhatus

Kasutajaagendi string on spetsiifiline tekstiline identifikaator, mille veebibrauserid ja muud rakendused saadavad veebisaitidele, et end tuvastada. See string sisaldab tavaliselt teavet brauseri, operatsioonisüsteemi, seadme tüübi ja renderdamismootori kohta, mida kasutatakse. Veebiarendajatele ja testijatele on juurdepääs mitmekesistele realistlikele kasutajaagendi stringidele hädavajalik, et testida veebisaidi ühilduvust, reageerimist ja funktsionaalsust erinevates platvormides.

See juhuslik kasutajaagendi generaatori tööriist loob autentse välimusega kasutajaagendi stringe vastavalt teie valitud parameetritele. Saate filtreerida seadme tüübi (lauaarvuti või mobiilseade), brauseri perekonna (Chrome, Firefox, Safari või Edge) ja operatsioonisüsteemi järgi, et genereerida kasutajaagende, mis vastavad teie testimisnõuetele. Tööriist pakub lihtsat liidest, mille abil saate genereeritud stringi ühe klõpsuga kopeerida ja kohe uusi juhuslikke stringe genereerida.

Kasutajaagendi struktuur

Kasutajaagendi stringid järgivad sõltuvalt brauserist ja platvormist spetsiifilisi mustreid, kuid need sisaldavad tavaliselt mitmeid ühiseid komponente:

Brauseri identifikaator: Alustatakse tavaliselt "Mozilla/5.0" ajalooliste ühilduvusprobleemide tõttu
Platvormi/OS-i teave: Teave operatsioonisüsteemi kohta (Windows, macOS, Android, iOS)
Brauseri mootor: Renderdamismootor (nt Gecko, WebKit või Blink)
Brauseri üksikasjad: Spetsiifilise brauseri nimi ja versioon

Siin on ülevaade tüüpilistest kasutajaagendi struktuuridest peamiste brauserite jaoks:

Chrome

1Mozilla/5.0 (platvorm; üksikasjad) AppleWebKit/537.36 (KHTML, nagu Gecko) Chrome/versioon Safari/537.36
2

Firefox

1Mozilla/5.0 (platvorm; rv:geckoversion) Gecko/geckotrail Firefox/firefoxversion
2

Safari

1Mozilla/5.0 (platvorm) AppleWebKit/webkitversion (KHTML, nagu Gecko) Versioon/safariversion Safari/safariversion
2

Edge

1Mozilla/5.0 (platvorm) AppleWebKit/537.36 (KHTML, nagu Gecko) Chrome/chromiumversion Safari/537.36 Edg/edgeversion
2

Platvormi osa varieerub oluliselt lauaarvutite ja mobiilseadmete vahel:

Lauaarvuti näited:

Windows: Windows NT 10.0; Win64; x64
macOS: Macintosh; Intel Mac OS X 10_15_7
Linux: X11; Linux x86_64

Mobiilseadme näited:

Android: Linux; Android 12; SM-G998B
iOS: iPhone; CPU iPhone OS 15_4 nagu Mac OS X

Seadmestiku tüübi erinevused

Lauaarvuti kasutajaagendid

Lauaarvuti kasutajaagendid sisaldavad tavaliselt spetsiifilist teavet operatsioonisüsteemi, arhitektuuri üksikasjade (nt x86_64 või Win64) ja mõnikord keele eelistuste kohta. Need kipuvad olema brauserite vahel järjepidevamad kui mobiilseadmete kasutajaagendid.

Mobiilseadme kasutajaagendid

Mobiilseadme kasutajaagendid sisaldavad seadme mudeli teavet, mobiilsete operatsioonisüsteemide versioone ja sageli sisaldavad nad sõna "Mobile" lõpus. Mobiilne Safari iOS-seadmetes sisaldab "iPhone" või "iPad" identifikaatoreid, samas kui Android-seadmed sisaldavad tootja ja mudeli numbrit.

Brauseri versioonimustrid

Igal brauseril on erinevad versioonimustrid:

Chrome: Kasutab neljaosalist versiooninumbrit (nt 96.0.4664.110)
Firefox: Kasutab tavaliselt kahe- või kolmeosalist versiooninumbrit (nt 95.0 või 95.0.2)
Safari: Kasutab lihtsaid versiooninumbreid nagu 15.2
Edge: Kasutab versiooninumbreid, mis on sarnased Chrome'ile, kuid oma Edge'i versiooniga (nt 96.0.1054.62)

Kasutuse juhtumid

Juhuslik kasutajaagendi genereerimine omab mitmeid olulisi rakendusi veebiarenduses ja testimises:

Üksikasjalik brauseri ühilduvuse testimine: Testige, kuidas teie veebisait renderdab ja toimib erinevates brauserites, ilma et peaksite installima mitut brauserit või kasutama mitmeid seadmeid.
Reageeriva disaini testimine: Veenduge, et teie veebisait tuvastab õigesti mobiil- ja lauaarvuti seadmed ning teenindab sobivat paigutust.
Funktsiooni tuvastamise valideerimine: Veenduge, et teie veebisaidi funktsiooni tuvastamise mehhanismid töötavad õigesti erinevate brauseri võimekuste jaoks.
QA ja automatiseeritud testimine: Integreerige erinevad kasutajaagendid oma automatiseeritud testimis skriptidesse, et simuleerida erinevaid kasutajakeskkondi.
Jõudlustestimine: Analüüsige, kuidas teie veebisait toimib, kui sellele pääseb juurde erinevatest brauserikeskkondadest.
Brauserispetsiifiliste probleemide tõrkeotsing: Taasesitage ja parandage vigu, mis esinevad ainult teatud brauserites või versioonides.
API testimine: Testige, kuidas teie API käsitleb päringuid erinevatelt kliendirakendustelt.

Alternatiivid

Kuigi meie juhuslik kasutajaagendi generaator on kasulik paljude testimisstsenaariumide jaoks, on olemas alternatiivsed lähenemisviisid:

Brauseri testimise teenused: Platvormid nagu BrowserStack, Sauce Labs või LambdaTest pakuvad tegelikke brauseri instantsse testimiseks, mitte ainult kasutajaagendi simuleerimiseks.
Brauseri arendaja tööriistad: Enamik kaasaegseid brausereid võimaldab teil oma kasutajaagendi üle kirjutada oma arendaja tööriistade kaudu, mis võib olla kasulik kiirete testide jaoks.
Kasutajaagendi vahetaja laiendused: Brauseri laiendused, mis võimaldavad teil sirvimise ajal vahetada eeldefineeritud kasutajaagente.
Virtuaalmasinad või konteinerid: Erinevate operatsioonisüsteemide ja brauserite tegelike instantside käitamine kõige täpsema testimise jaoks.
Peata brauseri testimine: Kasutades tööriistu nagu Puppeteer või Selenium, et programmiliselt juhtida brausereid erinevate kasutajaagendi seadistustega.

Igal alternatiivil on oma eelised ja see võib olla sobivam sõltuvalt teie spetsiifilistest testimisvajadustest ja ressurssidest.

Ajalugu

Kasutajaagendi stringi mõisted ulatuvad tagasi veebimaailma varajastesse päevadesse. Termini "kasutajaagent" päritolu on HTTP spetsifikatsioonist, kus see viitab kliendirakendusele, mis teeb päringu veebiserverile.

Varased päevad (1990ndad)

Esimene laialdaselt kasutatav brauser, NCSA Mosaic, sisaldas lihtsat kasutajaagendi stringi, mis tuvastas brauseri nime ja versiooni. Kui Netscape Navigator välja anti, kasutas see sarnast formaati. Kuid kui veebiserverid hakkasid teenindama erinevat sisu sõltuvalt brauserist, tekkis praktika, mida tuntakse kui "brauseri nuusutamine".

Brauserisõjad ja kasutajaagendi petmine (1990ndate lõpp)

Netscape'i ja Internet Explorer'i vaheliste brauserisõdade ajal teenindasid veebisaidid sageli optimeeritud sisu ainult teatud brauseritele. Ühilduvuse tagamiseks hakkasid brauserid lisama stringe, mis tuvastasid nad teiste brauseritena. Just seetõttu sisaldavad enamik kaasaegseid brausereid endiselt "Mozilla" oma kasutajaagendi stringides, mis viitab Netscape Navigatori koodinimele.

Mobiilrevolutsioon (2000ndad-2010ndad)

Mobiilseadmete tõus tõi kasutajaagendi stringidesse uue keerukuse. Mobiilsed brauserid pidid end mobiilsetena tuvastama, et saada sobivat sisu, mis viis seadme identifikaatorite ja mobiilsete spetsiifiliste tokenite lisamiseni.

Kaasaegsed väljakutsed (2010ndad-käesolev)

Kuna veebiekosüsteem on kasvanud keerulisemaks, on kasutajaagendi stringid muutunud üha segasemaks. Need sisaldavad nüüd viiteid mitmele brauserimootorile (nt "AppleWebKit" ja "Gecko") ühilduvuse tõttu, isegi kui neid mootoreid tegelikult ei kasutata.

See keerukus on põhjustanud väljakutseid kasutajaagendi stringide täpses analüüsimises, ja mõned veebistandardite rühmad on soovitanud kasutajaagendi stringide deklareerimist või lihtsustamist struktureeritud kliendi vihjete kasuks. Siiski, tagasipöörduva ühilduvuse tõttu jääb traditsiooniline kasutajaagendi string veebisirvimise olulise osana.

Koodinäited

Siin on näited, kuidas töötada kasutajaagendi stringidega erinevates programmeerimiskeeltes:

1// JavaScript: Brauseri tüübi tuvastamine kasutajaagendi põhjal
2function detectBrowser() {
3  const userAgent = navigator.userAgent;
4  
5  if (userAgent.indexOf("Firefox") > -1) {
6    return "Firefox";
7  } else if (userAgent.indexOf("SamsungBrowser") > -1) {
8    return "Samsung Browser";
9  } else if (userAgent.indexOf("Opera") > -1 || userAgent.indexOf("OPR") > -1) {
10    return "Opera";
11  } else if (userAgent.indexOf("Trident") > -1) {
12    return "Internet Explorer";
13  } else if (userAgent.indexOf("Edge") > -1) {
14    return "Edge";
15  } else if (userAgent.indexOf("Chrome") > -1) {
16    return "Chrome";
17  } else if (userAgent.indexOf("Safari") > -1) {
18    return "Safari";
19  } else {
20    return "Tundmatu";
21  }
22}
23
24// Kasutamine
25console.log("Kasutate: " + detectBrowser());
26

1# Python: Kohandatud kasutajaagendi seadmine päringutes
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# Näide kasutamisest
12chrome_ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, nagu Gecko) Chrome/96.0.4664.110 Safari/537.36'
13content = fetch_with_user_agent('https://example.com', chrome_ua)
14print(content[:100])  # Prindi vastuse esimesed 100 märki
15

1<?php
2// PHP: Mobiilsete seadmete tuvastamine kasutajaagendi abil
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// Kasutamine
16if (isMobileDevice()) {
17    echo "Kasutate mobiilseadet.";
18} else {
19    echo "Kasutate lauaarvutit.";
20}
21?>
22

1// Java: Juhusliku kasutajaagendi genereerimine
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, nagu Gecko) " +
16               "Chrome/" + chromeVersion + " Safari/537.36";
17    }
18    
19    public static void main(String[] args) {
20        System.out.println(generateRandomChromeUserAgent());
21    }
22}
23

1# Ruby: Kasutajaagendi stringi analüüsimine
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# Näide kasutamisest
18ua = 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 nagu Mac OS X) AppleWebKit/605.1.15 (KHTML, nagu Gecko) Versioon/14.0.3 Mobile/15E148 Safari/604.1'
19info = parse_user_agent(ua)
20puts info
21

1// C#: Kasutajaagendi seadmine HttpClientis
2using System;
3using System.Net.Http;
4using System.Threading.Tasks;
5
6class Program
7{
8    static async Task Main()
9    {
10        // Looge HttpClient kohandatud kasutajaagendiga
11        using (var httpClient = new HttpClient())
12        {
13            string userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, nagu Gecko) Chrome/96.0.4664.110 Safari/537.36";
14            httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
15            
16            try
17            {
18                // Tehke päring kohandatud kasutajaagendiga
19                HttpResponseMessage response = await httpClient.GetAsync("https://example.com");
20                response.EnsureSuccessStatusCode();
21                string responseBody = await response.Content.ReadAsStringAsync();
22                
23                Console.WriteLine($"Vastus saadud staatusega: {response.StatusCode}");
24                Console.WriteLine(responseBody.Substring(0, 100) + "..."); // Esimesed 100 märki
25            }
26            catch (HttpRequestException e)
27            {
28                Console.WriteLine($"Päringu viga: {e.Message}");
29            }
30        }
31    }
32}
33

1// Go: HTTP päringute loomine kohandatud kasutajaagendidega
2package main
3
4import (
5    "fmt"
6    "io/ioutil"
7    "net/http"
8)
9
10func main() {
11    // Looge uus päring
12    req, err := http.NewRequest("GET", "https://example.com", nil)
13    if err != nil {
14        fmt.Printf("Viga päringu loomisel: %s\n", err)
15        return
16    }
17    
18    // Seadke kohandatud kasutajaagent
19    req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, nagu Gecko) Chrome/96.0.4664.110 Safari/537.36")
20    
21    // Saatke päring
22    client := &http.Client{}
23    resp, err := client.Do(req)
24    if err != nil {
25        fmt.Printf("Viga päringu saatmisel: %s\n", err)
26        return
27    }
28    defer resp.Body.Close()
29    
30    // Looge vastus
31    body, err := ioutil.ReadAll(resp.Body)
32    if err != nil {
33        fmt.Printf("Viga vastuse lugemisel: %s\n", err)
34        return
35    }
36    
37    fmt.Printf("Vastuse staatus: %s\n", resp.Status)
38    fmt.Printf("Vastuse sisu eelvaade: %s\n", body[:100])
39}
40

Tavalised kasutajaagendi mustrid

Siin on mõned näited tegelikest kasutajaagendi stringidest erinevate brauserite ja platvormide jaoks:

Lauaarvuti brauserid

Chrome Windowsis:

1Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, nagu Gecko) Chrome/96.0.4664.110 Safari/537.36
2

Firefox macOS-is:

1Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:95.0) Gecko/20100101 Firefox/95.0
2

Safari macOS-is:

1Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, nagu Gecko) Versioon/15.2 Safari/605.1.15
2

Edge Windowsis:

1Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, nagu Gecko) Chrome/96.0.4664.110 Safari/537.36 Edg/96.0.1054.62
2

Mobiilseadme brauserid

Chrome Androidis:

1Mozilla/5.0 (Linux; Android 12; SM-G998B) AppleWebKit/537.36 (KHTML, nagu Gecko) Chrome/96.0.4664.104 Mobile Safari/537.36
2

Safari iPhone'is:

1Mozilla/5.0 (iPhone; CPU iPhone OS 15_2 nagu Mac OS X) AppleWebKit/605.1.15 (KHTML, nagu Gecko) Versioon/15.2 Mobile/15E148 Safari/604.1
2

Firefox Androidis:

1Mozilla/5.0 (Android 12; Mobile; rv:95.0) Gecko/95.0 Firefox/95.0
2

Samsung Internet Galaxy'l:

1Mozilla/5.0 (Linux; Android 12; SM-G998B) AppleWebKit/537.36 (KHTML, nagu Gecko) SamsungBrowser/16.0 Chrome/92.0.4515.166 Mobile Safari/537.36
2

Viidatud allikad

"Kasutajaagent." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
"Brauseri kasutajaagendi stringid." WhatIsMyBrowser.com, https://www.whatismybrowser.com/guides/the-latest-user-agent/
"HTTP kasutajaagendi päis selgitatud." KeyCDN, https://www.keycdn.com/support/user-agent
"Kliendi vihjed." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Client_hints
"Kasutajaagendi stringi ajalugu." WebAIM, https://webaim.org/blog/user-agent-string-history/
"Brauseri tuvastamine kasutajaagendi abil." Google Developers, https://developer.chrome.com/docs/multidevice/user-agent/

Whiz Tools

Juhuslik kasutajaagendi generaator veebiarenduse testimiseks

Juhusliku kasutajaagendi generaator

Genereeritud kasutajaagendi

Dokumentatsioon