Slumptalsanvändaragentgenerator för webb utvecklingstestning

Slumptalsanvändaragentgenerator

Introduktion

En användaragentsträng är en specifik textidentifierare som webbläsare och andra applikationer skickar till webbplatser för att identifiera sig själva. Denna sträng innehåller vanligtvis information om webbläsaren, operativsystemet, enhetstypen och renderingmotorn som används. För webb utvecklare och testare är det avgörande att ha tillgång till en mängd realistiska användaragentsträngar för att testa webbplatsens kompatibilitet, responsivitet och funktionalitet över olika plattformar.

Detta verktyg för slumptalsanvändaragentgenerator skapar autentiska användaragentsträngar baserat på dina valda parametrar. Du kan filtrera efter enhetstyp (skrivbord eller mobil), webbläsarfamilj (Chrome, Firefox, Safari eller Edge) och operativsystem för att generera användaragentsträngar som matchar dina testkrav. Verktyget erbjuder ett enkelt gränssnitt med alternativ för att kopiera den genererade strängen med ett enda klick och omedelbart generera nya slumpmässiga strängar.

Användaragentstruktur

Användaragentsträngar följer specifika mönster beroende på webbläsaren och plattformen, men de innehåller vanligtvis flera gemensamma komponenter:

Webbläsaridentifierare: Börjar vanligtvis med "Mozilla/5.0" av historiska kompatibilitetsskäl
Plattform/OS-information: Detaljer om operativsystemet (Windows, macOS, Android, iOS)
Webbläsarmotor: Renderingmotorn (som Gecko, WebKit eller Blink)
Webbläsardetaljer: Det specifika webbläsarnamnet och versionen

Här är en sammanställning av typiska användaragentstrukturer för stora webbläsare:

Chrome

1Mozilla/5.0 (plattform; detaljer) AppleWebKit/537.36 (KHTML, som Gecko) Chrome/version Safari/537.36
2

Firefox

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

Safari

1Mozilla/5.0 (plattform) AppleWebKit/webkitversion (KHTML, som Gecko) Version/safariversion Safari/safariversion
2

Edge

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

Plattformssektionen varierar betydligt mellan skrivbord och mobila enheter:

Skrivbords exempel:

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

Mobila exempel:

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

Skillnader i enhetstyper

Skrivbordsanvändaragent

Skrivbordsanvändaragentsträngar innehåller vanligtvis specifik information om operativsystem, arkitekturdetaljer (som x86_64 eller Win64) och ibland språkpreferenser. De tenderar att vara mer konsekventa över webbläsare än mobila användaragentsträngar.

Mobila användaragent

Mobila användaragentsträngar innehåller enhetsmodellinformation, versioner av mobila operativsystem och inkluderar ofta ordet "Mobil" i slutet. Mobilt Safari på iOS-enheter kommer att inkludera "iPhone" eller "iPad" identifierare, medan Android-enheter inkluderar tillverkare och modellnummer.

Mönster för webbläsarversioner

Varje webbläsare följer olika versionsmönster:

Chrome: Använder fyrdelade versionsnummer (t.ex. 96.0.4664.110)
Firefox: Använder typiskt två eller tredelade versionsnummer (t.ex. 95.0 eller 95.0.2)
Safari: Använder enkla versionsnummer som 15.2
Edge: Använder versionsnummer som liknar Chrome men med sin egen Edge-version (t.ex. 96.0.1054.62)

Användningsområden

Slumptalsanvändargenerering har flera viktiga tillämpningar inom webb utveckling och testning:

Testning av tvärwebbläsarkompatibilitet: Testa hur din webbplats renderas och fungerar över olika webbläsare utan att behöva installera flera webbläsare eller använda flera enheter.
Testning av responsiv design: Verifiera att din webbplats korrekt upptäcker mobila och skrivbords enheter och serverar rätt layout.
Validering av funktionsdetektering: Säkerställ att din webbplatsens funktionsdetekteringsmekanismer fungerar korrekt för olika webbläsares kapabiliteter.
QA och automatiserad testning: Integrera olika användaragentsträngar i dina automatiserade testskript för att simulera olika användarmiljöer.
Prestandatestning: Analysera hur din webbplats presterar när den nås från olika webbläsarmiljöer.
Felsökning av webbläsarspecifika problem: Återskapa och fixa buggar som endast inträffar i specifika webbläsare eller versioner.
API-testning: Testa hur ditt API hanterar förfrågningar från olika klientapplikationer.

Alternativ

Även om vår slumptalsanvändaragentgenerator är användbar för många testscenarier, finns det alternativa tillvägagångssätt:

Webbläsartestningstjänster: Plattformar som BrowserStack, Sauce Labs eller LambdaTest erbjuder faktiska webbläsarinstanser för testning snarare än att bara simulera användaragenten.
Webbläsarens utvecklarverktyg: De flesta moderna webbläsare tillåter dig att åsidosätta användaragenten genom sina utvecklarverktyg, vilket kan vara användbart för snabba tester.
Tillägg för användaragentväxling: Webbläsartillägg som låter dig växla mellan fördefinierade användaragentsträngar medan du surfar.
Virtuella maskiner eller containrar: Köra faktiska instanser av olika operativsystem och webbläsare för den mest exakta testningen.
Huvudlös webbläsartestning: Använda verktyg som Puppeteer eller Selenium för att programmera kontroll av webbläsare med olika användaragentinställningar.

Varje alternativ har sina egna fördelar och kan vara mer lämpligt beroende på dina specifika testbehov och resurser.

Historia

Konceptet med användaragentsträngen går tillbaka till de tidiga dagarna av World Wide Web. Termen "användaragent" kommer från HTTP-specifikationen, där den hänvisar till klientapplikationen som gör en begäran till en webbserver.

Tidiga dagar (1990-talet)

Den första allmänt använda webbläsaren, NCSA Mosaic, inkluderade en enkel användaragentsträng som identifierade webbläsarens namn och version. När Netscape Navigator släpptes använde den ett liknande format. Men när webbservrar började leverera olika innehåll baserat på webbläsaren, uppstod en praxis känd som "webbläsarsniffning".

Webbläsarkriget och användaragentspoofing (sent 1990-tal)

Under webbläsarkriget mellan Netscape och Internet Explorer serverade webbplatser ofta optimerat innehåll exklusivt till specifika webbläsare. För att säkerställa kompatibilitet började webbläsare inkludera strängar som identifierade dem själva som andra webbläsare. Detta är anledningen till att de flesta moderna webbläsare fortfarande inkluderar "Mozilla" i sina användaragentsträngar, en referens till Netscape Navigators kodnamn.

Mobilrevolutionen (2000-talet-2010-talet)

Ökningen av mobila enheter introducerade ny komplexitet till användaragentsträngar. Mobila webbläsare behövde identifiera sig som mobila för att få lämpligt innehåll, vilket ledde till tillägg av enhetsidentifierare och mobilspecifika token.

Moderna utmaningar (2010-talet-nutid)

När webb ekosystemet har vuxit mer komplext har användaragentsträngar blivit alltmer invecklade. De innehåller nu referenser till flera webbläsarmotorer (som "AppleWebKit" och "Gecko") av kompatibilitetsskäl, även när dessa motorer faktiskt inte används.

Denna komplexitet har lett till utmaningar i att noggrant analysera användaragentsträngar, och vissa webbstandardgrupper har föreslagit att avskriva eller förenkla användaragentsträngar till förmån för mer strukturerade klientledtrådar. Men av bakåtkompatibilitetsskäl förblir den traditionella användaragentsträngen en väsentlig del av webbläsning.

Kodexempel

Här är exempel på hur man arbetar med användaragentsträngar i olika programmeringsspråk:

1// JavaScript: Upptäck webbläsartyp från användaragent
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 "Okänd";
21  }
22}
23
24// Användning
25console.log("Du använder: " + detectBrowser());
26

1# Python: Ställa in anpassad användaragent i requests
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# Exempel på användning
12chrome_ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, som Gecko) Chrome/96.0.4664.110 Safari/537.36'
13content = fetch_with_user_agent('https://example.com', chrome_ua)
14print(content[:100])  # Skriv ut de första 100 tecknen av svaret
15

1<?php
2// PHP: Upptäck mobila enheter med hjälp av användaragent
3function isMobileDevice() {
4    $userAgent = $_SERVER['HTTP_USER_AGENT'];
5    $mobileKeywords = array('Mobil', '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// Användning
16if (isMobileDevice()) {
17    echo "Du använder en mobil enhet.";
18} else {
19    echo "Du använder en skrivbords enhet.";
20}
21?>
22

1// Java: Generera en slumpmässig användaragent
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, som 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: Analysera användaragentsträng
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# Exempel på användning
18ua = 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 liknande Mac OS X) AppleWebKit/605.1.15 (KHTML, som Gecko) Version/14.0.3 Mobil/15E148 Safari/604.1'
19info = parse_user_agent(ua)
20puts info
21

1// C#: Ställa in användaragent i HttpClient
2using System;
3using System.Net.Http;
4using System.Threading.Tasks;
5
6class Program
7{
8    static async Task Main()
9    {
10        // Skapa HttpClient med anpassad användaragent
11        using (var httpClient = new HttpClient())
12        {
13            string userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, som Gecko) Chrome/96.0.4664.110 Safari/537.36";
14            httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
15            
16            try
17            {
18                // Gör begäran med anpassad användaragent
19                HttpResponseMessage response = await httpClient.GetAsync("https://example.com");
20                response.EnsureSuccessStatusCode();
21                string responseBody = await response.Content.ReadAsStringAsync();
22                
23                Console.WriteLine($"Svar mottaget med statuskod: {response.StatusCode}");
24                Console.WriteLine(responseBody.Substring(0, 100) + "..."); // Första 100 tecknen
25            }
26            catch (HttpRequestException e)
27            {
28                Console.WriteLine($"Begärningsfel: {e.Message}");
29            }
30        }
31    }
32}
33

1// Go: Skapa HTTP-förfrågningar med anpassade användaragent
2package main
3
4import (
5    "fmt"
6    "io/ioutil"
7    "net/http"
8)
9
10func main() {
11    // Skapa en ny begäran
12    req, err := http.NewRequest("GET", "https://example.com", nil)
13    if err != nil {
14        fmt.Printf("Fel vid skapande av begäran: %s\n", err)
15        return
16    }
17    
18    // Ställ in anpassad användaragent
19    req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, som Gecko) Chrome/96.0.4664.110 Safari/537.36")
20    
21    // Skicka begäran
22    client := &http.Client{}
23    resp, err := client.Do(req)
24    if err != nil {
25        fmt.Printf("Fel vid skickande av begäran: %s\n", err)
26        return
27    }
28    defer resp.Body.Close()
29    
30    // Läs svaret
31    body, err := ioutil.ReadAll(resp.Body)
32    if err != nil {
33        fmt.Printf("Fel vid läsning av svar: %s\n", err)
34        return
35    }
36    
37    fmt.Printf("Svarstatus: %s\n", resp.Status)
38    fmt.Printf("Förhandsvisning av svarskropp: %s\n", body[:100])
39}
40

Vanliga användaragentmönster

Här är några exempel på riktiga användaragentsträngar för olika webbläsare och plattformar:

Skrivbordswebbläsare

Chrome på Windows:

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

Firefox på macOS:

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

Safari på macOS:

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

Edge på Windows:

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

Mobila webbläsare

Chrome på Android:

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

Safari på iPhone:

1Mozilla/5.0 (iPhone; CPU iPhone OS 15_2 liknande Mac OS X) AppleWebKit/605.1.15 (KHTML, som Gecko) Version/15.2 Mobil/15E148 Safari/604.1
2

Firefox på Android:

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

Samsung Internet på Galaxy:

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

Referenser

"Användaragent." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
"Webbläsaranvändaragentsträngar." WhatIsMyBrowser.com, https://www.whatismybrowser.com/guides/the-latest-user-agent/
"HTTP Användaragent Header Förklarad." KeyCDN, https://www.keycdn.com/support/user-agent
"Klientledtrådar." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Client_hints
"Historik över webbläsarens användaragentsträng." WebAIM, https://webaim.org/blog/user-agent-string-history/
"Webbläsardetektering med hjälp av användaragent." Google Developers, https://developer.chrome.com/docs/multidevice/user-agent/

Whiz Tools

Slumptalsanvändaragentgenerator för webb utvecklingstestning

Slumptalsgenerator för användaragent

Genererad användaragent

Dokumentation