User Agent Parser

// Browser JavaScript
const userAgent = navigator.userAgent;
console.log('User Agent:', userAgent);

// Node.js - Getting client User Agent in Express
const express = require('express');
const app = express();

app.get('/', (req, res) => {
  const userAgent = req.headers['user-agent'];
  res.json({ userAgent });
});

// Setting custom User Agent in Node.js fetch
fetch('https://api.testingbot.com', {
  headers: {
    'User-Agent': 'MyApp/1.0.0'
  }
});

# Flask - Getting client User Agent
from flask import Flask, request

app = Flask(__name__)

@app.route('/')
def index():
    user_agent = request.headers.get('User-Agent')
    return {'user_agent': user_agent}

# Using requests library with custom User Agent
import requests

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0'
}
response = requests.get('https://testingbot.com', headers=headers)

# Getting User Agent from HTTP request
from http.server import BaseHTTPRequestHandler

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        user_agent = self.headers.get('User-Agent')
        print(f"User Agent: {user_agent}")

<?php
// Getting client User Agent
$userAgent = $_SERVER['HTTP_USER_AGENT'];
echo "User Agent: " . $userAgent;

// Parse User Agent with get_browser()
$browser = get_browser($userAgent, true);
print_r($browser);

// Setting custom User Agent with cURL
$ch = curl_init('https://testingbot.com');
curl_setopt($ch, CURLOPT_USERAGENT, 'MyBot/1.0');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

// Using file_get_contents with custom User Agent
$options = [
    'http' => [
        'header' => "User-Agent: MyApp/1.0\r\n"
    ]
];
$context = stream_context_create($options);
$content = file_get_contents('https://testingbot.com', false, $context);
?>

# Rails - Getting client User Agent
class ApplicationController < ActionController::Base
  def index
    user_agent = request.user_agent
    render json: { user_agent: user_agent }
  end
end

# Using Net::HTTP with custom User Agent
require 'net/http'
require 'uri'

uri = URI('https://testingbot.com')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['User-Agent'] = 'MyRubyApp/1.0'
response = http.request(request)

# Using HTTParty gem
require 'httparty'

response = HTTParty.get('https://testingbot.com',
  headers: { 'User-Agent' => 'MyApp/1.0' }
)

// Servlet - Getting client User Agent
import javax.servlet.http.HttpServletRequest;

public class UserAgentServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
        String userAgent = request.getHeader("User-Agent");
        System.out.println("User Agent: " + userAgent);
    }
}

// Using HttpURLConnection
URL url = new URL("https://testingbot.com");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestProperty("User-Agent", "MyJavaApp/1.0");

// Using Apache HttpClient
CloseableHttpClient client = HttpClients.custom()
    .setUserAgent("MyApp/1.0")
    .build();

HttpGet request = new HttpGet("https://testingbot.com");
CloseableHttpResponse response = client.execute(request);

// Spring Boot
@RestController
public class UserAgentController {
    @GetMapping("/")
    public String getUserAgent(@RequestHeader("User-Agent") String userAgent) {
        return userAgent;
    }
}

// ASP.NET Core - Getting client User Agent
public class HomeController : Controller
{
    public IActionResult Index()
    {
        string userAgent = Request.Headers["User-Agent"].ToString();
        return Json(new { userAgent });
    }
}

// Using HttpClient with custom User Agent
using var client = new HttpClient();
client.DefaultRequestHeaders.UserAgent.ParseAdd("MyApp/1.0");
var response = await client.GetAsync("https://testingbot.com");

// WebClient (legacy)
using var webClient = new WebClient();
webClient.Headers.Add("User-Agent", "MyApp/1.0");
string result = webClient.DownloadString("https://testingbot.com");

// ASP.NET Core Middleware
public class UserAgentMiddleware
{
    public async Task InvokeAsync(HttpContext context)
    {
        var userAgent = context.Request.Headers["User-Agent"].ToString();
        Console.WriteLine($"User Agent: {userAgent}");
        await _next(context);
    }
}

package main

import (
    "fmt"
    "net/http"
)

// HTTP Server - Getting client User Agent
func handler(w http.ResponseWriter, r *http.Request) {
    userAgent := r.Header.Get("User-Agent")
    fmt.Fprintf(w, "User Agent: %s", userAgent)
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

// HTTP Client - Setting custom User Agent
client := &http.Client{}
req, _ := http.NewRequest("GET", "https://testingbot.com", nil)
req.Header.Set("User-Agent", "MyGoApp/1.0")

resp, err := client.Do(req)
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()

#!/usr/bin/perl
use strict;
use warnings;

# CGI - Getting client User Agent
use CGI;
my $q = CGI->new;
my $user_agent = $q->user_agent();
print "User Agent: $user_agent\n";

# Using LWP::UserAgent
use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
$ua->agent("MyPerlBot/1.0");

my $response = $ua->get('https://testingbot.com');
if ($response->is_success) {
    print $response->decoded_content;
}

# Using HTTP::Tiny
use HTTP::Tiny;

my $http = HTTP::Tiny->new(
    agent => 'MyPerlApp/1.0'
);

my $response = $http->get('https://testingbot.com');

// Getting system User Agent in iOS/macOS
#import <UIKit/UIKit.h>

// Method 1: Using UIWebView (deprecated)
UIWebView *webView = [[UIWebView alloc] init];
NSString *userAgent = [webView stringByEvaluatingJavaScriptFromString:@"navigator.userAgent"];
NSLog(@"User Agent: %@", userAgent);

// Method 2: Using WKWebView
#import <WebKit/WebKit.h>

WKWebView *webView = [[WKWebView alloc] init];
[webView evaluateJavaScript:@"navigator.userAgent"
          completionHandler:^(NSString *userAgent, NSError *error) {
    NSLog(@"User Agent: %@", userAgent);
}];

// Setting custom User Agent with NSURLRequest
NSURL *url = [NSURL URLWithString:@"https://testingbot.com"];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setValue:@"MyIOSApp/1.0" forHTTPHeaderField:@"User-Agent"];

// Using NSURLSession
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *task = [session dataTaskWithRequest:request
                                         completionHandler:^(NSData *data,
                                                           NSURLResponse *response,
                                                           NSError *error) {
    // Handle response
}];
[task resume];

import UIKit
import WebKit

// Getting User Agent with WKWebView
let webView = WKWebView()
webView.evaluateJavaScript("navigator.userAgent") { (result, error) in
    if let userAgent = result as? String {
        print("User Agent: \(userAgent)")
    }
}

// Setting custom User Agent with URLRequest
var request = URLRequest(url: URL(string: "https://testingbot.com")!)
request.setValue("MySwiftApp/1.0", forHTTPHeaderField: "User-Agent")

// Using URLSession
let task = URLSession.shared.dataTask(with: request) { data, response, error in
    // Handle response
}
task.resume()

// SwiftUI with custom User Agent
struct WebView: UIViewRepresentable {
    func makeUIView(context: Context) -> WKWebView {
        let webView = WKWebView()
        webView.customUserAgent = "MyCustomApp/1.0"
        return webView
    }
}

// Actix-web - Getting client User Agent
use actix_web::{web, App, HttpRequest, HttpServer, Result};

async fn index(req: HttpRequest) -> Result<String> {
    let user_agent = req.headers()
        .get("user-agent")
        .and_then(|h| h.to_str().ok())
        .unwrap_or("Unknown");
    Ok(format!("User Agent: {}", user_agent))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().route("/", web::get().to(index)))
        .bind("127.0.0.1:8080")?
        .run()
        .await
}

// Using Reqwest with custom User Agent
use reqwest;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::builder()
        .user_agent("MyRustApp/1.0")
        .build()?;

    let response = client
        .get("https://testingbot.com")
        .send()
        .await?;

    Ok(())
}