Generator de agent utilizator aleator

Generați șiruri de agent utilizator realiste și aleatorii pentru testarea dezvoltării web.

Agent utilizator generat

Copiați

Generator aleatoriu de User Agent

Introducere

Un șir User Agent este un identificator text specific pe care browserele web și alte aplicații îl trimit site-urilor pentru a se identifica. Acest șir conține de obicei informații despre browser, sistemul de operare, tipul de dispozitiv și motorul de redare utilizat. Pentru dezvoltatorii web și testeri, accesul la o varietate de șiruri User Agent realiste este esențial pentru testarea compatibilității, răspunsului și funcționalității site-urilor pe diferite platforme.

Acest instrument Generator aleatoriu de User Agent creează șiruri User Agent care arată autentic, bazate pe parametrii selectați de tine. Poți filtra după tipul de dispozitiv (desktop sau mobil), familia de browsere (Chrome, Firefox, Safari sau Edge) și sistemul de operare pentru a genera agenți utilizatori care se potrivesc cerințelor tale de testare. Instrumentul oferă o interfață simplă cu opțiuni de a copia șirul generat cu un singur clic și de a genera instantaneu șiruri aleatorii noi.

Structura User Agent

Șirurile User Agent urmează modele specifice în funcție de browser și platformă, dar conțin în general mai multe componente comune:

Identificatorul Browserului: De obicei începe cu "Mozilla/5.0" din motive de compatibilitate istorică
Informații despre Platformă/Sistem de Operare: Detalii despre sistemul de operare (Windows, macOS, Android, iOS)
Motorul Browserului: Motorul de redare (cum ar fi Gecko, WebKit sau Blink)
Detalii despre Browser: Numele și versiunea specifică a browserului

Iată o defalcare a structurilor tipice ale user agent pentru browserele majore:

Chrome

Mozilla/5.0 (platform; details) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/version Safari/537.36

Firefox

Mozilla/5.0 (platform; rv:geckoversion) Gecko/geckotrail Firefox/firefoxversion

Safari

Mozilla/5.0 (platform) AppleWebKit/webkitversion (KHTML, like Gecko) Version/safariversion Safari/safariversion

Edge

Mozilla/5.0 (platform) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/chromiumversion Safari/537.36 Edg/edgeversion

Secțiunea platformă variază semnificativ între dispozitivele desktop și mobile:

Exemple Desktop:

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

Exemple Mobile:

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

Diferențele Tipului de Dispozitiv

User Agents Desktop

User agents desktop includ de obicei informații specifice despre sistemul de operare, detalii despre arhitectură (cum ar fi x86_64 sau Win64) și uneori preferințe de limbă. Acestea tind să fie mai consistente între browsere decât user agents mobile.

User Agents Mobile

User agents mobile conțin informații despre modelul dispozitivului, versiunile sistemului de operare mobil și adesea includ cuvântul "Mobile" la sfârșit. Safari pe dispozitivele iOS va include identificatori "iPhone" sau "iPad", în timp ce dispozitivele Android includ numele și numărul modelului producătorului.

Modele de Versiune a Browserului

Fiecare browser urmează modele diferite de versiune:

Chrome: Folosește numere de versiune în patru părți (de exemplu, 96.0.4664.110)
Firefox: Folosește de obicei numere de versiune în două sau trei părți (de exemplu, 95.0 sau 95.0.2)
Safari: Folosește numere de versiune simple, cum ar fi 15.2
Edge: Folosește numere de versiune similare cu Chrome, dar cu propria versiune Edge (de exemplu, 96.0.1054.62)

Cazuri de Utilizare

Generarea aleatorie de user agent are mai multe aplicații importante în dezvoltarea web și testare:

Testarea Compatibilității între Browsere: Testează cum se redă și funcționează site-ul tău pe diferite browsere fără a fi nevoie să instalezi mai multe browsere sau să folosești mai multe dispozitive.
Testarea Designului Responsiv: Verifică dacă site-ul tău detectează corect dispozitivele mobile și desktop și servește layout-ul corespunzător.
Validarea Detectării Funcțiilor: Asigură-te că mecanismele tale de detectare a funcțiilor funcționează corect pentru diferite capacități ale browserului.
Testare QA și Automată: Încorporează diferite user agents în scripturile tale de testare automate pentru a simula diverse medii de utilizator.
Testarea Performanței: Analizează cum performează site-ul tău când este accesat din diferite medii de browser.
Depanarea Problemelor Specifice Browserului: Reproduce și repară erori care apar doar în browsere sau versiuni specifice.
Testarea API-ului: Testează cum API-ul tău gestionează cererile din diferite aplicații client.

Alternative

Deși generatorul nostru aleatoriu de user agent este util pentru multe scenarii de testare, există abordări alternative:

Servicii de Testare a Browserului: Platforme precum BrowserStack, Sauce Labs sau LambdaTest oferă instanțe reale de browsere pentru testare, mai degrabă decât doar simularea user agent-ului.
Instrumente de Dezvoltare ale Browserului: Cele mai moderne browsere permit să suprascrii user agent-ul prin instrumentele lor de dezvoltare, ceea ce poate fi util pentru teste rapide.
Extensii de Schimbare a User Agent-ului: Extensii de browser care îți permit să schimbi între user agents predefinite în timp ce navighezi.
Mașini Virtuale sau Containere: Rularea instanțelor reale ale diferitelor sisteme de operare și browsere pentru testarea cea mai precisă.
Testare cu Browsere Headless: Utilizarea unor instrumente precum Puppeteer sau Selenium pentru a controla programatic browsere cu diferite setări de user agent.

Fiecare alternativă are propriile sale avantaje și poate fi mai potrivită în funcție de nevoile tale specifice de testare și resurse.

Istorie

Conceptul de șir User Agent datează din primele zile ale World Wide Web-ului. Termenul "user agent" provine din specificația HTTP, unde se referă la aplicația client care face o cerere către un server web.

Zilele Timpurii (Anii 1990)

Primul browser utilizat pe scară largă, NCSA Mosaic, includea un șir User Agent simplu care identifica numele și versiunea browserului. Când Netscape Navigator a fost lansat, a folosit un format similar. Cu toate acestea, pe măsură ce serverele web au început să livreze conținut diferit în funcție de browser, a apărut o practică cunoscută sub numele de "browser sniffing".

Războiul Browserelor și Spoofing-ul User Agent-ului (Sfârșitul anilor 1990)

În timpul războiului browserelor între Netscape și Internet Explorer, site-urile web serveau adesea conținut optimizat exclusiv pentru browsere specifice. Pentru a asigura compatibilitatea, browserele au început să includă șiruri care se identificau ca fiind alte browsere. Acesta este motivul pentru care cele mai moderne browsere includ încă "Mozilla" în șirurile lor User Agent, o referință la numele de cod al Netscape Navigator.

Revoluția Mobilă (Anii 2000-2010)

Creșterea dispozitivelor mobile a introdus o nouă complexitate în șirurile User Agent. Browserele mobile trebuiau să se identifice ca mobile pentru a primi conținutul corespunzător, ceea ce a dus la adăugarea identificatorilor de dispozitive și token-uri specifice mobile.

Provocări Moderne (Anii 2010-Până în Prezent)

Pe măsură ce ecosistemul web a crescut mai complex, șirurile User Agent au devenit din ce în ce mai complicate. Acestea conțin acum referințe la mai multe motoare de browser (cum ar fi "AppleWebKit" și "Gecko") din motive de compatibilitate, chiar și atunci când acele motoare nu sunt de fapt utilizate.

Această complexitate a dus la provocări în analiza precisă a șirurilor User Agent, iar unele grupuri de standarde web au propus să se deprecieze sau să se simplifice șirurile User Agent în favoarea unor indicii de client mai structurate. Cu toate acestea, din motive de compatibilitate retroactivă, șirul User Agent tradițional rămâne o parte esențială a navigării web.

Exemple de Cod

Iată exemple despre cum să lucrezi cu șirurile User Agent în diferite limbaje de programare:

// JavaScript: Detectarea tipului de browser din user agent
function detectBrowser() {
  const userAgent = navigator.userAgent;
  
  if (userAgent.indexOf("Firefox") > -1) {
    return "Firefox";
  } else if (userAgent.indexOf("SamsungBrowser") > -1) {
    return "Samsung Browser";
  } else if (userAgent.indexOf("Opera") > -1 || userAgent.indexOf("OPR") > -1) {
    return "Opera";
  } else if (userAgent.indexOf("Trident") > -1) {
    return "Internet Explorer";
  } else if (userAgent.indexOf("Edge") > -1) {
    return "Edge";
  } else if (userAgent.indexOf("Chrome") > -1) {
    return "Chrome";
  } else if (userAgent.indexOf("Safari") > -1) {
    return "Safari";
  } else {
    return "Necunoscut";
  }
}

// Utilizare
console.log("Folosești: " + detectBrowser());

# Python: Setarea unui user agent personalizat în requests
import requests

def fetch_with_user_agent(url, user_agent):
    headers = {
        'User-Agent': user_agent
    }
    response = requests.get(url, headers=headers)
    return response.text

# Exemplu de utilizare
chrome_ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36'
content = fetch_with_user_agent('https://example.com', chrome_ua)
print(content[:100])  # Afișează primele 100 de caractere ale răspunsului

<?php
// PHP: Detectarea dispozitivelor mobile folosind user agent
function isMobileDevice() {
    $userAgent = $_SERVER['HTTP_USER_AGENT'];
    $mobileKeywords = array('Mobile', 'Android', 'iPhone', 'iPad', 'Windows Phone');
    
    foreach ($mobileKeywords as $keyword) {
        if (stripos($userAgent, $keyword) !== false) {
            return true;
        }
    }
    return false;
}

// Utilizare
if (isMobileDevice()) {
    echo "Folosești un dispozitiv mobil.";
} else {
    echo "Folosești un dispozitiv desktop.";
}
?>

// Java: Generarea unui user agent aleator
import java.util.Random;

public class UserAgentGenerator {
    private static final String[] CHROME_VERSIONS = {"96.0.4664.110", "95.0.4638.69", "94.0.4606.81"};
    private static final String[] OS_VERSIONS = {"Windows NT 10.0; Win64; x64", 
                                               "Macintosh; Intel Mac OS X 10_15_7",
                                               "X11; Linux x86_64"};
    
    public static String generateRandomChromeUserAgent() {
        Random random = new Random();
        String osVersion = OS_VERSIONS[random.nextInt(OS_VERSIONS.length)];
        String chromeVersion = CHROME_VERSIONS[random.nextInt(CHROME_VERSIONS.length)];
        
        return "Mozilla/5.0 (" + osVersion + ") AppleWebKit/537.36 (KHTML, like Gecko) " +
               "Chrome/" + chromeVersion + " Safari/537.36";
    }
    
    public static void main(String[] args) {
        System.out.println(generateRandomChromeUserAgent());
    }
}

# Ruby: Analiza șirului user agent
require 'user_agent_parser'

def parse_user_agent(user_agent_string)
  parser = UserAgentParser::Parser.new
  client = parser.parse(user_agent_string)
  
  {
    browser_name: client.family,
    browser_version: client.version.to_s,
    os_name: client.os.family,
    os_version: client.os.version.to_s,
    device: client.device.family
  }
end

# Exemplu de utilizare
ua = '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'
info = parse_user_agent(ua)
puts info

// C#: Setarea user agent-ului în HttpClient
using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        // Creează HttpClient cu un user agent personalizat
        using (var httpClient = new HttpClient())
        {
            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";
            httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
            
            try
            {
                // Face cererea cu user agent personalizat
                HttpResponseMessage response = await httpClient.GetAsync("https://example.com");
                response.EnsureSuccessStatusCode();
                string responseBody = await response.Content.ReadAsStringAsync();
                
                Console.WriteLine($"Răspuns primit cu codul de stare: {response.StatusCode}");
                Console.WriteLine(responseBody.Substring(0, 100) + "..."); // Primele 100 de caractere
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine($"Eroare la cerere: {e.Message}");
            }
        }
    }
}

// Go: Crearea cererilor HTTP cu user agents personalizate
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    // Creează o nouă cerere
    req, err := http.NewRequest("GET", "https://example.com", nil)
    if err != nil {
        fmt.Printf("Eroare la crearea cererii: %s\n", err)
        return
    }
    
    // Setează user agent-ul personalizat
    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")
    
    // Trimite cererea
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("Eroare la trimiterea cererii: %s\n", err)
        return
    }
    defer resp.Body.Close()
    
    // Citește răspunsul
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Eroare la citirea răspunsului: %s\n", err)
        return
    }
    
    fmt.Printf("Starea răspunsului: %s\n", resp.Status)
    fmt.Printf("Previzualizare corp răspuns: %s\n", body[:100])
}

Modele Comune de User Agent

Iată câteva exemple de șiruri User Agent reale pentru diferite browsere și platforme:

Browsere Desktop

Chrome pe Windows:

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

Firefox pe macOS:

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

Safari pe macOS:

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

Edge pe Windows:

Mozilla/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

Browsere Mobile

Chrome pe Android:

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

Safari pe iPhone:

Mozilla/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

Firefox pe Android:

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

Samsung Internet pe Galaxy:

Mozilla/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

Referințe

"User Agent." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
"Browser User Agent Strings." WhatIsMyBrowser.com, https://www.whatismybrowser.com/guides/the-latest-user-agent/
"HTTP User-Agent Header Explained." KeyCDN, https://www.keycdn.com/support/user-agent
"Client Hints." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Client_hints
"History of the browser user-agent string." WebAIM, https://webaim.org/blog/user-agent-string-history/
"Browser Detection Using the User Agent." Google Developers, https://developer.chrome.com/docs/multidevice/user-agent/

Instrumente Conexe

Generator de Locații Aleatorii: Creator de Coordonate Globale

Generator de UUID-uri pentru aplicații diverse și sisteme

Generator de Nume pentru Proiecte Aleatorii

Generator de Chei API Aleatorii: Crează Șiruri Securizate de 32 de Caractere

Generator de ObjectID-uri valide pentru MongoDB

Generator de identificatori unici Nano ID pentru aplicații

Generator CPF pentru Testare și Validare Date Fictive

Generator de ID-uri Snowflake pentru sisteme distribuite

Generator de hash MD5

Generator de Identificatori Unici Sortabili K (KSUID)