Ping 测试 API

# 设置您的 API 密钥
export IPCONFIG_API_KEY='your-api-key-here'

# 测试特定位置
curl -H "Content-Type: application/json" \
  -H "Authorization: Bearer $IPCONFIG_API_KEY" \
  "https://ipconfig.com/api/ping" \
  -d '{
    "host": "google.com",
    "lang": "zh",
    "ipVersion": "ipv4",
    "areas": ["beijing", "tokyo", "california"],
    "count": 4
  }'

# 测试所有位置
curl -H "Content-Type: application/json" \
  -H "Authorization: Bearer $IPCONFIG_API_KEY" \
  "https://ipconfig.com/api/ping" \
  -d '{
    "host": "example.com",
    "lang": "zh",
    "ipVersion": "ipv4",
    "areas": ["all"],
    "count": 2
  }'

async function pingTest(host, options = {}) {
  const apiKey = process.env.IPCONFIG_API_KEY;

  if (!apiKey) {
    throw new Error('API 密钥未配置');
  }

  const {
    lang = 'zh',
    ipVersion = 'ipv4',
    areas = ['all'],
    count = 4
  } = options;

  try {
    const response = await fetch('https://ipconfig.com/api/ping', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        host,
        lang,
        ipVersion,
        areas,
        count
      })
    });

    if (!response.ok) {
      throw new Error(`HTTP 错误! 状态: ${response.status}`);
    }

    const data = await response.json();

    if (data.success) {
      return data.data;
    } else {
      throw new Error(data.error || '未知 API 错误');
    }
  } catch (error) {
    console.error('Ping 测试失败:', error);
    throw error;
  }
}

// 使用示例
pingTest('google.com', {
  areas: ['beijing', 'tokyo', 'california'],
  count: 4
})
.then(result => {
  console.log(`${result.pingHost} 的 Ping 测试结果:`);
  console.log(`成功率: ${result.successNodes}/${result.totalNodes}`);

  result.pingResultDetail.forEach(detail => {
    if (detail.result && detail.pingResult) {
      const location = detail.pingServerArea || detail.pingServerAreaEN;
      const avgTime = detail.pingResult.rttAvgTime;
      const loss = detail.pingResult.lossPacket;
      console.log(`${location}: ${avgTime}ms (丢包率: ${loss}%)`);
    }
  });
})
.catch(error => {
  console.error('错误:', error.message);
});

import requests
import os
import json

def ping_test(host, lang='zh', ip_version='ipv4', areas=['all'], count=4):
    """从多个全球位置执行 ping 测试"""

    # 从环境变量获取 API 密钥
    api_key = os.getenv("IPCONFIG_API_KEY")
    if not api_key:
        raise ValueError("请设置 IPCONFIG_API_KEY 环境变量")

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    payload = {
        "host": host,
        "lang": lang,
        "ipVersion": ip_version,
        "areas": areas,
        "count": count
    }

    try:
        response = requests.post(
            "https://ipconfig.com/api/ping",
            headers=headers,
            json=payload,
            timeout=30  # Ping 测试可能需要更长时间
        )
        response.raise_for_status()

        data = response.json()

        if data.get("success"):
            return data["data"]
        else:
            raise Exception(f"API 错误: {data.get('error', '未知错误')}")

    except requests.exceptions.RequestException as e:
        raise Exception(f"请求失败: {e}")

def analyze_ping_results(result):
    """分析并显示 ping 测试结果"""
    print(f"{result['pingHost']} 的 Ping 测试结果:")
    print(f"IP 版本: {result['IPversion']}")
    print(f"成功率: {result['successNodes']}/{result['totalNodes']}")
    print(f"失败节点: {result['failedNodes']}")
    print("\n详细结果:")
    print("-" * 80)

    successful_results = []

    for detail in result['pingResultDetail']:
        location = detail.get('pingServerArea', detail.get('pingServerAreaEN', '未知'))
        continent = detail.get('continent', '未知')

        if detail['result'] and detail.get('pingResult'):
            ping_result = detail['pingResult']
            avg_time = ping_result['rttAvgTime']
            min_time = ping_result['rttMinTime']
            max_time = ping_result['rttMaxTime']
            loss = ping_result['lossPacket']
            ip = ping_result['pingIP']

            successful_results.append({
                'location': location,
                'continent': continent,
                'avg_time': avg_time,
                'ip': ip
            })

            print(f"{location:15} ({continent:12}): {avg_time:6.2f}ms "
                  f"(最小: {min_time:5.2f}ms, 最大: {max_time:5.2f}ms, 丢包: {loss:4.1f}%) "
                  f"- IP: {ip}")
        else:
            print(f"{location:15} ({continent:12}): 失败 - {detail.get('message', '未知错误')}")

    # 显示最快的位置
    if successful_results:
        successful_results.sort(key=lambda x: x['avg_time'])
        print(f"\n最快的位置:")
        for i, result in enumerate(successful_results[:3], 1):
            print(f"{i}. {result['location']} ({result['continent']}): {result['avg_time']:.2f}ms")

# 使用示例
if __name__ == "__main__":
    try:
        # 测试特定位置
        result = ping_test(
            host="google.com",
            areas=["beijing", "tokyo", "california", "london"],
            count=4
        )

        analyze_ping_results(result)

    except Exception as e:
        print(f"错误: {e}")

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "sort"
    "strings"
    "time"
)

type PingRequest struct {
    Host      string   `json:"host"`
    Lang      string   `json:"lang"`
    IPVersion string   `json:"ipVersion"`
    Areas     []string `json:"areas"`
    Count     int      `json:"count"`
}

type APIResponse struct {
    Success bool      `json:"success"`
    Data    *PingData `json:"data,omitempty"`
    Error   string    `json:"error,omitempty"`
    Meta    *Meta     `json:"meta,omitempty"`
}

type Meta struct {
    IsLoggedIn     bool `json:"isLoggedIn"`
    IsApiRequest   bool `json:"isApiRequest"`
    CurrentCredits int  `json:"currentCredits"`
}

type PingData struct {
    Result           bool                `json:"result"`
    Code             string              `json:"code"`
    Message          string              `json:"message"`
    PingHost         string              `json:"pingHost"`
    IPVersion        string              `json:"IPversion"`
    TotalNodes       int                 `json:"totalNodes"`
    SuccessNodes     int                 `json:"successNodes"`
    FailedNodes      int                 `json:"failedNodes"`
    PingResultDetail []PingResultDetail  `json:"pingResultDetail"`
}

type PingResultDetail struct {
    Result           bool            `json:"result"`
    Code             string          `json:"code"`
    Message          string          `json:"message"`
    Continent        string          `json:"continent,omitempty"`
    PingServerArea   string          `json:"pingServerArea"`
    PingServerAreaEN string          `json:"pingServerAreaEN,omitempty"`
    PingResult       *PingResult     `json:"pingResult,omitempty"`
    PingIPLocation   *PingIPLocation `json:"pingIPLocation,omitempty"`
}

type PingResult struct {
    LossPacket             float64 `json:"lossPacket"`
    PingHost               string  `json:"pingHost"`
    PingIP                 string  `json:"pingIP"`
    PingStatisticsDetail   string  `json:"pingStatisticsDetail"`
    ReceivedPackets        int     `json:"receivedPackets"`
    RttAvgTime             float64 `json:"rttAvgTime"`
    RttMaxTime             float64 `json:"rttMaxTime"`
    RttMdevTime            float64 `json:"rttMdevTime"`
    RttMinTime             float64 `json:"rttMinTime"`
    SendPackets            int     `json:"sendPackets"`
    TotalElapsedTime       int     `json:"totalElapsedTime"`
}

type PingIPLocation struct {
    Address string `json:"Address"`
    ISP     string `json:"ISP"`
    ASN     string `json:"asn"`
}

type LocationResult struct {
    Location  string
    Continent string
    AvgTime   float64
    IP        string
}

func pingTest(host, lang, ipVersion string, areas []string, count int) (*PingData, error) {
    // 从环境变量获取 API 密钥
    apiKey := os.Getenv("IPCONFIG_API_KEY")
    if apiKey == "" {
        return nil, fmt.Errorf("未设置 IPCONFIG_API_KEY 环境变量")
    }

    // 准备请求载荷
    payload := PingRequest{
        Host:      host,
        Lang:      lang,
        IPVersion: ipVersion,
        Areas:     areas,
        Count:     count,
    }

    jsonData, err := json.Marshal(payload)
    if err != nil {
        return nil, fmt.Errorf("JSON 序列化失败: %v", err)
    }

    // 创建请求
    req, err := http.NewRequest("POST", "https://ipconfig.com/api/ping", bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, fmt.Errorf("创建请求失败: %v", err)
    }

    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    // 发送请求，ping 测试需要更长的超时时间
    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("请求失败: %v", err)
    }
    defer resp.Body.Close()

    // 解析响应
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("读取响应失败: %v", err)
    }

    var apiResp APIResponse
    if err := json.Unmarshal(body, &apiResp); err != nil {
        return nil, fmt.Errorf("JSON 解析失败: %v", err)
    }

    if !apiResp.Success {
        return nil, fmt.Errorf("API 错误: %s", apiResp.Error)
    }

    return apiResp.Data, nil
}

func analyzePingResults(result *PingData) {
    fmt.Printf("%s 的 Ping 测试结果:\n", result.PingHost)
    fmt.Printf("IP 版本: %s\n", result.IPVersion)
    fmt.Printf("成功率: %d/%d\n", result.SuccessNodes, result.TotalNodes)
    fmt.Printf("失败节点: %d\n", result.FailedNodes)
    fmt.Println("\n详细结果:")
    fmt.Println(strings.Repeat("-", 80))

    var successfulResults []LocationResult

    for _, detail := range result.PingResultDetail {
        location := detail.PingServerArea
        if location == "" {
            location = detail.PingServerAreaEN
        }
        continent := detail.Continent
        if continent == "" {
            continent = "未知"
        }

        if detail.Result && detail.PingResult != nil {
            pingResult := detail.PingResult
            successfulResults = append(successfulResults, LocationResult{
                Location:  location,
                Continent: continent,
                AvgTime:   pingResult.RttAvgTime,
                IP:        pingResult.PingIP,
            })

            fmt.Printf("%-15s (%-12s): %6.2fms (最小: %5.2fms, 最大: %5.2fms, 丢包: %4.1f%%) - IP: %s\n",
                location, continent,
                pingResult.RttAvgTime,
                pingResult.RttMinTime,
                pingResult.RttMaxTime,
                pingResult.LossPacket,
                pingResult.PingIP)
        } else {
            fmt.Printf("%-15s (%-12s): 失败 - %s\n", location, continent, detail.Message)
        }
    }

    // 显示最快的位置
    if len(successfulResults) > 0 {
        sort.Slice(successfulResults, func(i, j int) bool {
            return successfulResults[i].AvgTime < successfulResults[j].AvgTime
        })

        fmt.Println("\n最快的位置:")
        for i, result := range successfulResults {
            if i >= 3 {
                break
            }
            fmt.Printf("%d. %s (%s): %.2fms\n", i+1, result.Location, result.Continent, result.AvgTime)
        }
    }
}

func main() {
    result, err := pingTest(
        "google.com",
        "zh",
        "ipv4",
        []string{"beijing", "tokyo", "california", "london"},
        4,
    )
    if err != nil {
        fmt.Printf("Ping 测试失败: %v\n", err)
        return
    }

    analyzePingResults(result)
}

<?php

function pingTest($host, $options = []) {
    // 从环境变量获取 API 密钥
    $apiKey = getenv('IPCONFIG_API_KEY');
    if (!$apiKey) {
        throw new Exception('未设置 IPCONFIG_API_KEY 环境变量');
    }

    $defaults = [
        'lang' => 'zh',
        'ipVersion' => 'ipv4',
        'areas' => ['all'],
        'count' => 4
    ];

    $options = array_merge($defaults, $options);

    $payload = json_encode([
        'host' => $host,
        'lang' => $options['lang'],
        'ipVersion' => $options['ipVersion'],
        'areas' => $options['areas'],
        'count' => $options['count']
    ]);

    $context = stream_context_create([
        'http' => [
            'method' => 'POST',
            'header' => [
                'Content-Type: application/json',
                'Authorization: Bearer ' . $apiKey
            ],
            'content' => $payload,
            'timeout' => 30 // Ping 测试可能需要更长时间
        ]
    ]);

    $response = file_get_contents('https://ipconfig.com/api/ping', false, $context);

    if ($response === false) {
        throw new Exception('请求失败');
    }

    $data = json_decode($response, true);

    if (!$data['success']) {
        throw new Exception('API 错误: ' . ($data['error'] ?? '未知错误'));
    }

    return $data['data'];
}

function analyzePingResults($result) {
    echo "{$result['pingHost']} 的 Ping 测试结果:\n";
    echo "IP 版本: {$result['IPversion']}\n";
    echo "成功率: {$result['successNodes']}/{$result['totalNodes']}\n";
    echo "失败节点: {$result['failedNodes']}\n";
    echo "\n详细结果:\n";
    echo str_repeat("-", 80) . "\n";

    $successfulResults = [];

    foreach ($result['pingResultDetail'] as $detail) {
        $location = $detail['pingServerArea'] ?? $detail['pingServerAreaEN'] ?? '未知';
        $continent = $detail['continent'] ?? '未知';

        if ($detail['result'] && isset($detail['pingResult'])) {
            $pingResult = $detail['pingResult'];
            $successfulResults[] = [
                'location' => $location,
                'continent' => $continent,
                'avgTime' => $pingResult['rttAvgTime'],
                'ip' => $pingResult['pingIP']
            ];

            printf("%-15s (%-12s): %6.2fms (最小: %5.2fms, 最大: %5.2fms, 丢包: %4.1f%%) - IP: %s\n",
                $location, $continent,
                $pingResult['rttAvgTime'],
                $pingResult['rttMinTime'],
                $pingResult['rttMaxTime'],
                $pingResult['lossPacket'],
                $pingResult['pingIP']
            );
        } else {
            printf("%-15s (%-12s): 失败 - %s\n", $location, $continent, $detail['message'] ?? '未知错误');
        }
    }

    // 显示最快的位置
    if (!empty($successfulResults)) {
        usort($successfulResults, function($a, $b) {
            return $a['avgTime'] <=> $b['avgTime'];
        });

        echo "\n最快的位置:\n";
        for ($i = 0; $i < min(3, count($successfulResults)); $i++) {
            $result = $successfulResults[$i];
            printf("%d. %s (%s): %.2fms\n", $i + 1, $result['location'], $result['continent'], $result['avgTime']);
        }
    }
}

// 使用示例
try {
    $result = pingTest('google.com', [
        'areas' => ['beijing', 'tokyo', 'california', 'london'],
        'count' => 4
    ]);

    analyzePingResults($result);

} catch (Exception $e) {
    echo "错误: " . $e->getMessage() . "\n";
}

?>