Ping检测工具

// HTTP Ping - 测量HTTP请求响应时间
async function httpPing(url, count = 5) {
    const results = [];
    
    for (let i = 0; i < count; i++) {
        const startTime = performance.now();
        try {
            const response = await fetch(url, {
                method: 'HEAD',
                mode: 'no-cors',
                cache: 'no-cache'
            });
            const endTime = performance.now();
            const latency = Math.round(endTime - startTime);
            
            results.push({
                index: i + 1,
                success: true,
                latency: latency,
                timestamp: new Date().toISOString()
            });
        } catch (error) {
            const endTime = performance.now();
            const latency = Math.round(endTime - startTime);
            
            results.push({
                index: i + 1,
                success: false,
                latency: latency,
                error: error.message,
                timestamp: new Date().toISOString()
            });
        }
        
        // 间隔一秒
        if (i < count - 1) {
            await new Promise(resolve => setTimeout(resolve, 1000));
        }
    }
    
    return results;
}

// 计算统计数据
function calculatePingStats(results) {
    const successful = results.filter(r => r.success);
    const latencies = successful.map(r => r.latency);
    
    if (latencies.length === 0) {
        return {
            total: results.length,
            success: 0,
            failed: results.length,
            min: '-',
            max: '-',
            avg: '-'
        };
    }
    
    return {
        total: results.length,
        success: successful.length,
        failed: results.length - successful.length,
        min: Math.min(...latencies) + 'ms',
        max: Math.max(...latencies) + 'ms',
        avg: Math.round(latencies.reduce((a, b) => a + b, 0) / latencies.length) + 'ms'
    };
}

// 使用示例
httpPing('https://www.baidu.com', 5).then(results => {
    console.log('Ping结果:', results);
    console.log('统计:', calculatePingStats(results));
});

import subprocess
import re
import time
from statistics import mean

# 使用系统ping命令
def ping_host(host, count=4):
    try:
        # 根据操作系统选择ping命令
        if platform.system() == 'Windows':
            cmd = ['ping', '-n', str(count), host]
        else:
            cmd = ['ping', '-c', str(count), host]
        
        result = subprocess.run(cmd, capture_output=True, text=True)
        output = result.stdout
        
        # 解析结果
        # Windows: 平均 = 12ms
        # Linux: rtt min/avg/max/mdev = 10.123/12.456/15.789/2.123 ms
        
        return {
            'host': host,
            'success': result.returncode == 0,
            'output': output
        }
    except Exception as e:
        return {
            'host': host,
            'success': False,
            'error': str(e)
        }

# 使用requests库测试HTTP响应
import requests

def http_ping(url, count=5):
    results = []
    
    for i in range(count):
        start_time = time.time()
        try:
            response = requests.head(url, timeout=10)
            latency = round((time.time() - start_time) * 1000)
            
            results.append({
                'index': i + 1,
                'success': True,
                'latency': latency,
                'status': response.status_code
            })
        except Exception as e:
            latency = round((time.time() - start_time) * 1000)
            results.append({
                'index': i + 1,
                'success': False,
                'latency': latency,
                'error': str(e)
            })
        
        if i < count - 1:
            time.sleep(1)
    
    return results

# 计算统计数据
def calculate_stats(results):
    successful = [r for r in results if r['success']]
    latencies = [r['latency'] for r in successful]
    
    if not latencies:
        return {
            'total': len(results),
            'success': 0,
            'failed': len(results),
            'min': '-',
            'max': '-',
            'avg': '-'
        }
    
    return {
        'total': len(results),
        'success': len(successful),
        'failed': len(results) - len(successful),
        'min': f'{min(latencies)}ms',
        'max': f'{max(latencies)}ms',
        'avg': f'{round(mean(latencies))}ms'
    }

# 使用示例
if __name__ == '__main__':
    print(http_ping('https://www.baidu.com', 5))

const net = require('net');
const dns = require('dns').promises;

// TCP端口检测
async function checkPort(host, port, timeout = 5000) {
    return new Promise((resolve) => {
        const startTime = Date.now();
        const socket = new net.Socket();
        let resolved = false;
        
        socket.setTimeout(timeout);
        
        socket.on('connect', () => {
            const latency = Date.now() - startTime;
            socket.destroy();
            if (!resolved) {
                resolved = true;
                resolve({
                    host,
                    port,
                    success: true,
                    latency
                });
            }
        });
        
        socket.on('timeout', () => {
            socket.destroy();
            if (!resolved) {
                resolved = true;
                resolve({
                    host,
                    port,
                    success: false,
                    error: 'Connection timeout'
                });
            }
        });
        
        socket.on('error', (err) => {
            if (!resolved) {
                resolved = true;
                resolve({
                    host,
                    port,
                    success: false,
                    error: err.message
                });
            }
        });
        
        socket.connect(port, host);
    });
}

// DNS查询
async function dnsLookup(domain, type = 'A') {
    try {
        switch (type) {
            case 'A':
                const address = await dns.lookup4(domain);
                return { type: 'A', records: [address.address] };
            case 'AAAA':
                const address6 = await dns.lookup6(domain);
                return { type: 'AAAA', records: [address6.address] };
            case 'MX':
                const mx = await dns.resolveMx(domain);
                return { type: 'MX', records: mx.map(r => `${r.exchange} (priority: ${r.priority})`) };
            case 'TXT':
                const txt = await dns.resolveTxt(domain);
                return { type: 'TXT', records: txt.flat() };
            case 'NS':
                const ns = await dns.resolveNs(domain);
                return { type: 'NS', records: ns };
            case 'CNAME':
                try {
                    const cname = await dns.resolveCname(domain);
                    return { type: 'CNAME', records: [cname] };
                } catch (e) {
                    return { type: 'CNAME', records: [] };
                }
            default:
                throw new Error(`Unsupported record type: ${type}`);
        }
    } catch (error) {
        throw new Error(`DNS lookup failed: ${error.message}`);
    }
}

// 使用示例
async function main() {
    // 测试端口
    const portResult = await checkPort('www.baidu.com', 80);
    console.log('Port check:', portResult);
    
    // DNS查询
    const dnsResult = await dnsLookup('www.baidu.com', 'A');
    console.log('DNS result:', dnsResult);
}

main();

package main

import (
    "fmt"
    "net"
    "time"
)

// 检查TCP端口
func CheckPort(host string, port int, timeout time.Duration) (bool, time.Duration, error) {
    startTime := time.Now()
    
    address := fmt.Sprintf("%s:%d", host, port)
    
    conn, err := net.DialTimeout("tcp", address, timeout)
    if err != nil {
        latency := time.Since(startTime)
        return false, latency, err
    }
    defer conn.Close()
    
    latency := time.Since(startTime)
    return true, latency, nil
}

// HTTP Ping
func HTTPPing(url string, count int) {
    for i := 0; i < count; i++ {
        startTime := time.Now()
        
        resp, err := http.Get(url)
        latency := time.Since(startTime)
        
        if err != nil {
            fmt.Printf("Ping %d: 失败 (%v)\n", i+1, err)
        } else {
            resp.Body.Close()
            fmt.Printf("Ping %d: 成功 - 延迟: %v, 状态: %d\n", 
                i+1, latency, resp.StatusCode)
        }
        
        if i < count-1 {
            time.Sleep(1 * time.Second)
        }
    }
}

func main() {
    // 测试端口
    success, latency, err := CheckPort("www.baidu.com", 80, 5*time.Second)
    if success {
        fmt.Printf("端口可达 - 延迟: %v\n", latency)
    } else {
        fmt.Printf("端口不可达: %v\n", err)
    }
}