/**
 * API请求DEMO-PHP
 * 
 * 本demo支持GET与POST请求。
 */

//你申请的token密钥
$API_TOKEN = 'YOUR_TOKEN';

//API接口地址
$API_URL = 'https://api.ovo1.cc/api/fx';

$get_post_data = array(
    'token' => 'YOUR_TOKEN',
    'u' => '1',
    'mode' => 'json',
);

/*发起请求API接口:
第1个参数：API接口地址URL，跟上面的同名变量相对应，无需更改。
第2个参数：API接口参数数组，跟上面的同名变量相对应，无需更改。
第3个参数：请求协议（GET或POST），一般默认GET，部分接口需要POST请求，根据实际情况修改为POST即可。
 */
$resdata = api::send($API_URL, $get_post_data, 'GET/POST');  //发起请求，注意这里要选择接口支持的协议，默认GET，可选POST

//打印请求结果
print($resdata);
///////////////你的业务代码可写在这里处理API返回的数据

/**
 * API请求类
 */
class api
{
    public static function send($API_URL, $get_post_data, $type)
    {
        $get_post_data = http_build_query($get_post_data);
        $res = self::send_curl($API_URL, $type, $get_post_data, null);
        return $res;
    }
    //封装好的CURL请求函数,支持POST|GET
    public static function send_curl($API_URL, $type, $get_post_data)
    {
        $ch = curl_init();
        if ($type == 'POST') {
            curl_setopt($ch, CURLOPT_URL, $API_URL);
            curl_setopt($ch, CURLOPT_POST, true);
            curl_setopt($ch, CURLOPT_POSTFIELDS, $get_post_data);
        } elseif ($type == 'GET') {
            curl_setopt($ch, CURLOPT_URL, $API_URL . '?' . $get_post_data);
        }
        curl_setopt($ch, CURLOPT_REFERER, $API_URL);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_TIMEOUT, 10);
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
        curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
        $resdata = curl_exec($ch);
        curl_close($ch);
        return $resdata;
    }
}

/**
 * API请求DEMO-JavaScript
 * 
 * 本demo支持GET与POST请求。
 */

 //jQuery-Ajax
$.ajax({
    url: 'https://api.ovo1.cc/api/fx',
    data: {
        token: 'YOUR_TOKEN',
        u: '1',
        mode: 'json',
    },
    type: 'GET/POST', //请求协议（GET或POST），一般默认GET，部分接口需要POST请求，根据实际情况修改为POST即可。
    dataType: 'json',
    success: function(data) {
        console.log(data); //请求成功，输出结果到控制台
    },
    timeout: 3000, //超时时间
    error: function(data) {
        console.log('请求失败'); //失败处理
    }
});

/**
 * API请求DEMO-NodeJs
 * 
 * 本demo支持GET与POST请求。
 */

const https = require('https');
const querystring = require('querystring');

// 定义请求选项
const options = {
  hostname: 'api.ovo1.cc',
  path: '/api/fx',
  method: 'GET/POST'
};

// 发送POST请求
const postData = querystring.stringify({
  'token': 'YOUR_TOKEN',
  'u': '1',
  'mode': 'json',
});

const postOptions = {
  hostname: 'api.ovo1.cc',
  path: '/api/fx',
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Content-Length': Buffer.byteLength(postData)
  }
};

const postReq = https.request(postOptions, res => {
  console.log(`statusCode: ${res.statusCode}`);

  res.on('data', d => {
    process.stdout.write(d);
  });
});

postReq.on('error', error => {
  console.error(error);
});

postReq.write(postData);
postReq.end();

import requests

url = "https://api.ovo1.cc/api/fx"
data = {
    "token": "YOUR_TOKEN",
    "u": "1",
    "mode": "json",
}

response = requests.post(url, data=data)
print(response.json())

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
    "strings"
)

func main() {
    apiURL := "https://api.ovo1.cc/api/fx"
    
    // POST请求
    data := url.Values{}
    data.Set("token", "YOUR_TOKEN")
    data.Set("u", "1")
    data.Set("mode", "json")
    
    resp, err := http.Post(apiURL, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
    if err != nil {
        fmt.Println("请求失败:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;

public class ApiRequest {
    public static void main(String[] args) {
        try {
            String apiUrl = "https://api.ovo1.cc/api/fx";
            
            URL url = new URL(apiUrl);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setDoOutput(true);
            
            // 构建POST参数
            StringBuilder postData = new StringBuilder();
            postData.append("token=").append(URLEncoder.encode("YOUR_TOKEN", "UTF-8"));
            postData.append("&");            postData.append("u=").append(URLEncoder.encode("1", "UTF-8"));
            postData.append("&");            postData.append("mode=").append(URLEncoder.encode("json", "UTF-8"));
            
            byte[] postDataBytes = postData.toString().getBytes("UTF-8");
            conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            conn.setRequestProperty("Content-Length", String.valueOf(postDataBytes.length));
            
            try (OutputStream os = conn.getOutputStream()) {
                os.write(postDataBytes);
            }
            
            BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();
            
            System.out.println(response.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
    static async Task Main() {
        string apiUrl = "https://api.ovo1.cc/api/fx";
        
        using (HttpClient client = new HttpClient()) {
            // POST请求
            var formData = new Dictionary<string, string> {
                { "token", "YOUR_TOKEN" },
                { "u", "1" },
                { "mode", "json" },
            };
            
            var content = new FormUrlEncodedContent(formData);
            HttpResponseMessage response = await client.PostAsync(apiUrl, content);
            
            string result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
    }
}

/**
 * API请求DEMO-C
 * 
 * 本demo支持GET与POST请求。
 * 需要安装libcurl库
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>

// API地址
const char* url = "https://api.ovo1.cc/api/fx";

// POST请求
void postRequest(CURL* curl) {
    CURLcode res;
    const char* postData = "token=YOUR_TOKEN&u=1&mode=json";
    
    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postData);
    res = curl_easy_perform(curl);
    
    if(res != CURLE_OK) {
        fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
    }
}

int main() {
    CURL* curl = curl_easy_init();
    if(curl) {
        postRequest(curl);        curl_easy_cleanup(curl);
    }
    return 0;
}

/**
 * API请求DEMO-C++
 * 
 * 本demo支持GET与POST请求。
 * 需要安装libcurl库
 */

#include <iostream>
#include <string>
#include <curl/curl.h>

int main() {
    CURL* curl = curl_easy_init();
    if(curl) {
        std::string apiUrl = "https://api.ovo1.cc/api/fx";
        
        // POST请求
        std::string postData = "token=YOUR_TOKEN&u=1&mode=json";
        curl_easy_setopt(curl, CURLOPT_URL, apiUrl.c_str());
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postData.c_str());
        
        CURLcode res = curl_easy_perform(curl);
        
        if(res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        }
        
        curl_easy_cleanup(curl);
    }
    return 0;
}

.版本 2

.支持库 spec

.子程序 _启动子程序
.局部变量 url, 文本型
.局部变量 data, 文本型
.局部变量 result, 文本型

url ＝ "https://api.ovo1.cc/api/fx"
data ＝ "token=YOUR_TOKEN&u=1&mode=json"
result ＝ 网页_访问 (url, 1, data, , , , , , , , , )

调试输出 (result)