Generatore di User Agent Casual per Test di Sviluppo Web
Genera stringhe di user agent del browser realistiche con opzioni per filtrare per tipo di dispositivo, famiglia di browser e sistema operativo. Perfetto per test di sviluppo web e controlli di compatibilità.
Generatore di User Agent Casuali
Genera stringhe di user agent del browser casuali e realistiche per il testing dello sviluppo web.
User Agent Generato
Documentazione
Generatore di User Agent Casuale
Introduzione
Una stringa User Agent è un identificatore di testo specifico che i browser web e altre applicazioni inviano ai siti web per identificarsi. Questa stringa contiene tipicamente informazioni sul browser, sul sistema operativo, sul tipo di dispositivo e sul motore di rendering utilizzato. Per gli sviluppatori web e i tester, avere accesso a una varietà di stringhe user agent realistiche è essenziale per testare la compatibilità, la reattività e la funzionalità del sito web su diverse piattaforme.
Questo strumento Generatore di User Agent Casuale crea stringhe user agent dall'aspetto autentico in base ai parametri selezionati. Puoi filtrare per tipo di dispositivo (desktop o mobile), famiglia di browser (Chrome, Firefox, Safari o Edge) e sistema operativo per generare user agent che corrispondano ai tuoi requisiti di test. Lo strumento offre un'interfaccia semplice con opzioni per copiare la stringa generata con un solo clic e generare nuove stringhe casuali istantaneamente.
Struttura dell'User Agent
Le stringhe user agent seguono schemi specifici a seconda del browser e della piattaforma, ma generalmente contengono diversi componenti comuni:
- Identificatore del Browser: Di solito inizia con "Mozilla/5.0" per motivi di compatibilità storica
- Informazioni sulla Piattaforma/SO: Dettagli sul sistema operativo (Windows, macOS, Android, iOS)
- Motore del Browser: Il motore di rendering (come Gecko, WebKit o Blink)
- Dettagli del Browser: Il nome e la versione specifici del browser
Ecco una suddivisione delle strutture tipiche degli user agent per i principali browser:
Chrome
1Mozilla/5.0 (piattaforma; dettagli) AppleWebKit/537.36 (KHTML, come Gecko) Chrome/versione Safari/537.36
2Firefox
1Mozilla/5.0 (piattaforma; rv:versionegecko) Gecko/traccia Gecko Firefox/versione
2Safari
1Mozilla/5.0 (piattaforma) AppleWebKit/versionewebkit (KHTML, come Gecko) Version/versionesafari Safari/versionesafari
2Edge
1Mozilla/5.0 (piattaforma) AppleWebKit/537.36 (KHTML, come Gecko) Chrome/versionechromium Safari/537.36 Edg/versionedge
2La sezione piattaforma varia significativamente tra dispositivi desktop e mobili:
Esempi Desktop:
- Windows:
Windows NT 10.0; Win64; x64 - macOS:
Macintosh; Intel Mac OS X 10_15_7 - Linux:
X11; Linux x86_64
Esempi Mobili:
- Android:
Linux; Android 12; SM-G998B - iOS:
iPhone; CPU iPhone OS 15_4 come Mac OS X
Differenze tra i Tipi di Dispositivo
User Agent Desktop
Gli user agent desktop tipicamente includono informazioni specifiche sul sistema operativo, dettagli sull'architettura (come x86_64 o Win64) e talvolta preferenze linguistiche. Tendono a essere più coerenti tra i browser rispetto agli user agent mobili.
User Agent Mobile
Gli user agent mobili contengono informazioni sul modello del dispositivo, versioni del sistema operativo mobile e spesso includono la parola "Mobile" alla fine. Safari mobile sui dispositivi iOS includerà identificatori "iPhone" o "iPad", mentre i dispositivi Android includono il produttore e il numero di modello.
Schemi di Versione del Browser
Ogni browser segue schemi di versioning diversi:
- Chrome: Usa numeri di versione a quattro parti (ad es., 96.0.4664.110)
- Firefox: Tipicamente usa numeri di versione a due o tre parti (ad es., 95.0 o 95.0.2)
- Safari: Usa numeri di versione semplici come 15.2
- Edge: Usa numeri di versione simili a Chrome ma con la propria versione Edge (ad es., 96.0.1054.62)
Casi d'Uso
La generazione casuale di user agent ha diverse applicazioni importanti nello sviluppo web e nei test:
-
Test di Compatibilità Cross-Browser: Testa come il tuo sito web si presenta e funziona su diversi browser senza dover installare più browser o utilizzare più dispositivi.
-
Test di Design Responsivo: Verifica che il tuo sito web rilevi correttamente i dispositivi mobili e desktop e fornisca il layout appropriato.
-
Validazione della Rilevazione delle Funzionalità: Assicurati che i meccanismi di rilevazione delle funzionalità del tuo sito web funzionino correttamente per diverse capacità del browser.
-
QA e Test Automatizzati: Integra diversi user agent nei tuoi script di test automatizzati per simulare vari ambienti utente.
-
Test delle Prestazioni: Analizza come il tuo sito web si comporta quando viene accesso da diversi ambienti browser.
-
Debugging di Problemi Specifici del Browser: Riproduci e correggi bug che si verificano solo in browser o versioni specifiche.
-
Test delle API: Testa come la tua API gestisce le richieste da diverse applicazioni client.
Alternative
Sebbene il nostro generatore di user agent casuale sia utile per molti scenari di test, ci sono approcci alternativi:
-
Servizi di Test del Browser: Piattaforme come BrowserStack, Sauce Labs o LambdaTest forniscono istanze di browser reali per il test anziché simulare solo l'user agent.
-
Strumenti di Sviluppo del Browser: La maggior parte dei browser moderni consente di sovrascrivere l'user agent tramite i propri strumenti di sviluppo, che possono essere utili per test rapidi.
-
Estensioni di Switcher per User Agent: Estensioni del browser che ti consentono di passare tra user agent predefiniti durante la navigazione.
-
Macchine Virtuali o Contenitori: Esegui istanze reali di diversi sistemi operativi e browser per il test più accurato.
-
Test di Browser Headless: Utilizza strumenti come Puppeteer o Selenium per controllare programmaticamente i browser con diverse impostazioni di user agent.
Ogni alternativa ha i propri vantaggi e potrebbe essere più appropriata a seconda delle tue specifiche esigenze e risorse di test.
Storia
Il concetto di stringa user agent risale ai primi giorni del World Wide Web. Il termine "user agent" deriva dalle specifiche HTTP, dove si riferisce all'applicazione client che effettua una richiesta a un server web.
Giorni Iniziali (Anni '90)
Il primo browser ampiamente utilizzato, NCSA Mosaic, includeva una semplice stringa user agent che identificava il nome e la versione del browser. Quando fu rilasciato Netscape Navigator, utilizzava un formato simile. Tuttavia, man mano che i server web iniziavano a fornire contenuti diversi in base al browser, emerse una pratica nota come "browser sniffing".
Le Guerre dei Browser e la Falsificazione dell'User Agent (Fine Anni '90)
Durante le guerre dei browser tra Netscape e Internet Explorer, i siti web spesso servivano contenuti ottimizzati esclusivamente per browser specifici. Per garantire la compatibilità, i browser iniziarono a includere stringhe che si identificavano come altri browser. Questo è il motivo per cui la maggior parte dei browser moderni include ancora "Mozilla" nelle proprie stringhe user agent, un riferimento al nome in codice di Netscape Navigator.
Rivoluzione Mobile (Anni 2000-2010)
L'ascesa dei dispositivi mobili ha introdotto una nuova complessità alle stringhe user agent. I browser mobili dovevano identificarsi come mobili per ricevere contenuti appropriati, portando all'aggiunta di identificatori di dispositivo e token specifici per i mobili.
Sfide Moderne (Anni 2010-Presente)
Man mano che l'ecosistema web è cresciuto in complessità, le stringhe user agent sono diventate sempre più contorte. Ora contengono riferimenti a più motori di browser (come "AppleWebKit" e "Gecko") per motivi di compatibilità, anche quando quegli motori non vengono effettivamente utilizzati.
Questa complessità ha portato a sfide nell'analizzare accuratamente le stringhe user agent, e alcuni gruppi di standard web hanno proposto di deprecare o semplificare le stringhe user agent a favore di suggerimenti client più strutturati. Tuttavia, per motivi di compatibilità retroattiva, la tradizionale stringa user agent rimane una parte essenziale della navigazione web.
Esempi di Codice
Ecco esempi di come lavorare con le stringhe user agent in vari linguaggi di programmazione:
1// JavaScript: Rilevamento del tipo di browser dalla stringa user agent
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 "Sconosciuto";
21 }
22}
23
24// Utilizzo
25console.log("Stai usando: " + detectBrowser());
261# Python: Impostare un user agent personalizzato in 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# Esempio di utilizzo
12chrome_ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, come Gecko) Chrome/96.0.4664.110 Safari/537.36'
13content = fetch_with_user_agent('https://example.com', chrome_ua)
14print(content[:100]) # Stampa i primi 100 caratteri della risposta
151<?php
2// PHP: Rilevamento dei dispositivi mobili utilizzando la stringa user agent
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// Utilizzo
16if (isMobileDevice()) {
17 echo "Stai usando un dispositivo mobile.";
18} else {
19 echo "Stai usando un dispositivo desktop.";
20}
21?>
221// Java: Generazione di un user agent casuale
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, come Gecko) " +
16 "Chrome/" + chromeVersion + " Safari/537.36";
17 }
18
19 public static void main(String[] args) {
20 System.out.println(generateRandomChromeUserAgent());
21 }
22}
231# Ruby: Analizzare la stringa user agent
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# Esempio di utilizzo
18ua = 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 come Mac OS X) AppleWebKit/605.1.15 (KHTML, come Gecko) Version/14.0.3 Mobile/15E148 Safari/604.1'
19info = parse_user_agent(ua)
20puts info
211// C#: Impostare l'user agent in HttpClient
2using System;
3using System.Net.Http;
4using System.Threading.Tasks;
5
6class Program
7{
8 static async Task Main()
9 {
10 // Crea HttpClient con user agent personalizzato
11 using (var httpClient = new HttpClient())
12 {
13 string userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, come Gecko) Chrome/96.0.4664.110 Safari/537.36";
14 httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
15
16 try
17 {
18 // Effettua la richiesta con user agent personalizzato
19 HttpResponseMessage response = await httpClient.GetAsync("https://example.com");
20 response.EnsureSuccessStatusCode();
21 string responseBody = await response.Content.ReadAsStringAsync();
22
23 Console.WriteLine($"Risposta ricevuta con codice di stato: {response.StatusCode}");
24 Console.WriteLine(responseBody.Substring(0, 100) + "..."); // I primi 100 caratteri
25 }
26 catch (HttpRequestException e)
27 {
28 Console.WriteLine($"Errore nella richiesta: {e.Message}");
29 }
30 }
31 }
32}
331// Go: Creare richieste HTTP con user agent personalizzati
2package main
3
4import (
5 "fmt"
6 "io/ioutil"
7 "net/http"
8)
9
10func main() {
11 // Crea una nuova richiesta
12 req, err := http.NewRequest("GET", "https://example.com", nil)
13 if err != nil {
14 fmt.Printf("Errore nella creazione della richiesta: %s\n", err)
15 return
16 }
17
18 // Imposta user agent personalizzato
19 req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, come Gecko) Chrome/96.0.4664.110 Safari/537.36")
20
21 // Invia la richiesta
22 client := &http.Client{}
23 resp, err := client.Do(req)
24 if err != nil {
25 fmt.Printf("Errore nell'invio della richiesta: %s\n", err)
26 return
27 }
28 defer resp.Body.Close()
29
30 // Leggi la risposta
31 body, err := ioutil.ReadAll(resp.Body)
32 if err != nil {
33 fmt.Printf("Errore nella lettura della risposta: %s\n", err)
34 return
35 }
36
37 fmt.Printf("Stato della risposta: %s\n", resp.Status)
38 fmt.Printf("Anteprima del corpo della risposta: %s\n", body[:100])
39}
40Schemi di User Agent Comuni
Ecco alcuni esempi di stringhe user agent reali per diversi browser e piattaforme:
Browser Desktop
Chrome su Windows:
1Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, come Gecko) Chrome/96.0.4664.110 Safari/537.36
2Firefox su macOS:
1Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:95.0) Gecko/20100101 Firefox/95.0
2Safari su macOS:
1Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, come Gecko) Version/15.2 Safari/605.1.15
2Edge su Windows:
1Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, come Gecko) Chrome/96.0.4664.110 Safari/537.36 Edg/96.0.1054.62
2Browser Mobili
Chrome su Android:
1Mozilla/5.0 (Linux; Android 12; SM-G998B) AppleWebKit/537.36 (KHTML, come Gecko) Chrome/96.0.4664.104 Mobile Safari/537.36
2Safari su iPhone:
1Mozilla/5.0 (iPhone; CPU iPhone OS 15_2 come Mac OS X) AppleWebKit/605.1.15 (KHTML, come Gecko) Version/15.2 Mobile/15E148 Safari/604.1
2Firefox su Android:
1Mozilla/5.0 (Android 12; Mobile; rv:95.0) Gecko/95.0 Firefox/95.0
2Samsung Internet su Galaxy:
1Mozilla/5.0 (Linux; Android 12; SM-G998B) AppleWebKit/537.36 (KHTML, come Gecko) SamsungBrowser/16.0 Chrome/92.0.4515.166 Mobile Safari/537.36
2Riferimenti
-
"User Agent." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
-
"Stringhe User Agent del Browser." WhatIsMyBrowser.com, https://www.whatismybrowser.com/guides/the-latest-user-agent/
-
"Intestazione User-Agent HTTP Spiegata." KeyCDN, https://www.keycdn.com/support/user-agent
-
"Suggerimenti Client." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Client_hints
-
"Storia della stringa user agent del browser." WebAIM, https://webaim.org/blog/user-agent-string-history/
-
"Rilevamento del Browser Utilizzando l'User Agent." Google Developers, https://developer.chrome.com/docs/multidevice/user-agent/
Feedback
Fare clic sul feedback toast per iniziare a fornire feedback su questo strumento
Strumenti correlati
Scopri più strumenti che potrebbero essere utili per il tuo flusso di lavoro