Generator losowych ciągów user agent do testowania w rozwoju stron internetowych
Generuj realistyczne ciągi user agent przeglądarki z opcjami filtrowania według typu urządzenia, rodziny przeglądarki i systemu operacyjnego. Idealne do testowania w rozwoju stron internetowych i sprawdzania zgodności.
Generator losowych identyfikatorów użytkowników
Generuj losowe, realistyczne ciągi identyfikatorów użytkowników przeglądarki do testowania w rozwoju webowym.
Wygenerowany identyfikator użytkownika
Dokumentacja
Generator losowych identyfikatorów użytkowników
Wprowadzenie
Ciężar identyfikatora użytkownika to konkretny tekstowy identyfikator, który przeglądarki internetowe i inne aplikacje wysyłają do witryn internetowych, aby się zidentyfikować. Ten ciąg zazwyczaj zawiera informacje o przeglądarce, systemie operacyjnym, typie urządzenia i silniku renderującym, który jest używany. Dla programistów internetowych i testerów dostęp do różnych realistycznych identyfikatorów użytkowników jest niezbędny do testowania zgodności witryn, responsywności i funkcjonalności na różnych platformach.
Narzędzie Generator losowych identyfikatorów użytkowników tworzy autentycznie wyglądające ciągi identyfikatorów użytkowników na podstawie wybranych parametrów. Możesz filtrować według typu urządzenia (komputer stacjonarny lub mobilny), rodziny przeglądarek (Chrome, Firefox, Safari lub Edge) oraz systemu operacyjnego, aby generować identyfikatory użytkowników, które odpowiadają Twoim wymaganiom testowym. Narzędzie oferuje prosty interfejs z opcjami skopiowania wygenerowanego ciągu za pomocą jednego kliknięcia oraz natychmiastowego generowania nowych losowych ciągów.
Struktura identyfikatora użytkownika
Ciągi identyfikatorów użytkowników podążają za określonymi wzorcami w zależności od przeglądarki i platformy, ale ogólnie zawierają kilka wspólnych komponentów:
- Identyfikator przeglądarki: Zazwyczaj zaczyna się od "Mozilla/5.0" z powodów historycznych
- Informacje o platformie/OS: Szczegóły dotyczące systemu operacyjnego (Windows, macOS, Android, iOS)
- Silnik przeglądarki: Silnik renderujący (taki jak Gecko, WebKit lub Blink)
- Szczegóły przeglądarki: Nazwa i wersja konkretnej przeglądarki
Oto podział typowych struktur identyfikatorów użytkowników dla głównych przeglądarek:
Chrome
1Mozilla/5.0 (platforma; szczegóły) AppleWebKit/537.36 (KHTML, jak Gecko) Chrome/wersja Safari/537.36
2Firefox
1Mozilla/5.0 (platforma; rv:geckowersja) Gecko/geckoszlaki Firefox/firefoxwersja
2Safari
1Mozilla/5.0 (platforma) AppleWebKit/webkitwersja (KHTML, jak Gecko) Wersja/safariversja Safari/safariversja
2Edge
1Mozilla/5.0 (platforma) AppleWebKit/537.36 (KHTML, jak Gecko) Chrome/chromiumwersja Safari/537.36 Edg/edgewersja
2Sekcja platformy znacznie różni się między urządzeniami stacjonarnymi a mobilnymi:
Przykłady dla komputerów stacjonarnych:
- Windows:
Windows NT 10.0; Win64; x64 - macOS:
Macintosh; Intel Mac OS X 10_15_7 - Linux:
X11; Linux x86_64
Przykłady dla urządzeń mobilnych:
- Android:
Linux; Android 12; SM-G998B - iOS:
iPhone; CPU iPhone OS 15_4 jak Mac OS X
Różnice między typami urządzeń
Identyfikatory użytkowników dla komputerów stacjonarnych
Identyfikatory użytkowników dla komputerów stacjonarnych zazwyczaj zawierają konkretne informacje o systemie operacyjnym, szczegóły architektury (takie jak x86_64 lub Win64) i czasami preferencje językowe. Zazwyczaj są bardziej spójne między przeglądarkami niż identyfikatory użytkowników dla urządzeń mobilnych.
Identyfikatory użytkowników dla urządzeń mobilnych
Identyfikatory użytkowników dla urządzeń mobilnych zawierają informacje o modelu urządzenia, wersjach mobilnych systemów operacyjnych i często na końcu zawierają słowo "Mobile". Mobilny Safari na urządzeniach iOS będzie zawierać identyfikatory "iPhone" lub "iPad", podczas gdy urządzenia Android zawierają producenta i numer modelu.
Wzorce wersji przeglądarki
Każda przeglądarka podąża za różnymi wzorcami wersjonowania:
- Chrome: Używa czteroczęściowych numerów wersji (np. 96.0.4664.110)
- Firefox: Zazwyczaj używa dwu- lub trzyczęściowych numerów wersji (np. 95.0 lub 95.0.2)
- Safari: Używa prostych numerów wersji, takich jak 15.2
- Edge: Używa numerów wersji podobnych do Chrome, ale z własną wersją Edge (np. 96.0.1054.62)
Przypadki użycia
Generowanie losowych identyfikatorów użytkowników ma kilka ważnych zastosowań w programowaniu i testowaniu internetowym:
-
Testowanie zgodności między przeglądarkami: Testuj, jak Twoja witryna renderuje się i działa w różnych przeglądarkach bez potrzeby instalowania wielu przeglądarek lub używania wielu urządzeń.
-
Testowanie responsywnego projektu: Sprawdź, czy Twoja witryna poprawnie wykrywa urządzenia mobilne i stacjonarne oraz dostarcza odpowiedni układ.
-
Walidacja wykrywania funkcji: Upewnij się, że mechanizmy wykrywania funkcji Twojej witryny działają poprawnie dla różnych możliwości przeglądarek.
-
QA i testowanie automatyczne: Włącz różne identyfikatory użytkowników do swoich skryptów testowania automatycznego, aby symulować różne środowiska użytkowników.
-
Testowanie wydajności: Analizuj, jak Twoja witryna działa, gdy jest dostępna z różnych środowisk przeglądarek.
-
Debugowanie problemów specyficznych dla przeglądarki: Reprodukuj i naprawiaj błędy, które występują tylko w określonych przeglądarkach lub wersjach.
-
Testowanie API: Sprawdź, jak Twoje API obsługuje żądania z różnych aplikacji klienckich.
Alternatywy
Chociaż nasz generator losowych identyfikatorów użytkowników jest przydatny w wielu scenariuszach testowych, istnieją alternatywne podejścia:
-
Usługi testowania przeglądarek: Platformy takie jak BrowserStack, Sauce Labs lub LambdaTest oferują rzeczywiste instancje przeglądarek do testowania, a nie tylko symulowanie identyfikatora użytkownika.
-
Narzędzia dewelopera przeglądarki: Większość nowoczesnych przeglądarek pozwala na nadpisanie identyfikatora użytkownika za pomocą swoich narzędzi dewelopera, co może być przydatne do szybkich testów.
-
Rozszerzenia przełącznika identyfikatora użytkownika: Rozszerzenia przeglądarki, które pozwalają przełączać się między zdefiniowanymi identyfikatorami użytkowników podczas przeglądania.
-
Maszyny wirtualne lub kontenery: Uruchamianie rzeczywistych instancji różnych systemów operacyjnych i przeglądarek dla najdokładniejszego testowania.
-
Testowanie przeglądarek bez interfejsu: Używanie narzędzi takich jak Puppeteer lub Selenium do programowego kontrolowania przeglądarek z różnymi ustawieniami identyfikatora użytkownika.
Każda alternatywa ma swoje własne zalety i może być bardziej odpowiednia w zależności od Twoich konkretnych potrzeb testowych i zasobów.
Historia
Koncepcja ciągu identyfikatora użytkownika sięga wczesnych dni World Wide Web. Termin "identyfikator użytkownika" pochodzi z specyfikacji HTTP, w której odnosi się do aplikacji klienckiej wysyłającej żądanie do serwera internetowego.
Wczesne dni (lata 90.)
Pierwsza szeroko używana przeglądarka, NCSA Mosaic, zawierała prosty ciąg identyfikatora użytkownika, który identyfikował nazwę i wersję przeglądarki. Gdy wydano Netscape Navigator, używał podobnego formatu. Jednak w miarę jak serwery internetowe zaczęły dostarczać różne treści w zależności od przeglądarki, pojawiła się praktyka znana jako "sniffing przeglądarek".
Wojny przeglądarek i oszustwa identyfikatorów użytkowników (koniec lat 90.)
Podczas wojen przeglądarek między Netscape a Internet Explorer, witryny często dostarczały zoptymalizowane treści wyłącznie do określonych przeglądarek. Aby zapewnić zgodność, przeglądarki zaczęły zawierać ciągi, które identyfikowały je jako inne przeglądarki. Dlatego większość nowoczesnych przeglądarek nadal zawiera "Mozilla" w swoich ciągach identyfikatorów użytkowników, odniesienie do nazwy kodowej Netscape Navigator.
Rewolucja mobilna (lata 2000-2010)
Wzrost urządzeń mobilnych wprowadził nową złożoność do ciągów identyfikatorów użytkowników. Mobilne przeglądarki musiały identyfikować się jako mobilne, aby otrzymać odpowiednie treści, co doprowadziło do dodania identyfikatorów urządzeń i mobilnych tokenów.
Współczesne wyzwania (lata 2010-obecnie)
W miarę jak ekosystem internetowy stał się coraz bardziej złożony, ciągi identyfikatorów użytkowników stały się coraz bardziej zawiłe. Zawierają teraz odniesienia do wielu silników przeglądarek (takich jak "AppleWebKit" i "Gecko") z powodów zgodności, nawet gdy te silniki nie są faktycznie używane.
Ta złożoność doprowadziła do wyzwań w dokładnym analizowaniu ciągów identyfikatorów użytkowników, a niektóre grupy standardów internetowych zaproponowały deprecjację lub uproszczenie ciągów identyfikatorów użytkowników na rzecz bardziej ustrukturyzowanych wskazówek klienta. Jednak z powodów zgodności wstecznej tradycyjny ciąg identyfikatora użytkownika pozostaje istotną częścią przeglądania internetu.
Przykłady kodu
Oto przykłady, jak pracować z ciągami identyfikatorów użytkowników w różnych językach programowania:
1// JavaScript: Wykrywanie typu przeglądarki z identyfikatora użytkownika
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 "Nieznany";
21 }
22}
23
24// Użycie
25console.log("Używasz: " + detectBrowser());
261# Python: Ustawianie niestandardowego identyfikatora użytkownika w 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# Przykład użycia
12chrome_ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, jak Gecko) Chrome/96.0.4664.110 Safari/537.36'
13content = fetch_with_user_agent('https://example.com', chrome_ua)
14print(content[:100]) # Drukuj pierwsze 100 znaków odpowiedzi
151<?php
2// PHP: Wykrywanie urządzeń mobilnych za pomocą identyfikatora użytkownika
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// Użycie
16if (isMobileDevice()) {
17 echo "Używasz urządzenia mobilnego.";
18} else {
19 echo "Używasz urządzenia stacjonarnego.";
20}
21?>
221// Java: Generowanie losowego identyfikatora użytkownika
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, jak 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: Analizowanie ciągu identyfikatora użytkownika
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# Przykład użycia
18ua = 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, jak Gecko) Version/14.0.3 Mobile/15E148 Safari/604.1'
19info = parse_user_agent(ua)
20puts info
211// C#: Ustawianie identyfikatora użytkownika w HttpClient
2using System;
3using System.Net.Http;
4using System.Threading.Tasks;
5
6class Program
7{
8 static async Task Main()
9 {
10 // Tworzenie HttpClient z niestandardowym identyfikatorem użytkownika
11 using (var httpClient = new HttpClient())
12 {
13 string userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, jak Gecko) Chrome/96.0.4664.110 Safari/537.36";
14 httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
15
16 try
17 {
18 // Wykonaj żądanie z niestandardowym identyfikatorem użytkownika
19 HttpResponseMessage response = await httpClient.GetAsync("https://example.com");
20 response.EnsureSuccessStatusCode();
21 string responseBody = await response.Content.ReadAsStringAsync();
22
23 Console.WriteLine($"Otrzymano odpowiedź z kodem statusu: {response.StatusCode}");
24 Console.WriteLine(responseBody.Substring(0, 100) + "..."); // Pierwsze 100 znaków
25 }
26 catch (HttpRequestException e)
27 {
28 Console.WriteLine($"Błąd żądania: {e.Message}");
29 }
30 }
31 }
32}
331// Go: Tworzenie żądań HTTP z niestandardowymi identyfikatorami użytkowników
2package main
3
4import (
5 "fmt"
6 "io/ioutil"
7 "net/http"
8)
9
10func main() {
11 // Tworzenie nowego żądania
12 req, err := http.NewRequest("GET", "https://example.com", nil)
13 if err != nil {
14 fmt.Printf("Błąd tworzenia żądania: %s\n", err)
15 return
16 }
17
18 // Ustawianie niestandardowego identyfikatora użytkownika
19 req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, jak Gecko) Chrome/96.0.4664.110 Safari/537.36")
20
21 // Wysłanie żądania
22 client := &http.Client{}
23 resp, err := client.Do(req)
24 if err != nil {
25 fmt.Printf("Błąd wysyłania żądania: %s\n", err)
26 return
27 }
28 defer resp.Body.Close()
29
30 // Odczyt odpowiedzi
31 body, err := ioutil.ReadAll(resp.Body)
32 if err != nil {
33 fmt.Printf("Błąd odczytu odpowiedzi: %s\n", err)
34 return
35 }
36
37 fmt.Printf("Status odpowiedzi: %s\n", resp.Status)
38 fmt.Printf("Podgląd treści odpowiedzi: %s\n", body[:100])
39}
40Typowe wzorce identyfikatorów użytkowników
Oto kilka przykładów rzeczywistych ciągów identyfikatorów użytkowników dla różnych przeglądarek i platform:
Przeglądarki stacjonarne
Chrome na Windows:
1Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, jak Gecko) Chrome/96.0.4664.110 Safari/537.36
2Firefox na macOS:
1Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:95.0) Gecko/20100101 Firefox/95.0
2Safari na macOS:
1Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, jak Gecko) Wersja/15.2 Safari/605.1.15
2Edge na Windows:
1Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, jak Gecko) Chrome/96.0.4664.110 Safari/537.36 Edg/96.0.1054.62
2Przeglądarki mobilne
Chrome na Androidzie:
1Mozilla/5.0 (Linux; Android 12; SM-G998B) AppleWebKit/537.36 (KHTML, jak Gecko) Chrome/96.0.4664.104 Mobile Safari/537.36
2Safari na iPhonie:
1Mozilla/5.0 (iPhone; CPU iPhone OS 15_2 jak Mac OS X) AppleWebKit/605.1.15 (KHTML, jak Gecko) Wersja/15.2 Mobile/15E148 Safari/604.1
2Firefox na Androidzie:
1Mozilla/5.0 (Android 12; Mobile; rv:95.0) Gecko/95.0 Firefox/95.0
2Internet Samsung na Galaxy:
1Mozilla/5.0 (Linux; Android 12; SM-G998B) AppleWebKit/537.36 (KHTML, jak Gecko) SamsungBrowser/16.0 Chrome/92.0.4515.166 Mobile Safari/537.36
2Źródła
-
"Identyfikator użytkownika." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
-
"Ciągi identyfikatorów użytkowników przeglądarki." WhatIsMyBrowser.com, https://www.whatismybrowser.com/guides/the-latest-user-agent/
-
"Nagłówek HTTP User-Agent wyjaśniony." KeyCDN, https://www.keycdn.com/support/user-agent
-
"Wskazówki dla klientów." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Client_hints
-
"Historia ciągu identyfikatora użytkownika przeglądarki." WebAIM, https://webaim.org/blog/user-agent-string-history/
-
"Wykrywanie przeglądarki za pomocą identyfikatora użytkownika." Google Developers, https://developer.chrome.com/docs/multidevice/user-agent/
Powiązane narzędzia
Odkryj więcej narzędzi, które mogą być przydatne dla Twojego przepływu pracy