सिस्टम का वर्तमान संस्करण नंबर लौटाता है.
वर्तमान सिस्टम संस्करण संख्या, उदाहरण के लिएः3.6◊
स्ट्रिंग
संस्करण
function main() {
Log("version:", Version())
}
def main():
Log("version:", Version())
void main() {
Log("version:", Version());
}
सिस्टम संस्करण संख्या, होस्टिंग प्रोग्राम का संस्करण संख्या है।
निंदक फ़ंक्शन, जो प्रोग्राम को कुछ समय के लिए रोकता है.
नींद (मिलीसेकंड)
millisecond
true
number
```javascript
function main() {
Sleep(1000 * 10) // 等待10秒钟
Log("等待了10秒钟")
}
def main():
Sleep(1000 * 10)
Log("等待了10秒钟")
void main() {
Sleep(1000 * 10);
Log("等待了10秒钟");
}
उदाहरण के लिएSleep(1000)फ़ंक्शन के दौरान, प्रोग्राम 1 सेकंड के लिए निष्क्रिय रहता है।Sleep(0.1)◎ समर्थन न्यूनतम पैरामीटर है0.000001और यह एक नैनो सेकंड के बराबर है.1e-6एक मिलीसेकंड।
उपयोग मेंPythonजब भाषा की नीति लिखी जाती है, तो पूछताछ अंतराल, समय प्रतीक्षा के लिए उपयोग किया जाना चाहिएSleep(millisecond)फ़ंक्शन. इसका प्रयोग करने की अनुशंसा नहीं की जाती हैPythonकाtimeकु काtime.sleep(second)फ़ंक्शन. क्योंकि यह नीति में उपयोग किया जाता हैtime.sleep(second)फ़ंक्शन को रीट्वीट करते समय पॉलिसी प्रोग्राम को वास्तव में कुछ समय के लिए इंतजार करना पड़ता है (रिट्वीट सिस्टम के समय अनुक्रम में नहीं), इसलिए पॉलिसी रीट्वीट बहुत धीमा होता है।
यह निर्धारित करता है कि क्या रणनीति का परिचालन वातावरण एक रीट्रीट सिस्टम है।
नीति का निष्पादन सिस्टम वातावरण को पुनः परीक्षण करते समय सही मान देता है, जैसेःtrue◎ नीति वास्तविक डिस्क वातावरण में चलती है जब फर्जी मान लौटाता है, उदाहरण के लिएःfalse◊
बोल
आभासी है
function main() {
if (IsVirtual()) {
Log("当前为回测系统环境。")
} else {
Log("当前为实盘环境。")
}
}
def main():
if IsVirtual():
Log("当前为回测系统环境。")
else:
Log("当前为实盘环境。")
void main() {
if (IsVirtual()) {
Log("当前为回测系统环境。");
} else {
Log("当前为实盘环境。");
}
}
यह निर्धारित करता है कि क्या वर्तमान परिचालन वातावरण एक रीसेट सिस्टम है, जो रीसेट और वास्तविक डिस्क के बीच अंतर को संगत करने के लिए उपयोग किया जाता है।
ईमेल भेजें।
ईमेल भेजने में सफलता प्राप्त करने के बाद, एक वास्तविक मान लौटाया जाता है, उदाहरण के लिएःtrue, भेजने में विफलता एक झूठा मान लौटाता है, उदाहरण के लिएःfalse◊
बोल
मेल ((smtpसर्वर, smtpउपयोगकर्ता नाम, smtpपासवर्ड, मेलTo, शीर्षक, शरीर)
ईमेल भेजने वाले को निर्दिष्ट करने के लिए उपयोग किया जाता हैSMTPसेवा का पता।
smtp सर्वर
सच
string
ईमेल भेजने वाले का पता निर्दिष्ट करने के लिए प्रयोग किया जाता है।
smtpउपयोगकर्ता नाम
सच
string
ईमेल भेजने वाले के ईमेल बॉक्स मेंSMTPपासवर्ड।
smtpपासवर्ड
सच
string
ईमेल प्राप्तकर्ता का पता निर्दिष्ट करने के लिए प्रयोग किया जाता है।
mailTo
सच
string
पोस्ट का शीर्षक है।
title
सच
string
ईमेल सही है।
शरीर
सच
string
function main(){
Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
}
def main():
Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
void main() {
Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body");
}
设置```smtpServer```参数时，如果需要更改端口可以直接在参数```smtpServer```中加入端口号。 例如：QQ邮箱```smtp.qq.com:587```该端口测试可用。
如果出现报错：```unencryped connection```，需要修改```Mail```函数的```smtpServer```。 参数格式为：```ssl://xxx.com:xxx```，例如QQ邮箱的```SMTP```的```ssl```方式：```ssl://smtp.qq.com:465```或者```smtp://xxx.com:xxx```。
回测系统中不起作用。
{@fun/Global/Mail_Go Mail_Go}
### Mail_Go
```Mail```函数的异步版本。
```Mail_Go```函数立即返回一个并发对象，可以使用该并发对象的```wait```方法获取邮件发送结果， 邮件发送成功返回真值，例如：```true```，发送失败返回假值，例如：```false```。
object
Mail_Go(smtpServer, smtpUsername, smtpPassword, mailTo, title, body)
用于指定邮件发送方的```SMTP```服务地址。
smtpServer
true
string
用于指定邮件发送方的邮箱地址。
smtpUsername
true
string
邮件发送方邮箱的```SMTP```密码。
smtpPassword
true
string
用于指定邮件接收方的邮箱地址。
mailTo
true
string
邮件标题。
title
true
string
邮件正文。
body
true
string
```javascript
function main() {
var r1 = Mail_Go("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
var r2 = Mail_Go("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
var ret1 = r1.wait()
var ret2 = r2.wait()
Log("ret1:", ret1)
Log("ret2:", ret2)
}
# 不支持
// 不支持
यह परीक्षण प्रणाली में काम नहीं करता है।
{@मज़ा/ग्लोबल/मेल मेल}
गलत लॉग फ़िल्टर करना ।
SetErrorFilter (फ़िल्टर सेट करें)
सामान्य अभिव्यक्ति स्ट्रिंग। फ़िल्टर सच string
function main() {
SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused")
}
def main():
SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused")
void main() {
SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused");
}
फ़िल्टर करने में आम गलती है।
function main() {
// 随便查询一个不存在的订单，id为123，故意让接口报错
var order = exchange.GetOrder("123")
Log(order)
// 过滤http502错误、GetOrder接口错误，设置错误过滤之后，第二次调用GetOrder不再报错
SetErrorFilter("502:|GetOrder")
order = exchange.GetOrder("123")
Log(order)
}
def main():
order = exchange.GetOrder("123")
Log(order)
SetErrorFilter("502:|GetOrder")
order = exchange.GetOrder("123")
Log(order)
void main() {
TId orderId;
Order order = exchange.GetOrder(orderId);
Log(order);
SetErrorFilter("502:|GetOrder");
order = exchange.GetOrder(orderId);
Log(order);
}
कुछ इंटरफेस गलत सूचनाओं को फ़िल्टर करना।
इस नियमित अभिव्यक्ति से मेल खाने वाले त्रुटि लॉग को लॉग सिस्टम में अपलोड नहीं किया जाएगा, कई बार कॉल किया जा सकता है ((कोई संख्या सीमा नहीं) कई फ़िल्टर स्थितियों को सेट करें। कई बार सेट किए गए नियमित अभिव्यक्ति एक साथ जमा हो जाते हैं और एक ही समय में प्रभावी होते हैं। रिक्त स्ट्रिंग सेट करके त्रुटि लॉग को फ़िल्टर करने वाले नियमित अभिव्यक्ति को फिर से सेट किया जा सकता हैःSetErrorFilter(""); फ़िल्टर किए गए लॉग को होस्ट निर्देशिका के तहत वास्तविक डिस्क आईडी के अनुरूप डेटाबेस फ़ाइलों में नहीं लिखा जाता है, जिससे डेटाबेस फ़ाइलों के बढ़ने के कारण लगातार त्रुटियों को रोका जा सकता है.
वास्तविक डिस्क प्रक्रिया आईडी प्राप्त करें
वास्तविक डिस्क प्रक्रिया आईडी लौटाता है string
GetPid()
function main(){
var id = GetPid()
Log(id)
}
def main():
id = GetPid()
Log(id)
void main() {
auto id = GetPid();
Log(id);
}
हाल ही में हुई गलतियों के बारे में जानकारी प्राप्त करें।
हाल ही में गलत जानकारी मिली है। string
GetLastError() प्राप्त करें
function main(){
// 因为不存在编号为123的订单，所以会出错
exchange.GetOrder("123")
var error = GetLastError()
Log(error)
}
def main():
exchange.GetOrder("123")
error = GetLastError()
Log(error)
void main() {
// 订单ID类型：TId，所以不能传入字符串，我们下一个不符合交易所规范的订单来触发
exchange.GetOrder(exchange.Buy(1, 1));
auto error = GetLastError();
Log(error);
}
यह परीक्षण प्रणाली में काम नहीं करता है।
नीतिगत इंटरैक्शन कमांड प्राप्त करें.
कमांड का फ़ॉर्मेट लौटाया गया हैControlName:Data。ControlNameयह है कि आप क्या कर रहे हैं?Dataनियंत्रण में इनपुट किया गया डेटा है. यदि इंटरैक्टिव नियंत्रण में इनपुट बॉक्स, ड्रॉप-डाउन बॉक्स आदि घटक नहीं हैं (उदाहरण के लिएः इनपुट बॉक्स के बिना बटन नियंत्रण) तो कमांड का स्वरूप लौटाया जाता हैControlName, केवल फ़ोल्डर का नाम लौटाता है.
string
कमांड प्राप्त करें()
function main(){
while(true) {
var cmd = GetCommand()
if (cmd) {
Log(cmd)
}
Sleep(1000)
}
}
def main():
while True:
cmd = GetCommand()
if cmd:
Log(cmd)
Sleep(1000)
void main() {
while(true) {
auto cmd = GetCommand();
if(cmd != "") {
Log(cmd);
}
Sleep(1000);
}
}
इंटरैक्टिव कमांड का पता लगाने और इंटरैक्टिव कमांड का पता लगाने के लिए उपयोग किया जाता हैLogफ़ंक्शन इंटरैक्टिव कमांड आउटपुट करता है।
function main() {
while (true) {
LogStatus(_D())
var cmd = GetCommand()
if (cmd) {
Log("cmd:", cmd)
var arr = cmd.split(":")
if (arr[0] == "buy") {
Log("买入，该控件不带数量")
} else if (arr[0] == "sell") {
Log("卖出，该控件带数量：", arr[1])
} else {
Log("其它控件触发：", arr)
}
}
Sleep(1000)
}
}
def main():
while True:
LogStatus(_D())
cmd = GetCommand()
if cmd:
Log("cmd:", cmd)
arr = cmd.split(":")
if arr[0] == "buy":
Log("买入，该控件不带数量")
elif arr[0] == "sell":
Log("卖出，该控件带数量：", arr[1])
else:
Log("其它控件触发：", arr)
Sleep(1000)
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
void split(const string& s,vector<string>& sv,const char flag = ' ') {
sv.clear();
istringstream iss(s);
string temp;
while (getline(iss, temp, flag)) {
sv.push_back(temp);
}
return;
}
void main() {
while(true) {
LogStatus(_D());
auto cmd = GetCommand();
if (cmd != "") {
vector<string> arr;
split(cmd, arr, ':');
if(arr[0] == "buy") {
Log("买入，该控件不带数量");
} else if (arr[0] == "sell") {
Log("卖出，该控件带数量：", arr[1]);
} else {
Log("其它控件触发：", arr);
}
}
Sleep(1000);
}
}
उदाहरण के लिए, नीति इंटरैक्शन कंट्रोल में एक कंट्रोल जोड़ा गया है जिसमें इनपुट बॉक्स नहीं है, और इंटरैक्शन कंट्रोल का नाम हैःbuyइस तरह से, नियंत्रण जानकारी का वर्णन करता हैः买入, यह एक बटन कंट्रोल है. एक इनपुट बॉक्स वाला कंट्रोल जोड़ने के लिए आगे बढ़ें, इंटरैक्टिव कंट्रोल का नामःsellइस तरह से, नियंत्रण जानकारी का वर्णन करता हैः卖出यह एक इंटरैक्टिव कंट्रोल है जो बटन और इनपुट बॉक्स के संयोजन से बना है।
यह परीक्षण प्रणाली में काम नहीं करता है।
मेटा का मान प्राप्त करें जो पंजीकरण कोड उत्पन्न करने के लिए लिखा गया है।
string
GetMeta()
```javascript
function main() {
// 策略允许的计价币最大资产数值
var maxBaseCurrency = null
// 获取创建注册码时的元数据
var level = GetMeta()
// 检测Meta对应的条件
if (level == "level1") {
// -1为不限制
maxBaseCurrency = -1
} else if (level == "level2") {
maxBaseCurrency = 10
} else if (level == "level3") {
maxBaseCurrency = 1
} else {
maxBaseCurrency = 0.5
}
while(1) {
Sleep(1000)
var ticker = exchange.GetTicker()
// 检测资产数值
var acc = exchange.GetAccount()
if (maxBaseCurrency != -1 && maxBaseCurrency < acc.Stocks + acc.FrozenStocks) {
// 停止执行策略交易逻辑
LogStatus(_D(), "level:", level, "持仓超过注册码的使用限定，不再执行策略交易逻辑！")
continue
}
// 其它交易逻辑
// 正常输出状态栏信息
LogStatus(_D(), "level:", level, "策略正常运行！ticker数据：\n", ticker)
}
}
def main():
maxBaseCurrency = null
level = GetMeta()
if level == "level1":
maxBaseCurrency = -1
elif level == "level2":
maxBaseCurrency = 10
elif level == "level3":
maxBaseCurrency = 1
else:
maxBaseCurrency = 0.5
while True:
Sleep(1000)
ticker = exchange.GetTicker()
acc = exchange.GetAccount()
if maxBaseCurrency != -1 and maxBaseCurrency < acc["Stocks"] + acc["FrozenStocks"]:
LogStatus(_D(), "level:", level, "持仓超过注册码的使用限定，不再执行策略交易逻辑！")
continue
# 其它交易逻辑
# 正常输出状态栏信息
LogStatus(_D(), "level:", level, "策略正常运行！ticker数据：\n", ticker)
void main() {
auto maxBaseCurrency = 0.0;
auto level = GetMeta();
if (level == "level1") {
maxBaseCurrency = -1;
} else if (level == "level2") {
maxBaseCurrency = 10;
} else if (level == "level3") {
maxBaseCurrency = 1;
} else {
maxBaseCurrency = 0.5;
}
while(1) {
Sleep(1000);
auto ticker = exchange.GetTicker();
auto acc = exchange.GetAccount();
if (maxBaseCurrency != -1 && maxBaseCurrency < acc.Stocks + acc.FrozenStocks) {
// 停止执行策略交易逻辑
LogStatus(_D(), "level:", level, "持仓超过注册码的使用限定，不再执行策略交易逻辑！");
continue;
}
// 其它交易逻辑
// 正常输出状态栏信息
LogStatus(_D(), "level:", level, "策略正常运行！ticker数据：\n", ticker);
}
}
उपयोग के उदाहरणMetaइस तरह की रणनीति के लिए धनराशि को सीमित करना।
उपयोग के परिदृश्यः विभिन्न रणनीतियों के लिए किरायेदारों के लिए धन सीमाएं। पंजीकरण कोड उत्पन्न करते समय सेट करेंMetaएक मूल्य की लंबाई 190 वर्ण से अधिक नहीं हो सकती है।GetMeta()फ़ंक्शन केवल वास्तविक डिस्क का समर्थन करता है. यदि नीति पंजीकरण कोड उत्पन्न करते समय मेटाडेटा सेट नहीं किया गया है।Meta），GetMeta()फ़ंक्शन रिक्त मान देता है. यह परीक्षण प्रणाली में काम नहीं करता.
मूल के लिए इस्तेमाल कियाSocketपहुंच, समर्थनtcp，udp，tls，unixप्रोटोकॉल: चार लोकप्रिय संचार प्रोटोकॉल का समर्थन करता हैःmqtt、nats、amqp、kafka◎ कनेक्टिविटी डेटाबेस का समर्थन करता है, जिसमें निम्नलिखित डेटाबेस शामिल हैंःsqlite3、mysql、postgres、clickhouse。
अगर समय से अधिक होDial()फ़ंक्शन रिक्त लौटाता है. सामान्य कॉल पर एक कनेक्टिंग ऑब्जेक्ट लौटाता है, जिसका तीन तरीके हैंःread、write、close。readइस तरह की जानकारी का उपयोग डेटा को पढ़ने के लिए किया जाता है।writeडेटा भेजने के लिए उपयोग की जाने वाली विधियाँ।closeइस विधि का उपयोग कनेक्शन बंद करने के लिए किया जाता है।
- 不传参数时，阻塞到有消息时就返回。例如：```ws.read()```。
- 传入参数时，单位为毫秒，指定消息等待超时时间。例如：```ws.read(2000)```指定超时时间为两秒（2000毫秒）。
- 以下两个参数只对WebSocket有效：
传入参数```-1```指不管有无消息，函数立即返回，例如：```ws.read(-1)```。
传入参数```-2```指不管有无消息，函数立即返回，但只返回最新的消息，缓冲区的消息会被丢弃。例如```ws.read(-2)```。
```read()```函数缓冲区说明：
WebSocket协议推送的来的数据，如果在策略```read()```函数调用之间时间间隔过长，就可能造成数据累积。这些数据储存在缓冲区，缓冲区数据结构为队列，上限2000个。超出2000后最新的数据进入缓冲区，最旧的数据清除掉。
|场景|无参数|参数：-1|参数：-2|参数：2000，单位是毫秒|
| - | - | - | - | - |
|缓冲区已有数据|立即返回最旧数据|立即返回最旧数据|立即返回最新数据|立即返回最旧数据|
|缓冲区无数据|阻塞到有数据时返回|立即返回空值|立即返回空值|等待2000毫秒，无数据返回空值，有数据则返回|
|WebSocket连接断开或者底层重连时|read()函数返回空字符串，即：""，write()函数返回0，检测到该情况。可以使用close()函数关闭连接，如果设置了自动重连则不用关闭，系统底层会自动重连。||||
object
Dial(address)
Dial(address, timeout)
请求地址。
address
true
string
超时秒数，
timeout
false
number
```javascript
function main(){
// Dial支持tcp://，udp://，tls://，unix://协议，可加一个参数指定超时的秒数
var client = Dial("tls://www.baidu.com:443")
if (client) {
// write可再跟一个数字参数指定超时,write返回成功发送的字节数
client.write("GET / HTTP/1.1\nConnection: Closed\n\n")
while (true) {
// read可再跟一个数字参数指定超时，单位：毫秒。返回null指出错或者超时或者socket已经关闭
var buf = client.read()
if (!buf) {
break
}
Log(buf)
}
client.close()
}
}
def main():
client = Dial("tls://www.baidu.com:443")
if client:
client.write("GET / HTTP/1.1\nConnection: Closed\n\n")
while True:
buf = client.read()
if not buf:
break
Log(buf)
client.close()
void main() {
auto client = Dial("tls://www.baidu.com:443");
if(client.Valid) {
client.write("GET / HTTP/1.1\nConnection: Closed\n\n");
while(true) {
auto buf = client.read();
if(buf == "") {
break;
}
Log(buf);
}
client.close();
}
}
डायल फ़ंक्शन का उदाहरणः
function main() {
LogStatus("正在连接...")
// 访问币安的WebSocket接口
var client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr")
if (!client) {
Log("连接失败, 程序退出")
return
}
while (true) {
// read只返回调用read之后获取的数据
var buf = client.read()
if (!buf) {
break
}
var table = {
type: 'table',
title: '行情图表',
cols: ['币种', '最高', '最低', '买一', '卖一', '最后成交价', '成交量', '更新时间'],
rows: []
}
var obj = JSON.parse(buf)
_.each(obj, function(ticker) {
table.rows.push([ticker.s, ticker.h, ticker.l, ticker.b, ticker.a, ticker.c, ticker.q, _D(ticker.E)])
})
LogStatus('`' + JSON.stringify(table) + '`')
}
client.close()
}
import json
def main():
LogStatus("正在连接...")
client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr")
if not client:
Log("连接失败, 程序退出")
return
while True:
buf = client.read()
if not buf:
break
table = {
"type" : "table",
"title" : "行情图表",
"cols" : ["币种", "最高", "最低", "买一", "卖一", "最后成交价", "成交量", "更新时间"],
"rows" : []
}
obj = json.loads(buf)
for i in range(len(obj)):
table["rows"].append([obj[i]["s"], obj[i]["h"], obj[i]["l"], obj[i]["b"], obj[i]["a"], obj[i]["c"], obj[i]["q"], _D(int(obj[i]["E"]))])
LogStatus('`' + json.dumps(table) + '`')
client.close()
void main() {
LogStatus("正在连接...");
auto client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr");
if(!client.Valid) {
Log("连接失败, 程序退出");
return;
}
while(true) {
auto buf = client.read();
if(buf == "") {
break;
}
json table = R"({
"type" : "table",
"title" : "行情图表",
"cols" : ["币种", "最高", "最低", "买一", "卖一", "最后成交价", "成交量", "更新时间"],
"rows" : []
})"_json;
json obj = json::parse(buf);
for(auto& ele : obj.items()) {
table["rows"].push_back({ele.value()["s"], ele.value()["h"], ele.value()["l"], ele.value()["b"], ele.value()["a"], ele.value()["c"],
ele.value()["q"], _D(ele.value()["E"])});
}
LogStatus("`" + table.dump() + "`");
}
client.close();
}
Binance के लिए WebSocket बाजार इंटरफ़ेस पर जाएँः
var ws = null
function main(){
var param = {
"op": "subscribe",
"args": [{
"channel": "tickers",
"instId": "BTC-USDT"
}]
}
// 在调用Dial函数时，指定reconnect=true即设置为重连模式，指定payload即为重连时发送的消息。在WebSocket连接断开后，会自动重连，自动发送消息
ws = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true&payload="+ JSON.stringify(param))
if(ws){
var pingCyc = 1000 * 20
var lastPingTime = new Date().getTime()
while(true){
var nowTime = new Date().getTime()
var ret = ws.read()
Log("ret:", ret)
if(nowTime - lastPingTime > pingCyc){
var retPing = ws.write("ping")
lastPingTime = nowTime
Log("发送 ：ping", "#FF0000")
}
LogStatus("当前时间：", _D())
Sleep(1000)
}
}
}
function onexit() {
ws.close()
Log("退出")
}
import json
import time
ws = None
def main():
global ws
param = {
"op": "subscribe",
"args": [{
"channel": "tickers",
"instId": "BTC-USDT"
}]
}
ws = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true&payload=" + json.dumps(param))
if ws:
pingCyc = 1000 * 20
lastPingTime = time.time() * 1000
while True:
nowTime = time.time() * 1000
ret = ws.read()
Log("ret:", ret)
if nowTime - lastPingTime > pingCyc:
retPing = ws.write("ping")
lastPingTime = nowTime
Log("发送：ping", "#FF0000")
LogStatus("当前时间：", _D())
Sleep(1000)
def onexit():
ws.close()
Log("退出")
auto objWS = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true");
void main() {
json param = R"({
"op": "subscribe",
"args": [{
"channel": "tickers",
"instId": "BTC-USDT"
}]
})"_json;
objWS.write(param.dump());
if(objWS.Valid) {
uint64_t pingCyc = 1000 * 20;
uint64_t lastPingTime = Unix() * 1000;
while(true) {
uint64_t nowTime = Unix() * 1000;
auto ret = objWS.read();
Log("ret:", ret);
if(nowTime - lastPingTime > pingCyc) {
auto retPing = objWS.write("ping");
lastPingTime = nowTime;
Log("发送：ping", "#FF0000");
}
LogStatus("当前时间：", _D());
Sleep(1000);
}
}
}
void onexit() {
objWS.close();
Log("退出");
}
ओकेएक्स के वेबसोकेट बाज़ार इंटरफेस को देखने के लिएः
var ws = null
function main(){
var param = {"sub": "market.btcusdt.detail", "id": "id1"}
ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload="+ JSON.stringify(param))
if(ws){
while(1){
var ret = ws.read()
Log("ret:", ret)
// 响应心跳包操作
try {
var jsonRet = JSON.parse(ret)
if(typeof(jsonRet.ping) == "number") {
var strPong = JSON.stringify({"pong" : jsonRet.ping})
ws.write(strPong)
Log("响应ping，发送pong:", strPong, "#FF0000")
}
} catch(e) {
Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
}
LogStatus("当前时间：", _D())
Sleep(1000)
}
}
}
function onexit() {
ws.close()
Log("执行ws.close()函数")
}
import json
ws = None
def main():
global ws
param = {"sub" : "market.btcusdt.detail", "id" : "id1"}
ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload=" + json.dumps(param))
if ws:
while True:
ret = ws.read()
Log("ret:", ret)
# 响应心跳包操作
try:
jsonRet = json.loads(ret)
if "ping" in jsonRet and type(jsonRet["ping"]) == int:
strPong = json.dumps({"pong" : jsonRet["ping"]})
ws.write(strPong)
Log("响应ping，发送pong:", strPong, "#FF0000")
except Exception as e:
Log("e:", e)
LogStatus("当前时间：", _D())
Sleep(1000)
def onexit():
ws.close()
Log("执行ws.close()函数")
using namespace std;
void main() {
json param = R"({"sub" : "market.btcusdt.detail", "id" : "id1"})"_json;
auto ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload=" + param.dump());
if(ws.Valid) {
while(true) {
auto ret = ws.read();
Log("ret:", ret);
// 响应心跳包操作
try
{
auto jsonRet = json::parse(ret);
if(jsonRet["ping"].is_number()) {
json pong = R"({"pong" : 0})"_json;
pong["pong"] = jsonRet["ping"];
auto strPong = pong.dump();
ws.write(strPong);
Log("响应ping，发送pong:", strPong, "#FF0000");
}
} catch(exception &e)
{
Log("e:", e.what());
}
LogStatus("当前时间：", _D());
Sleep(1000);
}
}
}
void onexit() {
// ws.close();
Log("执行ws.close()函数");
}
टोकन का उपयोग करने के लिए वेबसोकेट बाज़ार इंटरफ़ेसः
function getLogin(pAccessKey, pSecretKey, pPassphrase) {
// 签名函数，用于登录
var ts = (new Date().getTime() / 1000).toString()
var login = {
"op": "login",
"args":[{
"apiKey" : pAccessKey,
"passphrase" : pPassphrase,
"timestamp" : ts,
"sign" : exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey) // exchange.HMAC已经废弃，暂时支持。请替换使用最新的exchange.Encode函数
}]
}
return login
}
var client_private = null
function main() {
// 因为read函数使用了超时设置，过滤超时的报错，否则会有冗余错误输出
SetErrorFilter("timeout")
// 持仓频道订阅信息
var posSubscribe = {
"op": "subscribe",
"args": [{
"channel": "positions",
"instType": "ANY"
}]
}
var accessKey = "xxx"
var secretKey = "xxx"
var passphrase = "xxx"
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(JSON.stringify(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000) // 登录时，不能立即订阅私有频道，需要等待服务器反应
client_private.write(JSON.stringify(posSubscribe))
if (client_private) {
var lastPingTS = new Date().getTime()
while (true) {
var buf = client_private.read(-1)
if (buf) {
Log(buf)
}
// 检测断开，重连
if (buf == "" && client_private.write(JSON.stringify(posSubscribe)) == 0) {
Log("检测到断开，关闭连接，重连")
client_private.close()
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(JSON.stringify(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000)
client_private.write(JSON.stringify(posSubscribe))
}
// 发送心跳包
var nowPingTS = new Date().getTime()
if (nowPingTS - lastPingTS > 10 * 1000) {
client_private.write("ping")
lastPingTS = nowPingTS
}
}
}
}
function onexit() {
var ret = client_private.close()
Log("关闭连接！", ret)
}
import json
import time
def getLogin(pAccessKey, pSecretKey, pPassphrase):
ts = str(time.time())
login = {
"op": "login",
"args":[{
"apiKey" : pAccessKey,
"passphrase" : pPassphrase,
"timestamp" : ts,
"sign" : exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey)
}]
}
return login
client_private = None
def main():
global client_private
SetErrorFilter("timeout")
posSubscribe = {
"op": "subscribe",
"args": [{
"channel": "positions",
"instType": "ANY"
}]
}
accessKey = "xxx"
secretKey = "xxx"
passphrase = "xxx"
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(json.dumps(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000)
client_private.write(json.dumps(posSubscribe))
if client_private:
lastPingTS = time.time() * 1000
while True:
buf = client_private.read(-1)
if buf:
Log(buf)
if buf == "" and client_private.write(json.dumps(posSubscribe)) == 0:
Log("检测到断开，关闭连接，重连")
ret = client_private.close()
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(json.dumps(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000)
client_private.write(json.dumps(posSubscribe))
nowPingTS = time.time() * 1000
if nowPingTS - lastPingTS > 10 * 1000:
client_private.write("ping")
lastPingTS = nowPingTS
def onexit():
ret = client_private.close()
Log("关闭连接！", ret)
auto client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");
json getLogin(string pAccessKey, string pSecretKey, string pPassphrase) {
auto ts = std::to_string(Unix());
json login = R"({
"op": "login",
"args": [{
"apiKey": "",
"passphrase": "",
"timestamp": "",
"sign": ""
}]
})"_json;
login["args"][0]["apiKey"] = pAccessKey;
login["args"][0]["passphrase"] = pPassphrase;
login["args"][0]["timestamp"] = ts;
login["args"][0]["sign"] = exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey);
return login;
}
void main() {
SetErrorFilter("timeout");
json posSubscribe = R"({
"op": "subscribe",
"args": [{
"channel": "positions",
"instType": "ANY"
}]
})"_json;
auto accessKey = "xxx";
auto secretKey = "xxx";
auto passphrase = "xxx";
client_private.write(getLogin(accessKey, secretKey, passphrase).dump());
Sleep(3000);
client_private.write(posSubscribe.dump());
if (client_private.Valid) {
uint64_t lastPingTS = Unix() * 1000;
while (true) {
auto buf = client_private.read(-1);
if (buf != "") {
Log(buf);
}
if (buf == "") {
if (client_private.write(posSubscribe.dump()) == 0) {
Log("检测到断开，关闭连接，重连");
client_private.close();
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");
client_private.write(getLogin(accessKey, secretKey, passphrase).dump());
Sleep(3000);
client_private.write(posSubscribe.dump());
}
}
uint64_t nowPingTS = Unix() * 1000;
if (nowPingTS - lastPingTS > 10 * 1000) {
client_private.write("ping");
lastPingTS = nowPingTS;
}
}
}
}
void onexit() {
client_private.close();
Log("退出");
}
OKX के लिए WebSocket सत्यापन इंटरफ़ेस का उपयोग करेंः
var client = null
function main() {
// client = Dial("sqlite3://:memory:") // 使用内存数据库
client = Dial("sqlite3://test1.db") // 打开/连接托管者所在目录的数据库文件
// 记录句柄
var sqlite3Handle = client.fd()
Log("sqlite3Handle:", sqlite3Handle)
// 查询数据库中的表
var ret = client.exec("SELECT name FROM sqlite_master WHERE type='table'")
Log(ret)
}
function onexit() {
Log("执行client.close()")
client.close()
}
// 不支持
// 不支持
डायल फ़ंक्शन डेटाबेस से कनेक्ट होने पर जो कनेक्शन ऑब्जेक्ट लौटाता है, उसके दो अद्वितीय विधि फ़ंक्शन होते हैंः
- क्या?exec(sqlString): SQL कथन को निष्पादित करने के लिए उपयोग किया जाता हैDBExec()फ़ंक्शन।
- क्या?fd(): fd()फ़ंक्शन एक हैंडल (उदाहरण के लिएः हैंडल चर हैंडल है) वापस करता है, जिसे अन्य थ्रेडों के लिए फिर से जोड़ने के लिए उपयोग किया जाता है (भले ही डायल द्वारा बनाए गए ऑब्जेक्ट पहले ही निष्पादित किए गए हों)close()फ़ंक्शन कनेक्शन बंद करता है), वाक्य हैंडल को पास करता हैDial()फ़ंक्शन, उदाहरण के लिएःDial(handle)एक बार फिर से कनेक्ट करें
यहाँ डायल फ़ंक्शन कनेक्शन हैsqlite3डेटाबेस के उदाहरण।
|Dial函数的address参数支持的功能|参数说明|
| - | - |
|WebSocket协议数据压缩相关的参数：compress=参数值|compress为压缩方式，compress参数可选gzip_raw、gzip等。如果gzip方式非标准gzip，可以使用扩展的方式：gzip_raw|
|WebSocket协议数据压缩相关的参数：mode=参数值|mode为压缩模式，mode参数可选dual，send，recv三种。dual为双向压缩，发送压缩数据，接收压缩数据。send为发送压缩数据。recv为接收压缩数据，本地解压缩。|
|WebSocket协议设置底层自动重连相关的参数：reconnect=参数值|reconnect为是否设置重连，reconnect=true为启用重连。不设置该参数时默认不重连。|
|WebSocket协议设置底层自动重连相关的参数：interval=参数值|interval为重试时间间隔，单位毫秒，interval=10000为重试间隔10秒，不设置默认1秒，即interval=1000。|
|WebSocket协议设置底层自动重连相关的参数：payload=参数值|payload为WebSocket重连时需要发送的订阅消息，例如：payload=okok。|
|socks5代理的相关参数：proxy=参数值|proxy为ss5代理设置，参数值格式：socks5://name:pwd@192.168.0.1:1080，name为ss5服务端用户名，pwd为ss5服务端登录密码，1080为ss5服务的端口。|
```Dial()```函数仅支持实盘。
使用Dial函数连接数据库时，编写的连接字符串参考各数据库的go语言驱动项目。
| 支持的数据库 | 驱动项目 | 连接字符串（Connection String） | 备注 |
| - | - | - | - |
| sqlite3 | github.com/mattn/go-sqlite3 | sqlite3://file:test.db?cache=shared&mode=memory | ```sqlite3://```前缀表示使用的是sqlite3数据库，调用例子：```Dial("sqlite3://test1.db")``` |
| mysql | github.com/go-sql-driver/mysql | mysql://username:yourpassword@tcp(localhost:3306)/yourdatabase?charset=utf8mb4 | -- |
| postgres | github.com/lib/pq | postgres://user=postgres dbname=yourdatabase sslmode=disable password=yourpassword host=localhost port=5432 | -- |
| clickhouse | github.com/ClickHouse/clickhouse-go | clickhouse://tcp://host:9000?username=username&password=yourpassword&database=youdatabase | -- |
需要注意当```address```参数中设置的```payload```内容中有字符```=```或者其它特殊字符时，可能影响```Dial```函数的```address```参数解析，例如以下例子。
backPack交易所websocket私有接口调用范例：
```js
var client = null
function main() {
// base64编码的秘钥对公钥，即在FMZ上配置的access key
var base64ApiKey = "xxx"
var ts = String(new Date().getTime())
var data = "instruction=subscribe×tamp=" + ts + "&window=5000"
// 由于signEd25519最终返回的是base64编码，其中会有字符"="
var signature = signEd25519(data)
// payload 被JSON编码后可能包含字符"="
payload = {
"method": "SUBSCRIBE",
"params": ["account.orderUpdate"],
"signature": [base64ApiKey, signature, ts, "5000"]
}
client = Dial("wss://ws.backpack.exchange")
client.write(JSON.stringify(payload))
if (!client) {
Log("连接失败, 程序退出")
return
}
while (true) {
var buf = client.read()
Log(buf)
}
}
function onexit() {
client.close()
}
function signEd25519(data) {
return exchange.Encode("ed25519.seed", "raw", "base64", data, "base64", "{{secretkey}}")
}
कोड में लिखा है कि निम्नलिखित कॉल करने के तरीके ठीक से काम करते हैंः
client = Dial("wss://ws.backpack.exchange")
client.write(JSON.stringify(payload))
अगर यह सीधे लिखा गया हैpayloadयह एक बहुत ही सामान्य समस्या है, जैसे किः
client = Dial("wss://ws.backpack.exchange|payload=" + JSON.stringify(payload))
वर्तमान में केवल जावास्क्रिप्ट भाषा डायल फ़ंक्शन में उपयोग करने के लिए समर्थित हैmqtt、nats、amqp、kafkaसंचार प्रोटोकॉल, जावास्क्रिप्ट भाषा नीति कोड के उदाहरण के रूप मेंmqtt、nats、amqp、kafkaचार प्रोटोकॉल उपयोग उदाहरणः
// 需要先配置、部署完成各个协议的代理服务器
// 为了便于演示，主题test_topic的订阅（read操作）、发布（write操作）都在当前这个策略中进行
var arrConn = []
var arrName = []
function main() {
LogReset(1)
conn_nats = Dial("nats://admin@127.0.0.1:4222?topic=test_topic")
conn_mqtt = Dial("mqtt://127.0.0.1:1883?topic=test_topic")
conn_amqp = Dial("amqp://q:admin@127.0.0.1:5672/?queue=test_Queue")
conn_kafka = Dial("kafka://localhost:9092/test_topic")
arrConn = [conn_nats, conn_amqp, conn_mqtt, conn_kafka]
arrName = ["nats", "amqp", "mqtt", "kafka"]
while (true) {
for (var i in arrConn) {
var conn = arrConn[i]
var name = arrName[i]
// 写数据
conn.write(name + ", time: " + _D() + ", test msg.")
// 读数据
var readMsg = conn.read(1000)
Log(name + " readMsg: ", readMsg, "#FF0000")
}
Sleep(1000)
}
}
function onexit() {
for (var i in arrConn) {
arrConn[i].close()
Log("关闭", arrName[i], "连接")
}
}
इस लेख के बारे में अधिक जानकारी के लिए देखेंःएफएमजेड का अन्वेषण करेंः लेनदेन की रणनीति और वास्तविक डिस्क के बीच संचार प्रोटोकॉल का अभ्यास
http अनुरोध भेजें.
अनुरोध के लिए प्रतिक्रिया डेटा लौटाता है यदि लौटाया गया मान हैJSONएक स्ट्रिंग,JavaScriptभाषा की रणनीतियों में इस्तेमाल किया जा सकता हैJSON.parse()फ़ंक्शन विश्लेषण,C++भाषा की रणनीतियों में इस्तेमाल किया जा सकता हैjson::parse()फ़ंक्शन हल करना. पैरामीटरoptionsसंरचना में अगरdebugसेट करें true और वापस करें मान वस्तु ((JSON); यदिdebugगलत पर सेट करें और स्ट्रिंग का मूल्य लौटाएं.
string, object
HttpQuery (URL) HttpQuery ((url, विकल्प)
Http ने यूआरएल का अनुरोध किया है। यूआरएल सच string HTTP अनुरोधों के लिए सेटिंग्स, उदाहरण के लिए, निम्न संरचना हो सकती हैंः
{
method: "POST",
body: "a=10&b=20&c=30",
charset: "UTF-8",
cookie: "session_id=12345; lang=en",
profile: "chrome_103",
debug: false,
headers: {"TEST-HTTP-QUERY": "123"},
timeout: 1000
}
tlsउंगलियों के निशान।
समर्थित सेटिंग्स में निम्नलिखित विकल्प हैंः
क्रोम："chrome_103"、"chrome_104"、"chrome_105"、"chrome_106"、"chrome_107"、"chrome_108"、"chrome_109"、"chrome_110"、"chrome_111"、"chrome_112"、"chrome_117"、
सफारी："safari_15_6_1"、"safari_16_0"、"safari_ipad_15_6"、"safari_ios_15_5"、"safari_ios_15_6"、"safari_ios_16_0"、
फ़ायरफ़ॉक्स："firefox_102"、"firefox_104"、"firefox_105"、"firefox_106"、"firefox_108"、"firefox_110"、"firefox_117"、
ओपेरा："opera_89"、"opera_90"、"opera_91"、
ज़ालंदो："zalando_android_mobile"、"zalando_ios_mobile"、
नाइकी："nike_ios_mobile"、"nike_android_mobile"、
बादलबिहार:"cloudscraper"、
एमएमएस："mms_ios"、
जाल："mesh_ios"、"mesh_ios_1"、"mesh_ios_2"、"mesh_android"、"mesh_android_1"、"mesh_android_2"、
पुष्टि："confirmed_ios"、"confirmed_android"、
ठीक हैhttp4："okhttp4_android_7"、"okhttp4_android_8"、"okhttp4_android_9"、"okhttp4_android_10"、"okhttp4_android_11"、"okhttp4_android_12"、"okhttp4_android_13"、trueइस बारHttpQueryफ़ंक्शन कॉल पूर्ण उत्तर पाठ लौटाता है.falseकेवल उत्तर संदेशों के लिए उत्तर देंBodyइस तरह के आंकड़े हैं।इस संरचना में सभी फ़ील्ड्स वैकल्पिक हैं, जैसे कि सेट करना या नहीं करनाprofileफ़ील्डों के बारे में।
विकल्प झूठी वस्तु
function main(){
// 一个GET访问不带参数的例子
var info = JSON.parse(HttpQuery("https://www.okx.com/api/v5/public/time"))
Log(info)
// 一个GET访问带参数的例子
var ticker = JSON.parse(HttpQuery("https://www.okx.com/api/v5/market/books?instId=BTC-USDT"))
Log(ticker)
}
import json
import urllib.request
def main():
# HttpQuery不支持Python，可以使用urllib/urllib2库代替
info = json.loads(urllib.request.urlopen("https://www.okx.com/api/v5/public/time").read().decode('utf-8'))
Log(info)
ticker = json.loads(urllib.request.urlopen("https://www.okx.com/api/v5/market/books?instId=BTC-USDT").read().decode('utf-8'))
Log(ticker)
void main() {
auto info = json::parse(HttpQuery("https://www.okx.com/api/v5/public/time"));
Log(info);
auto ticker = json::parse(HttpQuery("https://www.okx.com/api/v5/market/books?instId=BTC-USDT"));
Log(ticker);
}
ओकेएक्स सार्वजनिक बाजार एपीआई इंटरफ़ेस का उदाहरण देखें।
function main() {
// 本次设置代理并发送http请求，无用户名，无密码，此次http请求会通过代理发送
HttpQuery("socks5://127.0.0.1:8889/http://www.baidu.com/")
// 本次设置代理并发送http请求，输入用户名和密码，仅HttpQuery当前调用生效，之后再次调用HttpQuery("http://www.baidu.com")这样不会使用代理
HttpQuery("socks5://username:password@127.0.0.1:8889/http://www.baidu.com/")
}
# HttpQuery不支持Python，可以使用Python的urllib2库
void main() {
HttpQuery("socks5://127.0.0.1:8889/http://www.baidu.com/");
HttpQuery("socks5://username:password@127.0.0.1:8889/http://www.baidu.com/");
}
HttpQuery फ़ंक्शन एजेंट सेटिंग्स का उपयोग करता है।
{@fun/Global/HttpQuery_Go HttpQuery_Go}
### HttpQuery_Go
发送Http请求，```HttpQuery```函数的异步版本。
```HttpQuery_Go()```函数立即返回一个并发对象，可以使用该并发对象的```wait```方法获取Http请求的结果， ```JavaScript```语言的策略中可以用```JSON.parse()```函数解析。
object
HttpQuery_Go(url)
HttpQuery_Go(url, options)
Http请求url。
url
true
string
Http请求相关设置，例如可以是以下结构：
{
विधि:
- profile：用来模拟浏览器```tls```指纹。
- debug：设置为```true```时，此次```HttpQuery_Go```函数调用返回完整的应答报文。设置为```false```时只返回应答报文```Body```中的数据。
- timeout：超时设置，设置1000表示1秒钟超时。
此结构中的所有字段均为可选，例如可以不设置```profile```字段。
options
false
object
```javascript
function main() {
// 创建第一个异步线程
var r1 = HttpQuery_Go("https://www.okx.com/api/v5/market/tickers?instType=SPOT")
// 创建第二个异步线程
var r2 = HttpQuery_Go("https://api.huobi.pro/market/tickers")
// 获取第一个异步线程调用的返回值
var tickers1 = r1.wait()
// 获取第二个异步线程调用的返回值
var tickers2 = r2.wait()
// 打印结果
Log("tickers1:", tickers1)
Log("tickers2:", tickers2)
}
# 不支持
// 不支持
एक्सचेंज के सार्वजनिक इंटरफ़ेस पर असिंक्रोनस एक्सेस करके बाजार डेटा एकत्रित करें।
{@fun/Global/HttpQuery HttpQuery}
### Encode
该函数根据传入的参数对数据进行编码。
```Encode```函数返回编码、加密之后的数据。
string
Encode(algo, inputFormat, outputFormat, data)
Encode(algo, inputFormat, outputFormat, data, keyFormat, key)
参数```algo```为编码计算时使用的算法。 支持设置为："raw"（不使用算法），"sign"，"signTx"，"md4"，"md5"，"sha256"，"sha512"，"sha1"，"keccak256"， "sha3.224"，"sha3.256"，"sha3.384"，"sha3.512"，"sha3.keccak256"，"sha3.keccak512"，"sha512.384"， "sha512.256"，"sha512.224"，"ripemd160"，"blake2b.256"，"blake2b.512"，"blake2s.128"，"blake2s.256"。 参数```algo```也支持："text.encoder.utf8"，"text.decoder.utf8"，"text.encoder.gbk"，"text.decoder.gbk"，对字符串编码、解码。 参数```algo```也支持："ed25519"算法。支持使用不同的哈希算法，例如参数```algo```可写为"ed25519.md5"、"ed25519.sha512"等。支持```ed25519.seed```计算。
algo
true
string
用于指定```data```参数的数据格式。 ```inputFormat```参数支持设置为："raw"，"hex"，"base64"，"string"其中之一。 "raw"表示数据为原始数据，"hex"表示数据为```hex```编码，"base64"表示数据为```base64```编码，"string"表示数据为字符串。
inputFormat
true
string
用于指定输出的数据格式。 ```outputFormat```参数支持设置为："raw"，"hex"，"base64"，"string"其中之一。 "raw"表示数据为原始数据，"hex"表示数据为```hex```编码，"base64"表示数据为```base64```编码，"string"表示数据为字符串。
outputFormat
true
string
参数```data```为所要处理的数据。
data
true
string
用于指定```key```参数的数据格式。 ```key```参数支持设置为："raw"，"hex"，"base64"，"string"其中之一。 "raw"表示数据为原始数据，"hex"表示数据为```hex```编码，"base64"表示数据为```base64```编码，"string"表示数据为字符串。
keyFormat
false
string
参数```key```为```HMAC```加密时使用的秘钥。 参数```algo```设置为"sign"或者"signTx"时需要参数```key```。 参数```algo```设置为"raw"时不会使用```key```参数进行```HMAC```加密（因为HMAC加密必须指定算法）。
key
false
string
```javascript
function main() {
Log(Encode("raw", "raw", "hex", "example", "raw", "123")) // 6578616d706c65
Log(Encode("raw", "raw", "hex", "example")) // 6578616d706c65
Log(Encode("sha256", "raw", "hex", "example", "raw", "123")) // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "", "123")) // 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
Log(Encode("sha256", "raw", "hex", "example", null, "123")) // 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
Log(Encode("sha256", "raw", "hex", "example", "string", "123")) // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("raw", "raw", "hex", "123")) // 313233
Log(Encode("raw", "raw", "base64", "123")) // MTIz
Log(Encode("sha256", "raw", "hex", "example", "hex", "313233")) // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "base64", "MTIz")) // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
}
def main():
Log(Encode("raw", "raw", "hex", "example", "raw", "123")) # 6578616d706c65
Log(Encode("raw", "raw", "hex", "example", "", "")) # 6578616d706c65
Log(Encode("sha256", "raw", "hex", "example", "raw", "123")) # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "", "123")) # 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
Log(Encode("sha256", "raw", "hex", "example", "string", "123")) # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("raw", "raw", "hex", "123", "", "")) # 313233
Log(Encode("raw", "raw", "base64", "123", "", "")) # MTIz
Log(Encode("sha256", "raw", "hex", "example", "hex", "313233")) # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "base64", "MTIz")) # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
void main() {
Log(Encode("raw", "raw", "hex", "example", "raw", "123")); // 6578616d706c65
Log(Encode("raw", "raw", "hex", "example")); // 6578616d706c65
Log(Encode("sha256", "raw", "hex", "example", "raw", "123")); // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "", "123")); // 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
Log(Encode("sha256", "raw", "hex", "example", "string", "123")); // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("raw", "raw", "hex", "123")); // 313233
Log(Encode("raw", "raw", "base64", "123")); // MTIz
Log(Encode("sha256", "raw", "hex", "example", "hex", "313233")); // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "base64", "MTIz")); // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
}
Encode फ़ंक्शन को कॉल करने का उदाहरण।
function main(){
var ret1 = Encode("text.encoder.utf8", "raw", "hex", "你好") // e4bda0e5a5bd
Log(ret1)
var ret2 = Encode("text.decoder.utf8", "hex", "string", ret1)
Log(ret2)
var ret3 = Encode("text.encoder.gbk", "raw", "hex", "你好") // c4e3bac3
Log(ret3)
var ret4 = Encode("text.decoder.gbk", "hex", "string", ret3)
Log(ret4)
}
def main():
ret1 = Encode("text.encoder.utf8", "raw", "hex", "你好", "", "") # e4bda0e5a5bd
Log(ret1)
ret2 = Encode("text.decoder.utf8", "hex", "string", ret1, "", "")
Log(ret2)
ret3 = Encode("text.encoder.gbk", "raw", "hex", "你好", "", "") # c4e3bac3
Log(ret3)
ret4 = Encode("text.decoder.gbk", "hex", "string", ret3, "", "")
Log(ret4)
void main(){
auto ret1 = Encode("text.encoder.utf8", "raw", "hex", "你好"); // e4bda0e5a5bd
Log(ret1);
auto ret2 = Encode("text.decoder.utf8", "hex", "string", ret1);
Log(ret2);
auto ret3 = Encode("text.encoder.gbk", "raw", "hex", "你好"); // c4e3bac3
Log(ret3);
auto ret4 = Encode("text.decoder.gbk", "hex", "string", ret3);
Log(ret4);
}
पैरामीटरalgoयह भी समर्थन करता हैः
### UnixNano
获取当前时刻的纳秒级时间戳。
```UnixNano()```函数返回纳秒级时间戳。
number
UnixNano()
```javascript
function main() {
var time = UnixNano() / 1000000
Log(_N(time, 0))
}
def main():
time = UnixNano()
Log(time)
void main() {
auto time = UnixNano();
Log(time);
}
यदि आपको मिलीसेकंड के पैमाने पर टाइमलाइन प्राप्त करने की आवश्यकता है, तो निम्न कोड का उपयोग करेंः
{@fun/Global/Unix यूनिक्स}
वर्तमान क्षण के लिए सेकंड स्तर का समय टैप प्राप्त करें.
सेकंड के स्तर पर समय की लौटाएँ । संख्या
यूनिक्स
function main() {
var t = Unix()
Log(t)
}
def main():
t = Unix()
Log(t)
void main() {
auto t = Unix();
Log(t);
}
{@fun/Global/UnixNano यूनिक्स नैनो}
सिस्टम जानकारी प्राप्त करें कि होस्ट के डिवाइस पर क्या है।
सिस्टम सूचनाएं। string
GetOS()
function main() {
Log("GetOS:", GetOS())
}
def main():
Log("GetOS:", GetOS())
void main() {
Log("GetOS:", GetOS());
}
उदाहरण के लिएमैक ओएसऑपरेटिंग सिस्टम पर चल रहे होस्ट, कॉलGetOS()फ़ंक्शन वापस कर सकता हैःdarwin/amd64Apple के कंप्यूटरों में कई प्रकार के हार्डवेयर आर्किटेक्चर होते हैं।darwinयानीमैक ओएससिस्टम का नाम।
गणना पैरामीटरdataMD5 हैश मान।
MD5 हैश मान। string
MD5 (डेटा)
MD5 गणना के लिए आवश्यक डेटा। डेटा सच string
function main() {
Log("MD5", MD5("hello world"))
}
def main():
Log("MD5", MD5("hello world"))
void main() {
Log("MD5", MD5("hello world"));
}
कॉल करेंMD5("hello world")एक फ़ंक्शन, जो कि एक मान लौटाता हैः5eb63bbbe01eeed093cb22bb8f5acdc3。
{@fun/Global/EncodeEncode} {@fun/Global/EncodeEncode} {@fun/Global/EncodeEncode}
डेटाबेस इंटरफ़ेस फ़ंक्शन।
शामिलस्क्वायरवाक्य के निष्पादन के परिणामों का ऑब्जेक्ट, उदाहरण के लिएः
{"columns":["TS","HIGH","OPEN","LOW","CLOSE","VOLUME"],"values":[[1518970320000,100,99.1,90,100,12345.6]]}
वस्तु
DBExec ((sql)
स्क्वायरशब्द स्ट्रिंग्स । sql सच string
function main() {
var strSql = [
":CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
].join("")
var ret = DBExec(strSql)
Log(ret)
// 增加一条数据
Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
// 查询数据
Log(DBExec(":SELECT * FROM TEST_TABLE;"))
}
def main():
arr = [
":CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
]
strSql = ""
for i in range(len(arr)):
strSql += arr[i]
ret = DBExec(strSql)
Log(ret)
# 增加一条数据
Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
# 查询数据
Log(DBExec(":SELECT * FROM TEST_TABLE;"))
void main() {
string strSql = ":CREATE TABLE TEST_TABLE(\
TS INT PRIMARY KEY NOT NULL,\
HIGH REAL NOT NULL,\
OPEN REAL NOT NULL,\
LOW REAL NOT NULL,\
CLOSE REAL NOT NULL,\
VOLUME REAL NOT NULL)";
auto ret = DBExec(strSql);
Log(ret);
// 增加一条数据
Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"));
// 查询数据
Log(DBExec(":SELECT * FROM TEST_TABLE;"));
}
मेमोरी डेटाबेस का समर्थन करता हैDBExecफ़ंक्शन के पैरामीटर, अगरस्क्वायरयह वाक्य है:प्रारंभ में, यह मेमोरी डेटाबेस में संचालित होता है और फ़ाइलों को लिखने के बिना तेज़ होता है। यह उन डेटाबेस कार्यों के लिए उपयुक्त है जिन्हें स्थायी रूप से सहेजने की आवश्यकता नहीं होती है, जैसेः
function main() {
var strSql = [
"CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
].join("")
var ret = DBExec(strSql)
Log(ret)
}
def main():
arr = [
"CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
]
strSql = ""
for i in range(len(arr)):
strSql += arr[i]
ret = DBExec(strSql)
Log(ret)
void main() {
string strSql = "CREATE TABLE TEST_TABLE(\
TS INT PRIMARY KEY NOT NULL,\
HIGH REAL NOT NULL,\
OPEN REAL NOT NULL,\
LOW REAL NOT NULL,\
CLOSE REAL NOT NULL,\
VOLUME REAL NOT NULL)";
auto ret = DBExec(strSql);
Log(ret);
}
तालिकाएँ बनाएं
function main() {
var strSql = [
"CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
].join("")
Log(DBExec(strSql))
// 增加一条数据
Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
// 查询数据
Log(DBExec("SELECT * FROM TEST_TABLE;"))
// 修改数据
Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000))
// 删除数据
Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110))
}
def main():
arr = [
"CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
]
strSql = ""
for i in range(len(arr)):
strSql += arr[i]
Log(DBExec(strSql))
# 增加一条数据
Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
# 查询数据
Log(DBExec("SELECT * FROM TEST_TABLE;"))
# 修改数据
Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000))
# 删除数据
Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110))
void main() {
string strSql = "CREATE TABLE TEST_TABLE(\
TS INT PRIMARY KEY NOT NULL,\
HIGH REAL NOT NULL,\
OPEN REAL NOT NULL,\
LOW REAL NOT NULL,\
CLOSE REAL NOT NULL,\
VOLUME REAL NOT NULL)";
Log(DBExec(strSql));
// 增加一条数据
Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"));
// 查询数据
Log(DBExec("SELECT * FROM TEST_TABLE;"));
// 修改数据
Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000));
// 删除数据
Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110));
}
तालिका में रिकॉर्ड को जोड़ने, हटाने और बदलने का कार्य।
फ़ंक्शनDBExec()इनपुट पैरामीटर के माध्यम से, एक वास्तविक डिस्क डेटाबेस (SQLite डेटाबेस) का संचालन किया जा सकता है। वास्तविक डिस्क डेटाबेस में डेटा को जोड़ने, हटाने, देखने, बदलने आदि कार्यों को पूरा करने के लिए, समर्थनएसक्यूलाइटसिंटैक्स. वास्तविक डिस्क डेटाबेस में सिस्टम आरक्षित तालिकाःkvdb、cfg、log、profit、chart, इन तालिकाओं पर कोई कार्यवाही न करें.कार्यइस तरह के कार्यों को करने की सिफारिश नहीं की जाती है, क्योंकि यह सिस्टम में संघर्ष पैदा कर सकता है।DBExec()फ़ंक्शन केवल वास्तविक डिस्क का समर्थन करता है।
{@fun/Global/_G _G}
एक यूयूआईडी बनाएँ.
32 बिट्स का यूयूआईडी। string
UUID (()
function main() {
var uuid1 = UUID()
var uuid2 = UUID()
Log(uuid1, uuid2)
}
def main():
uuid1 = UUID()
uuid2 = UUID()
Log(uuid1, uuid2)
void main() {
auto uuid1 = UUID();
auto uuid2 = UUID();
Log(uuid1, uuid2);
}
### EventLoop
监听事件，在有任意```WebSocket```可读数据或者```exchange.Go()```、```HttpQuery_Go()```等并发的任务完成以后返回。
返回的对象如果不为空值，则返回内容中包含的```Event```为事件触发类型。例如以下返回值结构：
{
object
EventLoop()
EventLoop(timeout)
参数```timeout```为超时设置，单位为毫秒。 参数```timeout```如果设置为0则等待有事件发生才返回，如果大于0就是设置事件等待超时，小于0立即返回最近事件。
timeout
false
number
```javascript
function main() {
var routine_getTicker = exchange.Go("GetTicker")
var routine_getDepth = exchange.Go("GetDepth")
var routine_getTrades = exchange.Go("GetTrades")
// Sleep(2000)，如果这里使用Sleep语句，会导致之后的EventLoop函数错过之前的事件，因为等待了2秒，并发的函数已经收到了数据，后续才开始EventLoop监听机制，就错过了这些事件
// 除非在第一行代码开始调用EventLoop(-1)，首先初始化EventLoop的监听机制，则不会错过这些事件
// Log("GetDepth:", routine_getDepth.wait()) 如果这里提前调用wait函数取出GetDepth函数并发调用的结果，此次GetDepth函数收到请求结果的事件便不会在EventLoop函数返回
var ts1 = new Date().getTime()
var ret1 = EventLoop(0)
var ts2 = new Date().getTime()
var ret2 = EventLoop(0)
var ts3 = new Date().getTime()
var ret3 = EventLoop(0)
Log("第1个并发任务完成的为：", _D(ts1), ret1)
Log("第2个并发任务完成的为：", _D(ts2), ret2)
Log("第3个并发任务完成的为：", _D(ts3), ret3)
Log("GetTicker:", routine_getTicker.wait())
Log("GetDepth:", routine_getDepth.wait())
Log("GetTrades:", routine_getTrades.wait())
}
import time
def main():
routine_getTicker = exchange.Go("GetTicker")
routine_getDepth = exchange.Go("GetDepth")
routine_getTrades = exchange.Go("GetTrades")
ts1 = time.time()
ret1 = EventLoop(0)
ts2 = time.time()
ret2 = EventLoop(0)
ts3 = time.time()
ret3 = EventLoop(0)
Log("第1个并发任务完成的为：", _D(ts1), ret1)
Log("第2个并发任务完成的为：", _D(ts2), ret2)
Log("第3个并发任务完成的为：", _D(ts3), ret3)
Log("GetTicker:", routine_getTicker.wait())
Log("GetDepth:", routine_getDepth.wait())
Log("GetTrades:", routine_getTrades.wait())
void main() {
auto routine_getTicker = exchange.Go("GetTicker");
auto routine_getDepth = exchange.Go("GetDepth");
auto routine_getTrades = exchange.Go("GetTrades");
auto ts1 = Unix() * 1000;
auto ret1 = EventLoop(0);
auto ts2 = Unix() * 1000;
auto ret2 = EventLoop(0);
auto ts3 = Unix() * 1000;
auto ret3 = EventLoop(0);
Log("第1个并发任务完成的为：", _D(ts1), ret1);
Log("第2个并发任务完成的为：", _D(ts2), ret2);
Log("第3个并发任务完成的为：", _D(ts3), ret3);
Ticker ticker;
Depth depth;
Trades trades;
routine_getTicker.wait(ticker);
routine_getDepth.wait(depth);
routine_getTrades.wait(trades);
Log("GetTicker:", ticker);
Log("GetDepth:", depth);
Log("GetTrades:", trades);
}
कोड में पहली बार कॉलEventLoop()फ़ंक्शन उस मॉनिटरिंग घटना के लिए तंत्र को आरंभ करता है, यदि यह पहली बार घटना कॉल के बाद शुरू होता हैEventLoop()कॉल, जो पिछली घटनाओं को याद करता है. अंतर्निहित प्रणाली में लिपटे कतार संरचनाएं अधिकतम 500 घटनाओं को कैश करती हैं, यदि प्रोग्राम निष्पादन के दौरान समय पर कॉल नहीं किया जाता हैEventLoop()यदि फ़ंक्शन हटा दिया जाता है, तो 500 से अधिक कैश के बाद की घटनाओं को खो दिया जाता है।EventLoop()फ़ंक्शन के कॉल से सिस्टम के तहत वेबसॉकेट की कैशिंग कतार प्रभावित नहीं होती हैexchange.Go()उदाहरण के लिए, समवर्ती फ़ंक्शन के कैश के लिए, इन कैशों के लिए अभी भी अपने स्वयं के तरीकों का उपयोग करके डेटा निकालने की आवश्यकता है।EventLoop()फ़ंक्शन वापस आने से पहले, जो डेटा निकाला गया है, वह वापस नहीं आएगा।EventLoop()फ़ंक्शन में रिटर्न इवेंट उत्पन्न करता है.EventLoop()फ़ंक्शन का मुख्य उपयोग नीति स्तर को सूचित करना है, जब सिस्टम के निचले स्तर को नया नेटवर्क डेटा प्राप्त होता है।EventLoop()जब फ़ंक्शन घटनाओं को लौटाता है, तो यह सभी डेटा स्रोतों को पार करने के लिए पर्याप्त होता है। उदाहरण के लिए, वेबसॉकेट कनेक्शन।exchange.Go()ऑब्जेक्ट जो बनाया गया है वह डेटा प्राप्त करने का प्रयास करता है।EventLoop()फ़ंक्शन केवल वास्तविक डिस्क का समर्थन करता है।
मुख्य फ़ंक्शन मेंmain()मध्य कॉल के दौरान, मुख्य थ्रेड की घटनाओं की निगरानी करें.JavaScriptभाषा लेखन की रणनीतियों में,threading.Thread()फ़ंक्शन द्वारा बनाए गए थ्रेड, फ़ंक्शन के निष्पादन फ़ंक्शन में भी बुलाए जा सकते हैं, वर्तमान थ्रेड की घटनाओं की निगरानी कर सकते हैं।
{@fun/Global/Dial Dial}, {@fun/Trade/exchange.Go exchange.Go}, {@fun/Global/HttpQuery_Go HttpQuery_Go}
返回一个字符串，记录创建的服务的IP地址、端口。例如：```127.0.0.1:8088```、```[::]:8089```。
string
__Serve(serveURI, handler)
__Serve(serveURI, handler, ...args)
```serveURI```参数用于配置服务绑定的协议、IP地址、端口等设置，例如：```http://0.0.0.0:8088?gzip=true```，即：```http://:8088?gzip=true```。
- TCP协议
```serveURI```参数设置例如：```tcp://127.0.0.1:6666?tls=true```；可以添加证书、私钥例如：```tls=true&cert_pem=xxxx&cert_key_pem=xxxx```。
- Http协议
```serveURI```参数设置例如：```http://127.0.0.1:6666?gzip=true```；可以设置压缩设置：```gzip=true```。
```serveURI```参数用于Https例如：```https://127.0.0.1:6666?tls=true&gzip=true```；可以加入```cert_pem```和```cert_key_pem```参数来加载证书。
serveURI
true
string
```handler```参数用于传入路由处理函数（Http协议）、消息处理函数（TCP协议）、Stream处理函数（Websocket）。
参数```handler```传入的回调函数可以定义多个参数，第一个参数为ctx对象（上下文对象）。
handler
true
function
作为参数```handler```传入的**回调函数**的参数的实参，参数```arg```可能有多个，例如：
```js
__Serve("http://:8088", function(ctx, a, b, c) {
Log(`ctx.host():`, ctx.host(), ", a=", a, ", b=", b, ", c=", c)
}, 1, 2, 3)
कॉल करें__Serve()फ़ंक्शन के दौरान दिए गए पैरामीटर1, 2, 3इनपुट-बैक फ़ंक्शन के लिए पैरामीटरa, b, c。
arg गलत string, number, boole, object, array, function, empty, आदि सभी प्रकार सिस्टम द्वारा समर्थित हैं
function main() {
let httpServer = __Serve("http://:8088?gzip=true", function (ctx) {
Log("http connect from: ", ctx.remoteAddr(), "->", ctx.localAddr())
let path = ctx.path()
if (path == "/") {
ctx.write(JSON.stringify({
path: ctx.path(),
method: ctx.method(),
headers: ctx.headers(),
cookie: ctx.header("Cookie"),
remote: ctx.remoteAddr(),
query: ctx.rawQuery()
}))
} else if (path == "/tickers") {
let ret = exchange.GetTickers()
if (!ret) {
ctx.setStatus(500)
ctx.write(GetLastError())
} else {
ctx.write(JSON.stringify(ret))
}
} else if (path == "/wss") {
if (ctx.upgrade("websocket")) { // upgrade to websocket
while (true) {
let r = ctx.read(10)
if (r == "") {
break
} else if (r) {
if (r == "ticker") {
ctx.write(JSON.stringify(exchange.GetTicker()))
} else {
ctx.write("not support")
}
}
}
Log("websocket closed", ctx.remoteAddr())
}
} else {
ctx.setStatus(404)
}
})
let echoServer = __Serve("tcp://:8089", function (ctx) {
Log("tcp connect from: ", ctx.remoteAddr(), "->", ctx.localAddr())
while (true) {
let d = ctx.read()
if (!d) {
break
}
ctx.write(d)
}
Log("connect closed")
})
Log("http serve on", httpServer, "tcp serve on", echoServer)
for (var i = 0; i < 5; i++) {
if (i == 2) {
// test Http
var retHttp = HttpQuery("http://127.0.0.1:8088?num=123&limit=100", {"debug": true})
Log("retHttp:", retHttp)
} else if (i == 3) {
// test TCP
var tcpConn = Dial("tcp://127.0.0.1:8089")
tcpConn.write("Hello TCP Server")
var retTCP = tcpConn.read()
Log("retTCP:", retTCP)
} else if (i == 4) {
// test Websocket
var wsConn = Dial("ws://127.0.0.1:8088/wss|compress=gzip")
wsConn.write("ticker")
var retWS = wsConn.read(1000)
Log("retWS:", retWS)
// no depth
wsConn.write("depth")
retWS = wsConn.read(1000)
Log("retWS:", retWS)
}
Sleep(1000)
}
}
# 不支持
// 不支持
Websocketसेवा HTTP प्रोटोकॉल पर आधारित है, जिसमें पथ में एक रूटर शाखा स्थापित की जा सकती है, जिसे डिज़ाइन किया गया हैWebsocketसंदेश सदस्यता / धक्का के लिए कार्यान्वयन कोड, इस अनुभाग के उदाहरण कोड का संदर्भ लें।पैरामीटरhandlerइनपुट callback प्रसंस्करण फ़ंक्शन एक प्राप्त करता हैctxपैरामीटर ।ctxएक पैरामीटर एक संदर्भ वस्तु है जिसका उपयोग डेटा प्राप्त करने और डेटा लिखने के लिए किया जाता है, जिसमें निम्न तरीके हैंः
- ctx.proto ((()
HTTP/TCP प्रोटोकॉल के लिए प्रयोग किया जाता है, जिसे कॉल करने पर प्रोटोकॉल का नाम लौटाया जाता है; उदाहरण के लिएःHTTP/1.1、tcp..
- ctx.host ((()
HTTP प्रोटोकॉल के लिए उपयोग किया जाता है, जो कॉल पर होस्ट की जानकारी देता हैः आईपी पता, पोर्ट।
- ctx.path ((()
HTTP प्रोटोकॉल के लिए उपयोग किया जाता है, जो अनुरोध पथ को वापस करने के लिए चलाया जाता है।
- ctx.query ((key)
HTTP प्रोटोकॉल के लिए लागू होता है, जब कॉल किया जाता है, तो अनुरोध में क्वेरी क्वेरी में कुंजी के अनुरूप मान वापस आ जाता है; उदाहरण के लिए, भेजा गया अनुरोध हैःhttp://127.0.0.1:8088?num=123, पैरामीटरhandlerइनपुट रिकॉल प्रसंस्करण फ़ंक्शन मेंctx.query("num")कॉल पर वापस आएं"123"..
- ctx.rawQuery ((()
HTTP प्रोटोकॉल के लिए उपयोग किया जाता है, जो कॉल पर अनुरोध में मूल क्वेरी ("Http अनुरोध की क्वेरी") वापस करता है।
- ctx.headers ((()
HTTP प्रोटोकॉल के लिए उपयोग किया जाता है, जो कॉल पर अनुरोध में अनुरोध शीर्षक की जानकारी लौटाता है।
- ctx.header(key)
HTTP प्रोटोकॉल के लिए प्रयोग किया जाता है, जिसे कॉल करने पर निर्दिष्ट अनुरोध हेडर में किसी कुंजी के अनुरूप मान लौटाता है; उदाहरण के लिए वर्तमान अनुरोध के हेडर में से एक प्राप्त करनाUser-Agent：ctx.header("User-Agent")..
- ctx.method ((()
HTTP प्रोटोकॉल के लिए उपयोग किया जाता है, कॉल पर वापस अनुरोध विधि, जैसेGET、POSTऔर इस तरह।
- ctx.body (()
HTTP प्रोटोकॉल पर लागू POST अनुरोध, कॉल पर अनुरोध का मूल पाठ लौटाता है।
- ctx.setHeader ((key, value)
HTTP प्रोटोकॉल के लिए उपयोग किया जाता है, जो उत्तर संदेश के लिए अनुरोध शीर्षक संदेश सेट करता है।
- ctx.setStatus ((कोड)
HTTP प्रोटोकॉल के लिए उपयोग किया जाता है, जो HTTP समाचार पत्र स्थिति कोड को सेट करता है, आमतौर पर रूटर शाखा के अंत में HTTP स्थिति कोड को सेट करता है, जो डिफ़ॉल्ट रूप से 200 है।
- ctx.remoteAddr ((()
यह HTTP/TCP प्रोटोकॉल के लिए उपयोग किया जाता है, जो कॉल पर रिमोट क्लाइंट के पते या पोर्ट को वापस करता है।
- ctx.localAddr ((()
HTTP/TCP प्रोटोकॉल के लिए उपयोग किया जाता है, जो कॉल पर सेवा के स्थानीय पते, बंदरगाहों को लौटाता है।
- ctx.upgrade ((ctxउपरोक्त संदर्भ ऑब्जेक्ट वेबसॉकेट प्रोटोकॉल है; स्विच सफल रूप से बुल मान ((सत्य) लौटाता है, असफल रूप से बुल मान ((झूठ)) लौटाता है।
- ctx.read ((timeout_ms)
HTTP प्रोटोकॉल पर आधारित वेबसॉकेट प्रोटोकॉल कार्यान्वयन/TCP प्रोटोकॉल के लिए उपयोग किया जाता है, वेबसॉकेट कनेक्शन से डेटा पढ़ता है, TCP कनेक्शन से डेटा, सामान्य HTTP प्रोटोकॉल में इसका उपयोग समर्थन नहीं करता हैreadविधि; ओवरटाइम समय पैरामीटर निर्दिष्ट किया जा सकता हैtimeout_ms, यूनिट मिलीसेकंड ।
- ctx.write(s)
HTTP/TCP प्रोटोकॉल के लिए उपयोग किया जाता है, स्ट्रिंग डेटा लिखने के लिए उपयोग किया जा सकता हैJSON.stringify()JSON ऑब्जेक्ट को स्ट्रिंग के बाद लिखने के लिए एन्कोड करें.WebSocketप्रोटोकॉल, जो इस विधि का उपयोग करके क्लाइंट को एन्कोडेड स्ट्रिंग्स को पास कर सकता है।
{@fun/Global/HttpQuery HttpQuery}, {@fun/Global/HttpQuery_Go HttpQuery_Go}
स्थायी रूप से डेटा सहेजें, यह फ़ंक्शन एक सहेजने योग्य सार्वभौमिक शब्दकोश सुविधा को लागू करता है। डेटा संरचना केवी तालिका है, जो होस्ट के स्थानीय डेटाबेस फ़ाइलों को स्थायी रूप से सहेजती है।
स्थायी रूप से संरक्षितk-vकुंजी मान जोड़ी में कुंजी मान डेटा।
string, number, bool, object, array, और रिक्त मान
_G() _G(k) _G(k, v)
पैरामीटरkसहेजे गए कुंजी मानों के लिए जोड़े में कुंजी नाम, बड़े या छोटे अक्षरों के बिना।
k
गलत
string, खाली मान
पैरामीटरvजोड़े के लिए सहेजे गए कुंजी मान के लिए कुंजी मान हो सकता हैJSONसीरिएटेड डेटा।
v
गलत
string, number, bool, object, array, और रिक्त मान
function main(){
// 设置一个全局变量num，值为1
_G("num", 1)
// 更改一个全局变量num，值为字符串ok
_G("num", "ok")
// 删除全局变量num
_G("num", null)
// 返回全局变量num的值
Log(_G("num"))
// 删除所有全局变量
_G(null)
// 返回实盘ID
var robotId = _G()
}
def main():
_G("num", 1)
_G("num", "ok")
_G("num", None)
Log(_G("num"))
_G(None)
robotId = _G()
void main() {
_G("num", 1);
_G("num", "ok");
_G("num", NULL);
Log(_G("num"));
_G(NULL);
// 不支持 auto robotId = _G();
}
प्रत्येक डिस्क के लिए एक अलग डेटाबेस, नीति को फिर से शुरू करें या होस्ट को बंद करें।_G()फ़ंक्शन द्वारा सहेजे गए डेटा हमेशा मौजूद रहते हैं._G()फ़ंक्शन के द्वारा पुनर्लेखन प्रणाली में सहेजे गए डेटा को मिटा दिया जाता है._G()जब फ़ंक्शनल स्थायित्व डेटा को संग्रहीत करता है, तो हार्डवेयर डिवाइस के मेमोरी, हार्ड डिस्क स्थान के उचित उपयोग के आधार पर इसका दुरुपयोग नहीं किया जाना चाहिए।
वास्तविक डिस्क पर कॉल करें_G()जब कोई फ़ंक्शन कोई पैरामीटर नहीं देता है,_G()फ़ंक्शन वर्तमान डिस्क पर लौटता हैId❖ कॉल करें_G()जब फ़ंक्शन, पैरामीटरvखाली मानों को भेजने से हटाया जाना चाहिएk-vकुंजी मान सही है._G()फ़ंक्शन के लिए, केवल पैरामीटरkएक बार जब आप एक स्ट्रिंग भेजते हैं,_G()फ़ंक्शन सहेजे गए पैरामीटर लौटाता हैkसंबंधित कुंजी मानों को कॉल करें._G()फ़ंक्शन के लिए, केवल पैरामीटरkरिक्त मान भेजें, सभी रिकॉर्ड हटाएंk-vकुंजी मान सही है।k-vकुंजी मानों को फिर से कॉल करने के लिए स्थायी रूप से सहेजा गया है_G()फ़ंक्शन, जो स्थायी रूप से सहेजे गए कुंजी नामों को पैरामीटर के रूप में पास करता हैk, नए कुंजी मान को पैरामीटर के रूप में दर्ज करेंv..k-vकुंजी का मान सही है।
{@fun/Global/DBExec DBExec}
तो, क्या आप इसे एक बार में एक बार में बदल सकते हैं?Dateऑब्जेक्ट को टाइम स्ट्रिंग में परिवर्तित किया जाता है.
समय की स्ट्रिंग। string
_D() _D (समय) _D ((समयमुद्रण, fmt)
एक मिलीसेकंड का समय याDateवस्तुएं ।
टाइमस्टैम्प
गलत
संख्या, वस्तु
यह एक बहुत ही अच्छा तरीका है।JavaScriptभाषा का डिफ़ॉल्ट प्रारूपःyyyy-MM-dd hh:mm:ss；Pythonभाषा का डिफ़ॉल्ट प्रारूपः%Y-%m-%d %H:%M:%S；C++भाषा का डिफ़ॉल्ट प्रारूपः%Y-%m-%d %H:%M:%S◊
fmt
झूठी
स्ट्रिंग
function main(){
var time = _D()
Log(time)
}
def main():
strTime = _D()
Log(strTime)
void main() {
auto strTime = _D();
Log(strTime);
}
वर्तमान समय स्ट्रिंग प्राप्त करें, प्रिंट करेंः
function main() {
Log(_D(1574993606000))
}
def main():
# 北京时间的服务器上运行：2019-11-29 10:13:26 ，另一台其它地区的服务器上的托管者运行此代码结果则为：2019-11-29 02:13:26
Log(_D(1574993606))
void main() {
Log(_D(1574993606000));
}
समय सीमा 1574993606000 है, कोड का उपयोग करके परिवर्तित करेंः
function main() {
Log(_D(1574993606000, "yyyy--MM--dd hh--mm--ss")) // 2019--11--29 10--13--26
}
def main():
# 1574993606为秒级别时间戳
Log(_D(1574993606, "%Y--%m--%d %H--%M--%S")) # 2019--11--29 10--13--26
void main() {
Log(_D(1574993606000, "%Y--%m--%d %H--%M--%S")); // 2019--11--29 10--13--26
}
पैरामीटर का उपयोग करनाfmtयह एक बहुत ही अच्छा तरीका है।JavaScript、Python、C++भाषाओं में स्वरूपण स्ट्रिंग अलग-अलग होती है, उदाहरण के लिए निम्नलिखित देखेंः
बिना किसी पैरामीटर को पास किए वर्तमान समय स्ट्रिंग लौटता है.Pythonरणनीतिक उपयोग_D()जब फ़ंक्शन का उपयोग किया जाता है, तो ध्यान देने योग्य पैरामीटर सेकंड स्तर का समय है ((जावास्क्रिप्ट, सी ++ नीतियों में मिलीसेकंड स्तर का समय है, 1 सेकंड 1000 मिलीसेकंड के बराबर है) । वास्तविक समय में उपयोग किया जाता है।_D()जब फ़ंक्शन एक टाइमलाइन को पठनीय समय स्ट्रिंग के रूप में पार्स करता है, तो उस ऑपरेटिंग सिस्टम के समय क्षेत्र, समय सेटिंग्स पर ध्यान देना आवश्यक होता है जहां होस्टिंग प्रोग्राम स्थित है।_D()फ़ंक्शन का विश्लेषण करें कि एक टाइमलाइन को पढ़ने योग्य समय स्ट्रिंग के रूप में होस्टिंग सिस्टम के समय के आधार पर निर्धारित किया गया है।
{@fun/Global/UnixNano UnixNano}, {@fun/Global/Unix Unix}
एक फ्लोटिंग बिंदु संख्या को स्वरूपित करें.
सटीकता सेटिंग्स के आधार पर, स्वरूपित फ्लोटिंग बिंदुओं की संख्या। संख्या
_N() _N(num) _N ((num, सटीकता)
फ्लोटिंग बिंदुओं की संख्या को प्रारूपित करने की आवश्यकता है।
num
सच
संख्या
स्वरूपण सटीकता सेटिंग्स, पैरामीटरprecisionपूर्णांक के लिए, पैरामीटरprecision4 का अनुमान लगाएं।
सटीकता
गलत
संख्या
function main(){
var i = 3.1415
Log(i)
var ii = _N(i, 2)
Log(ii)
}
def main():
i = 3.1415
Log(i)
ii = _N(i, 2)
Log(ii)
void main() {
auto i = 3.1415;
Log(i);
auto ii = _N(i, 2);
Log(ii);
}
उदाहरण के लिए_N(3.1415, 2)हटाया जाएगा3.1415दो अंकों के बाद, फ़ंक्शन लौटाता है3.14。
function main(){
var i = 1300
Log(i)
var ii = _N(i, -3)
// 查看日志得知为1000
Log(ii)
}
def main():
i = 1300
Log(i)
ii = _N(i, -3)
Log(ii)
void main() {
auto i = 1300;
Log(i);
auto ii = _N(i, -3);
Log(ii);
}
यदि आप सभी n अंक को शून्य में बदलना चाहते हैं, तो आप इसे लिख सकते हैं:
पैरामीटरprecisionयह सकारात्मक पूर्णांक या नकारात्मक पूर्णांक हो सकता है.
{@fun/Trade/exchange.SetPrecision exchange.SetPrecision} {@fun/Trade/exchange.SetPrecision exchange.SetPrecision} {@trade/exchange.SetPrecision exchange.SetPrecision} {@fun/Trade.
पुनः परीक्षण फ़ंक्शन, इंटरफ़ेस त्रुटि स्वीकार करने के लिए प्रयोग किया जाता है.
एक रिकॉल फ़ंक्शन के निष्पादन के समय लौटाया गया मान। सिवायतार्किक मिथक、शून्य मानसभी प्रकारों को बाहरी प्रणाली द्वारा समर्थित है।
_C(pfn) _C ((pfn,...args)
पैरामीटरpfnएक फ़ंक्शन के लिए संदर्भ, एकरिकॉल फ़ंक्शन◊
पीएफएन
सच
कार्यरिकॉल फ़ंक्शनके लिए पैरामीटर, पैरामीटरargवहाँ हो सकता है कई पैरामीटर.argप्रकार और संख्या के आधार पररिकॉल फ़ंक्शनइस तरह के एक बहुत ही अच्छा विकल्प है।
arg
गलत
string, number, boole, object, array, function, empty, आदि सभी प्रकार सिस्टम द्वारा समर्थित हैं
function main(){
var ticker = _C(exchange.GetTicker)
// 调整_C()函数重试时间间隔为2秒
_CDelay(2000)
var depth = _C(exchange.GetDepth)
Log(ticker)
Log(depth)
}
def main():
ticker = _C(exchange.GetTicker)
_CDelay(2000)
depth = _C(exchange.GetDepth)
Log(ticker)
Log(depth)
void main() {
auto ticker = _C(exchange.GetTicker);
_CDelay(2000);
auto depth = _C(exchange.GetDepth);
Log(ticker);
Log(depth);
}
यदि कोई फ़ंक्शन पैरामीटर के बिना है, तो त्रुटि स्वीकार करेंः
function main(){
var records = _C(exchange.GetRecords, PERIOD_D1)
Log(records)
}
def main():
records = _C(exchange.GetRecords, PERIOD_D1)
Log(records)
void main() {
auto records = _C(exchange.GetRecords, PERIOD_D1);
Log(records);
}
यदि कोई फ़ंक्शन पैरामीटर के साथ है, तो त्रुटि स्वीकार करेंः
var test = function(a, b){
var time = new Date().getTime() / 1000
if(time % b == 3){
Log("符合条件！", "#FF0000")
return true
}
Log("重试！", "#FF0000")
return false
}
function main(){
var ret = _C(test, 1, 5)
Log(ret)
}
import time
def test(a, b):
ts = time.time()
if ts % b == 3:
Log("符合条件！", "#FF0000")
return True
Log("重试！", "#FF0000")
return False
def main():
ret = _C(test, 1, 5)
Log(ret)
// C++ 不支持这种方式对于自定义函数容错
यह कस्टम फ़ंक्शन के लिए त्रुटि-संभाल के लिए भी उपयोग किया जा सकता हैः
可以但不限于对以下函数做容错处理：
- ```exchange.GetTicker()```
- ```exchange.GetDepth()```
- ```exchange.GetTrades()```
- ```exchange.GetRecords()```
- ```exchange.GetAccount()```
- ```exchange.GetOrders()```
- ```exchange.GetOrder()```
- ```exchange.GetPositions()```
都可以通过```_C()```函数来调用进行容错。```_C()```函数不局限于以上列出的函数容错，参数```pfn```是函数引用并非函数调用，
注意是```_C(exchange.GetTicker)```并不是```_C(exchange.GetTicker())```。
### _Cross
返回数组```arr1```与数组```arr2```的交叉周期数。
数组```arr1```与数组```arr2```的交叉周期数。
number
_Cross(arr1, arr2)
元素为```number```类型的数组。
arr1
true
array
元素为```number```类型的数组。
arr2
true
array
```javascript
// 快线指标
var arr1 = [1,2,3,4,5,6,8,8,9]
// 慢线指标
var arr2 = [2,3,4,5,6,7,7,7,7]
function main(){
Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2))
Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1))
}
arr1 = [1,2,3,4,5,6,8,8,9]
arr2 = [2,3,4,5,6,7,7,7,7]
def main():
Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2))
Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1))
void main() {
vector<double> arr1 = {1,2,3,4,5,6,8,8,9};
vector<double> arr2 = {2,3,4,5,6,7,7,7,7};
Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2));
Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1));
}
एक डेटा सेट का परीक्षण करने के लिए_Cross ((Arr1, Arr2) फ़ंक्शन का अनुकरण किया जा सकता हैः
### JSONParse
函数```JSONParse()```用于解析```JSON```字符串。
```JSON```对象。
object
JSONParse(s)
```JSON```字符串。
s
true
string
```javascript
function main() {
let s1 = '{"num": 8754613216564987646512354656874651651358}'
Log("JSON.parse:", JSON.parse(s1)) // JSON.parse: {"num":8.754613216564988e+39}
Log("JSONParse:", JSONParse(s1)) // JSONParse: {"num":"8754613216564987646512354656874651651358"}
let s2 = '{"num": 123}'
Log("JSON.parse:", JSON.parse(s2)) // JSON.parse: {"num":123}
Log("JSONParse:", JSONParse(s2)) // JSONParse: {"num":123}
}
import json
def main():
s1 = '{"num": 8754613216564987646512354656874651651358}'
Log("json.loads:", json.loads(s1)) # json.loads: map[num:8.754613216564987e+39]
Log("JSONParse:", JSONParse(s1)) # JSONParse: map[num:8754613216564987646512354656874651651358]
s2 = '{"num": 123}'
Log("json.loads:", json.loads(s2)) # json.loads: map[num:123]
Log("JSONParse:", JSONParse(s2)) # JSONParse: map[num:123]
void main() {
auto s1 = "{\"num\":8754613216564987646512354656874651651358}";
Log("json::parse:", json::parse(s1));
// Log("JSONParse:", JSONParse(s1)); // 不支持该函数
auto s2 = "{\"num\":123}";
Log("json::parse:", json::parse(s2));
// Log("JSONParse:", JSONParse(s2)); // 不支持该函数
}
बड़ी संख्या वाले JSON स्ट्रिंग को सही ढंग से पार्सल किया जा सकता है, जो बड़ी संख्या को स्ट्रिंग प्रकार के रूप में पार्सल करेगा.JSONParse()फ़ंक्शन ।
लॉग को आउटपुट करें।
लॉग ((...msgs)
पैरामीटरmsgआउटपुट के लिए सामग्री, पैरामीटरmsgकई संदेश भेजे जा सकते हैं।
msg
गलत
string, number, bool, object, array, null आदि सिस्टम समर्थित किसी भी प्रकार
function main() {
Log("msg1", "msg2", "msg3")
}
def main():
Log("msg1", "msg2", "msg3")
void main() {
Log("msg1", "msg2", "msg3");
}
एक से अधिकmsgपैरामीटरः
function main() {
Log("发明者量化你好 !@")
Sleep(1000 * 5)
// 字符串内加入#ff0000，打印日志显示为红色，并且推送消息
Log("你好, #ff0000@")
}
def main():
Log("发明者量化你好 !@")
Sleep(1000 * 5)
Log("你好, #ff0000@")
void main() {
Log("发明者量化你好 !@");
Sleep(1000 * 5);
Log("你好, #ff0000@");
}
आउटपुट संदेशों के रंग सेट करने का समर्थन करता है, यदि रंग सेट करना और पुश करना एक साथ उपयोग किया जाता है, तो रंग पहले सेट करना आवश्यक है, अंतिम उपयोग करें@अक्षरों को सेट करें और आगे बढ़ाएं.
function main() {
Log("`data:image/png;base64,AAAA`")
}
def main():
Log("`data:image/png;base64,AAAA`")
void main() {
Log("`data:image/png;base64,AAAA`");
}
```python
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
Log(plt)
```javascript
function main() {
Log("[trans]中文|abc[/trans]")
}
def main():
Log("[trans]中文|abc[/trans]")
void main() {
Log("[trans]中文|abc[/trans]");
}
```Log()```函数在实盘或者回测系统的日志区域输出一条日志信息，实盘运行时日志会保存在实盘的数据库中。 ```Log()```函数输出的内容以```@```字符结尾则这条日志会进入消息推送队列。 推送到当前发明者量化交易平台账号[推送设置](https://www.fmz.com/m/account)中配置的邮箱、WebHook地址等。 [调试工具](https://www.fmz.com/m/debug)、回测系统不支持消息推送。 消息推送有频率限制，具体限制规则如下：在一个实盘20秒周期内，只有最后一条推送消息会被保留并进行推送，其它消息将被过滤，不进行推送（通过 Log 函数输出的推送日志会正常打印显示在日志区域）。
关于```WebHook```推送，可以使用```Golang```编写的服务程序：
पैकेज मुख्य
आयात (
कार्य संभालें (http.ResponseWriter, r *http.Request) {
स्थगित करना
fmt.Println ((
मुख्य कार्य () {
fmt.Println ((
在[推送设置](https://www.fmz.com/m/account)中设置```WebHook```：```http://XXX.XX.XXX.XX:9090/data?data=Hello_FMZ```，
运行写好的```Golang```服务程序后，开始实盘运行策略，以下为```JavaScript```语言编写的策略，策略运行时执行```Log()```函数并推送消息：
```js
function main() {
Log("msg", "@")
}
सुनोhttp://localhost:9090req: {GET /data?data=Hello_FMZ HTTP/1.1 1 1 नक्शा[User-Agent:[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, जैसे Gecko) क्रोम/xx.x.xxxx.xxx सफारी/537.36] स्वीकार करें-संकेतनः[gzip]] {} 0 [] गलत 1XX.XX.X.XX:9090 नक्शा[] नक्शा[] नक्शा[] XXX.XX.XXX.XX:xxx2 /data?data=Hello_FMZ 0xc420056300
{@fun/Log/LogReset LogReset}, {@fun/Log/LogVacuum LogVacuum}
### LogProfit
记录盈亏值，打印盈亏数值并根据盈亏数值绘制收益曲线。
LogProfit(profit)
LogProfit(profit, ...args)
参数```profit```为收益数据，该数据由策略中设计算法、计算给出。
profit
true
number
扩展参数，可以输出附带信息到这条收益日志中，```arg```参数可以传多个。
arg
false
string、number、bool、object、array、空值等系统支持的任意类型
```javascript
function main() {
// 在收益图表上打印30个点
for(var i = 0; i < 30; i++) {
LogProfit(i, '&')
Sleep(500)
}
}
def main():
for i in range(30):
LogProfit(i, '&')
Sleep(500)
void main() {
for(int i = 0; i < 30; i++) {
LogProfit(i, '&');
Sleep(500);
}
}
{@fun/Log/LogProfitReset LogProfitReset}
### LogProfitReset
清空所有收益日志、收益图表。
LogProfitReset()
LogProfitReset(remain)
```remain```参数用于指定保留的日志条数（整数值）。
remain
false
number
```javascript
function main() {
// 在收益图表上打印30个点，然后重置，只保留最后10个点
for(var i = 0; i < 30; i++) {
LogProfit(i)
Sleep(500)
}
LogProfitReset(10)
}
def main():
for i in range(30):
LogProfit(i)
Sleep(500)
LogProfitReset(10)
void main() {
for(int i = 0; i < 30; i++) {
LogProfit(i);
Sleep(500);
}
LogProfitReset(10);
}
{@fun/Log/LogProfit लॉगप्रॉफिट}
पुनः परीक्षण प्रणाली या वास्तविक डिस्क पृष्ठ स्थिति में जानकारी का आउटपुट करें।
लॉगस्टेटस ((...msgs)
पैरामीटरmsgआउटपुट के लिए सामग्री, पैरामीटरmsgकई संदेश भेजे जा सकते हैं।
msg
गलत
string, number, bool, object, array, null आदि सिस्टम समर्थित किसी भी प्रकार
function main() {
LogStatus('这是一个普通的状态提示')
LogStatus('这是一个红色字体的状态提示#ff0000')
LogStatus('这是一个多行的状态信息\n我是第二行')
}
def main():
LogStatus('这是一个普通的状态提示')
LogStatus('这是一个红色字体的状态提示#ff0000')
LogStatus('这是一个多行的状态信息\n我是第二行')
void main() {
LogStatus("这是一个普通的状态提示");
LogStatus("这是一个红色字体的状态提示#ff0000");
LogStatus("这是一个多行的状态信息\n我是第二行");
}
आउटपुट सामग्री के रंग सेट करने के लिए समर्थनः
function main() {
var table = {type: 'table', title: '持仓信息', cols: ['列1', '列2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
// JSON序列化后两边加上`字符,视为一个复杂消息格式(当前支持表格)
LogStatus('`' + JSON.stringify(table) + '`')
// 表格信息也可以在多行中出现
LogStatus('第一行消息\n`' + JSON.stringify(table) + '`\n第三行消息')
// 支持多个表格同时显示,将以TAB显示到一组里
LogStatus('`' + JSON.stringify([table, table]) + '`')
// 也可以构造一个按钮在表格中,策略用GetCommand接收cmd属性的内容
var table = {
type: 'table',
title: '持仓操作',
cols: ['列1', '列2', 'Action'],
rows: [
['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': '平仓'}]
]
}
LogStatus('`' + JSON.stringify(table) + '`')
// 或者构造一单独的按钮
LogStatus('`' + JSON.stringify({'type':'button', 'cmd': 'coverAll', 'name': '平仓'}) + '`')
// 可以自定义按钮风格(bootstrap的按钮属性)
LogStatus('`' + JSON.stringify({'type':'button', 'class': 'btn btn-xs btn-danger', 'cmd': 'coverAll', 'name': '平仓'}) + '`')
}
import json
def main():
table = {"type": "table", "title": "持仓信息", "cols": ["列1", "列2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]}
LogStatus('`' + json.dumps(table) + '`')
LogStatus('第一行消息\n`' + json.dumps(table) + '`\n第三行消息')
LogStatus('`' + json.dumps([table, table]) + '`')
table = {
"type" : "table",
"title" : "持仓操作",
"cols" : ["列1", "列2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]
]
}
LogStatus('`' + json.dumps(table) + '`')
LogStatus('`' + json.dumps({"type": "button", "cmd": "coverAll", "name": "平仓"}) + '`')
LogStatus('`' + json.dumps({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "平仓"}) + '`')
void main() {
json table = R"({"type": "table", "title": "持仓信息", "cols": ["列1", "列2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
LogStatus("`" + table.dump() + "`");
LogStatus("第一行消息\n`" + table.dump() + "`\n第三行消息");
json arr = R"([])"_json;
arr.push_back(table);
arr.push_back(table);
LogStatus("`" + arr.dump() + "`");
table = R"({
"type" : "table",
"title" : "持仓操作",
"cols" : ["列1", "列2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]
]
})"_json;
LogStatus("`" + table.dump() + "`");
LogStatus("`" + R"({"type": "button", "cmd": "coverAll", "name": "平仓"})"_json.dump() + "`");
LogStatus("`" + R"({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "平仓"})"_json.dump() + "`");
}
स्थिति पट्टी में डेटा आउटपुट का उदाहरणः
function main() {
var table = {
type: "table",
title: "状态栏按钮样式",
cols: ["默认", "原始", "成功", "信息", "警告", "危险"],
rows: [
[
{"type":"button", "class": "btn btn-xs btn-default", "name": "默认"},
{"type":"button", "class": "btn btn-xs btn-primary", "name": "原始"},
{"type":"button", "class": "btn btn-xs btn-success", "name": "成功"},
{"type":"button", "class": "btn btn-xs btn-info", "name": "信息"},
{"type":"button", "class": "btn btn-xs btn-warning", "name": "告警"},
{"type":"button", "class": "btn btn-xs btn-danger", "name": "危险"}
]
]
}
LogStatus("`" + JSON.stringify(table) + "`")
}
import json
def main():
table = {
"type": "table",
"title": "状态栏按钮样式",
"cols": ["默认", "原始", "成功", "信息", "警告", "危险"],
"rows": [
[
{"type":"button", "class": "btn btn-xs btn-default", "name": "默认"},
{"type":"button", "class": "btn btn-xs btn-primary", "name": "原始"},
{"type":"button", "class": "btn btn-xs btn-success", "name": "成功"},
{"type":"button", "class": "btn btn-xs btn-info", "name": "信息"},
{"type":"button", "class": "btn btn-xs btn-warning", "name": "告警"},
{"type":"button", "class": "btn btn-xs btn-danger", "name": "危险"}
]
]
}
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type": "table",
"title": "状态栏按钮样式",
"cols": ["默认", "原始", "成功", "信息", "警告", "危险"],
"rows": [
[
{"type":"button", "class": "btn btn-xs btn-default", "name": "默认"},
{"type":"button", "class": "btn btn-xs btn-primary", "name": "原始"},
{"type":"button", "class": "btn btn-xs btn-success", "name": "成功"},
{"type":"button", "class": "btn btn-xs btn-info", "name": "信息"},
{"type":"button", "class": "btn btn-xs btn-warning", "name": "告警"},
{"type":"button", "class": "btn btn-xs btn-danger", "name": "危险"}
]
]
})"_json;
LogStatus("`" + table.dump() + "`");
}
स्थिति टैब में डिज़ाइन बटन नियंत्रणों का समर्थन (पुराने संस्करण बटन संरचना):
function main() {
var table = {
type: "table",
title: "状态栏按钮的禁用、描述功能测试",
cols: ["列1", "列2", "列3"],
rows: []
}
var button1 = {"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"}
var button2 = {"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮，设置为禁用", "disabled": true}
var button3 = {"type": "button", "name": "按钮3", "cmd": "button3", "description": "这是第三个按钮，设置为启用", "disabled": false}
table.rows.push([button1, button2, button3])
LogStatus("`" + JSON.stringify(table) + "`")
}
import json
def main():
table = {
"type": "table",
"title": "状态栏按钮的禁用、描述功能测试",
"cols": ["列1", "列2", "列3"],
"rows": []
}
button1 = {"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"}
button2 = {"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮，设置为禁用", "disabled": True}
button3 = {"type": "button", "name": "按钮3", "cmd": "button3", "description": "这是第三个按钮，设置为启用", "disabled": False}
table["rows"].append([button1, button2, button3])
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type": "table",
"title": "状态栏按钮的禁用、描述功能测试",
"cols": ["列1", "列2", "列3"],
"rows": []
})"_json;
json button1 = R"({"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"})"_json;
json button2 = R"({"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮，设置为禁用", "disabled": true})"_json;
json button3 = R"({"type": "button", "name": "按钮3", "cmd": "button3", "description": "这是第三个按钮，设置为启用", "disabled": false})"_json;
json arr = R"([])"_json;
arr.push_back(button1);
arr.push_back(button2);
arr.push_back(button3);
table["rows"].push_back(arr);
LogStatus("`" + table.dump() + "`");
}
स्थिति बटन सेट करना अक्षम करें, फ़ंक्शन का वर्णन (पुराने संस्करण में बटन संरचना):
function test1() {
Log("调用自定义函数")
}
function main() {
while (true) {
var table = {
type: 'table',
title: '操作',
cols: ['列1', '列2', 'Action'],
rows: [
['a', '1', {
'type': 'button',
'cmd': "CoverAll",
'name': '平仓'
}],
['b', '1', {
'type': 'button',
'cmd': 10,
'name': '发送数值'
}],
['c', '1', {
'type': 'button',
'cmd': _D(),
'name': '调用函数'
}],
['d', '1', {
'type': 'button',
'cmd': 'test1',
'name': '调用自定义函数'
}]
]
}
LogStatus(_D(), "\n", '`' + JSON.stringify(table) + '`')
var str_cmd = GetCommand()
if (str_cmd) {
Log("接收到的交互数据 str_cmd:", "类型：", typeof(str_cmd), "值：", str_cmd)
if(str_cmd == "test1") {
test1()
}
}
Sleep(500)
}
}
import json
def test1():
Log("调用自定义函数")
def main():
while True:
table = {
"type": "table",
"title": "操作",
"cols": ["列1", "列2", "Action"],
"rows": [
["a", "1", {
"type": "button",
"cmd": "CoverAll",
"name": "平仓"
}],
["b", "1", {
"type": "button",
"cmd": 10,
"name": "发送数值"
}],
["c", "1", {
"type": "button",
"cmd": _D(),
"name": "调用函数"
}],
["d", "1", {
"type": "button",
"cmd": "test1",
"name": "调用自定义函数"
}]
]
}
LogStatus(_D(), "\n", "`" + json.dumps(table) + "`")
str_cmd = GetCommand()
if str_cmd:
Log("接收到的交互数据 str_cmd", "类型：", type(str_cmd), "值：", str_cmd)
if str_cmd == "test1":
test1()
Sleep(500)
void test1() {
Log("调用自定义函数");
}
void main() {
while(true) {
json table = R"({
"type": "table",
"title": "操作",
"cols": ["列1", "列2", "Action"],
"rows": [
["a", "1", {
"type": "button",
"cmd": "CoverAll",
"name": "平仓"
}],
["b", "1", {
"type": "button",
"cmd": 10,
"name": "发送数值"
}],
["c", "1", {
"type": "button",
"cmd": "",
"name": "调用函数"
}],
["d", "1", {
"type": "button",
"cmd": "test1",
"name": "调用自定义函数"
}]
]
})"_json;
table["rows"][2][2]["cmd"] = _D();
LogStatus(_D(), "\n", "`" + table.dump() + "`");
auto str_cmd = GetCommand();
if(str_cmd != "") {
Log("接收到的交互数据 str_cmd", "类型：", typeid(str_cmd).name(), "值：", str_cmd);
if(str_cmd == "test1") {
test1();
}
}
Sleep(500);
}
}
संयोजनGetCommand()फ़ंक्शन, स्टेटस बटन इंटरैक्शन (पुराने संस्करण बटन संरचना):
function main() {
var tbl = {
type: "table",
title: "操作",
cols: ["列1", "列2"],
rows: [
["开仓操作", {"type": "button", "cmd": "open", "name": "开仓", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}],
["平仓操作", {"type": "button", "cmd": "coverAll", "name": "全部平仓"}]
]
}
LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
while (true) {
var cmd = GetCommand()
if (cmd) {
Log("cmd:", cmd)
}
Sleep(1000)
}
}
import json
def main():
tbl = {
"type": "table",
"title": "操作",
"cols": ["列1", "列2"],
"rows": [
["开仓操作", {"type": "button", "cmd": "open", "name": "开仓", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}],
["平仓操作", {"type": "button", "cmd": "coverAll", "name": "全部平仓"}]
]
}
LogStatus(_D(), "\n", "`" + json.dumps(tbl) + "`")
while True:
cmd = GetCommand()
if cmd:
Log("cmd:", cmd)
Sleep(1000)
void main() {
json tbl = R"({
"type": "table",
"title": "操作",
"cols": ["列1", "列2"],
"rows": [
["开仓操作", {"type": "button", "cmd": "open", "name": "开仓", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}],
["平仓操作", {"type": "button", "cmd": "coverAll", "name": "全部平仓"}]
]
})"_json;
LogStatus(_D(), "\n", "`" + tbl.dump() + "`");
while(true) {
auto cmd = GetCommand();
if(cmd != "") {
Log("cmd:", cmd);
}
Sleep(1000);
}
}
निर्माण स्थिति बटन के साथ बातचीत करते समय भी डेटा इनपुट का समर्थन किया जाता है, अंततः बातचीत निर्देशों द्वारा समर्थित।GetCommand()फ़ंक्शन कैप्चर. स्टेटस टैब में दिए गए बटन कंट्रोल के डेटा संरचना में वृद्धिinputउदाहरण के लिए (पुराने संस्करण बटन संरचना){"type": "button", "cmd": "open", "name": "开仓"}जोड़ेंः"input": {"name": "开仓数量", "type": "number", "defValue": 1}, बटन पर क्लिक करने पर इनपुट बॉक्स कंट्रोल के साथ एक पॉपअप विंडो (इनपुट बॉक्स में डिफ़ॉल्ट मान 1 है) को पॉप अप करने के लिए अनुमति देता है।defValueसेट किए गए डेटा), जिसे एक डेटा और बटन कमांड के साथ भेजा जा सकता है. उदाहरण के लिए, जब निम्न परीक्षण कोड चल रहा है, तो इनपुट बॉक्स के साथ एक पॉप-अप विंडो दिखाई देती है, जिसमें इनपुट बॉक्स में 111 दर्ज करने के बाद "पुष्टि" पर क्लिक करें।GetCommand()फ़ंक्शन संदेश को कैप्चर करता हैःopen:111。
function main() {
var tbl = {
type: "table",
title: "演示分组按钮控件",
cols: ["操作"],
rows: []
}
// 创建分组按钮控件结构
var groupBtn = {
type: "button",
cmd: "open",
name: "开仓",
group: [
{"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "市价单|挂单"},
{"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
{"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
{"name": "boolean", "description": "是/否|boolean", "type": "boolean", "defValue": true}
]
}
// 测试按钮1
var testBtn1 = {"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"}
var testBtn2 = {"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}
// 在tbl中添加groupBtn
tbl.rows.push([groupBtn])
// 支持状态栏表格的一个单元格内设置多个按钮，即一个单元格内的数据为一个按钮结构数组：[testBtn1, testBtn2]
tbl.rows.push([[testBtn1, testBtn2]])
while (true) {
LogStatus("`" + JSON.stringify(tbl) + "`", "\n", "分组按钮控件除了设置在状态栏表格中，也可以直接设置在状态栏上：", "`" + JSON.stringify(groupBtn) + "`")
var cmd = GetCommand()
if (cmd) {
Log("cmd:", cmd)
}
Sleep(5000)
}
}
import json
def main():
tbl = {
"type": "table",
"title": "演示分组按钮控件",
"cols": ["操作"],
"rows": []
}
groupBtn = {
"type": "button",
"cmd": "open",
"name": "开仓",
"group": [
{"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "市价单|挂单"},
{"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
{"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
{"name": "boolean", "description": "是/否|boolean", "type": "boolean", "defValue": True}
]
}
testBtn1 = {"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"}
testBtn2 = {"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}
tbl["rows"].append([groupBtn])
tbl["rows"].append([[testBtn1, testBtn2]])
while True:
LogStatus("`" + json.dumps(tbl) + "`", "\n", "分组按钮控件除了设置在状态栏表格中，也可以直接设置在状态栏上：", "`" + json.dumps(groupBtn) + "`")
cmd = GetCommand()
if cmd:
Log("cmd:", cmd)
Sleep(5000)
void main() {
json tbl = R"({
"type": "table",
"title": "演示分组按钮控件",
"cols": ["操作"],
"rows": []
})"_json;
json groupBtn = R"({
"type": "button",
"name": "开仓",
"cmd": "open",
"group": [
{"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "市价单|挂单"},
{"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
{"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
{"name": "boolean", "description": "是/否|boolean", "type": "boolean", "defValue": true}
]})"_json;
json testBtn1 = R"({"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"})"_json;
json testBtn2 = R"({"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮", "input": {"name": "开仓数量", "type": "number", "defValue": 1}})"_json;
tbl["rows"].push_back({groupBtn});
tbl["rows"].push_back({{testBtn1, testBtn2}});
while(true) {
LogStatus("`" + tbl.dump() + "`", "\n", "分组按钮控件除了设置在状态栏表格中，也可以直接设置在状态栏上：", "`" + groupBtn.dump() + "`");
auto cmd = GetCommand();
if(cmd != "") {
Log("cmd:", cmd);
}
Sleep(5000);
}
}
समूह बटन नियंत्रण (पुराने संस्करण बटन संरचना) का समर्थन करता हैडेटा इनपुट का समर्थन करने के लिए स्टेटस बटन(इनपुट फ़ील्ड सेट करें) एक साथ।GetCommand()फ़ंक्शन कैप्चर."group"फ़ील्ड सेटिंग्स, जब बटन पर क्लिक करने से बातचीत शुरू होती है, तो पृष्ठ पर पॉप-अप संवाद बॉक्स में अच्छी सेटिंग्स होती हैंएक समूहइनपुट कंट्रोल, एक बार में डेटा के एक सेट इनपुट करने के लिए प्रयोग किया जाता है।
स्थिति बटन नियंत्रण और समूह बटन नियंत्रण संरचना के बारे में"group"इस लेख में हम आपको कुछ महत्वपूर्ण बिंदुओं के बारे में बताएंगे।
- समूह मेंtypeगुण केवल निम्नलिखित चार प्रकारों का समर्थन करते हैं।defValueगुणों का डिफ़ॉल्ट मान है ।
|प्रतीक को अलग करना ।
"name": "tradePrice@orderType==1"सेटिंग्स, जो सेटिंग्स को सक्षम करती हैंलेन-देन की कीमतें（tradePrice) इनपुट नियंत्रक केवल जबकैसे प्राप्त करें(orderType) ड्रॉपडाउन ड्रॉपबॉक्स कंट्रोल का चयन करेंसूचीबद्धयह बहुत अच्छा है।
- इंटरैक्टिव इनपुट के दौरान नियंत्रण नाम द्विभाषी सेटिंग्स का समर्थन करता है
उदाहरण के लिए, निम्नलिखित उदाहरण मेंः |संकेतक अलग-अलग अंग्रेजी में वर्णन करता है।
- group मेंname、descriptionबटन संरचना के साथname、descriptionयद्यपि फ़ील्ड नाम समान हैं, लेकिन परिभाषाएं अलग हैं।
group मेंnameइनपुट मेंnameइस तरह की परिभाषाएं भी अलग हैं।
- विभाजन बटन नियंत्रक को ट्रिगर करने के बाद, इंटरैक्टिव सामग्री भेजने के लिए प्रारूपः बटन के cmd फ़ील्ड मान, समूह फ़ील्ड से संबंधित डेटा, उदाहरण के लिए निम्नलिखित उदाहरण परीक्षण मेंLog("cmd:", cmd)इस वाक्य का आउटपुटः
- 按钮控件的```type```属性仅支持：```"button"```。
支持输入数据的按钮控件，即设置了```input```属性的控件，```input```字段的配置信息中的```type```属性支持多种控件类型。
参考以下例子：
```javascript
function main() {
// 状态栏按钮控件（设置input字段实现）testBtn1按钮触发的页面中的下拉框控件使用options字段设置选项，使用defValue字段设置默认选项。区别于本章其它例子中直接使用defValue设置选项。
var testBtn1 = {
type: "button",
name: "testBtn1",
cmd: "cmdTestBtn1",
input: {name: "testBtn1ComboBox", type: "selected", options: ["A", "B"], defValue: 1}
}
/*
状态栏按钮控件（设置input字段实现）testBtn2按钮触发的页面中的下拉框控件使用options字段设置选项，options字段中的选项不仅支持字符串，
也支持使用```{text: "描述", value: "值"}```结构。使用defValue字段设置默认选项，默认选项可以是多选（通过数组结构实现多选）。多选需要设置额外的字段multiple为真值（true）。
*/
var testBtn2 = {
type: "button",
name: "testBtn2",
cmd: "cmdTestBtn2",
input: {
name: "testBtn2MultiComboBox",
type: "selected",
description: "实现下拉框多选",
options: [{text: "选项A", value: "A"}, {text: "选项B", value: "B"}, {text: "选项C", value: "C"}],
defValue: ["A", "C"],
multiple: true
}
}
// 状态栏分组按钮控件（设置group字段实现）testBtn3按钮触发的页面中的下拉框控件使用options字段设置选项，也支持直接使用defValue设置选项。
var testBtn3 = {
type: "button",
name: "testBtn3",
cmd: "cmdTestBtn3",
group: [
{name: "comboBox1", label: "labelComboBox1", description: "下拉框1", type: "selected", defValue: 1, options: ["A", "B"]},
{name: "comboBox2", label: "labelComboBox2", description: "下拉框2", type: "selected", defValue: "A|B"},
{name: "comboBox3", label: "labelComboBox3", description: "下拉框3", type: "selected", defValue: [0, 2], multiple: true, options: ["A", "B", "C"]},
{
name: "comboBox4",
label: "labelComboBox4",
description: "下拉框4",
type: "selected",
defValue: ["A", "C"],
multiple: true,
options: [{text: "选项A", value: "A"}, {text: "选项B", value: "B"}, {text: "选项C", value: "C"}, {text: "选项D", value: "D"}]
}
]
}
while (true) {
LogStatus("`" + JSON.stringify(testBtn1) + "`\n", "`" + JSON.stringify(testBtn2) + "`\n", "`" + JSON.stringify(testBtn3) + "`\n")
var cmd = GetCommand()
if (cmd) {
Log(cmd)
}
Sleep(5000)
}
}
import json
def main():
testBtn1 = {
"type": "button",
"name": "testBtn1",
"cmd": "cmdTestBtn1",
"input": {"name": "testBtn1ComboBox", "type": "selected", "options": ["A", "B"], "defValue": 1}
}
testBtn2 = {
"type": "button",
"name": "testBtn2",
"cmd": "cmdTestBtn2",
"input": {
"name": "testBtn2MultiComboBox",
"type": "selected",
"description": "实现下拉框多选",
"options": [{"text": "选项A", "value": "A"}, {"text": "选项B", "value": "B"}, {"text": "选项C", "value": "C"}],
"defValue": ["A", "C"],
"multiple": True
}
}
testBtn3 = {
"type": "button",
"name": "testBtn3",
"cmd": "cmdTestBtn3",
"group": [
{"name": "comboBox1", "label": "labelComboBox1", "description": "下拉框1", "type": "selected", "defValue": 1, "options": ["A", "B"]},
{"name": "comboBox2", "label": "labelComboBox2", "description": "下拉框2", "type": "selected", "defValue": "A|B"},
{"name": "comboBox3", "label": "labelComboBox3", "description": "下拉框3", "type": "selected", "defValue": [0, 2], "multiple": True, "options": ["A", "B", "C"]},
{
"name": "comboBox4",
"label": "labelComboBox4",
"description": "下拉框4",
"type": "selected",
"defValue": ["A", "C"],
"multiple": True,
"options": [{"text": "选项A", "value": "A"}, {"text": "选项B", "value": "B"}, {"text": "选项C", "value": "C"}, {"text": "选项D", "value": "D"}]
}
]
}
while True:
LogStatus("`" + json.dumps(testBtn1) + "`\n", "`" + json.dumps(testBtn2) + "`\n", "`" + json.dumps(testBtn3) + "`\n")
cmd = GetCommand()
if cmd:
Log(cmd)
Sleep(5000)
void main() {
json testBtn1 = R"({
"type": "button",
"name": "testBtn1",
"cmd": "cmdTestBtn1",
"input": {"name": "testBtn1ComboBox", "type": "selected", "options": ["A", "B"], "defValue": 1}
})"_json;
json testBtn2 = R"({
"type": "button",
"name": "testBtn2",
"cmd": "cmdTestBtn2",
"input": {
"name": "testBtn2MultiComboBox",
"type": "selected",
"description": "实现下拉框多选",
"options": [{"text": "选项A", "value": "A"}, {"text": "选项B", "value": "B"}, {"text": "选项C", "value": "C"}],
"defValue": ["A", "C"],
"multiple": true
}
})"_json;
json testBtn3 = R"({
"type": "button",
"name": "testBtn3",
"cmd": "cmdTestBtn3",
"group": [
{"name": "comboBox1", "label": "labelComboBox1", "description": "下拉框1", "type": "selected", "defValue": 1, "options": ["A", "B"]},
{"name": "comboBox2", "label": "labelComboBox2", "description": "下拉框2", "type": "selected", "defValue": "A|B"},
{"name": "comboBox3", "label": "labelComboBox3", "description": "下拉框3", "type": "selected", "defValue": [0, 2], "multiple": true, "options": ["A", "B", "C"]},
{
"name": "comboBox4",
"label": "labelComboBox4",
"description": "下拉框4",
"type": "selected",
"defValue": ["A", "C"],
"multiple": true,
"options": [{"text": "选项A", "value": "A"}, {"text": "选项B", "value": "B"}, {"text": "选项C", "value": "C"}, {"text": "选项D", "value": "D"}]
}
]
})"_json;
while (true) {
LogStatus("`" + testBtn1.dump() + "`\n", "`" + testBtn2.dump() + "`\n", "`" + testBtn3.dump() + "`\n");
auto cmd = GetCommand();
if (cmd != "") {
Log(cmd);
}
Sleep(5000);
}
}
स्टेटस पैनल समूह बटन नियंत्रण ((सेट करेंgroupफ़ील्ड कार्यान्वयन) और स्टेटस बटन नियंत्रण ((सेट करेंinputफ़ील्ड कार्यान्वयन) पर क्लिक करने पर बातचीत शुरू होती है (पहले संस्करण बटन संरचना), पृष्ठ पर पॉप अप होने वाले संवाद बॉक्स में ड्रॉपबॉक्स नियंत्रण भी बहुविकल्पीयता का समर्थन करता है, निम्नलिखित उदाहरण प्रदर्शित करते हैं कि कैसे एक ड्रॉपबॉक्स नियंत्रण को डिज़ाइन किया जाए जिसमें कई विकल्प शामिल होंः
var symbols = ["BTC_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "BNB_USDT.swap", "SOL_USDT.swap"]
function createBtn(tmp, group) {
var btn = JSON.parse(JSON.stringify(tmp))
_.each(group, function(eleByGroup) {
btn["group"].unshift(eleByGroup)
})
return btn
}
function main() {
var arrManager = []
_.each(symbols, function(symbol) {
arrManager.push({
"symbol": symbol,
})
})
// Btn
var tmpBtnOpen = {
"type": "button",
"cmd": "open",
"name": "开仓下单",
"group": [{
"type": "selected",
"name": "tradeType",
"label": "下单类型",
"description": "市价单、限价单",
"default": 0,
"group": "交易设置",
"settings": {
"options": ["市价单", "限价单"],
"required": true,
}
}, {
"type": "selected",
"name": "direction",
"label": "交易方向",
"description": "买入、卖出",
"default": "buy",
"group": "交易设置",
"settings": {
"render": "segment",
"required": true,
"options": [{"name": "买入", "value": "buy"}, {"name": "卖出", "value": "sell"}],
}
}, {
"type": "number",
"name": "price",
"label": "价格",
"description": "订单的价格",
"group": "交易设置",
"filter": "tradeType==1",
"settings": {
"required": true,
}
}, {
"type": "number",
"name": "amount",
"label": "下单量",
"description": "订单的下单量",
"group": "交易设置",
"settings": {
"required": true,
}
}],
}
while (true) {
var tbl = {"type": "table", "title": "dashboard", "cols": ["symbol", "actionOpen"], "rows": []}
_.each(arrManager, function(m) {
var btnOpen = createBtn(tmpBtnOpen, [{"type": "string", "name": "symbol", "label": "交易品种", "default": m["symbol"], "settings": {"required": true}}])
tbl["rows"].push([m["symbol"], btnOpen])
})
var cmd = GetCommand()
if (cmd) {
Log("收到交互：", cmd)
// 解析交互消息: open:{"symbol":"LTC_USDT.swap","tradeType":0,"direction":"buy","amount":111}
// 根据第一个冒号:之前的指令判断是哪种按钮模板触发的消息
var arrCmd = cmd.split(":", 2)
if (arrCmd[0] == "open") {
var msg = JSON.parse(cmd.slice(5))
Log("交易品种：", msg["symbol"], "，交易方向：", msg["direction"], "，订单类型：", msg["tradeType"] == 0 ? "市价单" : "限价单", msg["tradeType"] == 0 ? "，订单价格：当前市价" : "，订单价格：" + msg["price"], "，订单数量：", msg["amount"])
}
}
LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
Sleep(1000)
}
}
import json
symbols = ["BTC_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "BNB_USDT.swap", "SOL_USDT.swap"]
def createBtn(tmp, group):
btn = json.loads(json.dumps(tmp))
for eleByGroup in group:
btn["group"].insert(0, eleByGroup)
return btn
def main():
arrManager = []
for symbol in symbols:
arrManager.append({"symbol": symbol})
# Btn
tmpBtnOpen = {
"type": "button",
"cmd": "open",
"name": "开仓下单",
"group": [{
"type": "selected",
"name": "tradeType",
"label": "下单类型",
"description": "市价单、限价单",
"default": 0,
"group": "交易设置",
"settings": {
"options": ["市价单", "限价单"],
"required": True,
}
}, {
"type": "selected",
"name": "direction",
"label": "交易方向",
"description": "买入、卖出",
"default": "buy",
"group": "交易设置",
"settings": {
"render": "segment",
"required": True,
"options": [{"name": "买入", "value": "buy"}, {"name": "卖出", "value": "sell"}],
}
}, {
"type": "number",
"name": "price",
"label": "价格",
"description": "订单的价格",
"group": "交易设置",
"filter": "tradeType==1",
"settings": {
"required": True,
}
}, {
"type": "number",
"name": "amount",
"label": "下单量",
"description": "订单的下单量",
"group": "交易设置",
"settings": {
"required": True,
}
}],
}
while True:
tbl = {"type": "table", "title": "dashboard", "cols": ["symbol", "actionOpen"], "rows": []}
for m in arrManager:
btnOpen = createBtn(tmpBtnOpen, [{"type": "string", "name": "symbol", "label": "交易品种", "default": m["symbol"], "settings": {"required": True}}])
tbl["rows"].append([m["symbol"], btnOpen])
cmd = GetCommand()
if cmd != "" and cmd != None:
Log("收到交互：", cmd)
# 解析交互消息: open:{"symbol":"LTC_USDT.swap","tradeType":0,"direction":"buy","amount":111}
# 根据第一个冒号:之前的指令判断是哪种按钮模板触发的消息
arrCmd = cmd.split(":")
if arrCmd[0] == "open":
msg = json.loads(cmd[5:])
Log("交易品种：", msg["symbol"], "，交易方向：", msg["direction"], "，订单类型：", "市价单" if msg["tradeType"] == 0 else "限价单", "，订单价格：当前市价" if msg["tradeType"] == 0 else "，订单价格：" + str(msg["price"]), "，订单数量：", msg["amount"])
# 输出状态栏信息
LogStatus(_D(), "\n", "`" + json.dumps(tbl) + "`")
Sleep(1000)
// 略...
वर्तमान में नवीनतम बटन संरचना का उपयोग करके, स्थिति पट्टी फ़ॉर्म में बटन बनाएं, और क्लिक करने पर एक बहु-नियंत्रण पॉपअप विंडो दिखाई देगी। अधिक जानकारी के लिए देखेंःउपयोगकर्ता गाइड - स्टेटस टैब में इंटरैक्टिव नियंत्रण。
function main() {
var table = {
type: 'table',
title: '持仓操作',
cols: ['列1', '列2', 'Action'],
rows: [
['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': '平仓'}]
]
}
var ticker = exchange.GetTicker()
// 添加一行数据，第一个和第二个单元格合并，并且输出ticker变量在合并后的单元格内
table.rows.push([{body : JSON.stringify(ticker), colspan : 2}, "abc"])
LogStatus('`' + JSON.stringify(table) + '`')
}
import json
def main():
table = {
"type" : "table",
"title" : "持仓操作",
"cols" : ["列1", "列2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]
]
}
ticker = exchange.GetTicker()
table["rows"].append([{"body": json.dumps(ticker), "colspan": 2}, "abc"])
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type" : "table",
"title" : "持仓操作",
"cols" : ["列1", "列2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]
]
})"_json;
auto ticker = exchange.GetTicker();
json jsonTicker = R"({"Buy": 0, "Sell": 0, "High": 0, "Low": 0, "Volume": 0, "Last": 0, "Time": 0})"_json;
jsonTicker["Buy"] = ticker.Buy;
jsonTicker["Sell"] = ticker.Sell;
jsonTicker["Last"] = ticker.Last;
jsonTicker["Volume"] = ticker.Volume;
jsonTicker["Time"] = ticker.Time;
jsonTicker["High"] = ticker.High;
jsonTicker["Low"] = ticker.Low;
json arr = R"([{"body": {}, "colspan": 2}, "abc"])"_json;
arr[0]["body"] = jsonTicker;
table["rows"].push_back(arr);
LogStatus("`" + table.dump() + "`");
}
क्षैतिज विलयLogStatus()फ़ंक्शन द्वारा चित्रित तालिका में कक्षः
function main() {
var table = {
type: 'table',
title: '表格演示',
cols: ['列A', '列B', '列C'],
rows: [
['A1', 'B1', {'type':'button', 'cmd': 'coverAll', 'name': 'C1'}]
]
}
var ticker = exchange.GetTicker()
var name = exchange.GetName()
table.rows.push([{body : "A2 + B2:" + JSON.stringify(ticker), colspan : 2}, "C2"])
table.rows.push([{body : "A3 + A4 + A5:" + name, rowspan : 3}, "B3", "C3"])
// A3被上一行第一个单元格合并
table.rows.push(["B4", "C4"])
// A2被上一行第一个单元格合并
table.rows.push(["B5", "C5"])
table.rows.push(["A6", "B6", "C6"])
LogStatus('`' + JSON.stringify(table) + '`')
}
import json
def main():
table = {
"type" : "table",
"title" : "表格演示",
"cols" : ["列A", "列B", "列C"],
"rows" : [
["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
]
}
ticker = exchange.GetTicker()
name = exchange.GetName()
table["rows"].append([{"body": "A2 + B2:" + json.dumps(ticker), "colspan": 2}, "C2"])
table["rows"].append([{"body": "A3 + A4 + A5:" + name, "rowspan": 3}, "B3", "C3"])
table["rows"].append(["B4", "C4"])
table["rows"].append(["B5", "C5"])
table["rows"].append(["A6", "B6", "C6"])
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type" : "table",
"title" : "表格演示",
"cols" : ["列A", "列B", "列C"],
"rows" : [
["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
]
})"_json;
// 为了测试，代码简短易读，这里使用构造的数据
json jsonTicker = R"({"High": 0, "Low": 0, "Buy": 0, "Sell": 0, "Last": 0, "Time": 0, "Volume": 0})"_json;
auto name = exchange.GetName();
json arr1 = R"([{"body": "", "colspan": 2}, "C2"])"_json;
arr1[0]["body"] = "A2 + B2:" + jsonTicker.dump();
json arr2 = R"([{"body": "", "rowspan": 3}, "B3", "C3"])"_json;
arr2[0]["body"] = "A3 + A4 + A5:" + name;
table["rows"].push_back(arr1);
table["rows"].push_back(arr2);
table["rows"].push_back(R"(["B4", "C4"])"_json);
table["rows"].push_back(R"(["B5", "C5"])"_json);
table["rows"].push_back(R"(["A6", "B6", "C6"])"_json);
LogStatus("`" + table.dump() + "`");
}
लंबवत विलयLogStatus()फ़ंक्शन द्वारा चित्रित तालिका में कक्षः
function main() {
var table1 = {type: 'table', title: 'table1', cols: ['列1', '列2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
var table2 = {type: 'table', title: 'table2', cols: ['列1', '列2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
LogStatus('`' + JSON.stringify([table1, table2]) + '`')
}
import json
def main():
table1 = {"type": "table", "title": "table1", "cols": ["列1", "列2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
table2 = {"type": "table", "title": "table2", "cols": ["列1", "列2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
LogStatus("`" + json.dumps([table1, table2]) + "`")
void main() {
json table1 = R"({"type": "table", "title": "table1", "cols": ["列1", "列2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
json table2 = R"({"type": "table", "title": "table2", "cols": ["列1", "列2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
json arr = R"([])"_json;
arr.push_back(table1);
arr.push_back(table2);
LogStatus("`" + arr.dump() + "`");
}
स्थिति टैब में पृष्ठ विभाजन दिखाता हैः
function main(){
var tab1 = {
type : "table",
title : "表格1",
cols : ["1", "2"],
rows : []
}
var tab2 = {
type : "table",
title : "表格2",
cols : ["1", "2", "3"],
rows : []
}
var tab3 = {
type : "table",
title : "表格3",
cols : ["A", "B", "C"],
rows : []
}
tab1.rows.push(["jack", "lucy"])
tab2.rows.push(["A", "B", "C"])
tab3.rows.push(["A", "B", "C"])
LogStatus('`' + JSON.stringify(tab1) + '`\n' +
'`' + JSON.stringify(tab2) + '`\n' +
'`' + JSON.stringify(tab3) + '`')
Log("exit")
}
import json
def main():
tab1 = {
"type": "table",
"title": "表格1",
"cols": ["1", "2"],
"rows": []
}
tab2 = {
"type": "table",
"title": "表格2",
"cols": ["1", "2", "3"],
"rows": []
}
tab3 = {
"type": "table",
"title": "表格3",
"cols": ["A", "B", "C"],
"rows": []
}
tab1["rows"].append(["jack", "lucy"])
tab2["rows"].append(["A", "B", "C"])
tab3["rows"].append(["A", "B", "C"])
LogStatus("`" + json.dumps(tab1) + "`\n" +
"`" + json.dumps(tab2) + "`\n" +
"`" + json.dumps(tab3) + "`")
void main() {
json tab1 = R"({
"type": "table",
"title": "表格1",
"cols": ["1", "2"],
"rows": []
})"_json;
json tab2 = R"({
"type": "table",
"title": "表格2",
"cols": ["1", "2", "3"],
"rows": []
})"_json;
json tab3 = R"({
"type": "table",
"title": "表格3",
"cols": ["A", "B", "C"],
"rows": []
})"_json;
tab1["rows"].push_back(R"(["jack", "lucy"])"_json);
tab2["rows"].push_back(R"(["A", "B", "C"])"_json);
tab3["rows"].push_back(R"(["A", "B", "C"])"_json);
LogStatus("`" + tab1.dump() + "`\n" +
"`" + tab2.dump() + "`\n" +
"`" + tab3.dump() + "`");
}
पृष्ठों को विभाजित करने के अलावा, आप कई तालिकाओं को ऊपर से नीचे तक प्रदर्शित कर सकते हैंः
function main() {
var tbl = {
type : "table",
title : "test scroll",
scroll : "auto",
cols : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
"col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
rows : []
}
for (var i = 1 ; i < 100 ; i++) {
tbl.rows.push([i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
"11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i])
}
LogStatus("`" + JSON.stringify(tbl) + "`")
}
import json
def main():
tbl = {
"type" : "table",
"title" : "test scroll",
"scroll" : "auto",
"cols" : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
"col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
"rows" : []
}
for index in range(1, 100):
i = str(index)
tbl["rows"].append([i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
"11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i])
LogStatus("`" + json.dumps(tbl) + "`")
void main() {
json table = R"({
"type" : "table",
"title" : "test scroll",
"scroll" : "auto",
"cols" : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
"col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
"rows" : []
})"_json;
for (int index = 1; index < 100; ++index) {
std::string i = std::to_string(index);
table["rows"].push_back({i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
"11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i});
}
LogStatus("`" + table.dump() + "`");
}
स्थिति तालिकाओं को क्षैतिज, लंबवत स्क्रॉल मोड पर सेट करने का समर्थन करता है।scrollविशेषता"auto", जब स्थिति टैब में लंबवत पंक्तियों की संख्या 20 से अधिक पंक्तियों से अधिक हो, तो सामग्री को स्क्रॉल किया जाता है, जब लंबवत स्तंभ पृष्ठ प्रदर्शन के दायरे से बाहर हो, तो लंबवत स्क्रॉल किया जाता है,scrollगुण वास्तविक समय स्थिति पट्टी में बहुत अधिक डेटा लिखने के लिए कार्डबोर्ड समस्या को कम कर सकते हैं; निम्नलिखित परीक्षण उदाहरण देखेंः
वास्तविक डिस्क चल रहा हैLogStatus()फ़ंक्शन के आउटपुट की जानकारी डिस्क डेटाबेस में सहेजी नहीं जाती है, केवल वर्तमान डिस्क की स्थिति टैब सामग्री को अपडेट करती है।
```LogStatus()```函数支持直接传入```Python```的```matplotlib.pyplot```对象，只要对象包含```savefig```方法就可以作为参数传入```LogStatus()```函数，例如：
```python
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
LogStatus(plt)
जब नीति वास्तविक डिस्क पर चल रही है, तो यदि वास्तविक डिस्क पृष्ठ पर इतिहास को देखा जाता है, तो स्थिति टैब निष्क्रिय हो जाता है और अद्यतन करना बंद कर देता है। केवल लॉग के पहले पृष्ठ पर स्थिति टैब डेटा ताज़ा होता है। स्थिति टैब में आउटपुट का समर्थन करता है।base64इनकोडेड चित्रों को स्टेटस बार में प्रदर्शित तालिकाओं में निर्यात करने का भी समर्थन करता हैbase64एन्कोडेड चित्रों के लिए उदाहरण कोड प्रदर्शित नहीं किया जाता है क्योंकि एन्कोडेड चित्रों के स्ट्रिंग डेटा आमतौर पर लंबे होते हैं।
{@fun/Global/GetCommand GetCommand} {@fun/Global/GetCommand GetCommand}
लॉग रिकॉर्डिंग जो ऑर्डर की जानकारी को खोलती है या बंद करती है।
enableLog (सक्षम करें)
enable
true
bool
```javascript
function main() {
EnableLog(false)
}
def main():
EnableLog(False)
void main() {
EnableLog(false);
}
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.CancelOrder exchange.CancelOrder}, {@fun/Trade/exchange.CancelOrder exchange.CancelOrder}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Buy.Exchange.Buy}, {@fun/Trade/exchange.Buy.Exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Order exchange.CancelOrder}, {@fun/Trade/exchange.CancelOrder exchange.CancelOrder}, {@fun/Trade/Exchange.
कस्टम चार्ट चित्रण फ़ंक्शन।
चार्ट ऑब्जेक्ट्स object
चार्ट (विकल्प)
options
true
object、object数组
```javascript
function main() {
var cfgA = {
extension: {
layout: 'single', // 不参于分组，单独显示, 默认为分组 'group'
height: 300, // 指定高度
},
title: {
text: '盘口图表'
},
xAxis: {
type: 'datetime'
},
series: [{
name: '买一',
data: [],
}, {
name: '卖一',
data: [],
}]
}
var cfgB = {
title: {
text: '差价图'
},
xAxis: {
type: 'datetime'
},
series: [{
name: '差价',
type: 'column',
data: [],
}]
}
var cfgC = {
__isStock: false,
title: {
text: '饼图'
},
series: [{
type: 'pie',
name: 'one',
data: [
["A", 25],
["B", 25],
["C", 25],
["D", 25],
] // 指定初始数据后不需要用add函数更新, 直接更改图表配置就可以更新序列.
}]
};
var cfgD = {
extension: {
layout: 'single',
col: 8, // 指定宽度占的单元值, 总值 为12
height: '300px',
},
title: {
text: '盘口图表'
},
xAxis: {
type: 'datetime'
},
series: [{
name: '买一',
data: [],
}, {
name: '卖一',
data: [],
}]
}
var cfgE = {
__isStock: false,
extension: {
layout: 'single',
col: 4,
height: '300px',
},
title: {
text: '饼图2'
},
series: [{
type: 'pie',
name: 'one',
data: [
["A", 25],
["B", 25],
["C", 25],
["D", 25],
]
}]
};
var chart = Chart([cfgA, cfgB, cfgC, cfgD, cfgE]);
chart.reset()
// 为饼图清加一个数点，add只能更新通过add方式添加的数据点, 内置的数据点无法后期更新
chart.add(3, {
name: "ZZ",
y: Math.random() * 100
});
while (true) {
Sleep(1000)
var ticker = exchange.GetTicker()
if (!ticker) {
continue;
}
var diff = ticker.Sell - ticker.Buy
cfgA.subtitle = {
text: '买一 ' + ticker.Buy + ', 卖一 ' + ticker.Sell,
};
cfgB.subtitle = {
text: '价差 ' + diff,
};
chart.add([0, [new Date().getTime(), ticker.Buy]]);
chart.add([1, [new Date().getTime(), ticker.Sell]]);
// 相当于更新第二个图表的第一个数据序列
chart.add([2, [new Date().getTime(), diff]]);
chart.add(4, [new Date().getTime(), ticker.Buy]);
chart.add(5, [new Date().getTime(), ticker.Buy]);
cfgC.series[0].data[0][1] = Math.random() * 100;
cfgE.series[0].data[0][1] = Math.random() * 100;
// update实际上等于重置了图表的配置
chart.update([cfgA, cfgB, cfgC, cfgD, cfgE]);
}
}
import random
import time
def main():
cfgA = {
"extension" : {
"layout" : "single",
"height" : 300,
"col" : 8
},
"title" : {
"text" : "盘口图表"
},
"xAxis" : {
"type" : "datetime"
},
"series" : [{
"name" : "买一",
"data" : []
}, {
"name" : "卖一",
"data" : []
}]
}
cfgB = {
"title" : {
"text" : "差价图"
},
"xAxis" : {
"type" : "datetime",
},
"series" : [{
"name" : "差价",
"type" : "column",
"data" : []
}]
}
cfgC = {
"__isStock" : False,
"title" : {
"text" : "饼图"
},
"series" : [{
"type" : "pie",
"name" : "one",
"data" : [
["A", 25],
["B", 25],
["C", 25],
["D", 25],
]
}]
}
cfgD = {
"extension" : {
"layout" : "single",
"col" : 8,
"height" : "300px"
},
"title" : {
"text" : "盘口图表"
},
"series" : [{
"name" : "买一",
"data" : []
}, {
"name" : "卖一",
"data" : []
}]
}
cfgE = {
"__isStock" : False,
"extension" : {
"layout" : "single",
"col" : 4,
"height" : "300px"
},
"title" : {
"text" : "饼图2"
},
"series" : [{
"type" : "pie",
"name" : "one",
"data" : [
["A", 25],
["B", 25],
["C", 25],
["D", 25]
]
}]
}
chart = Chart([cfgA, cfgB, cfgC, cfgD, cfgE])
chart.reset()
chart.add(3, {
"name" : "ZZ",
"y" : random.random() * 100
})
while True:
Sleep(1000)
ticker = exchange.GetTicker()
if not ticker :
continue
diff = ticker["Sell"] - ticker["Buy"]
cfgA["subtitle"] = {
"text" : "买一" + str(ticker["Buy"]) + "卖一" + str(ticker["Sell"])
}
cfgB["subtitle"] = {
"text" : "价差 " + str(diff)
}
chart.add(0, [time.time() * 1000, ticker["Buy"]])
chart.add(1, [time.time() * 1000, ticker["Sell"]])
chart.add(2, [time.time() * 1000, diff])
chart.add(4, [time.time() * 1000, ticker["Buy"]])
chart.add(5, [time.time() * 1000, ticker["Buy"]])
cfgC["series"][0]["data"][0][1] = random.random() * 100
cfgE["series"][0]["data"][0][1] = random.random() * 100
void main() {
json cfgA = R"({
"extension" : {
"layout" : "single",
"height" : 300,
"col" : 8
},
"title" : {
"text" : "盘口图表"
},
"xAxis" : {
"type" : "datetime"
},
"series" : [{
"name" : "买一",
"data" : []
}, {
"name" : "卖一",
"data" : []
}]
})"_json;
json cfgB = R"({
"title" : {
"text" : "差价图"
},
"xAxis" : {
"type" : "datetime"
},
"series" : [{
"name" : "差价",
"type" : "column",
"data" : []
}]
})"_json;
json cfgC = R"({
"__isStock" : false,
"title" : {
"text" : "饼图"
},
"series" : [{
"type" : "pie",
"name" : "one",
"data" : [
["A", 25],
["B", 25],
["C", 25],
["D", 25]
]
}]
})"_json;
json cfgD = R"({
"extension" : {
"layout" : "single",
"col" : 8,
"height" : "300px"
},
"title" : {
"text" : "盘口图表"
},
"series" : [{
"name" : "买一",
"data" : []
}, {
"name" : "卖一",
"data" : []
}]
})"_json;
json cfgE = R"({
"__isStock" : false,
"extension" : {
"layout" : "single",
"col" : 4,
"height" : "300px"
},
"title" : {
"text" : "饼图2"
},
"series" : [{
"type" : "pie",
"name" : "one",
"data" : [
["A", 25],
["B", 25],
["C", 25],
["D", 25]
]
}]
})"_json;
auto chart = Chart({cfgA, cfgB, cfgC, cfgD, cfgE});
chart.reset();
json zz = R"({
"name" : "ZZ",
"y" : 0
})"_json;
zz["y"] = rand() % 100;
chart.add(3, zz);
while(true) {
Sleep(1000);
auto ticker = exchange.GetTicker();
if(!ticker.Valid) {
continue;
}
auto diff = ticker.Sell - ticker.Buy;
json cfgASubTitle = R"({"text" : ""})"_json;
cfgASubTitle["text"] = format("买一 %f , 卖一 %f", ticker.Buy, ticker.Sell);
cfgA["subtitle"] = cfgASubTitle;
json cfgBSubTitle = R"({"text" : ""})"_json;
cfgBSubTitle["text"] = format("价差 %f", diff);
cfgB["subtitle"] = cfgBSubTitle;
chart.add(0, {Unix() * 1000, ticker.Buy});
chart.add(1, {Unix() * 1000, ticker.Sell});
chart.add(2, {Unix() * 1000, diff});
chart.add(4, {Unix() * 1000, ticker.Buy});
chart.add(5, {Unix() * 1000, ticker.Buy});
cfgC["series"][0]["data"][0][1] = rand() % 100;
cfgE["series"][0]["data"][0][1] = rand() % 100;
chart.update({cfgA, cfgB, cfgC, cfgD, cfgE});
}
}
मल्टी-ग्राफ पिक्चर कॉन्फ़िगरेशनः
- क्या?extension.layoutगुण
यदि इस गुण को सेट किया जाता है, तो मान एक एकल तालिका है, तो चार्ट ओवरलैप नहीं होगा (किसी भी पेज को अलग-अलग टैग के रूप में प्रदर्शित नहीं किया जाएगा) और अलग-अलग प्रदर्शित होगा (फ्लैट डिस्प्ले) ।
- क्या?extension.heightगुण
यह गुण चार्ट की ऊंचाई को सेट करने के लिए उपयोग किया जाता है, जिसका मान संख्यात्मक प्रकार हो सकता है, या 300px के रूप में सेट किया जा सकता है।
- क्या?extension.colगुण
यह गुण चार्ट की चौड़ाई को सेट करने के लिए उपयोग किया जाता है, जिसमें पृष्ठ चौड़ाई को कुल 12 इकाइयों में विभाजित किया जाता है, जिसे 8 पर सेट किया जाता है ताकि चार्ट 8 इकाइयों की चौड़ाई पर हो।
// 这个chart在JavaScript语言中是对象，在使用Chart函数之前我们需要声明一个配置图表的对象变量chart
var chart = {
// 该字段标记图表是否为一般图表，有兴趣的可以改成false运行看看
__isStock: true,
// 缩放工具
tooltip: {xDateFormat: '%Y-%m-%d %H:%M:%S, %A'},
// 标题
title : { text : '差价分析图'},
// 选择范围
rangeSelector: {
buttons: [{type: 'hour',count: 1, text: '1h'}, {type: 'hour',count: 3, text: '3h'}, {type: 'hour', count: 8, text: '8h'}, {type: 'all',text: 'All'}],
selected: 0,
inputEnabled: false
},
// 坐标轴横轴即：x轴，当前设置的类型是：时间
xAxis: { type: 'datetime'},
// 坐标轴纵轴即：y轴，默认数值随数据大小调整
yAxis : {
// 标题
title: {text: '差价'},
// 是否启用右边纵轴
opposite: false
},
// 数据系列，该属性保存的是各个数据系列（线，K线图，标签等...）
series : [
// 索引为0，data数组内存放的是该索引系列的数据
{name : "line1", id : "线1,buy1Price", data : []},
// 索引为1，设置了dashStyle:'shortdash'即：设置虚线
{name : "line2", id : "线2,lastPrice", dashStyle : 'shortdash', data : []}
]
}
function main(){
// 调用Chart函数，初始化图表
var ObjChart = Chart(chart)
// 清空
ObjChart.reset()
while(true){
// 获取本次轮询的时间戳，即一个毫秒的时间戳。用来确定写入到图表的X轴的位置
var nowTime = new Date().getTime()
// 获取行情数据
var ticker = _C(exchange.GetTicker)
// 从行情数据的返回值取得买一价
var buy1Price = ticker.Buy
// 取得最后成交价，为了2条线不重合在一起，我们加1
var lastPrice = ticker.Last + 1
// 用时间戳作为X值，买一价作为Y值传入索引0的数据序列
ObjChart.add(0, [nowTime, buy1Price])
// 同上
ObjChart.add(1, [nowTime, lastPrice])
Sleep(2000)
}
}
import time
chart = {
"__isStock" : True,
"tooltip" : {"xDateFormat" : "%Y-%m-%d %H:%M:%S, %A"},
"title" : {"text" : "差价分析图"},
"rangeSelector" : {
"buttons" : [{"type": "count", "count": 1, "text": "1h"}, {"type": "hour", "count": 3, "text": "3h"}, {"type": "hour", "count": 8, "text": "8h"}, {"type": "all", "text": "All"}],
"selected": 0,
"inputEnabled": False
},
"xAxis": {"type": "datetime"},
"yAxis": {
"title": {"text": "差价"},
"opposite": False
},
"series": [{
"name": "line1", "id": "线1,buy1Price", "data": []
}, {
"name": "line2", "id": "线2,lastPrice", "dashStyle": "shortdash", "data": []
}]
}
def main():
ObjChart = Chart(chart)
ObjChart.reset()
while True:
nowTime = time.time() * 1000
ticker = exchange.GetTicker()
buy1Price = ticker["Buy"]
lastPrice = ticker["Last"] + 1
ObjChart.add(0, [nowTime, buy1Price])
ObjChart.add(1, [nowTime, lastPrice])
Sleep(2000)
void main() {
// C++编写策略时，尽量不要声明非基础类型的全局变量，所以图表配置对象声明在main函数内
json chart = R"({
"__isStock" : true,
"tooltip" : {"xDateFormat" : "%Y-%m-%d %H:%M:%S, %A"},
"title" : {"text" : "差价分析图"},
"rangeSelector" : {
"buttons" : [{"type": "count", "count": 1, "text": "1h"}, {"type": "hour", "count": 3, "text": "3h"}, {"type": "hour", "count": 8, "text": "8h"}, {"type": "all", "text": "All"}],
"selected": 0,
"inputEnabled": false
},
"xAxis": {"type": "datetime"},
"yAxis": {
"title": {"text": "差价"},
"opposite": false
},
"series": [{
"name": "line1", "id": "线1,buy1Price", "data": []
}, {
"name": "line2", "id": "线2,lastPrice", "dashStyle": "shortdash", "data": []
}]
})"_json;
auto ObjChart = Chart(chart);
ObjChart.reset();
while(true) {
auto nowTime = Unix() * 1000;
auto ticker = exchange.GetTicker();
auto buy1Price = ticker.Buy;
auto lastPrice = ticker.Last + 1.0;
ObjChart.add(0, {nowTime, buy1Price});
ObjChart.add(1, {nowTime, lastPrice});
Sleep(2000);
}
}
एक सरल चित्रण उदाहरणः
// 用于初始化图表的对象
var chart = {
// 图表标题
title: {text: "line数值触发 plotLines 值"},
// Y轴相关设置
yAxis: {
// 垂直于Y轴的水平线，用作触发线，是一个结构数组，可以设置多条触发线
plotLines: [{
// 触发线的值，设置多少这条线就在相应的数值位置显示
value: 0,
// 设置触发线的颜色
color: 'red',
// 宽度
width: 2,
// 显示的标签
label: {
// 标签文本
text: '触发值',
// 标签位置居中
align: 'center'
}
}]
},
// X轴相关设置，这里设置类型是时间轴
xAxis: {type: "datetime"},
series: [
{name: "sin", type: "spline", data: []},
// 这个是比较重要的数据系列，可以设置多个数据系列，根据数组索引控制
{name: "cos", type: "spline", data: []}
]
}
function main(){
// 圆周率
var pi = 3.1415926535897
// 用于记录时间戳的变量
var time = 0
// 角度
var angle = 0
// 坐标y值，用于接收正弦值、余弦值
var y = 0
// 调用API接口用chart对象初始化图表
var objChart = Chart(chart)
// 初始，清空图表
objChart.reset()
// 设置触发线的值为1
chart.yAxis.plotLines[0].value = 1
// 循环
while(true){
// 获取当前时刻的时间戳
time = new Date().getTime()
// 每500ms角度angle增加5度，计算正弦值
y = Math.sin(angle * 2 * pi / 360)
// 把计算出来的y值写入图表相应索引的数据系列，add函数的第一个参数为指定的数据系列索引
objChart.add(0, [time, y])
// 计算余弦值
y = Math.cos(angle * 2 * pi / 360)
objChart.add(1, [time, y])
// 增加5度
angle += 5
// 暂停5秒，以免画图太频繁，数据增长过快
Sleep(5000)
}
}
import math
import time
chart = {
"title": {"text": "line数值触发 plotLines 值"},
"yAxis": {
"plotLines": [{
"value": 0,
"color": "red",
"width": 2,
"label": {
"text": "触发值",
"align": "center"
}
}]
},
"xAxis": {"type": "datetime"},
"series": [{"name": "sin", "type": "spline", "data": []},
{"name": "cos", "type": "spline", "data": []}]
}
def main():
pi = 3.1415926535897
ts = 0
angle = 0
y = 0
objChart = Chart(chart)
objChart.reset()
chart["yAxis"]["plotLines"][0]["value"] = 1
while True:
ts = time.time() * 1000
y = math.sin(angle * 2 * pi / 360)
objChart.add(0, [ts, y])
y = math.cos(angle * 2 * pi / 360)
objChart.add(1, [ts, y])
angle += 5
Sleep(5000)
void main() {
json chart = R"({
"title": {"text": "line数值触发 plotLines 值"},
"yAxis": {
"plotLines": [{
"value": 0,
"color": "red",
"width": 2,
"label": {
"text": "触发值",
"align": "center"
}
}]
},
"xAxis": {"type": "datetime"},
"series": [{"name": "sin", "type": "spline", "data": []},
{"name": "cos", "type": "spline", "data": []}]
})"_json;
auto pi = 3.1415926535897;
auto ts = 0;
auto angle = 0.0;
auto y = 0.0;
auto objChart = Chart(chart);
objChart.reset();
chart["yAxis"]["plotLines"][0]["value"] = 1;
while(true) {
ts = Unix() * 1000;
y = sin(angle * 2 * pi / 360);
objChart.add(0, {ts, y});
y = cos(angle * 2 * pi / 360);
objChart.add(1, {ts, y});
angle += 5;
Sleep(5000);
}
}
त्रिभुज फ़ंक्शन के लिए रेखाचित्र उदाहरणः
/*backtest
start: 2020-03-11 00:00:00
end: 2020-04-09 23:59:00
period: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
var chartCfg = {
subtitle: {
text: "subtitle",
},
yAxis: [{
height: "40%",
lineWidth: 2,
title: {
text: 'PnL',
},
tickPixelInterval: 20,
minorGridLineWidth: 1,
minorTickWidth: 0,
opposite: true,
labels: {
align: "right",
x: -3,
}
}, {
title: {
text: 'Profit',
},
top: "42%",
height: "18%",
offset: 0,
lineWidth: 2
}, {
title: {
text: 'Vol',
},
top: '62%',
height: '18%',
offset: 0,
lineWidth: 2
}, {
title: {
text: 'Asset',
},
top: '82%',
height: '18%',
offset: 0,
lineWidth: 2
}],
series: [{
name: 'PnL',
data: [],
id: 'primary',
tooltip: {
xDateFormat: '%Y-%m-%d %H:%M:%S'
},
yAxis: 0
}, {
type: 'column',
lineWidth: 2,
name: 'Profit',
data: [],
yAxis: 1,
}, {
type: 'column',
name: 'Trade',
data: [],
yAxis: 2
}, {
type: 'area',
step: true,
lineWidth: 0,
name: 'Long',
data: [],
yAxis: 2
}, {
type: 'area',
step: true,
lineWidth: 0,
name: 'Short',
data: [],
yAxis: 2
}, {
type: 'line',
step: true,
color: '#5b4b00',
name: 'Asset',
data: [],
yAxis: 3
}, {
type: 'pie',
innerSize: '70%',
name: 'Random',
data: [],
center: ['3%', '6%'],
size: '15%',
dataLabels: {
enabled: false
},
startAngle: -90,
endAngle: 90,
}],
};
function main() {
let c = Chart(chartCfg);
let preTicker = null;
while (true) {
let t = exchange.GetTicker();
c.add(0, [t.Time, t.Last]); // PnL
c.add(1, [t.Time, preTicker ? t.Last - preTicker.Last : 0]); // profit
let r = Math.random();
var pos = parseInt(t.Time/86400);
c.add(2, [t.Time, pos/2]); // Vol
c.add(3, [t.Time, r > 0.8 ? pos : null]); // Long
c.add(4, [t.Time, r < 0.8 ? -pos : null]); // Short
c.add(5, [t.Time, Math.random() * 100]); // Asset
// update pie
chartCfg.series[chartCfg.series.length-1].data = [
["A", Math.random()*100],
["B", Math.random()*100],
];
c.update(chartCfg)
preTicker = t;
}
}
'''backtest
start: 2020-03-11 00:00:00
end: 2020-04-09 23:59:00
period: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''
import random
chartCfg = {
"subtitle": {
"text": "subtitle"
},
"yAxis": [{
"height": "40%",
"lineWidth": 2,
"title": {
"text": 'PnL'
},
"tickPixelInterval": 20,
"minorGridLineWidth": 1,
"minorTickWidth": 0,
"opposite": True,
"labels": {
"align": "right",
"x": -3
}
}, {
"title": {
"text": 'Profit'
},
"top": "42%",
"height": "18%",
"offset": 0,
"lineWidth": 2
}, {
"title": {
"text": 'Vol'
},
"top": '62%',
"height": '18%',
"offset": 0,
"lineWidth": 2
}, {
"title": {
"text": 'Asset'
},
"top": '82%',
"height": '18%',
"offset": 0,
"lineWidth": 2
}],
"series": [{
"name": 'PnL',
"data": [],
"id": 'primary',
"tooltip": {
"xDateFormat": '%Y-%m-%d %H:%M:%S'
},
"yAxis": 0
}, {
"type": 'column',
"lineWidth": 2,
"name": 'Profit',
"data": [],
"yAxis": 1
}, {
"type": 'column',
"name": 'Trade',
"data": [],
"yAxis": 2
}, {
"type": 'area',
"step": True,
"lineWidth": 0,
"name": 'Long',
"data": [],
"yAxis": 2
}, {
"type": 'area',
"step": True,
"lineWidth": 0,
"name": 'Short',
"data": [],
"yAxis": 2
}, {
"type": 'line',
"step": True,
"color": '#5b4b00',
"name": 'Asset',
"data": [],
"yAxis": 3
}, {
"type": 'pie',
"innerSize": '70%',
"name": 'Random',
"data": [],
"center": ['3%', '6%'],
"size": '15%',
"dataLabels": {
"enabled": False
},
"startAngle": -90,
"endAngle": 90
}]
}
def main():
c = Chart(chartCfg)
preTicker = None
while True:
t = exchange.GetTicker()
c.add(0, [t["Time"], t["Last"]])
profit = t["Last"] - preTicker["Last"] if preTicker else 0
c.add(1, [t["Time"], profit])
r = random.random()
pos = t["Time"] / 86400
c.add(2, [t["Time"], pos / 2])
long = pos if r > 0.8 else None
c.add(3, [t["Time"], long])
short = -pos if r < 0.8 else None
c.add(4, [t["Time"], short])
c.add(5, [t["Time"], random.random() * 100])
# update pie
chartCfg["series"][len(chartCfg["series"]) - 1]["data"] = [
["A", random.random() * 100],
["B", random.random() * 100]
]
c.update(chartCfg)
preTicker = t
/*backtest
start: 2020-03-11 00:00:00
end: 2020-04-09 23:59:00
period: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
void main() {
json chartCfg = R"({
"subtitle": {
"text": "subtitle"
},
"yAxis": [{
"height": "40%",
"lineWidth": 2,
"title": {
"text": "PnL"
},
"tickPixelInterval": 20,
"minorGridLineWidth": 1,
"minorTickWidth": 0,
"opposite": true,
"labels": {
"align": "right",
"x": -3
}
}, {
"title": {
"text": "Profit"
},
"top": "42%",
"height": "18%",
"offset": 0,
"lineWidth": 2
}, {
"title": {
"text": "Vol"
},
"top": "62%",
"height": "18%",
"offset": 0,
"lineWidth": 2
}, {
"title": {
"text": "Asset"
},
"top": "82%",
"height": "18%",
"offset": 0,
"lineWidth": 2
}],
"series": [{
"name": "PnL",
"data": [],
"id": "primary",
"tooltip": {
"xDateFormat": "%Y-%m-%d %H:%M:%S"
},
"yAxis": 0
}, {
"type": "column",
"lineWidth": 2,
"name": "Profit",
"data": [],
"yAxis": 1
}, {
"type": "column",
"name": "Trade",
"data": [],
"yAxis": 2
}, {
"type": "area",
"step": true,
"lineWidth": 0,
"name": "Long",
"data": [],
"yAxis": 2
}, {
"type": "area",
"step": true,
"lineWidth": 0,
"name": "Short",
"data": [],
"yAxis": 2
}, {
"type": "line",
"step": true,
"color": "#5b4b00",
"name": "Asset",
"data": [],
"yAxis": 3
}, {
"type": "pie",
"innerSize": "70%",
"name": "Random",
"data": [],
"center": ["3%", "6%"],
"size": "15%",
"dataLabels": {
"enabled": false
},
"startAngle": -90,
"endAngle": 90
}]
})"_json;
Chart c = Chart(chartCfg);
Ticker preTicker;
while(true) {
auto t = exchange.GetTicker();
c.add(0, {t.Time, t.Last});
auto profit = preTicker.Valid ? t.Last - preTicker.Last : 0;
c.add(1, {t.Time, profit});
auto r = rand() % 100;
auto pos = t.Time / 86400.0;
c.add(2, {t.Time, pos / 2.0});
auto longPos = r > 0.8 ? pos : NULL;
c.add(3, {t.Time, longPos});
auto shortPos = r < 0.8 ? -pos : NULL;
c.add(4, {t.Time, shortPos});
c.add(5, {t.Time, rand() % 100});
// update pie
json pie = R"([["A", 0], ["B", 0]])"_json;
pie[0][1] = rand() % 100;
pie[1][1] = rand() % 100;
chartCfg["series"][chartCfg["series"].size() - 1]["data"] = pie;
c.update(chartCfg);
preTicker = t;
}
}
मिश्रित चार्ट का उपयोग करके जटिल उदाहरणः
// update pie
chartCfg.series[chartCfg.series.length-1].data = [
["A", Math.random()*100],
["B", Math.random()*100],
];
c.update(chartCfg)
# update pie
chartCfg["series"][len(chartCfg["series"]) - 1]["data"] = [
["A", random.random() * 100],
["B", random.random() * 100]
]
c.update(chartCfg)
// update pie
json pie = R"([["A", 0], ["B", 0]])"_json;
pie[0][1] = rand() % 100;
pie[1][1] = rand() % 100;
chartCfg["series"][chartCfg["series"].size() - 1]["data"] = pie;
c.update(chartCfg);
चार्ट मेंpieप्रकार का ग्राफ कोई समयरेखा वाला ग्राफ नहीं है, और डेटा अपडेट होने पर ग्राफ कॉन्फ़िगरेशन को सीधे अपडेट करना आवश्यक है। उदाहरण के लिए, उपरोक्त उदाहरण में कोड, डेटा अपडेट होने के बाद उपयोग किया जाता हैc.update(chartCfg)एक नया चार्ट, जैसा कि नीचे दिखाया गया हैः
- 1、```update()```方法：
```update()```方法可以更新图表配置信息，该方法的参数为Chart图表配置对象（JSON）。
- 2、```del()```方法：
```del()```方法可以根据传入的series参数，删除指定索引的数据系列。
- 3、```add()```方法：
```add()```方法可以向图表中写入数据，参数依次为：
- ```series```：用于设置数据系列索引，是整数。
- ```data```：用于设置写入的具体数据，是一个数组。
- ```index```（可选）：用于设置数据索引，是整数。指定修改数据的具体索引位置，支持使用负数表示，设置为```-1```指数据集的最后一个数据。
例如画线时，修改线的最后一个点上的数据：```chart.add(0, [1574993606000, 13.5], -1)```，即更改图表```series[0].data```的倒数第一个点的数据。
不设置```index```参数表示向当前数据系列（series）最后添加数据。
- 4、```reset()```方法：
```reset()```方法用于清空图表数据，```reset()```方法可以带一个参数```remain```用于指定保留数据的条数。不传参数```remain```表示清除全部数据。
{@fun/Log/KLineChart KLineChart}
### KLineChart
该函数用于使用类似```Pine```语言的画图方式进行策略运行时的自定义画图。
图表对象。 ```KLineChart()```函数返回的图表对象有多个方法，其中需要注意```begin()```和```close()```， 在K线数据上遍历执行画图操作，画图操作中必须以```begin()```函数调用作为起始，以```close()```函数调用作为结束。
object
KLineChart(options)
```options```参数为图表配置。
options
true
object、object数组
```javascript
function main() {
// 调用KLineChart函数创建图表控制对象c
let c = KLineChart({
overlay: true
})
// 使用现货交易所对象测试，获取K线数据。如果使用期货交易所对象测试，需要先设置合约
let bars = exchange.GetRecords()
if (!bars) {
return
}
// 在K线数据上遍历执行画图操作，画图操作中必须以```c.begin(bar)```函数调用作为起始，以```c.close()```函数调用作为结束。
bars.forEach(function(bar, index) {
c.begin(bar)
c.barcolor(bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(0, 0, 0, 0.2)')
if (bar.Close > bar.Open) {
c.bgcolor('rgba(0, 255, 0, 0.5)')
}
let h = c.plot(bar.High, 'high')
let l = c.plot(bar.Low, 'low')
c.fill(h, l, {
color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0.2)'
})
c.hline(bar.High)
c.plotarrow(bar.Close - bar.Open)
c.plotshape(bar.Low, {
style: 'diamond'
})
c.plotchar(bar.Close, {
char: 'X'
})
c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
if (bar.Close > bar.Open) {
// long/short/closelong/closeshort
c.signal("long", bar.High, 1.5)
} else if (bar.Close < bar.Open) {
c.signal("closelong", bar.Low, 1.5)
}
c.close()
})
}
def main():
# 调用KLineChart函数创建图表控制对象c
c = KLineChart({
"overlay": True
})
# 使用现货交易所对象测试，获取K线数据。如果使用期货交易所对象测试，需要先设置合约
bars = exchange.GetRecords()
if not bars:
return
for bar in bars:
c.begin(bar)
c.barcolor('rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(0, 0, 0, 0.2)')
if bar.Close > bar.Open:
c.bgcolor('rgba(0, 255, 0, 0.5)')
h = c.plot(bar.High, 'high')
l = c.plot(bar.Low, 'low')
c.fill(h, l, 'rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(255, 0, 0, 0.2)')
c.hline(bar.High)
c.plotarrow(bar.Close - bar.Open)
c.plotshape(bar.Low, style = 'diamond')
c.plotchar(bar.Close, char = 'X')
c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
if bar.Close > bar.Open:
# long/short/closelong/closeshort
c.signal("long", bar.High, 1.5)
elif bar.Close < bar.Open:
c.signal("closelong", bar.Low, 1.5)
c.close()
// 暂不支持
यदि नीति में चित्र क्षेत्र चित्र को चित्र नियंत्रण ऑब्जेक्ट होना चाहिए, तो चित्र का उपयोग करेंKLineChart()फ़ंक्शन इस ऑब्जेक्ट को बनाता है.KLineChart()फ़ंक्शन के पैरामीटर एक चार्ट कॉन्फ़िगरेशन संरचना है, जिसका उपयोग संदर्भ कोड में किया जाता है।{overlay: true}◎ यह चार्ट कॉन्फ़िगरेशन संरचना केवल चित्र चित्र सामग्री को चार्ट मेजर पर आउटपुट करने के लिए सेट करती है, यदिoverlayएक फ़ोल्डर के रूप में सेट करें, उदाहरण के लिएःfalseयदि आप किसी ग्राफ फ़ंक्शन को निर्दिष्ट करना चाहते हैं, तो इसे मुख्य ग्राफ पर चित्रित किया जा सकता है।overlayवास्तविक मान के लिए, जैसेःtrue。
c.barcolor(bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(0, 0, 0, 0.2)') // 使用本例中参考代码中的例子说明，不再赘述
c.barcolor('rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(0, 0, 0, 0.2)')
// 暂不支持
ग्राफिक्स ऑपरेशन में समर्थितPineभाषा के चित्र इंटरफ़ेस फ़ंक्शन में शामिल हैंः
> barcolor(color, offset, editable, show_last, title, display)
> display参数可选："none", "all"
```javascript
c.bgcolor('rgba(0, 255, 0, 0.5)')
c.bgcolor('rgba(0, 255, 0, 0.5)')
// 暂不支持
> bgcolor(color, offset, editable, show_last, title, display, overlay)
> display参数可选："none", "all"
```javascript
c.plot(bar.High, 'high')
c.plot(bar.Open < bar.Close ? NaN : bar.Close, "Close", {style: "linebr"}) // 支持画不连续的数据线
h = c.plot(bar.High, 'high')
h = c.plot(None if bar.Open < bar.Close else bar.Close, "Close", style = "linebr") # 支持画不连续的数据线
// 暂不支持
> plot(series, title, color, linewidth, style, trackprice, histbase, offset, join, editable, show_last, display)
> style参数可选："stepline_diamond", "stepline", "cross", "areabr", "area", "circles", "columns", "histogram", "linebr", "line"
> display参数可选："none", "all"
```javascript
let h = c.plot(bar.High, 'high')
let l = c.plot(bar.Low, 'low')
c.fill(h, l, {color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0.2)'})
h = c.plot(bar.High, 'high')
l = c.plot(bar.Low, 'low')
c.fill(h, l, color = 'rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(255, 0, 0, 0.2)')
// 暂不支持
> fill(hline1, hline2, color, title, editable, fillgaps, display)
> display参数可选："none", "all"
由于```JavaScript```语言不能根据函数形参名称指定传入参数，为了解决这个问题可以使用一个```{key: value}```结构指定传入某个形参名称的参数，
例如参考代码中使用```{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0.2)'}```指定```fill```函数的```color```参数。
如果需要连续指定多个形参名称的参数，可以使用```{key1: value1, key2: value2, key3: value3}```。
例如本例子中增加指定一个```title```参数：```{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0.2)', title: 'fill'}```。
对于颜色值可以使用```'rgba(255, 0, 0, 0.2)'```方式设置，也可以使用```'#FF0000'```方式设置。
```javascript
c.hline(bar.High)
c.hline(bar.High)
// 暂不支持
> hline(price, title, color, linestyle, linewidth, editable, display)
> linestyle参数可选："dashed", "dotted", "solid"
> display参数可选："none", "all"
```javascript
c.plotarrow(bar.Close - bar.Open)
c.plotarrow(bar.Close - bar.Open)
// 暂不支持
> plotarrow(series, title, colorup, colordown, offset, minheight, maxheight, editable, show_last, display)
> display参数可选："none", "all"
```javascript
c.plotshape(bar.Low, {style: 'diamond'})
c.plotshape(bar.Low, style = 'diamond')
// 暂不支持
> plotshape(series, title, style, location, color, offset, text, textcolor, editable, size, show_last, display)
> style参数可选："diamond", "square", "label_down", "label_up", "arrow_down", "arrow_up", "circle", "flag", "triangle_down", "triangle_up", "cross", "xcross"
> location参数可选："abovebar", "belowbar", "top", "bottom", "absolute"
> size参数可选："10px", "14px", "20px", "40px", "80px"，对比Pine语言中的size.tiny、size.small、size.normal、size.large、size.huge
> size.auto即size.small。
> display参数可选："none", "all"
```javascript
c.plotchar(bar.Close, {char: 'X'})
c.plotchar(bar.Close, char = 'X')
// 暂不支持
> plotchar(series, title, char, location, color, offset, text, textcolor, editable, size, show_last, display)
> location参数可选："abovebar", "belowbar", "top", "bottom", "absolute"
> size参数可选："10px", "14px", "20px", "40px", "80px"，对比Pine语言中的size.tiny、size.small、size.normal、size.large、size.huge
> size.auto即size.small。
> display参数可选："none", "all"
```javascript
c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
// 暂不支持
> plotcandle(open, high, low, close, title, color, wickcolor, editable, show_last, bordercolor, display)
> display参数可选："none", "all"
```javascript
c.signal("long", bar.High, 1.5)
c.signal("long", bar.High, 1.5)
// 暂不支持
> signal(direction, price, qty, id)
传入的参数"long"表示交易方向，可选"long"、"closelong"、"short"、"closeshort"。传入的参数```bar.High```为标记信号的Y轴位置。
传入的参数1.5表示信号的交易数量。可以传入第四个参数用来替换默认画出的文本内容，画出的信号标记默认文本为交易方向，例如："closelong"。
```javascript
c.reset()
c.reset()
// 暂不支持
> reset(remain)
```reset()```方法可以带一个参数```remain```用于指定保留数据的条数。不传参数```remain```表示清除全部数据。
策略自定义画图只能使用```KLineChart()```函数的方式或者```Chart()```函数的方式中的一种。 ```KLineChart()```函数调用时用到的一些颜色、样式等设置，参看[使用KLineChart函数画图的专题文章](https://www.fmz.com/bbs-topic/9482)
{@fun/Log/Chart Chart}
### LogReset
清除日志。
LogReset(remain)
```remain```参数用于设置保留的最近日志条数。
remain
false
number
```javascript
function main() {
// 保留最近10条日志，清除其余日志
LogReset(10)
}
def main():
LogReset(10)
void main() {
LogReset(10);
}
नीति डिस्क के प्रत्येक आरंभ पर एक प्रारंभ लॉग की गणना की जाती है, इसलिए यदि कोई पैरामीटर नहीं दिया जाता है और नीति शुरू होने पर कोई लॉग आउटपुट नहीं होता है, तो लॉग पूरी तरह से प्रदर्शित नहीं होता है और प्रशासक लॉग रिलीज़ होने का इंतजार किया जाता है (यह असामान्य नहीं है) ।
{@fun/Log Log}, {@fun/Log/LogVacuum LogVacuum}
कॉल करने के लिए उपयोग किया जाता हैLogReset()फ़ंक्शन लॉग हटाता है, फिर रीसायकल करता हैएसक्यूलाइटडेटा हटाने के लिए स्टोरेज का उपयोग करना।
लॉगवैक्यूम
function main() {
LogReset()
LogVacuum()
}
def main():
LogReset()
LogVacuum()
void main() {
LogReset()
LogVacuum()
}
इसका कारण हैSQLiteडेटा को हटाने पर रिकवर नहीं किया गया स्थान, निष्पादित करने की आवश्यकता हैVACUUMसफाई तालिका, खाली स्थान. इस फ़ंक्शन को कॉल करते समय फ़ाइल स्थानांतरण ऑपरेशन होता है, देरी अधिक होती है, उचित समय अंतराल पर कॉल करने की सिफारिश की जाती है.
{@fun/Log/LogReset लॉग रीसेट}
डिस्क पृष्ठ पर "डिस्क सूचना" फ़ील्ड में डिस्क सूचना को आउटपुट करने के लिए प्रयोग किया जाता है; उदाहरण के लिए डिस्क आईडी123456，console.logफ़ंक्शन डिस्क पृष्ठ पर डिबगिंग जानकारी आउटपुट करता है और साथ ही डिस्क के होस्ट निर्देशिका में/logs/storage/123456/एक एक्सटेंशन बनाने के लिए.logलॉग फ़ाइलों में लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिए लॉग फ़ाइलों के लिएstdout_。
कंसोल.लॉग ((...msgs)
पैरामीटरmsgआउटपुट के लिए सामग्री, पैरामीटरmsgकई संदेश भेजे जा सकते हैं।
msg
गलत
string, number, bool, object, array, null आदि सिस्टम समर्थित किसी भी प्रकार
function main() {
console.log("test console.log")
}
# 不支持
// 不支持
JavaScriptभाषा इस फ़ंक्शन का समर्थन करती है।[object Object]इस प्रकार, हम अपने उपयोगकर्ताओं को एक अच्छी जानकारी प्रदान करते हैं, इसलिए जितना संभव हो उतना पठनीय जानकारी निकालें।{@fun/Log/console.error console.error} {@fun/Log/console.error} {@fun/Log/console.error} {@fun/Log/console.error} {@error.console.error} {@error.console.error} {@error.console.error} {@error.console.error}
वास्तविक डिस्क पृष्ठ पर "डिबग सूचना" बॉक्स में गलत आउटपुट के लिए प्रयोग किया जाता है. उदाहरण के लिए, वास्तविक डिस्क आईडी123456，console.errorफ़ंक्शन फ़र्स्ट डिस्क पृष्ठ पर त्रुटि आउटपुट करता है जबकि फ़र्स्ट डिस्क के होस्ट निर्देशिका में/logs/storage/123456/एक एक्सटेंशन बनाने के लिए.logलॉग फ़ाइलों में गलत आउटपुट लिखा गया है, फ़ाइल शीर्षक के साथstderr_。
कंसोल.त्रुटि ((...msgs)
पैरामीटरmsgआउटपुट के लिए सामग्री, पैरामीटरmsgकई संदेश भेजे जा सकते हैं।
msg
गलत
string, number, bool, object, array, null आदि सिस्टम समर्थित किसी भी प्रकार
function main() {
console.error("test console.error")
}
# 不支持
// 不支持
JavaScriptभाषा इस फ़ंक्शन का समर्थन करती है।[object Object]इस प्रकार, हम अपने उपयोगकर्ताओं को एक अच्छी जानकारी प्रदान करते हैं, इसलिए जितना संभव हो उतना पठनीय जानकारी निकालें।{@fun/Log/console.log कंसोल.log}
वर्तमान में सेट किए गए लेन-देन जोड़े, अनुबंध कोड के अनुरूप वस्तुओं या अनुबंध के {@struct/Ticker Ticker} संरचनाओं, यानी लेन-देन डेटा को प्राप्त करें।GetTicker()फ़ंक्शन एक सदस्य फ़ंक्शन है जो एक एक्सचेंज ऑब्जेक्ट {@var/EXCHANGE exchange} के सदस्य है।exchangeऑब्जेक्ट के सदस्य फ़ंक्शन ((प्रणाली) का उपयोग केवल और केवलexchangeइस संबंध में, दस्तावेजों के बाद कोई चर्चा नहीं होगी।
{@struct/Ticker Ticker}、空值
exchange.GetTicker()
exchange.GetTicker(symbol)
参数```symbol```用于指定请求的{@struct/Ticker Ticker}数据对应的具体交易对、合约代码。不传该参数时默认请求当前设置的交易对、合约代码的行情数据。
当调用```exchange.GetTicker(symbol)```函数时，```exchange```为现货交易所对象，如果需要请求获取计价币种为USDT，交易币种为BTC的行情数据。参数```symbol```为：```"BTC_USDT"```，格式为FMZ平台定义的交易对格式。
当调用```exchange.GetTicker(symbol)```函数时，```exchange```为期货交易所对象，如果需要请求获取的是BTC的U本位永续合约的行情数据。参数```symbol```为：```"BTC_USDT.swap"```，格式为FMZ平台定义的**交易对**与**合约代码**组合，再以字符"."间隔。
当调用```exchange.GetTicker(symbol)```函数时，```exchange```为期货交易所对象，如果需要请求获取的是BTC的U本位期权合约的行情数据。参数```symbol```为：```"BTC_USDT.BTC-240108-40000-C"```（以币安期权BTC-240108-40000-C为例），格式为FMZ平台定义的**交易对**与交易所定义的具体期权合约代码组合，再以字符"."间隔。
symbol
false
string
```javascript
function main(){
// 如果是期货交易所对象，先设置合约代码，例如设置为永续合约
// exchange.SetContractType("swap")
var ticker = exchange.GetTicker()
/*
可能由于网络原因，访问不到交易所接口（即使托管者程序所在设备能打开交易所网站，但是API接口也可能访问不通）
此时ticker为null，当访问ticker.High时，会导致错误，所以在测试该代码时，确保可以访问到交易所接口
*/
Log("Symbol:", ticker.Symbol, "High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Open:", ticker.Open, "Volume:", ticker.Volume)
}
def main():
ticker = exchange.GetTicker()
Log("Symbol:", ticker["Symbol"], "High:", ticker["High"], "Low:", ticker["Low"], "Sell:", ticker["Sell"], "Buy:", ticker["Buy"], "Last:", ticker["Last"], "Open:", ticker["Open"], "Volume:", ticker["Volume"])
void main() {
auto ticker = exchange.GetTicker();
Log("Symbol:", ticker.Symbol, "High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Open:", ticker.Open, "Volume:", ticker.Volume);
}
फ्यूचर्स एक्सचेंजों के लिएexchangeयाexchanges[0]), जो कि बाज़ार फ़ंक्शन को कॉल करने से पहले इस्तेमाल किया जाना चाहिएexchange.SetContractType()फ़ंक्शन कॉन्ट्रैक्ट कोड सेट करता है, दस्तावेज़ के बाद कोई और टिप्पणी नहीं करता है।
function main() {
var ticker = exchange.GetTicker("BTC_USDT")
Log(ticker)
}
def main():
ticker = exchange.GetTicker("BTC_USDT")
Log(ticker)
void main() {
auto ticker = exchange.GetTicker("BTC_USDT");
Log(ticker);
}
उपयोगsymbolपैरामीटर विशिष्ट किस्मों के लिए बाजार डेटा का अनुरोध करता है।
रीसेट सिस्टम मेंexchange.GetTicker()फ़ंक्शन लौटाता हैTickerडेटा, जिनमें सेHigh、Lowसमकक्ष मूल्य के लिए, उस समय की बिक्री, खरीद और बिक्री की वास्तविक कीमत से लिया जाता है।exchange.GetTicker()फ़ंक्शन लौटाता हैTickerडेटा, जिनमें सेHighऔरLowमूल्य पैकेजिंग के आधार पर एक्सचेंज हैTickइंटरफेस द्वारा लौटाए गए डेटा को निर्धारित करने के लिए, इन आंकड़ों में एक निश्चित अवधि (आमतौर पर 24 घंटे की अवधि) में उच्चतम और निम्नतम मूल्य शामिल हैं।
समर्थन नहींexchange.GetTicker()फ़ंक्शन के लिए एक्सचेंजः
| फ़ंक्शन का नाम | असमर्थित मुद्रा विनिमय | गैर-समर्थित फ्यूचर्स एक्सचेंज |
|---|---|---|
| GetTicker | – | फ्यूचर्स_एवो |
{@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange
वर्तमान में सेट किए गए लेनदेन जोड़े, अनुबंध कोड के अनुरूप स्टॉक या अनुबंध के {@struct/Depth Depth} संरचना, यानी ऑर्डर थिन डेटा को प्राप्त करें।
{@struct/Depth Depth}、空值
exchange.GetDepth()
exchange.GetDepth(symbol)
参数```symbol```用于指定请求的{@struct/Depth Depth}数据对应的具体交易对、合约代码。不传该参数时默认请求当前设置的交易对、合约代码的订单薄数据。 当调用```exchange.GetDepth(symbol)```函数时，```exchange```为现货交易所对象，如果需要请求获取计价币种为USDT，交易币种为BTC的订单薄数据。参数```symbol```为：```"BTC_USDT"```，格式为FMZ平台定义的交易对格式。 当调用```exchange.GetDepth(symbol)```函数时，```exchange```为期货交易所对象，如果需要请求获取的是BTC的U本位永续合约的订单薄数据。参数```symbol```为：```"BTC_USDT.swap"```，格式为FMZ平台定义的**交易对**与**合约代码**组合，再以字符"."间隔。 当调用```exchange.GetDepth(symbol)```函数时，```exchange```为期货交易所对象，如果需要请求获取的是BTC的U本位期权合约的订单薄数据。参数```symbol```为：```"BTC_USDT.BTC-240108-40000-C"```（以币安期权BTC-240108-40000-C为例），格式为FMZ平台定义的**交易对**与交易所定义的具体期权合约代码组合，再以字符"."间隔。
symbol
false
string
```javascript
function main(){
var depth = exchange.GetDepth()
/*
可能由于网络原因，访问不到交易所接口（即使托管者程序所在设备能打开交易所网站，但是API接口也可能访问不通）
此时depth为null，当访问depth.Asks[1].Price时，会导致错误，所以在测试该代码时，确保可以访问到交易所接口
*/
var price = depth.Asks[1].Price
Log("卖二价为:", price)
}
def main():
depth = exchange.GetDepth()
price = depth["Asks"][1]["Price"]
Log("卖二价为:", price)
void main() {
auto depth = exchange.GetDepth();
auto price = depth.Asks[1].Price;
Log("卖二价为:", price);
}
परीक्षणexchange.GetDepth()फ़ंक्शनः
function main() {
// BTC的U本位永续合约
var depth = exchange.GetDepth("BTC_USDT.swap")
Log(depth)
}
def main():
depth = exchange.GetDepth("BTC_USDT.swap")
Log(depth)
void main() {
auto depth = exchange.GetDepth("BTC_USDT.swap");
Log(depth);
}
जब विन्यस्तexchangeवस्तुओं के लिए उपयोग किया जाता है जब वस्तुओं के लिए वायदा एक्सचेंजsymbolपैरामीटर विशिष्ट किस्मों (फ्यूचर्स किस्मों) के लिए ऑर्डर थिन डेटा का अनुरोध करता है।
पुनर्मूल्यांकन प्रणाली में उपयोगएनालॉग-स्तरीय टिकपुनः परीक्षण करते समयexchange.GetDepth()फ़ंक्शन द्वारा लौटाए गए डेटा के सभी ग्रेड एनालॉग मान हैं।वास्तविक डिस्क Tickपुनः परीक्षण करते समयexchange.GetDepth()फ़ंक्शन द्वारा लौटाए गए डेटा सेकंड स्तर के गहराई के स्नैपशॉट हैं।
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.GetRecords exchange.GetRecords}
वर्तमान में सेट किए गए ट्रेड जोड़े, अनुबंध कोड के अनुरूप वस्तुओं या अनुबंधों के {@struct/Trade Trade} संरचनात्मक सरणी, यानी बाजार के लेनदेन डेटा को प्राप्त करें।
{@struct/Trade Trade}数组、空值
exchange.GetTrades()
exchange.GetTrades(symbol)
参数```symbol```用于指定请求的{@struct/Trade Trade}数组数据对应的具体交易对、合约代码。不传该参数时默认请求当前设置的交易对、合约代码的最近成交记录数据。 当调用```exchange.GetTrades(symbol)```函数时，```exchange```为现货交易所对象，如果需要请求获取计价币种为USDT，交易币种为BTC的订单薄数据。参数```symbol```为：```"BTC_USDT"```，格式为FMZ平台定义的交易对格式。 当调用```exchange.GetTrades(symbol)```函数时，```exchange```为期货交易所对象，如果需要请求获取的是BTC的U本位永续合约的订单薄数据。参数```symbol```为：```"BTC_USDT.swap"```，格式为FMZ平台定义的**交易对**与**合约代码**组合，再以字符"."间隔。 当调用```exchange.GetTrades(symbol)```函数时，```exchange```为期货交易所对象，如果需要请求获取的是BTC的U本位期权合约的订单薄数据。参数```symbol```为：```"BTC_USDT.BTC-240108-40000-C"```（以币安期权BTC-240108-40000-C为例），格式为FMZ平台定义的**交易对**与交易所定义的具体期权合约代码组合，再以字符"."间隔。
symbol
false
string
```javascript
function main(){
var trades = exchange.GetTrades()
/*
可能由于网络原因，访问不到交易所接口（即使托管者程序所在设备能打开交易所网站，但是API接口也可能访问不通）
此时trades为null，当访问trades[0].Id时，会导致错误，所以在测试该代码时，确保可以访问到交易所接口
*/
Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type)
}
def main():
trades = exchange.GetTrades()
Log("id:", trades[0]["Id"], "time:", trades[0]["Time"], "Price:", trades[0]["Price"], "Amount:", trades[0]["Amount"], "type:", trades[0]["Type"])
void main() {
auto trades = exchange.GetTrades();
Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type);
}
परीक्षणexchange.GetTrades()फ़ंक्शनः
function main() {
// BTC的U本位永续合约
var trades = exchange.GetTrades("BTC_USDT.swap")
Log(trades)
}
def main():
trades = exchange.GetTrades("BTC_USDT.swap")
Log(trades)
void main() {
auto trades = exchange.GetTrades("BTC_USDT.swap");
Log(trades);
}
जब विन्यस्तexchangeवस्तुओं के लिए उपयोग किया जाता है जब वस्तुओं के लिए वायदा एक्सचेंजsymbolपैरामीटर विशिष्ट किस्मों (फ्यूचर्स किस्मों) के लिए बाजार लेनदेन रिकॉर्ड डेटा का अनुरोध करता है।
回测系统中，使用**模拟级 Tick**回测时```exchange.GetTrades()```函数返回空数组。 回测系统中，使用**实盘级 Tick**回测时```exchange.GetTrades()```函数返回的数据为订单流快照数据，即{@struct/Trade Trade}结构数组。
不支持```exchange.GetTrades()```函数的交易所：
| 函数名 | 不支持的现货交易所 | 不支持的期货交易所 |
| - | - | - |
| GetTrades | -- | Futures_BitMart / Futures_Bibox |
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetRecords exchange.GetRecords}
### exchange.GetRecords
获取当前设置的交易对、合约代码对应的现货或者合约的{@struct/Record Record}结构数组，即K线数据。
```exchange.GetRecords()```函数请求数据成功时返回{@struct/Record Record}结构数组，请求数据失败时返回空值。
{@struct/Record Record}数组、空值
exchange.GetRecords()
exchange.GetRecords(symbol)
exchange.GetRecords(symbol, period)
exchange.GetRecords(symbol, period, limit)
exchange.GetRecords(period)
exchange.GetRecords(period, limit)
参数```symbol```用于指定请求的{@struct/Record Record}数组数据对应的具体交易对、合约代码。不传该参数时默认请求当前设置的交易对、合约代码的K线数据。 当调用```exchange.GetRecords(symbol)```函数时，```exchange```为现货交易所对象，如果需要请求获取计价币种为USDT，交易币种为BTC的数据。参数```symbol```为：```"BTC_USDT"```，格式为FMZ平台定义的交易对格式。 当调用```exchange.GetRecords(symbol)```函数时，```exchange```为期货交易所对象，如果需要请求获取的是BTC的U本位永续合约的订单薄数据。参数```symbol```为：```"BTC_USDT.swap"```，格式为FMZ平台定义的**交易对**与**合约代码**组合，再以字符"."间隔。 当调用```exchange.GetRecords(symbol)```函数时，```exchange```为期货交易所对象，如果需要请求获取的是BTC的U本位期权合约的订单薄数据。参数```symbol```为：```"BTC_USDT.BTC-240108-40000-C"```（以币安期权BTC-240108-40000-C为例），格式为FMZ平台定义的**交易对**与交易所定义的具体期权合约代码组合，再以字符"."间隔。
symbol
false
string
参数```period```指定请求的K线数据的周期，例如：{@var/PERIOD/PERIOD_M1 PERIOD_M1}，{@var/PERIOD/PERIOD_M5 PERIOD_M5}，{@var/PERIOD/PERIOD_M15 PERIOD_M15}等；参数```period```的值除了可以传定义的标准周期，还可以传入整数数值，单位为秒。 不传该参数时默认请求的K线数据的周期为当前策略实盘/回测配置的默认K线周期。
period
false
number
参数```limit```用于指定请求的K线数据的长度，不传该参数时默认请求长度为交易所K线接口的单次最大请求K线柱数量；该参数可能会引起分页查询交易所K线数据，分页查询时该函数调用耗时会增加。
limit
false
number
```javascript
function main() {
// 打印K线周期为120秒（2分钟）的K线数据
Log(exchange.GetRecords(60 * 2))
// 打印K线周期为5分钟的K线数据
Log(exchange.GetRecords(PERIOD_M5))
}
def main():
Log(exchange.GetRecords(60 * 2))
Log(exchange.GetRecords(PERIOD_M5))
void main() {
Log(exchange.GetRecords(60 * 2)[0]);
Log(exchange.GetRecords(PERIOD_M5)[0]);
}
कस्टम चक्र के लिए के-लाइन डेटा प्राप्त करें।
function main() {
var records = exchange.GetRecords(PERIOD_H1)
/*
可能由于网络原因，访问不到交易所接口（即使托管者程序所在设备能打开交易所网站，但是API接口也可能访问不通）
此时records为null，当访问records[0].Time时，会导致错误，所以在测试该代码时，确保可以访问到交易所接口
*/
Log("第一根k线数据为，Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High)
Log("第二根k线数据为，Time:", records[1].Time ,"Close:", records[1].Close)
Log("当前K线（最新）", records[records.length-1], "上一根K线", records[records.length-2])
}
def main():
records = exchange.GetRecords(PERIOD_H1)
Log("第一根k线数据为，Time:", records[0]["Time"], "Open:", records[0]["Open"], "High:", records[0]["High"])
Log("第二根k线数据为，Time:", records[1]["Time"], "Close:", records[1]["Close"])
Log("当前K线（最新）", records[-1], "上一根K线", records[-2])
void main() {
auto records = exchange.GetRecords(PERIOD_H1);
Log("第一根k线数据为，Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High);
Log("第二根k线数据为，Time:", records[1].Time, "Close:", records[1].Close);
Log("当前K线（最新）", records[records.size() - 1], "上一根K线", records[records.size() - 2]);
}
आउटपुट K-लाइन स्तंभ डेटाः
function main() {
var records = exchange.GetRecords("BTC_USDT.swap", 60, 100)
Log(records)
}
def main():
records = exchange.GetRecords("BTC_USDT.swap", 60, 100)
Log(records)
void main() {
auto records = exchange.GetRecords("BTC_USDT.swap", 60, 100);
Log(records);
}
जब विन्यस्तexchangeवस्तुओं के लिए उपयोग किया जाता है जब वस्तुओं के लिए वायदा एक्सचेंजsymbol、period、limitपैरामीटर विशिष्ट किस्मों (फ्यूचर्स किस्मों) के लिए K-लाइन डेटा का अनुरोध करता है।
डिफ़ॉल्ट K-लाइन चक्र पुनः परीक्षण में, डिस्क पृष्ठ सेट किया जा सकता है, यदि कॉल किया जा रहा हैexchange.GetRecords()जब फ़ंक्शन पैरामीटर निर्दिष्ट करता है, तो यह उस पैरामीटर चक्र के लिए K-रेखा डेटा प्राप्त करता है। यदि फ़ंक्शन कॉल पर कोई पैरामीटर निर्दिष्ट नहीं किया गया है, तो यह वास्तविक डिस्क पैरामीटर पर सेट किए गए K-रेखा चक्र के अनुसार K-रेखा डेटा लौटाता है।
यह लौटाता हैRecordस्ट्रक्चरल सरणी, लौटाया गया K-रेखा डेटा समय के साथ संचयी होता है, संचयी K-रेखा स्तंभों की संख्या के ऊपर की सीमा के अधीन होता हैexchange.SetMaxBarLen()फ़ंक्शन सेटिंग्स का प्रभाव, जब सेट नहीं किया जाता है तो डिफ़ॉल्ट रूप से 5000 के-लाइन कॉलम तक सीमित होता है। जब के-लाइन डेटा के-लाइन कॉलम की संचयी सीमा तक पहुंचता है, तो एक के-लाइन कॉलम को जोड़ने के साथ-साथ सबसे पहले के-लाइन कॉलम को हटाने के लिए अपडेट किया जाता है ((जैसे कि कतार में प्रवेश करना) । कुछ एक्सचेंजों में के-लाइन इंटरफ़ेस उपलब्ध नहीं है, इसलिए संरक्षक वास्तविक समय में बाजार लेनदेन रिकॉर्डिंग डेटा एकत्र करते हैं।Tradeस्ट्रक्चरल सरणी) K लाइन उत्पन्न करता है।
यदि एक्सचेंज के के-लाइन इंटरफेस में पृष्ठ विभाजन क्वेरी का समर्थन किया जाता है, तो कॉल करने परexchange.SetMaxBarLen()जब फ़ंक्शन एक बड़ी K-लाइन लंबाई सेट करता है, तो कई एपीआई अनुरोध किए जाते हैं।
प्रारंभिक कॉलexchange.GetRecords()फ़ंक्शन के समय, प्राप्त किए गए K-लाइन स्तंभों की संख्या पुनः परीक्षण और वास्तविक डिस्क पर भिन्न होती हैः - पुनः परीक्षण प्रणाली में, पुनः परीक्षण समय सीमा शुरू होने के समय से पहले K-लाइन स्तंभों की एक निश्चित संख्या (डिफ़ॉल्ट रूप से 5000, पुनः परीक्षण प्रणाली की सेटिंग, डेटा की मात्रा अंतिम रिटर्न की संख्या को प्रभावित करेगी) को प्रारंभिक K-लाइन डेटा के रूप में प्राप्त किया जाता है। - वास्तविक डिस्क पर प्राप्त किए गए K-लाइन स्तंभों की संख्या एक्सचेंज के K-लाइन इंटरफ़ेस द्वारा प्राप्त किए जाने वाले अधिकतम डेटा के आधार पर निर्धारित की जाती है।
回测系统中模拟级别回测由于需要设置底层K线周期（回测系统模拟级别回测时，根据设置的底层K线周期使用对应的K线数据生成Tick数据）， 需要注意在策略中获取的K线数据的周期不能小于底层K线周期。因为在模拟级别回测中，各个周期的K线数据在回测系统中都是通过底层K线周期对应的K线数据合成的。
```C++```语言中如果需要自己构造K线数据有以下代码范例：
#include
void main (() {
Records r;
r.Valid = true;
for (auto i = 0; i < 10; i++) {
Record ele;
ele.Time = i * 100000;
ele.High = i * 10000;
ele.Low = i * 1000;
ele.Close = i * 100;
ele.Open = i * 10;
ele.Volume = i * 1;
r.push_back ((ele);
}
// आउटपुट प्रदर्शित करता हैः रिकॉर्ड्स[10]
लॉग®;
ऑटो मा = TA.MA(r,10);
// आउटपुट दिखाता हैः [nan,nan,nan,nan,nan,nan,nan,nan,nan,nan,nan,nan, 450]
Log ((ma);
}
不支持```exchange.GetRecords()```函数的交易所：
| 函数名 | 不支持的现货交易所 | 不支持的期货交易所 |
| - | - | - |
| GetRecords | Zaif / Coincheck / BitFlyer | Futures_Aevo |
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.SetMaxBarLen exchange.SetMaxBarLen}
### exchange.GetPeriod
获取回测、实盘运行策略时在发明者量化交易平台网站页面上设置的K线周期，即调用```exchange.GetRecords()```函数不传参数时使用的默认K线周期。
K线周期秒数，整数数值，单位为秒。
number
exchange.GetPeriod()
```javascript
function main() {
// 例如回测、实盘时发明者量化交易平台网站页面上设置的K线周期为1小时
var period = exchange.GetPeriod()
Log("K线周期：", period / (60 * 60), "小时")
}
def main():
period = exchange.GetPeriod()
Log("K线周期：", period / (60 * 60), "小时")
void main() {
auto period = exchange.GetPeriod();
Log("K线周期：", period / (60 * 60.0), "小时");
}
{@मज़ा/बाजार/विनिमय.GetRecordsविनिमय.GetRecords}
K लाइन की अधिकतम लंबाई सेट करें.
विनिमय.SetMaxBarLen ((n)
पैरामीटरnअधिकतम K लाइन की लंबाई निर्दिष्ट करने के लिए प्रयोग किया जाता है.
n
सच
संख्या
function main() {
exchange.SetMaxBarLen(50)
var records = exchange.GetRecords()
Log(records.length, records)
}
def main():
exchange.SetMaxBarLen(50)
r = exchange.GetRecords()
Log(len(r), r)
void main() {
exchange.SetMaxBarLen(50);
auto r = exchange.GetRecords();
Log(r.size(), r[0]);
}
- 影响第一次调用时获取K线的线柱（Bar）数量。
- 影响K线线柱（Bar）上限数量。
{@fun/Market/exchange.GetRecords exchange.GetRecords}
### exchange.GetRawJSON
获取当前交易所对象（{@var/EXCHANGE exchange}、{@var/EXCHANGE/exchanges exchanges}）最近一次```rest```请求返回的原始内容。
```rest```请求的应答数据。
string
exchange.GetRawJSON()
```javascript
function main(){
exchange.GetAccount();
var obj = JSON.parse(exchange.GetRawJSON());
Log(obj);
}
import json
def main():
exchange.GetAccount()
obj = json.loads(exchange.GetRawJSON())
Log(obj)
void main() {
auto obj = exchange.GetAccount();
// C++ 不支持GetRawJSON函数
Log(obj);
}
{@var/EXCHANGE exchange}
### exchange.GetRate
获取交易所对象当前设置的汇率。
交易所对象当前的汇率值。
number
exchange.GetRate()
```javascript
function main(){
Log(exchange.GetTicker())
// 设置汇率转换
exchange.SetRate(7)
Log(exchange.GetTicker())
Log("当前汇率：", exchange.GetRate())
}
def main():
Log(exchange.GetTicker())
exchange.SetRate(7)
Log(exchange.GetTicker())
Log("当前汇率：", exchange.GetRate())
void main() {
Log(exchange.GetTicker());
exchange.SetRate(7);
Log(exchange.GetTicker());
Log("当前汇率：", exchange.GetRate());
}
यदि कोई कॉल नहीं हैexchange.SetRate()यह एक बहुत ही अच्छा तरीका है कि आप अपने जीवन को बदल सकते हैं।exchange.GetRate()फ़ंक्शन का डिफ़ॉल्ट विनिमय दर 1 है, जिसका अर्थ है कि वर्तमान में दिखाए गए उद्धरण मुद्रा के लिए कोई विनिमय दर रूपांतरण नहीं हुआ है।
अगर इस्तेमाल कियाexchange.SetRate()एक विनिमय मान सेट करें, जैसे किexchange.SetRate(7), तो पारितexchangeइस एक्सचेंज के ऑब्जेक्ट द्वारा प्राप्त सभी मूल्य जानकारी जैसे कि बाजार, गहराई, ऑर्डर की कीमत, सेट किए गए विनिमय दर से गुणा की जाती है7यह एक बहुत ही अच्छा तरीका है।
अगरexchangeइसके विपरीत, एक एक्सचेंज जो डॉलर के रूप में मुद्रा को उद्धृत करता है, कॉल करता हैexchange.SetRate(7)और फिर, सभी वास्तविक कीमतों को गुणा किया जाएगा।7CNY के करीब मूल्य में परिवर्तित करें.exchange.GetRate()और यह एक बहुत ही अच्छा मूल्य है।7。
{@fun/Trade/exchange.SetRate exchange.SetRate}
参数```value```JSON编码后的字符串长度。
number
exchange.SetData(key, value)
数据集合名称。
key
true
string
```exchange.SetData()```函数所要加载的数据，数据结构为数组。数据结构与```exchange.GetData()```函数请求外部数据时所要求的数据格式相同，即：```"schema": ["time", "data"]```。
value
true
array
```javascript
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
var data = [
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
exchange.SetData("test", data)
while(true) {
Log(exchange.GetData("test"))
Sleep(1000)
}
}
'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''
def main():
data = [
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
exchange.SetData("test", data)
while True:
Log(exchange.GetData("test"))
Sleep(1000)
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
void main() {
json data = R"([
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
])"_json;
exchange.SetData("test", data);
while(true) {
Log(exchange.GetData("test"));
Sleep(1000);
}
}
पैरामीटर का अनुरोध करेंvalueडेटा प्रारूप निम्न उदाहरण में हैdataचर, आप देख सकते हैं कि समय की लहर1579622400000समय के लिए2020-01-22 00:00:00और जब यह चलाया जाता है, तो यह अगले डेटा बार के लिए एक समय चिप है.1579708800000समय2020-01-23 00:00:00पहले, कॉल करेंexchange.GetData()फ़ंक्शन डेटा प्राप्त करता है.[1579622400000, 123]इस डेटा की सामग्री, समय के साथ बदलती है, जैसे कि प्रोग्राम चल रहा है, इस तरह से डेटा प्राप्त करने के लिए। निम्नलिखित उदाहरणों में, जब चल रहा है (रीसेट या वास्तविक डिस्क), वर्तमान समय तक पहुंचता है या अधिक हो जाता है।1579795200000जब समय निकलता है, तो कॉल करेंexchange.GetData()एक फ़ंक्शन, जो कि एक मान लौटाता हैः{"Time":1579795200000,"Data":["abc",123,{"price":123}]}。 "Time":1579795200000संबंधित डेटा[1579795200000, ["abc", 123, {"price": 123}]]अंदर1579795200000。 "Data":["abc",123,{"price":123}]संबंधित डेटा[1579795200000, ["abc", 123, {"price": 123}]]अंदर["abc", 123, {"price": 123}]。
अपलोड किए गए डेटा किसी भी आर्थिक संकेतकों, उद्योग डेटा, संबंधित सूचकांक आदि हो सकते हैं, जो रणनीतिक रूप से सभी मात्रात्मक जानकारी को मापने के लिए उपयोग किए जाते हैं।
{@मज़ा/बाजार/विनिमय.GetData विनिमय.GetData}
数据集合中的记录。
object
exchange.GetData(key)
exchange.GetData(key, timeout)
数据集合名称。
key
true
string
用于设置缓存超时，单位为毫秒。实盘时默认为一分钟缓存超时。
timeout
false
number
```javascript
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
exchange.SetData("test", [[1579536000000, _D(1579536000000)], [1579622400000, _D(1579622400000)], [1579708800000, _D(1579708800000)]])
while(true) {
Log(exchange.GetData("test"))
Sleep(1000 * 60 * 60 * 24)
}
}
'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''
def main():
exchange.SetData("test", [[1579536000000, _D(1579536000000/1000)], [1579622400000, _D(1579622400000/1000)], [1579708800000, _D(1579708800000/1000)]])
while True:
Log(exchange.GetData("test"))
Sleep(1000 * 60 * 60 * 24)
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
void main() {
json arr = R"([[1579536000000, ""], [1579622400000, ""], [1579708800000, ""]])"_json;
arr[0][1] = _D(1579536000000);
arr[1][1] = _D(1579622400000);
arr[2][1] = _D(1579708800000);
exchange.SetData("test", arr);
while(true) {
Log(exchange.GetData("test"));
Sleep(1000 * 60 * 60 * 24);
}
}
एक बार जब आप अपने डेटा को सीधे लिखते हैं, तो इसे कॉल करने का तरीका।
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
while(true) {
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
Sleep(1000)
}
}
'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''
def main():
while True:
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
Sleep(1000)
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
void main() {
while(true) {
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
Sleep(1000);
}
}
बाहरी लिंक के माध्यम से अनुरोधित डेटा का समर्थन करें, अनुरोधित डेटा प्रारूपः
{
"schema":["time","data"],
"data":[
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
}
इनमें सेschemaडेटा विषय में लोड किए जाने वाले प्रत्येक रिकॉर्ड के लिए डेटा प्रारूप, जो कि["time","data"]मेल खाता हैdataगुणों में बार-बार डेटा का प्रारूप।
测试用的服务程序，使用Go语言编写：
```golang
package main
import (
"fmt"
"net/http"
"encoding/json"
)
func Handle (w http.ResponseWriter, r *http.Request) {
defer func() {
fmt.Println("req:", *r)
ret := map[string]interface{}{
"schema": []string{"time","data"},
"data": []interface{}{
[]interface{}{1579536000000, "abc"},
[]interface{}{1579622400000, 123},
[]interface{}{1579708800000, map[string]interface{}{"price":123}},
[]interface{}{1579795200000, []interface{}{"abc", 123, map[string]interface{}{"price":123}}},
},
}
b, _ := json.Marshal(ret)
w.Write(b)
}()
}
func main () {
fmt.Println("listen http://localhost:9090")
http.HandleFunc("/data", Handle)
http.ListenAndServe(":9090", nil)
}
अनुरोध प्राप्त करने के बाद प्रोग्राम का प्रतिक्रिया डेटाः
{
"schema":["time","data"],
"data":[
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
}
परीक्षण रणनीति कोडः
function main() {
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))
}
def main():
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))
void main() {
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"));
}
बाहरी लिंक से डेटा प्राप्त करने के लिए कॉल करने का तरीका।
function main() {
Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data")) // 链接中xxx部分为查询的数据的编码，此处xxx为举例
}
def main():
Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"))
void main() {
Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"));
}
अनुरोधडाटाडेटाप्लेटफॉर्म पर बनाए गए क्वेरी डेटा का उत्तर देने के लिए कहा गया डेटा प्रारूप है ((time, data फ़ील्ड में वर्णित होना चाहिए):
{
"data": [],
"schema": ["time", "data"]
}
इसमें, डेटा तालिका तालिका में आवश्यक डेटा सामग्री है, और तालिका तालिका में डेटा तालिका तालिका में सहमत होना चाहिए; जब कॉल किया जाता हैexchange.GetData()फ़ंक्शन एक JSON ऑब्जेक्ट देता है, जैसेः{"Time":1579795200000, "Data":"..."}。
पुनः परीक्षण के समय एक बार डेटा प्राप्त किया जाता है, वास्तविक समय में एक मिनट का डेटा कैश किया जाता है। पुनः परीक्षण प्रणाली में, जब एक्सेस इंटरफेस अनुरोध डेटा का उपयोग किया जाता है, तो पुनः परीक्षण प्रणाली स्वचालित रूप से अनुरोध में वृद्धि करती हैfrom(घंटे के लिए सेकंड)to(घंटे के लिए सेकंड)period(नीचे के लाइन चक्र, समय टोकन मिलीसेकंड) जैसे पैरामीटर डेटा प्राप्त करने के लिए समय सीमा निर्धारित करने के लिए उपयोग किए जाते हैं।
{@मज़ा/बाजार/विनिमय.सेटडेटा विनिमय.सेटडेटा}
包含{@struct/Market Market}结构体的字典。
object
exchange.GetMarkets()
```javascript
function main() {
var markets = exchange.GetMarkets()
var currency = exchange.GetCurrency()
// 获取当前合约代码也可以用exchange.GetContractType()函数
var ct = "swap"
var key = currency + "." + ct
Log(key, ":", markets[key])
}
def main():
markets = exchange.GetMarkets()
currency = exchange.GetCurrency()
ct = "swap"
key = currency + "." + ct
Log(key, ":", markets[key])
void main() {
auto markets = exchange.GetMarkets();
auto currency = exchange.GetCurrency();
auto ct = "swap";
auto key = currency + "." + ct;
Log(key, ":", markets[key]);
}
भविष्य के एक्सचेंजों के ऑब्जेक्ट के लिए कॉल उदाहरणः
/*backtest
start: 2023-05-10 00:00:00
end: 2023-05-20 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
var tbl1 = {
type: "table",
title: "markets1",
cols: ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
rows: []
}
var markets1 = exchange.GetMarkets()
for (var key in markets1) {
var market = markets1[key]
tbl1.rows.push([key, market.Symbol, market.BaseAsset, market.QuoteAsset, market.TickSize, market.AmountSize, market.PricePrecision, market.AmountPrecision, market.MinQty, market.MaxQty, market.MinNotional, market.MaxNotional, market.CtVal])
}
for (var symbol of arrSymbol) {
exchange.GetTicker(symbol)
}
var tbl2 = {
type: "table",
title: "markets2",
cols: ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
rows: []
}
var markets2 = exchange.GetMarkets()
for (var key in markets2) {
var market = markets2[key]
tbl2.rows.push([key, market.Symbol, market.BaseAsset, market.QuoteAsset, market.TickSize, market.AmountSize, market.PricePrecision, market.AmountPrecision, market.MinQty, market.MaxQty, market.MinNotional, market.MaxNotional, market.CtVal])
}
LogStatus("`" + JSON.stringify([tbl1, tbl2]) + "`")
}
'''backtest
start: 2023-05-10 00:00:00
end: 2023-05-20 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
tbl1 = {
"type": "table",
"title": "markets1",
"cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
"rows": []
}
markets1 = exchange.GetMarkets()
for key in markets1:
market = markets1[key]
tbl1["rows"].append([key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]])
for symbol in arrSymbol:
exchange.GetTicker(symbol)
tbl2 = {
"type": "table",
"title": "markets2",
"cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
"rows": []
}
markets2 = exchange.GetMarkets()
for key in markets2:
market = markets2[key]
tbl2["rows"].append([key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]])
LogStatus("`" + json.dumps([tbl1, tbl2]) + "`")
/*backtest
start: 2023-05-10 00:00:00
end: 2023-05-20 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
json tbl1 = R"({
"type": "table",
"title": "markets1",
"cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
"rows": []
})"_json;
auto markets1 = exchange.GetMarkets();
for (auto& [key, market] : markets1.items()) {
json arrJson = {key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]};
tbl1["rows"].push_back(arrJson);
}
for (const auto& symbol : arrSymbol) {
exchange.GetTicker(symbol);
}
json tbl2 = R"({
"type": "table",
"title": "markets2",
"cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
"rows": []
})"_json;
auto markets2 = exchange.GetMarkets();
for (auto& [key, market] : markets2.items()) {
json arrJson = {key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]};
tbl2["rows"].push_back(arrJson);
}
json tbls = R"([])"_json;
tbls.push_back(tbl1);
tbls.push_back(tbl2);
LogStatus("`" + tbls.dump() + "`");
}
फ्यूचर्स एक्सचेंज के ऑब्जेक्ट का उपयोग करके रीसेट सिस्टम में कॉल करेंexchange.GetMarkets()फ़ंक्शन. किसी भी बाजार फ़ंक्शन को कॉल करने से पहले, GetMarkets केवल वर्तमान डिफ़ॉल्ट ट्रेडिंग जोड़े के बाजार डेटा को वापस करता है, और बाजार फ़ंक्शन को कॉल करने के बाद, सभी अनुरोधित किस्मों के बाजार डेटा को वापस करता है. निम्नलिखित परीक्षण उदाहरण देखेंः
```json
{
"BTC_USDT" : {...}, // 键值为Market结构
"LTC_USDT" : {...},
...
}
फ्यूचर्स कॉन्ट्रैक्ट एक्सचेंजों के लिए, क्योंकि एक किस्म में कई अनुबंध हो सकते हैं, जैसेःBTC_USDTइस तरह के सौदों के लिए, स्थायी अनुबंध, तिमाही अनुबंध आदि हैं।exchange.GetMarkets()फ़ंक्शन एक शब्दकोश को लौटाता है, जिसका कुंजी नाम लेनदेन जोड़े और अनुबंध कोड के संयोजन के रूप में है, जैसेः
{
"BTC_USDT.swap" : {...}, // 键值为Market结构
"BTC_USDT.quarter" : {...},
"LTC_USDT.swap" : {...},
...
}
exchange.GetMarkets()फ़ंक्शन वास्तविक डिस्क, पुनः परीक्षण प्रणाली का समर्थन करता है।exchange.GetMarkets()फ़ंक्शन केवल एक्सचेंजों के ऑनलाइन लेनदेन के लिए विविध बाजार जानकारी लौटाता है।exchange.GetMarkets()यह विकल्प अनुबंधों का समर्थन नहीं करता है।समर्थन नहींexchange.GetMarkets()फ़ंक्शन के लिए एक्सचेंजः
| फ़ंक्शन का नाम | असमर्थित मुद्रा विनिमय | गैर-समर्थित फ्यूचर्स एक्सचेंज |
|---|---|---|
| GetMarkets | कॉइनचेक / बिथम्ब / बिटफ्लायर | – |
{@struct/मार्केट मार्केट}
```exchange.GetTickers()```函数请求数据成功时返回{@struct/Ticker Ticker}结构数组，请求数据失败时返回空值。
{@struct/Ticker Ticker}数组、空值
exchange.GetTickers()
```javascript
function main() {
var tickers = exchange.GetTickers()
if (tickers && tickers.length > 0) {
Log("交易所中可交易品种个数：", tickers.length)
}
}
def main():
tickers = exchange.GetTickers()
if tickers and len(tickers) > 0:
Log("交易所中可交易品种个数：", len(tickers))
void main() {
auto tickers = exchange.GetTickers();
if (tickers.Valid && tickers.size() > 0) {
Log("交易所中可交易品种个数：", tickers.size());
}
}
कॉल करेंexchange.GetTickers()फ़ंक्शन, बाजार के आंकड़ों को एकत्र करने के लिए।
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"]
// 请求其它交易对行情数据之前，调用GetTickers
var tickers1 = exchange.GetTickers()
var tbl1 = {type: "table", title: "tickers1", cols: ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], rows: []}
for (var ticker of tickers1) {
tbl1.rows.push([ticker.Symbol, ticker.High, ticker.Open, ticker.Low, ticker.Last, ticker.Buy, ticker.Sell, ticker.Time, ticker.Volume])
}
// 请求其它交易对行情数据
for (var symbol of arrSymbol) {
exchange.GetTicker(symbol)
}
// 再次调用GetTickers
var tickers2 = exchange.GetTickers()
var tbl2 = {type: "table", title: "tickers2", cols: ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], rows: []}
for (var ticker of tickers2) {
tbl2.rows.push([ticker.Symbol, ticker.High, ticker.Open, ticker.Low, ticker.Last, ticker.Buy, ticker.Sell, ticker.Time, ticker.Volume])
}
LogStatus("`" + JSON.stringify([tbl1, tbl2]) + "`")
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"]
tickers1 = exchange.GetTickers()
tbl1 = {"type": "table", "title": "tickers1", "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], "rows": []}
for ticker in tickers1:
tbl1["rows"].append([ticker["Symbol"], ticker["High"], ticker["Open"], ticker["Low"], ticker["Last"], ticker["Buy"], ticker["Sell"], ticker["Time"], ticker["Volume"]])
for symbol in arrSymbol:
exchange.GetTicker(symbol)
tickers2 = exchange.GetTickers()
tbl2 = {"type": "table", "title": "tickers2", "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], "rows": []}
for ticker in tickers2:
tbl2["rows"].append([ticker["Symbol"], ticker["High"], ticker["Open"], ticker["Low"], ticker["Last"], ticker["Buy"], ticker["Sell"], ticker["Time"], ticker["Volume"]])
LogStatus("`" + json.dumps([tbl1, tbl2]) + "`")
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
json tickerToJson(const Ticker& ticker) {
json arrJson;
arrJson.push_back(ticker.Symbol);
arrJson.push_back(ticker.High);
arrJson.push_back(ticker.Open);
arrJson.push_back(ticker.Low);
arrJson.push_back(ticker.Last);
arrJson.push_back(ticker.Buy);
arrJson.push_back(ticker.Sell);
arrJson.push_back(ticker.Time);
arrJson.push_back(ticker.Volume);
return arrJson;
}
void main() {
std::string arrSymbol[] = {"ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"};
auto tickers1 = exchange.GetTickers();
json tbl1 = R"({
"type": "table",
"cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"],
"rows": []
})"_json;
tbl1["title"] = "tickers1";
for (const auto& ticker : tickers1) {
json arrJson = tickerToJson(ticker);
tbl1["rows"].push_back(arrJson);
}
for (const std::string& symbol : arrSymbol) {
exchange.GetTicker(symbol);
}
auto tickers2 = exchange.GetTickers();
json tbl2 = R"({
"type": "table",
"cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"],
"rows": []
})"_json;
tbl2["title"] = "tickers2";
for (const auto& ticker : tickers2) {
json arrJson = tickerToJson(ticker);
tbl2["rows"].push_back(arrJson);
}
json tbls = R"([])"_json;
tbls.push_back(tbl1);
tbls.push_back(tbl2);
LogStatus("`" + tbls.dump() + "`");
}
रिस्क सिस्टम में कॉल करने के लिए वस्तुओं का उपयोग करेंexchange.GetTickers()फ़ंक्शन: किसी भी फ़ंक्शन को कॉल करने से पहले, GetTickers केवल वर्तमान डिफ़ॉल्ट लेनदेन जोड़े के टिकर डेटा को वापस करता है, और फ़ंक्शन को कॉल करने के बाद, सभी अनुरोधित किस्मों के टिकर डेटा को वापस करता है। निम्नलिखित परीक्षण उदाहरण देखेंः
समर्थन नहींexchange.GetTickers()फ़ंक्शन के लिए एक्सचेंजः
| फ़ंक्शन का नाम | असमर्थित मुद्रा विनिमय | गैर-समर्थित फ्यूचर्स एक्सचेंज |
|---|---|---|
| GetTickers | Zaif / WOO / Gemini / Coincheck / BitFlyer / Bibox | फ्यूचर्स_WOO / फ्यूचर्स_डीवाईडीएक्स / फ्यूचर्स_डेरबिट / फ्यूचर्स_बिबॉक्स / फ्यूचर्स_एवो |
{@struct/TickerTicker}, {@fun/Market/exchange.GetTicker एक्सचेंज.GetTicker}
下单成功返回订单Id，下单失败返回空值。
FMZ平台的订单{@struct/Order Order}结构的属性```Id```由交易所品种代码和交易所原始订单Id组成，以英文逗号间隔。例如OKX交易所的现货交易对```ETH_USDT```订单的属性```Id```格式为：```ETH-USDT,1547130415509278720```。
调用```exchange.Buy()```函数下单时，返回值订单```Id```与订单{@struct/Order Order}结构的```Id```属性一致。
string、空值
exchange.Buy(price, amount)
exchange.Buy(price, amount, ...args)
```price```参数用于设置订单价格。
price
true
number
```amount```参数用于设置订单量。
amount
true
number
扩展参数，可以输出附带信息到这条下单日志中，```arg```参数可以传多个。
arg
false
string、number、bool、object、array、空值等系统支持的任意类型
```javascript
function main() {
var id = exchange.Buy(100, 1);
Log("id:", id);
}
def main():
id = exchange.Buy(100, 1)
Log("id:", id)
void main() {
auto id = exchange.Buy(100, 1);
Log("id:", id);
}
```javascript
// 以下为错误调用
function main() {
exchange.SetContractType("quarter")
// 设置做空方向
exchange.SetDirection("sell")
// 下买单，会报错，做空只能卖出
var id = exchange.Buy(50, 1)
// 设置做多方向
exchange.SetDirection("buy")
// 下卖单，会报错，做多只能买入
var id2 = exchange.Sell(60, 1)
// 设置平多方向
exchange.SetDirection("closebuy")
// 下买单，会报错，平多只能卖出
var id3 = exchange.Buy(-1, 1)
// 设置平空方向
exchange.SetDirection("closesell")
// 下卖单,会报错,平空只能买入
var id4 = exchange.Sell(-1, 1)
}
# 以下为错误调用
def main():
exchange.SetContractType("quarter")
exchange.SetDirection("sell")
id = exchange.Buy(50, 1)
exchange.SetDirection("buy")
id2 = exchange.Sell(60, 1)
exchange.SetDirection("closebuy")
id3 = exchange.Buy(-1, 1)
exchange.SetDirection("closesell")
id4 = exchange.Sell(-1, 1)
// 以下为错误调用
void main() {
exchange.SetContractType("quarter");
exchange.SetDirection("sell");
auto id = exchange.Buy(50, 1);
exchange.SetDirection("buy");
auto id2 = exchange.Sell(60, 1);
exchange.SetDirection("closebuy");
auto id3 = exchange.Buy(-1, 1);
exchange.SetDirection("closesell");
auto id4 = exchange.Sell(-1, 1);
}
क्रिप्टोक्यूरेंसी फ्यूचर्स कॉन्ट्रैक्ट पर ऑर्डर करते समय ध्यान देना आवश्यक है कि क्या ट्रेडिंग दिशा सही ढंग से सेट है, यदि ट्रेडिंग दिशा और ट्रेडिंग फ़ंक्शन मेल नहीं खाते हैं तो त्रुटि दर्ज की जाती हैः
direction is sell, invalid order type Buy
direction is buy, invalid order type Sell
direction is closebuy, invalid order type Buy
direction is closesell, invalid order type Sell
// 例如交易对：ETH_BTC ，市价单买入
function main() {
// 下市价单买入，买入0.1个BTC（计价币）金额的ETH币
exchange.Buy(-1, 0.1)
}
def main():
exchange.Buy(-1, 0.1)
void main() {
exchange.Buy(-1, 0.1);
}
बाजार की कीमतों की सूची।
फ्यूचर्स कॉन्ट्रैक्ट पर ऑर्डर करते समय ध्यान देना चाहिए कि क्या ट्रेडिंग दिशा सही ढंग से सेट है, यदि ट्रेडिंग दिशा और ट्रेडिंग फ़ंक्शन मेल नहीं खाते हैं तो त्रुटि की रिपोर्ट होगी। क्रिप्टोक्यूरेंसी फ्यूचर्स कॉन्ट्रैक्ट एक्सचेंज पर ऑर्डर की मात्रा अगर कोई विशेष विवरण नहीं है तो यह अनुबंध संख्या है।
पैरामीटरpriceसेट करें-1बाजार में बोली लगाने के लिए, एक्सचेंजों के लिए बोली लगाने के लिए इंटरफेस को बाजार में बोली लगाने का समर्थन करने की आवश्यकता होती है। क्रिप्टोकरेंसी की नकदी में बाजार में बोली लगाने का तरीका, बोली लगाने पर बोली लगाने का पैरामीटरamountमुद्राओं में गणना की गई राशि है। क्रिप्टोक्यूरेंसी वायदा अनुबंधों के लिए बाजार मूल्य एकमुश्त तरीके से ऑर्डर, एकमुश्त पैरामीटर नीचेamountवास्तविक समय में, कुछ क्रिप्टोक्यूरेंसी एक्सचेंजों ने बाजार मूल्य एकल इंटरफ़ेस का समर्थन नहीं किया है। अलग-अलग प्रत्यक्ष एक्सचेंजों में बाजार मूल्य एकल भुगतान के लिए ऑर्डर की मात्रा लेन-देन सिक्कों की संख्या है, "उपयोगकर्ता गाइड" में देखें।एक्सचेंजों के लिए विशेष विवरण..
अगर आप पुराने होस्ट का उपयोग कर रहे हैं, तो आप अपने होस्ट को अपडेट कर सकते हैं।exchange.Buy()फ़ंक्शन का लौटाया गया मान आदेशIdवर्तमान दस्तावेज़ में वर्णित संभावित रिटर्न मूल्य ऑर्डरIdएक अंतर है।
{@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
下单成功返回订单Id，下单失败返回空值。 FMZ平台的订单{@struct/Order Order}结构的属性```Id```由交易所品种代码和交易所原始订单Id组成，以英文逗号间隔。例如OKX交易所的现货交易对```ETH_USDT```订单的属性```Id```格式为：```ETH-USDT,1547130415509278720```。 调用```exchange.Sell()```函数下单时，返回值订单```Id```与订单{@struct/Order Order}结构的```Id```属性一致。
string、空值
exchange.Sell(price, amount)
exchange.Sell(price, amount, ...args)
```price```参数用于设置订单价格。
price
true
number
```amount```参数用于设置订单量。
amount
true
number
扩展参数，可以输出附带信息到这条下单日志中，```arg```参数可以传多个。
arg
false
string、number、bool、object、array、空值等系统支持的任意类型
```javascript
function main(){
var id = exchange.Sell(100, 1)
Log("id:", id)
}
def main():
id = exchange.Sell(100, 1)
Log("id:", id)
void main() {
auto id = exchange.Sell(100, 1);
Log("id:", id);
}
```javascript
// 以下为错误调用
function main() {
exchange.SetContractType("quarter")
// 设置做空方向
exchange.SetDirection("sell")
// 下买单，会报错，做空只能卖出
var id = exchange.Buy(50, 1)
// 设置做多方向
exchange.SetDirection("buy")
// 下卖单，会报错，做多只能买入
var id2 = exchange.Sell(60, 1)
// 设置平多方向
exchange.SetDirection("closebuy")
// 下买单，会报错，平多只能卖出
var id3 = exchange.Buy(-1, 1)
// 设置平空方向
exchange.SetDirection("closesell")
// 下卖单,会报错,平空只能买入
var id4 = exchange.Sell(-1, 1)
}
# 以下为错误调用
def main():
exchange.SetContractType("quarter")
exchange.SetDirection("sell")
id = exchange.Buy(50, 1)
exchange.SetDirection("buy")
id2 = exchange.Sell(60, 1)
exchange.SetDirection("closebuy")
id3 = exchange.Buy(-1, 1)
exchange.SetDirection("closesell")
id4 = exchange.Sell(-1, 1)
// 以下为错误调用
void main() {
exchange.SetContractType("quarter");
exchange.SetDirection("sell");
auto id = exchange.Buy(50, 1);
exchange.SetDirection("buy");
auto id2 = exchange.Sell(60, 1);
exchange.SetDirection("closebuy");
auto id3 = exchange.Buy(-1, 1);
exchange.SetDirection("closesell");
auto id4 = exchange.Sell(-1, 1);
}
क्रिप्टोक्यूरेंसी फ्यूचर्स कॉन्ट्रैक्ट पर ऑर्डर करते समय ध्यान देना आवश्यक है कि क्या ट्रेडिंग दिशा सही ढंग से सेट है, यदि ट्रेडिंग दिशा और ट्रेडिंग फ़ंक्शन मेल नहीं खाते हैं तो त्रुटि दर्ज की जाती हैः
direction is sell, invalid order type Buy
direction is buy, invalid order type Sell
direction is closebuy, invalid order type Buy
direction is closesell, invalid order type Sell
// 例如交易对：ETH_BTC,市价单卖出
function main() {
// 注意：下市价单卖出，卖出0.2个ETH
exchange.Sell(-1, 0.2)
}
def main():
exchange.Sell(-1, 0.2)
void main() {
exchange.Sell(-1, 0.2);
}
बाजार की कीमतों की सूची।
फ्यूचर्स कॉन्ट्रैक्ट पर ऑर्डर करते समय ध्यान देना चाहिए कि क्या ट्रेडिंग दिशा सही ढंग से सेट है, यदि ट्रेडिंग दिशा और ट्रेडिंग फ़ंक्शन मेल नहीं खाते हैं तो त्रुटि की रिपोर्ट होगी। क्रिप्टोक्यूरेंसी फ्यूचर्स कॉन्ट्रैक्ट एक्सचेंज पर ऑर्डर की मात्रा अगर कोई विशेष विवरण नहीं है तो यह अनुबंध संख्या है।
पैरामीटरpriceसेट करें-1बाजार में बोली लगाने के लिए, एक्सचेंजों के लिए बोली लगाने के लिए इंटरफ़ेस बाजार में बोली लगाने का समर्थन करता है। क्रिप्टोक्यूरेंसी नकदी के लिए बाजार में बोली लगाने का तरीका, बोली लगाने के समय, बोली मात्रा पैरामीटरamountट्रेड करेंसी में इकाई की मात्रा है। क्रिप्टोकरेंसी फ्यूचर कॉन्ट्रैक्ट के लिए बाजार मूल्य एकमुश्त तरीके से ऑर्डर, एकमुश्त पैरामीटर नीचेamountएक इकाई अनुबंधों की संख्या है. वास्तविक समय में, कुछ क्रिप्टोकरेंसी एक्सचेंजों ने बाजार मूल्य एकल इंटरफ़ेस का समर्थन नहीं किया है.
अगर आप पुराने होस्ट का उपयोग कर रहे हैं, तो आप अपने ब्लॉग को अपडेट कर सकते हैं।exchange.Sell()फ़ंक्शन का लौटाया गया मान आदेशIdवर्तमान दस्तावेज़ में वर्णित संभावित रिटर्न मूल्य ऑर्डरIdएक अंतर है।
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/Futures/exchange.
下单成功返回订单Id，下单失败返回空值。 FMZ平台的订单{@struct/Order Order}结构的属性```Id```由交易所品种代码和交易所原始订单Id组成，以英文逗号间隔。例如OKX交易所的现货交易对```ETH_USDT```订单的属性```Id```格式为：```ETH-USDT,1547130415509278720```。 调用```exchange.CreateOrder(symbol, side, price, amount)```函数下单时，返回值订单```Id```与订单{@struct/Order Order}结构的```Id```属性一致。
string、空值
exchange.CreateOrder(symbol, side, price, amount)
exchange.CreateOrder(symbol, side, price, amount, ...args)
参数```symbol```用于指定订单的具体交易对、合约代码。 当调用```exchange.CreateOrder(symbol, side, price, amount)```函数下单时，```exchange```为现货交易所对象，如果订单计价币种为USDT，交易币种为BTC。则参数```symbol```为：```"BTC_USDT"```，格式为FMZ平台定义的交易对格式。 当调用```exchange.CreateOrder(symbol, side, price, amount)```函数下单时，```exchange```为期货交易所对象，如果订单为BTC的U本位永续合约订单。则参数```symbol```为：```"BTC_USDT.swap"```，格式为FMZ平台定义的**交易对**与**合约代码**组合，再以字符"."间隔。 当调用```exchange.CreateOrder(symbol, side, price, amount)```函数下单时，```exchange```为期货交易所对象，如果订单为BTC的U本位期权合约订单。则参数```symbol```为：```"BTC_USDT.BTC-240108-40000-C"```（以币安期权BTC-240108-40000-C为例），格式为FMZ平台定义的**交易对**与交易所定义的具体期权合约代码组合，再以字符"."间隔。
symbol
true
string
参数```side```用于指定订单的交易方向。
对于现货交易所对象，```side```参数的可选值为：```buy```、```sell```。```buy```表示买入，```sell```表示卖出。
对于期货交易所对象，```side```参数的可选值为：```buy```、```closebuy```、```sell```、```closesell```。```buy```表示开多仓、```closebuy```表示平多仓、```sell```表示开空仓、```closesell```表示平空仓。
side
true
string
参数```price```用于设置订单的价格。价格为-1时表示订单为市价单。
price
true
number
参数```amount```用于设置订单的下单量。需要注意当订单为**现货市价单买单**时，下单量为买入金额；个别现货交易所的市价单买单的下单量为交易币数，具体查看「用户指南」中的**交易所特殊说明**。
对于期货交易所对象，使用```CreateOrder()```/```Buy()```/```Sell()```函数下单时如无特殊说明，下单量参数```amount```均为合约张数。
amount
true
number
扩展参数，可以输出附带信息到这条下单日志中，```arg```参数可以传多个。
arg
false
string、number、bool、object、array、空值等系统支持的任意类型
```javascript
function main() {
var id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01) // 现货交易所对象下单币币交易BTC_USDT交易对
// var id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01) // 期货交易所对象下单BTC的U本位永续合约
Log("订单Id:", id)
}
def main():
id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01) # 现货交易所对象下单币币交易BTC_USDT交易对
# id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01) # 期货交易所对象下单BTC的U本位永续合约
Log("订单Id:", id)
void main() {
auto id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01); // 现货交易所对象下单币币交易BTC_USDT交易对
// auto id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01); // 期货交易所对象下单BTC的U本位永续合约
Log("订单Id:", id);
}
एक्सचेंज ऑब्जेक्ट, वायदा एक्सचेंज ऑब्जेक्ट कॉलexchange.CreateOrder()फ़ंक्शन के नीचे सूचीबद्ध है।
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
FMZ平台的订单{@struct/Order Order}结构的属性```Id```由交易所品种代码和交易所原始订单Id组成，以英文逗号间隔。例如OKX交易所的现货交易对```ETH_USDT```订单的属性```Id```格式为：```ETH-USDT,1547130415509278720```。
调用```exchange.CancelOrder()```函数撤销订单时传入的参数```orderId```与订单{@struct/Order Order}结构的```Id```属性一致。
```exchange.CancelOrder()```函数返回真值，例如```true```表示取消订单请求发送成功， 返回假值，例如```false```表示取消订单请求发送失败。返回值只是代表发送请求成功或失败，判断交易所是否取消订单， 可以调用```exchange.GetOrders()```判断。
bool
exchange.CancelOrder(orderId)
exchange.CancelOrder(orderId, ...args)
```orderId```参数用于指定所要取消的订单。
orderId
true
string
扩展参数，可以输出附带信息到这条撤单日志中，```arg```参数可以传多个。
arg
false
string、number、bool、object、array、空值等系统支持的任意类型
```javascript
function main(){
var id = exchange.Sell(99999, 1)
exchange.CancelOrder(id)
}
def main():
id = exchange.Sell(99999, 1)
exchange.CancelOrder(id)
void main() {
auto id = exchange.Sell(99999, 1);
exchange.CancelOrder(id);
}
यह एक बहुत ही अच्छा तरीका है।
function main() {
if (exchange.GetName().includes("Futures_")) {
Log("设置合约为：永续合约，设置交易方向为：开多仓。")
exchange.SetContractType("swap")
exchange.SetDirection("buy")
}
var ticker = exchange.GetTicker()
exchange.Buy(ticker.Last * 0.5, 0.1)
var orders = exchange.GetOrders()
for (var i = 0 ; i < orders.length ; i++) {
exchange.CancelOrder(orders[i].Id, "撤销的订单：", orders[i])
Sleep(500)
}
}
def main():
if exchange.GetName().find("Futures_") != -1:
Log("设置合约为：永续合约，设置交易方向为：开多仓。")
exchange.SetContractType("swap")
exchange.SetDirection("buy")
ticker = exchange.GetTicker()
exchange.Buy(ticker["Last"] * 0.5, 0.1)
orders = exchange.GetOrders()
for i in range(len(orders)):
exchange.CancelOrder(orders[i]["Id"], "撤销的订单：", orders[i])
Sleep(500)
void main() {
if (exchange.GetName().find("Futures_") != std::string::npos) {
Log("设置合约为：永续合约，设置交易方向为：开多仓。");
exchange.SetContractType("swap");
exchange.SetDirection("buy");
}
auto ticker = exchange.GetTicker();
exchange.Buy(ticker.Last * 0.5, 0.1);
auto orders = exchange.GetOrders();
for (int i = 0 ; i < orders.size() ; i++) {
exchange.CancelOrder(orders[i].Id, "撤销的订单：", orders[i]);
Sleep(500);
}
}
FMZ के एपीआई फ़ंक्शन में लॉग आउटपुट फ़ंक्शन उत्पन्न किए जा सकते हैं जैसेःLog()、exchange.Buy()、exchange.CancelOrder()उदाहरण के लिए, यदि आप किसी प्रकार के आउटपुट पैरामीटर के साथ आवश्यक पैरामीटर को जोड़ना चाहते हैं, तो आप इन पैरामीटरों को जोड़ सकते हैं।exchange.CancelOrder(orders[i].Id, orders[i])और यह है कि हम Id को हटा रहे हैं.orders[i].Idइस आदेश के साथ यह आदेश के बारे में जानकारी है, यानीorders[i]यह {@struct/Order Order} संरचना है।
अगर आप पुराने होस्ट का उपयोग कर रहे हैं, तो आप अपने होस्ट को अपडेट कर सकते हैं।exchange.CancelOrder()फ़ंक्शन के पैरामीटरorderIdवर्तमान दस्तावेजों में वर्णित हो सकता हैorderIdएक अंतर है।
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.
根据订单号查询订单详情，查询成功返回{@struct/Order Order}结构，查询失败返回空值。
{@struct/Order Order}、空值
exchange.GetOrder(orderId)
```orderId```参数用于指定所要查询的订单。
FMZ平台的订单{@struct/Order Order}结构的属性```Id```由交易所品种代码和交易所原始订单Id组成，以英文逗号间隔。例如OKX交易所的现货交易对```ETH_USDT```订单的属性```Id```格式为：```ETH-USDT,1547130415509278720```。
调用```exchange.GetOrder()```函数查询订单时传入的参数```orderId```与订单{@struct/Order Order}结构的```Id```属性一致。
orderId
true
string
```javascript
function main(){
var id = exchange.Sell(1000, 1)
// 参数id为订单号码，需填入你想要查询的订单的号码
var order = exchange.GetOrder(id)
Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:",
order.DealAmount, "Status:", order.Status, "Type:", order.Type)
}
def main():
id = exchange.Sell(1000, 1)
order = exchange.GetOrder(id)
Log("Id:", order["Id"], "Price:", order["Price"], "Amount:", order["Amount"], "DealAmount:",
order["DealAmount"], "Status:", order["Status"], "Type:", order["Type"])
void main() {
auto id = exchange.Sell(1000, 1);
auto order = exchange.GetOrder(id);
Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:",
order.DealAmount, "Status:", order.Status, "Type:", order.Type);
}
कुछ एक्सचेंजों का समर्थन नहींexchange.GetOrder()फ़ंक्शन ─ {@struct/Order Order} संरचना में मान लौटाता हैAvgPriceगुण लेन-देन के लिए समान मूल्य है, कुछ एक्सचेंजों में यह फ़ील्ड समर्थित नहीं है, और समर्थित नहीं है तो इसे 0 पर सेट किया गया है।
अगर आप पुराने होस्ट का उपयोग कर रहे हैं, तो आप अपने ब्लॉग को अपडेट कर सकते हैं।exchange.GetOrder()फ़ंक्शन के पैरामीटरorderIdवर्तमान दस्तावेजों में वर्णित हो सकता हैorderIdएक अंतर है।
समर्थन नहींexchange.GetOrder()फ़ंक्शन के लिए एक्सचेंजः
| फ़ंक्शन का नाम | असमर्थित मुद्रा विनिमय | गैर-समर्थित फ्यूचर्स एक्सचेंज |
|---|---|---|
| प्राप्त करेंआदेश | Zaif/Coincheck/बिटस्टैम्प | – |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@struct/Trade/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Trade/exchange
```exchange.GetOrders()```函数请求数据成功时返回{@struct/Order Order}结构数组，请求数据失败时返回空值。
{@struct/Order Order}数组、空值
exchange.GetOrders()
exchange.GetOrders(symbol)
参数```symbol```用于设置所要查询的**交易品种**或者**交易品种的范围**。
对于现货交易所对象，不传```symbol```参数时，请求所有现货品种的未完成订单数据。
对于期货交易所对象，不传```symbol```参数时，默认以当前交易对、合约代码所在维度范围请求所有品种的未完成订单数据。
symbol
false
string
```javascript
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]
for (var symbol of arrSymbol) {
var t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01)
}
var spotOrders = exchange.GetOrders()
var tbls = []
for (var orders of [spotOrders]) {
var tbl = {type: "table", title: "test GetOrders", cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
for (var order of orders) {
tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
}
tbls.push(tbl)
}
LogStatus("`" + JSON.stringify(tbls) + "`")
// 打印输出一次信息后返回，防止后续回测时订单成交，影响数据观察
return
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]
for symbol in arrSymbol:
t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 0.01)
spotOrders = exchange.GetOrders()
tbls = []
for orders in [spotOrders]:
tbl = {"type": "table", "title": "test GetOrders", "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
for order in orders:
tbl["rows"].append([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
tbls.append(tbl)
LogStatus("`" + json.dumps(tbls) + "`")
return
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"};
for (const auto& symbol : arrSymbol) {
auto t = exchange.GetTicker(symbol);
exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01);
}
auto spotOrders = exchange.GetOrders();
json tbls = R"([])"_json;
std::vector<std::vector<Order>> arr = {spotOrders};
for (const auto& orders : arr) {
json tbl = R"({
"type": "table",
"title": "test GetOrders",
"cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
"rows": []
})"_json;
for (const auto& order : orders) {
json arrJson = R"([])"_json;
arrJson.push_back("Symbol");
arrJson.push_back("Id");
arrJson.push_back(order.Price);
arrJson.push_back(order.Amount);
arrJson.push_back(order.DealAmount);
arrJson.push_back(order.AvgPrice);
arrJson.push_back(order.Status);
arrJson.push_back(order.Type);
arrJson.push_back(order.Offset);
arrJson.push_back(order.ContractType);
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
}
LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
return;
}
एक वस्तु का उपयोग करके, कई अलग-अलग व्यापारिक जोड़े का भुगतान करें, वर्तमान मूल्य के आधे हिस्से के लिए नीचे की ओर ऑर्डर करें, और फिर अधूरे ऑर्डर की जानकारी का पता लगाएं।
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for (var symbol of arrSymbol) {
var t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t.Last / 2, 1)
exchange.CreateOrder(symbol, "sell", t.Last * 2, 1)
}
var defaultOrders = exchange.GetOrders()
var swapOrders = exchange.GetOrders("USDT.swap")
var futuresOrders = exchange.GetOrders("USDT.futures")
var btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")
var tbls = []
var arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
var tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
for (var index in arr) {
var orders = arr[index]
var tbl = {type: "table", title: tblDesc[index], cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
for (var order of orders) {
tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
}
tbls.push(tbl)
}
LogStatus("`" + JSON.stringify(tbls) + "`")
// 打印输出一次信息后返回，防止后续回测时订单成交，影响数据观察
return
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for symbol in arrSymbol:
t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 1)
exchange.CreateOrder(symbol, "sell", t["Last"] * 2, 1)
defaultOrders = exchange.GetOrders()
swapOrders = exchange.GetOrders("USDT.swap")
futuresOrders = exchange.GetOrders("USDT.futures")
btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")
tbls = []
arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
for index in range(len(arr)):
orders = arr[index]
tbl = {"type": "table", "title": tblDesc[index], "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
for order in orders:
tbl["rows"].append([order["Symbol"], order["Id"], order["Price"], order["Amount"], order["DealAmount"], order["AvgPrice"], order["Status"], order["Type"], order["Offset"], order["ContractType"]])
tbls.append(tbl)
LogStatus("`" + json.dumps(tbls) + "`")
return
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
for (const auto& symbol : arrSymbol) {
auto t = exchange.GetTicker(symbol);
exchange.CreateOrder(symbol, "buy", t.Last / 2, 1);
exchange.CreateOrder(symbol, "sell", t.Last * 2, 1);
}
auto defaultOrders = exchange.GetOrders();
auto swapOrders = exchange.GetOrders("USDT.swap");
auto futuresOrders = exchange.GetOrders("USDT.futures");
auto btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap");
json tbls = R"([])"_json;
std::vector<std::vector<Order>> arr = {defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders};
std::string tblDesc[] = {"defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"};
for (int index = 0; index < arr.size(); index++) {
auto orders = arr[index];
json tbl = R"({
"type": "table",
"cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
"rows": []
})"_json;
tbl["title"] = tblDesc[index];
for (const auto& order : orders) {
json arrJson = R"([])"_json;
arrJson.push_back(order.Symbol);
arrJson.push_back(to_string(order.Id)); // Order订单结构中的Id属性类型为TId，使用FMZ平台内置的一个C++函数to_string编码
arrJson.push_back(order.Price);
arrJson.push_back(order.Amount);
arrJson.push_back(order.DealAmount);
arrJson.push_back(order.AvgPrice);
arrJson.push_back(order.Status);
arrJson.push_back(order.Type);
arrJson.push_back(order.Offset);
arrJson.push_back(order.ContractType);
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
}
LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
return;
}
फ्यूचर्स एक्सचेंज के ऑब्जेक्ट का उपयोग करके, कई अलग-अलग ट्रेडिंग जोड़े, अनुबंध कोड की किस्मों पर ऑर्डर करें; ऑर्डर की कीमत को अपने डिस्क प्रतिद्वंद्वी मूल्य से दूर रखें, ऑर्डर को निष्क्रिय रखें, ऑर्डर को कई तरीकों से जांचें।
function main() {
var orders = exchange.GetOrders("BTC_USDT") // 现货品种举例
// var orders = exchange.GetOrders("BTC_USDT.swap") // 期货品种举例
Log("orders:", orders)
}
def main():
orders = exchange.GetOrders("BTC_USDT") # 现货品种举例
# orders = exchange.GetOrders("BTC_USDT.swap") # 期货品种举例
Log("orders:", orders)
void main() {
auto orders = exchange.GetOrders("BTC_USDT"); // 现货品种举例
// auto orders = exchange.GetOrders("BTC_USDT.swap"); // 期货品种举例
Log("orders:", orders);
}
कॉल करेंexchange.GetOrders()फ़ंक्शन के समय में प्रवेश करेंSymbolपैरामीटर अनुरोधित विशिष्ट लेन-देन जोड़े, अनुबंध कोड के लिए आदेश डेटा निर्दिष्ट करता है।
मेंGetOrdersफ़ंक्शन में, symbol पैरामीटर के उपयोग के परिदृश्यों को संक्षेप में प्रस्तुत किया गया हैः
| एक्सचेंज ऑब्जेक्ट्स का वर्गीकरण | symbol पैरामीटर | पूछताछ का दायरा | नोट्स |
|---|---|---|---|
| नकदी | कोई प्रतीक पैरामीटर नहीं | सभी नकदी लेनदेन के लिए पूछताछ करें | सभी कॉल परिदृश्य, यदि एक्सचेंज इंटरफेस समर्थित नहीं है, तो त्रुटि रिटर्न रिक्त मान, और अधिक नहीं। |
| नकदी | ट्रेडों के प्रकार को निर्दिष्ट करें, प्रतीक पैरामीटर हैः |
BTC_USDT लेनदेन जोड़े की जांच करें | प्रत्यक्ष एक्सचेंज ऑब्जेक्ट के लिए, पैरामीटर प्रतीक प्रारूप हैः |
| वायदा | कोई प्रतीक पैरामीटर नहीं | वर्तमान लेनदेन जोड़े, अनुबंध कोड आयाम के सभी लेनदेन किस्मों की जांच करें | यदि वर्तमान लेन-देन जोड़ी BTC_USDT है, तो कॉन्ट्रैक्ट कोड swap है, यानी सभी USDT स्थानिक स्थायी अनुबंधों का पता लगाएं.GetOrders("USDT.swap") |
| वायदा | विनिमय प्रकार निर्दिष्ट करें, प्रतीक पैरामीटर हैः |
बीटीसी के लिए यूएसडीटी स्थायी ठेके की जांच करें | फ्यूचर्स एक्सचेंज ऑब्जेक्ट के लिए, पैरामीटर प्रतीक प्रारूपःसौदा सहीके साथअनुबंध कोडसंयोजन, अक्षरों के साथ"."यह एक बहुत ही दिलचस्प लेख है। |
| वायदा | 指定交易品种范围，symbol参数为：”USDT.swap” | USDT के सभी स्थायी ठेके देखें | - |
| विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज | कोई प्रतीक पैरामीटर नहीं | सभी विकल्प अनुबंधों के लिए आयाम सीमा पर वर्तमान लेनदेन की जांच करें | यदि वर्तमान ट्रेडिंग जोड़ी BTC_USDT है, तो अनुबंध को विकल्प अनुबंध के रूप में सेट करें, उदाहरण के लिए, बिनान विकल्प अनुबंधः BTC-240108-40000-C |
| विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज | विशिष्ट लेन-देन की किस्में निर्दिष्ट करें | निर्दिष्ट विकल्प अनुबंध की जांच करें | उदाहरण के लिए, विनय वायदा एक्सचेंज के लिए, प्रतीक पैरामीटरः BTC_USDT.BTC-240108-40000-C |
| विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज | 指定交易品种范围，symbol参数为：”USDT.option” | सभी USDT स्थानीय विकल्प अनुबंध देखें | - |
मेंGetOrdersफ़ंक्शन में, फ्यूचर्स एक्सचेंज ऑब्जेक्ट क्वेरी आयाम सीमा को समेकित किया जाता हैः
| symbol पैरामीटर | अनुरोध का दायरा | नोट्स |
|---|---|---|
| USDT.swap | USDT के स्थायी अनुबंध का दायरा। | एक्सचेंज एपीआई इंटरफेस द्वारा समर्थित नहीं किए गए आयामों के लिए, कॉल करने पर एक त्रुटि लौटाई जाएगी। |
| USDT.futures | USDT की स्थानीय विनिमय दर लगभग है। | - |
| USD.swap | इस तरह के एक नए नियम के तहत, मुद्रा विनिमय के लिए स्थायी अनुबंध का दायरा। | - |
| USD.futures | मुद्रा विनिमय दर लगभग दायरे में है। | - |
| USDT.option | USDT स्थानीय विकल्प अनुबंधों का दायरा। | - |
| USD.option | मुद्रा स्थानिक विकल्प अनुबंधों का दायरा। | - |
| USDT.futures_combo | यह एक बहुत ही अच्छा तरीका है। | Futures_Deribit एक्सचेंज |
| USD.futures_ff | मिश्रित प्रतिभूतियों का भुगतान अनुपात लगभग दायरा। | Futures_Kraken एक्सचेंज |
| USD.swap_pf | मिश्रित प्रतिभूतियों के लिए स्थायी अनुबंध का दायरा। | Futures_Kraken एक्सचेंज |
जब एक्सचेंज वस्तुexchangeप्रतिनिधि के खाते मेंपूछताछ के दायरे मेंयाविनिर्दिष्ट व्यापारिक किस्मजब कोई पेंडिंग ऑर्डर नहीं होता है, तो इस फ़ंक्शन को रिक्त सरणी को वापस करने के लिए कहा जाता है, अर्थात्ः[]..
निम्नलिखित एक्सचेंजों के इंटरफेस को वर्तमान में अधूरे ऑर्डर के लिए पूछताछ करने के लिए विविधता पैरामीटर को पास करना होगा, इन एक्सचेंजों का उपयोग करके GetOrders फ़ंक्शन को बुलाया जाता है, जब प्रतीक पैरामीटर को पास नहीं किया जाता है तो केवल वर्तमान विविधता के अधूरे ऑर्डर का अनुरोध किया जाता है, न कि सभी विविधताओं के अधूरे ऑर्डर ((क्योंकि एक्सचेंज इंटरफ़ेस समर्थित नहीं है) ।) ।
ज़ाइफ, मेक्ससी, एलबैंक, कोर्बिट, कॉइन, बिटमार्ट, बिथंब, बिटफ्लायर, बिगोन।
समर्थन नहींexchange.GetOrders()फ़ंक्शन के लिए एक्सचेंजः
| फ़ंक्शन का नाम | असमर्थित मुद्रा विनिमय | गैर-समर्थित फ्यूचर्स एक्सचेंज |
|---|---|---|
| GetOrders प्राप्त करें | – | वायदा_बिबॉक्स |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@struct/Trade/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOr
```exchange.GetHistoryOrders()```函数请求数据成功时返回{@struct/Order Order}结构数组，请求数据失败时返回空值。
{@struct/Order Order}数组、空值
exchange.GetHistoryOrders()
exchange.GetHistoryOrders(symbol)
exchange.GetHistoryOrders(symbol, since)
exchange.GetHistoryOrders(symbol, since, limit)
exchange.GetHistoryOrders(since)
exchange.GetHistoryOrders(since, limit)
```symbol```参数用来指定交易品种。以```BTC_USDT```交易对为例，```exchange```为现货交易所对象时，```symbol```参数格式为：```BTC_USDT```；如果是期货交易所对象，以永续合约为例，```symbol```参数格式为：```BTC_USDT.swap```。
如果查询的是期权合约的订单数据，参数```symbol```设置为```"BTC_USDT.BTC-240108-40000-C"```（以币安期权BTC-240108-40000-C为例），格式为FMZ平台定义的**交易对**与交易所定义的具体期权合约代码组合，再以字符"."间隔。
不传该参数时默认请求当前设置的交易对、合约代码的订单数据。
symbol
false
string
```since```参数用来指定查询的起始时间戳，单位为毫秒。
since
false
number
```limit```参数用来指定查询的订单数量。
limit
false
number
```javascript
function main() {
var historyOrders = exchange.GetHistoryOrders()
Log(historyOrders)
}
def main():
historyOrders = exchange.GetHistoryOrders()
Log(historyOrders)
void main() {
auto historyOrders = exchange.GetHistoryOrders();
Log(historyOrders);
}
symbol、since、limitपैरामीटर में, डिफ़ॉल्ट रूप से वर्तमान लेन-देन जोड़े, अनुबंध के लिए ऐतिहासिक आदेशों की जांच की जाती है। वर्तमान समय से निकटतम दूरी के भीतर ऐतिहासिक आदेशों की जांच की जाती है, जो कि एक्सचेंज इंटरफ़ेस के आधार पर एक बार की जांच के दायरे पर निर्भर करता है।symbolपैरामीटर में, सेट किए गए लेन-देन की विविधता के लिए ऐतिहासिक आदेश की जांच की जाती है.sinceयदि आप एक पैरामीटर है,sinceसमय चिह्न वर्तमान समय की दिशा में प्रारंभ समय के लिए पूछताछ करता है।limitपैरामीटर के लिए, क्वेरी पर्याप्त संख्या में वापस आ जाता है।समर्थन नहींexchange.GetHistoryOrders()फ़ंक्शन के लिए एक्सचेंजः
| फ़ंक्शन का नाम | असमर्थित मुद्रा विनिमय | गैर-समर्थित फ्यूचर्स एक्सचेंज |
|---|---|---|
| GetHistoryOrders प्राप्त करें | Zaif / Upbit / Coincheck / Bitstamp / Bithumb / BitFlyer / BigONE | फ्यूचर्स_बिबॉक्स / फ्यूचर्स_अपोलोएक्स |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@struct/Trade/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Trade.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrder exchange.GetOrder exchange
exchange.SetPrecision(pricePrecision, amountPrecision)
```pricePrecision```参数用来控制价格数据的精度。
pricePrecision
true
number
```amountPrecision```参数用来控制下单量数据的精度。
amountPrecision
true
number
```javascript
function main(){
// 设置价格小数位精度为2位,品种下单量小数位精度为3位
exchange.SetPrecision(2, 3)
}
def main():
exchange.SetPrecision(2, 3)
void main() {
exchange.SetPrecision(2, 3);
}
रीसेट सिस्टम इस फ़ंक्शन का समर्थन नहीं करता है और रीसेट सिस्टम की संख्यात्मक सटीकता स्वचालित रूप से संसाधित होती है।
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
एक्सचेंज ऑब्जेक्ट की वर्तमान विनिमय दर सेट करें.
exchange.SetRate (दर)
rate
true
number
```javascript
function main(){
Log(exchange.GetTicker())
// 设置汇率转换
exchange.SetRate(7)
Log(exchange.GetTicker())
// 设置为1，不转换
exchange.SetRate(1)
}
def main():
Log(exchange.GetTicker())
exchange.SetRate(7)
Log(exchange.GetTicker())
exchange.SetRate(1)
void main() {
Log(exchange.GetTicker());
exchange.SetRate(7);
Log(exchange.GetTicker());
exchange.SetRate(1);
}
अगर इस्तेमाल कियाexchange.SetRate()यदि फ़ंक्शन एक विनिमय मान सेट करता है, उदाहरण के लिए 7 सेट करें; तो वर्तमानexchangeइस एक्सचेंज के ऑब्जेक्ट द्वारा प्रतिनिधित्व किए जाने वाले एक्सचेंज के बाजार, गहराई, ऑर्डर की कीमत आदि के बारे में सभी मूल्य जानकारी को सेट किए गए विनिमय दर 7 से गुणा करके परिवर्तित किया जाता है। उदाहरण के लिएःexchangeयह एक ऐसा एक्सचेंज है जो डॉलर में मुद्रा के रूप में मूल्य निर्धारण करता है।exchange.SetRate(7)उसके बाद, सभी कीमतों को 7 से लगभग में परिवर्तित किया जाएगा।CNYकीमतों का निर्धारण किया गया है।
{@मज़ा/बाजार/विनिमय.GetRate विनिमय.GetRate}
```exchange.IO()```函数调用交易所对象相关的其它接口，调用成功时返回请求的应答数据，调用失败时返回空值。
string、number、bool、object、array、空值等系统支持的任意类型
exchange.IO(k, ...args)
```k```参数用于设置调用类型，可选值为```"api"```、```"currency"```、```"base"```、```"trade_margin"```、```"trade_normal"```、```"public_base"```、```"mbase"```、```selfTradePreventionMode```、```simulate```、```cross```、```dual```、```unified```等。
k
true
string
扩展参数，根据具体调用场景传参，```arg```参数可以传多个。 由于```exchange.IO()```函数的多态机制，不同的参数设置对应不同的功能。 ```exchange.IO()```函数的参数个数、类型都是不确定的。
arg
true
string、number、bool、object、array、空值等系统支持的任意类型
```javascript
function main() {
var arrOrders = [
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
]
// 调用 exchange.IO 直接访问交易所批量下单接口
var ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", JSON.stringify(arrOrders))
Log(ret)
}
import json
def main():
arrOrders = [
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
]
ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", json.dumps(arrOrders))
Log(ret)
void main() {
json arrOrders = R"([
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
])"_json;
auto ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", arrOrders.dump());
Log(ret);
}
उपयोगexchange.IO()फ़ंक्शन काexchange.IO("api", httpMethod, resource, params, raw)कॉल फ़ॉर्म, पहले एक्सचेंज के एपीआई इंटरफेस को समझने और संबंधित दस्तावेजों को देखने की आवश्यकता है।POSTअनुरोध को पैरामीटर एन्क्रिप्शन, हस्ताक्षर, सत्यापन आदि के बारे में चिंता करने की आवश्यकता नहीं है। FMZ को नीचे के स्तर पर संसाधित किया गया है, बस संबंधित पैरामीटर भरें।ओकेएक्स एक्सचेंजफ्यूचर्स कॉन्ट्रैक्ट के लिए थोक ऑर्डर उदाहरण, पैरामीटर का उपयोगrawऑर्डर पैरामीटरः
var amount = 1
var price = 10
var basecurrency = "ltc"
function main () {
// 注意 amount.toString() 和 price.toString() 左边右边都有一个 ' 字符
var message = "symbol=" + basecurrency + "&amount='" + amount.toString() + "'&price='" + price.toString() + "'&side=buy" + "&type=limit"
var id = exchange.IO("api", "POST", "/v1/order/new", message)
}
amount = 1
price = 10
basecurrency = "ltc"
def main():
message = "symbol=" + basecurrency + "&amount='" + str(amount) + "'&price='" + str(price) + "'&side=buy" + "&type=limit"
id = exchange.IO("api", "POST", "/v1/order/new", message)
void main() {
auto amount = 1.0;
auto price = 10.0;
auto basecurrency = "ltc";
string message = format("symbol=%s&amount=\"%.1f\"&price=\"%.1f\"&side=buy&type=limit", basecurrency, amount, price);
auto id = exchange.IO("api", "POST", "/v1/order/new", message);
}
अगरparamsपैरामीटर (यानी HTTP अनुरोध पैरामीटर) में कुंजी मान एक स्ट्रिंग है, जिसे पैरामीटर के मूल्य के चारों ओर सिंगल कोट्स (यानी प्रतीक चिह्न) के साथ लिखा जाना चाहिए, ताकि पैरामीटर मान को लपेटा जा सके।
function main() {
var ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
Log(ret)
}
def main():
ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
Log(ret)
void main() {
auto ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC");
Log(ret);
}
पूर्ण यूआरएल पैरामीटर को भेजने का समर्थन करें, ताकि बेस एड्रेस को स्विच करने के ऑपरेशन को छोड़ दिया जा सके ((कॉल)exchange.SetBase()फ़ंक्शन) ।
function main(){
var ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
Log(ret)
}
def main():
ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
Log(ret)
void main() {
auto ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT");
Log(ret);
}
कोई पैरामीटर नहींrawएक उदाहरण के रूप मेंः
function main() {
// 例如开始实盘上设置交易所对象目前交易对为BTC_USDT，打印目前交易对行情
Log(exchange.GetTicker())
// 切换交易对为LTC_BTC
exchange.IO("currency", "LTC_BTC")
Log(exchange.GetTicker())
}
def main():
Log(exchange.GetTicker())
exchange.IO("currency", "LTC_BTC")
Log(exchange.GetTicker())
void main() {
Log(exchange.GetTicker());
exchange.IO("currency", "LTC_BTC");
Log(exchange.GetTicker());
}
वर्तमान एक्सचेंज के लेनदेन जोड़े को स्विच करें, ताकि कोड के माध्यम से स्विच किया जा सकेजब डिस्क बनाई जाती हैयापुनः परीक्षण करते समयविन्यस्त लेनदेन जोड़े।
function main () {
// exchanges[0]就是实盘创建时，第一个添加的交易所对象
exchanges[0].IO("base", "https://api.huobi.pro")
}
def main():
exchanges[0].IO("base", "https://api.huobi.pro")
void main() {
exchanges[0].IO("base", "https://api.huobi.pro");
}
उदाहरण के लिए, एक्सचेंज ऑब्जेक्ट के पैकेजिंग के समय डिफ़ॉल्ट आधार पते के रूप मेंhttps://api.huobipro.com, पर स्विच करने की जरूरत हैhttps://api.huobi.proजब आप किसी भी प्रकार की समस्या का सामना करते हैं, तो निम्न कोड का उपयोग करके स्विच करेंः
function main() {
exchange.SetBase("https://api.bitfinex.com")
exchange.IO("mbase", "https://api-pub.bitfinex.com")
}
def main():
exchange.SetBase("https://api.bitfinex.com")
exchange.IO("mbase", "https://api-pub.bitfinex.com")
void main() {
exchange.SetBase("https://api.bitfinex.com");
exchange.IO("mbase", "https://api-pub.bitfinex.com");
}
बाजार इंटरफेस, लेनदेन इंटरफेस बेस एड्रेस के लिए अलग-अलग एक्सचेंजों के लिए, उदाहरण के लिए, Bitfinex फ्यूचर्स में दो पते होते हैं, एक बाजार इंटरफेस एड्रेस और एक ट्रेडिंग इंटरफेस एड्रेस। Bitfinex फ्यूचर्स स्विच निजी इंटरफेस बेस एड्रेस का उपयोग करता हैexchange.SetBase("xxx")◎ Bitfinex फ्यूचर्स स्विच पब्लिक इंटरफेस बेस का उपयोग करेंexchange.IO("mbase", "xxx")。
क्रिप्टोक्यूरेंसी केंद्रीकृत एक्सचेंजों के लिए अन्य असंगत एपीआई इंटरफ़ेस कॉल, पैरामीटरkसेट करें"api"：
exchange.IO("api", httpMethod, resource, params, raw)
POST、GETऔर इस तरह।URLयह कोडिंग है।仅实盘支持调用```exchange.IO("api", httpMethod, resource, params, raw)```函数。
**二、用于切换交易对，参数```k```设置为```"currency"```：**
```javascript
exchange.IO("currency", currency)
baseCurrencyके साथquoteCurrencyउदाहरण के लिएःBTC_USDT。1, पुनरावृत्ति प्रणाली अब स्वैप लेन-देन जोड़े (केवल डिजिटल मुद्रा प्रत्यक्ष विनिमय वस्तुओं के लिए) का समर्थन करती है, पुनरावृत्ति के दौरान ध्यान रखना आवश्यक है कि केवल उन लेनदेन जोड़े के लिए स्वैप किया जा सकता है जो एक ही मुद्रा में हैं, उदाहरण के लिए वर्तमान लेनदेन जोड़े के लिएETH_BTCकेवल स्विच करने के लिएLTC_BTC, को स्विच नहीं कर सकतेLTC_USDT..
2। क्रिप्टोकरेंसी फ्यूचर्स कॉन्ट्रैक्ट एक्सचेंज के लिए ऑब्जेक्ट के लिए लेन-देन का जोड़ा स्विच किया गया है, कॉन्ट्रैक्ट कोड को फिर से सेट करने की आवश्यकता है ताकि यह निर्धारित किया जा सके कि कौन सा कॉन्ट्रैक्ट कारोबार किया जा रहा है।
3, {@fun/Account/exchange.SetCurrency exchange.SetCurrency} फ़ंक्शन का उपयोग करके लेनदेन जोड़े को स्विच करने के कार्य और उपयोगexchange.IO("currency", currency)एक ही तरह से, एक ही तरह से, एक ही तरह से, एक ही तरह से।
3. क्रिप्टोकरेंसी एक्सचेंजों में ऑब्जेक्ट लीवरेज अकाउंट मोड के लिए स्विच करेंः- पैरामीटरkसेट करें"trade_margin", मुद्रा विनिमय खाता मोड पर स्विच करें. आदेश दें, खाता संपत्ति प्राप्त करें, एक्सचेंज के मुद्रा विनिमय लीवरेज इंटरफ़ेस तक पहुंच जाएगा.
यदि एक एक्सचेंज में पूर्ण या एक-एक करके लेनदेन करने के लिए तत्काल लीवरेज का उपयोग किया जाता हैःexchange.IO("trade_super_margin")यह एक बहुत ही अच्छा तरीका है कि हम अपने ग्राहकों के साथ एक अच्छा समय बिता सकते हैं।exchange.IO("trade_margin")एक बार जब आप अपने खाते को बंद कर देते हैं, तो आप अपने खाते को बंद कर देते हैं।
- पैरामीटरkसेट करें"trade_normal", सामान्य नकदी खाते मोड पर स्विच करें.
ऐसे एक्सचेंजों के लिए जो लीवरेज मोड को स्विच करने का समर्थन करते हैंः
| एक्सचेंज | विशेष टिप्पणी |
|---|---|
| ओकेएक्स | लीवरेज्ड खाते के मॉडल में व्यापारिक जोड़े सामान्य से भिन्न होते हैं और कुछ व्यापारिक जोड़े का उपयोग नहीं किया जा सकता है।exchange.IO("trade_super_margin")यह एक बहुत ही अच्छा तरीका है कि हम अपने ग्राहकों के साथ एक अच्छा समय बिता सकते हैं।exchange.IO("trade_margin")एक-एक करके स्विच करें.trade_normalआम मुद्रा मोड पर स्विच करें.exchange.IO("tdMode", "cross")सीधे लीवर मोड निर्दिष्ट करें. |
| सिक्का | लीवरेज खाते के मोड में व्यापारिक जोड़े सामान्य से भिन्न होते हैं, कुछ व्यापारिक जोड़े नहीं हो सकते हैं। टोकन लीवरेज खाते में पूर्ण और अलग-अलग हिस्से होते हैं, जिसका उपयोग किया जाता है।trade_marginलीवरेज खाते में स्विच करें, उपयोग करेंtrade_super_marginलीवरेज खाते के लिए पूर्ण स्टॉक स्विच करें.trade_normalइस तरह की मुद्राओं को आम मुद्राओं के रूप में बदला जा सकता है। |
| बिनेंस | लीवरेज खाते के मॉडल को एक-एक, पूर्ण-पूरा, उपयोग के रूप में विभाजित किया गया हैtrade_marginशेयरों में बदलाव, उपयोगtrade_super_marginपूर्ण भंडारण के लिए स्विच करेंtrade_normalइस तरह की मुद्राओं को आम मुद्राओं के रूप में बदला जा सकता है। |
| द्वार | लीवरेज खाते के मॉडल को एक-एक, पूर्ण-पूरा, उपयोग के रूप में विभाजित किया गया हैtrade_marginशेयरों में बदलाव, उपयोगtrade_super_marginपूर्ण भंडारण के लिए स्विच करेंtrade_normalइस तरह की मुद्राओं को आम मुद्राओं के रूप में बदला जा सकता है। |
| AscendEx | उपयोगexchange.IO("trade_margin")खाता मोड में स्विच करें, उपयोग करेंexchange.IO("trade_normal")एक सामान्य खाता मोड पर स्विच करें. |
| वू | उपयोगexchange.IO("trade_margin")लीवरेज खाता मोड में स्विच करें, उपयोग करेंexchange.IO("trade_normal")एक सामान्य खाता मोड पर स्विच करें. |
| CoinEx | उपयोगexchange.IO("trade_margin")लीवरेज खाता मोड में स्विच करें, उपयोग करेंexchange.IO("trade_normal")एक सामान्य खाता मोड पर स्विच करें. |
4. अन्य स्विचिंग सुविधाएंःउपयोगकर्ता गाइड में देखेंexchange.IO()फ़ंक्शन काअन्य स्विचिंग कार्य。
{@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@var EXCHANGE_OP_IO_CONTROL}
exchange.Log(orderType, price, amount)
exchange.Log(orderType, price, amount, ...args)
```orderType```参数用于设置输出的日志类型，可选值为{@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY}，{@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL}，{@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL}。
orderType
true
number
```price```参数用于设置输出的日志中显示的价格。
price
true
number
```amount```参数用于设置输出的日志中显示的下单量。
amount
true
number
扩展参数，可以输出附带信息到这条日志中，```arg```参数可以传多个。
arg
false
string、number、bool、object、array、空值等系统支持的任意类型
```javascript
var id = 123
function main() {
// 下单类型买入，价格999，数量 0.1
exchange.Log(LOG_TYPE_BUY, 999, 0.1)
// 取消订单
exchange.Log(LOG_TYPE_CANCEL, id)
}
id = 123
def main():
exchange.Log(LOG_TYPE_BUY, 999, 0.1)
exchange.Log(LOG_TYPE_CANCEL, id)
void main() {
auto id = 123;
exchange.Log(LOG_TYPE_BUY, 999, 0.1);
exchange.Log(LOG_TYPE_CANCEL, id);
}
उपयोगexchange.Log(orderType, price, amount)वास्तविक डिस्क पर ऑर्डर परीक्षण, सिमुलेशन ऑर्डर, ऑर्डर रिकॉर्डिंग के लिए सहायता प्रदान की जा सकती है। सबसे आम उपयोग के परिदृश्यों में से एक हैः {@fun/Trade/exchange.IO exchange.IO} फ़ंक्शन का उपयोग करके एक्सचेंज पर सर्त ऑर्डर बनाने के लिए इंटरफ़ेस का उपयोग करना, लेकिन उपयोग करनाexchange.IO()फ़ंक्शन वास्तविक डिस्क लॉग रिकॉर्ड में लेन-देन लॉग जानकारी का उत्पादन नहीं करता है।exchange.Log()फ़ंक्शन आउटपुट लॉग को पूरक करता है ताकि ऑर्डर की जानकारी दर्ज की जा सके।
जबorderTypeपैरामीटर हैLOG_TYPE_CANCELयह एक बहुत ही अच्छा समय है।priceऑर्डर आईडी के लिए पैरामीटर, सीधे उपयोग के लिएexchange.IO()फ़ंक्शन निकालने पर निकालने का लॉग प्रिंट करें।exchange.Log()फ़ंक्शन {@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट का सदस्य फ़ंक्शन है, जो वैश्विक फ़ंक्शन {@fun/Log Log} से अलग है।
{@fun/Log Log}, {@var/EXCHANGE exchange}, {@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY}, {@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL}, {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL}
```exchange.Encode()```函数返回计算出来的哈希值编码。
string
exchange.Encode(algo, inputFormat, outputFormat, data)
exchange.Encode(algo, inputFormat, outputFormat, data, keyFormat, key)
参数```algo```为编码计算时使用的算法。 支持设置为："raw"（不使用算法），"sign"，"signTx"，"md4"，"md5"，"sha256"，"sha512"，"sha1"，"keccak256"， "sha3.224"，"sha3.256"，"sha3.384"，"sha3.512"，"sha3.keccak256"，"sha3.keccak512"，"sha512.384"， "sha512.256"，"sha512.224"，"ripemd160"，"blake2b.256"，"blake2b.512"，"blake2s.128"，"blake2s.256"。 参数```algo```也支持："text.encoder.utf8"，"text.decoder.utf8"，"text.encoder.gbk"，"text.decoder.gbk"，对字符串编码、解码。 参数```algo```也支持："ed25519"算法。支持使用不同的哈希算法，例如参数```algo```可写为"ed25519.md5"、"ed25519.sha512"等。支持```ed25519.seed```计算。
algo
true
string
用于指定```data```参数的数据格式。```inputFormat```参数支持设置为："raw"，"hex"，"base64"，"string"其中之一。 "raw"表示数据为原始数据，"hex"表示数据为```hex```编码，"base64"表示数据为```base64```编码，"string"表示数据为字符串。
inputFormat
true
string
用于指定输出的数据格式。 ```outputFormat```参数支持设置为："raw"，"hex"，"base64"，"string"其中之一。 "raw"表示数据为原始数据，"hex"表示数据为```hex```编码，"base64"表示数据为```base64```编码，"string"表示数据为字符串。
outputFormat
true
string
参数```data```为所要处理的数据。
data
true
string
用于指定```key```参数的数据格式。 ```key```参数支持设置为："raw"，"hex"，"base64"，"string"其中之一。 "raw"表示数据为原始数据，"hex"表示数据为```hex```编码，"base64"表示数据为```base64```编码，"string"表示数据为字符串。
keyFormat
false
string
```key```参数用于指定签名计算时使用的密钥，可以使用明文字符串。 也可以使用```"{{accesskey}}"```、```"{{secretkey}}"```代指{@var/EXCHANGE exchange}交易所对象中配置的```accessKey```和```secretKey```。
key
false
string
```javascript
function main() {
var APIKEY = "your Access Key(Bitmex API ID)"
var expires = parseInt(Date.now() / 1000) + 10
var signature = exchange.Encode("sha256", "string", "hex", "GET/realtime" + expires, "hex", "{{secretkey}}")
var client = Dial("wss://www.bitmex.com/realtime", 60)
var auth = JSON.stringify({args: [APIKEY, expires, signature], op: "authKeyExpires"})
var pos = 0
client.write(auth)
client.write('{"op": "subscribe", "args": "position"}')
while (true) {
bitmexData = client.read()
if(bitmexData.table == 'position' && pos != parseInt(bitmexData.data[0].currentQty)){
Log('position change', pos, parseInt(bitmexData.data[0].currentQty), '@')
pos = parseInt(bitmexData.data[0].currentQty)
}
}
}
import time
def main():
APIKEY = "your Access Key(Bitmex API ID)"
expires = int(time.time() + 10)
signature = exchange.Encode("sha256", "string", "hex", "GET/realtime" + expires, "hex", "{{secretkey}}")
client = Dial("wss://www.bitmex.com/realtime", 60)
auth = json.dumps({"args": [APIKEY, expires, signature], "op": "authKeyExpires"})
pos = 0
client.write(auth)
client.write('{"op": "subscribe", "args": "position"}')
while True:
bitmexData = json.loads(client.read())
if "table" in bitmexData and bitmexData["table"] == "position" and len(bitmexData["data"]) != 0 and pos != bitmexData["data"][0]["currentQty"]:
Log("position change", pos, bitmexData["data"][0]["currentQty"], "@")
pos = bitmexData["data"][0]["currentQty"]
void main() {
auto APIKEY = "your Access Key(Bitmex API ID)";
auto expires = Unix() + 10;
auto signature = exchange.Encode("sha256", "string", "hex", format("GET/realtime%d", expires), "hex", "{{secretkey}}");
auto client = Dial("wss://www.bitmex.com/realtime", 60);
json auth = R"({"args": [], "op": "authKeyExpires"})"_json;
auth["args"].push_back(APIKEY);
auth["args"].push_back(expires);
auth["args"].push_back(signature);
auto pos = 0;
client.write(auth.dump());
client.write("{\"op\": \"subscribe\", \"args\": \"position\"}");
while(true) {
auto bitmexData = json::parse(client.read());
if(bitmexData["table"] == "position" && bitmexData["data"][0].find("currentQty") != bitmexData["data"][0].end() && pos != bitmexData["data"][0]["currentQty"]) {
Log("测试");
Log("position change", pos, bitmexData["data"][0]["currentQty"], "@");
pos = bitmexData["data"][0]["currentQty"];
}
}
}
BitMEX स्थिति परिवर्तन पुश (WSS प्रोटोकॉल) उदाहरणः
केवल डिस्क कॉल का समर्थन करेंexchange.Encode()फ़ंक्शन ।"{{accesskey}}"、"{{secretkey}}"केवल संदर्भ के लिएexchange.Encode()फ़ंक्शन का उपयोग करते समय प्रभावी होता है।
{@var/EXCHANGE exchange}, {@fun/Global/Encode Encode}
मल्टी-थ्रेड असिंक्रोनस फ़ंक्शन का समर्थन करता है, जो सभी समर्थित फ़ंक्शनों के संचालन को असिंक्रोनस के रूप में निष्पादित करता है।
object
exchange.Go(method)
exchange.Go(method, ...args)
```method```参数用于指定并发的函数名称，注意该参数是函数名称字符串，并非函数引用。
method
true
string
**并发执行函数**的参数，参数```arg```可能有多个。参数```arg```的类型与个数根据**并发执行函数**的参数而定。
arg
false
string、number、bool、object、array、function、空值等系统支持的所有类型
```javascript
function main(){
// 以下四种操作是并发多线程异步执行, 不会耗时, 立即返回的
var a = exchange.Go("GetTicker")
var b = exchange.Go("GetDepth")
var c = exchange.Go("Buy", 1000, 0.1)
var d = exchange.Go("GetRecords", PERIOD_H1)
// 调用wait方法等待返回异步获取ticker结果
var ticker = a.wait()
// 返回深度, 如果获取失败也是有可能返回null的
var depth = b.wait()
// 返回订单号, 限定1秒超时, 超时返回undefined, 此对象可以继续调用wait等待如果上次wait超时
var orderId = c.wait(1000)
if(typeof(orderId) == "undefined") {
// 超时，重新获取
orderId = c.wait()
}
var records = d.wait()
}
def main():
a = exchange.Go("GetTicker")
b = exchange.Go("GetDepth")
c = exchange.Go("Buy", 1000, 0.1)
d = exchange.Go("GetRecords", PERIOD_H1)
ticker, ok = a.wait()
depth, ok = b.wait()
orderId, ok = c.wait(1000)
if ok == False:
orderId, ok = c.wait()
records, ok = d.wait()
void main() {
auto a = exchange.Go("GetTicker");
auto b = exchange.Go("GetDepth");
auto c = exchange.Go("Buy", 1000, 0.1);
auto d = exchange.Go("GetRecords", PERIOD_H1);
Ticker ticker;
Depth depth;
Records records;
TId orderId;
a.wait(ticker);
b.wait(depth);
if(!c.wait(orderId, 300)) {
c.wait(orderId);
}
d.wait(records);
}
```javascript
function main() {
var d = exchange.Go("GetRecords", PERIOD_H1)
// 等待K线结果
var records = d.wait()
// 这里wait了一个已经wait过且结束的异步操作,会返回null,并记录出错信息
var ret = d.wait()
}
def main():
d = exchange.Go("GetRecords", PERIOD_H1)
records, ok = d.wait()
ret, ok = d.wait()
void main() {
auto d = exchange.Go("GetRecords", PERIOD_H1);
Records records;
d.wait(records);
Records ret;
d.wait(ret);
}
पहले से ही जारी किए गए समवर्ती ऑब्जेक्ट को कॉल करेंwait()इस तरह की गलतियाँ होती हैं:
function main() {
while(true) {
var beginTS = new Date().getTime()
var arrRoutine = []
var arrTicker = []
var arrName = []
for(var i = 0; i < exchanges.length; i++) {
arrRoutine.push(exchanges[i].Go("GetTicker"))
arrName.push(exchanges[i].GetName())
}
for(var i = 0; i < arrRoutine.length; i++) {
arrTicker.push(arrRoutine[i].wait())
}
var endTS = new Date().getTime()
var tbl = {
type: "table",
title: "行情",
cols: ["索引", "名称", "最新成交价"],
rows: []
}
for(var i = 0; i < arrTicker.length; i++) {
tbl.rows.push([i, arrName[i], arrTicker[i].Last])
}
LogStatus(_D(), "并发获取多个交易所行情总耗时：", endTS - beginTS, "毫秒", "\n", "`" + JSON.stringify(tbl) + "`")
Sleep(500)
}
}
import time
import json
def main():
while True:
beginTS = time.time()
arrRoutine = []
arrTicker = []
arrName = []
for i in range(len(exchanges)):
arrRoutine.append(exchanges[i].Go("GetTicker"))
arrName.append(exchanges[i].GetName())
for i in range(len(exchanges)):
ticker, ok = arrRoutine[i].wait()
arrTicker.append(ticker)
endTS = time.time()
tbl = {
"type": "table",
"title": "行情",
"cols": ["索引", "名称", "最新成交价"],
"rows": []
}
for i in range(len(arrTicker)):
tbl["rows"].append([i, arrName[i], arrTicker[i]["Last"]])
LogStatus(_D(), "并发获取多个交易所行情总耗时：", endTS - beginTS, "秒", "\n", "`" + json.dumps(tbl) + "`")
Sleep(500)
void main() {
while(true) {
int length = exchanges.size();
auto beginTS = UnixNano() / 1000000;
Ticker arrTicker[length] = {};
string arrName[length] = {};
// 注意，添加几个交易所对象，这里要执行几次exchanges[n].Go 函数，这个例子是需要添加四个交易所对象，具体可以修改
auto r0 = exchanges[0].Go("GetTicker");
auto r1 = exchanges[1].Go("GetTicker");
auto r2 = exchanges[2].Go("GetTicker");
auto r3 = exchanges[3].Go("GetTicker");
GoObj *arrRoutine[length] = {&r0, &r1, &r2, &r3};
for(int i = 0; i < length; i++) {
arrName[i] = exchanges[i].GetName();
}
for(int i = 0; i < length; i++) {
Ticker ticker;
arrRoutine[i]->wait(ticker);
arrTicker[i] = ticker;
}
auto endTS = UnixNano() / 1000000;
json tbl = R"({
"type": "table",
"title": "行情",
"cols": ["索引", "名称", "最新成交价"],
"rows": []
})"_json;
for(int i = 0; i < length; i++) {
json arr = R"(["", "", ""])"_json;
arr[0] = format("%d", i);
arr[1] = arrName[i];
arr[2] = format("%f", arrTicker[i].Last);
tbl["rows"].push_back(arr);
}
LogStatus(_D(), "并发获取多个交易所行情总耗时：", format("%d", endTS - beginTS), "毫秒", "\n", "`" + tbl.dump() + "`");
Sleep(500);
}
}
एक बार फिर से, यह एक बहुत ही महत्वपूर्ण कदम है।
function main() {
/*
使用OKX期货下单接口测试
POST /api/v5/trade/order
*/
var beginTS = new Date().getTime()
var param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
var ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
var ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
var ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
var id1 = ret1.wait()
var id2 = ret2.wait()
var id3 = ret3.wait()
var endTS = new Date().getTime()
Log("id1:", id1)
Log("id2:", id2)
Log("id3:", id3)
Log("并发下单耗时：", endTS - beginTS, "毫秒")
}
import time
import json
def main():
beginTS = time.time()
param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
id1, ok1 = ret1.wait()
id2, ok2 = ret2.wait()
id3, ok3 = ret3.wait()
endTS = time.time()
Log("id1:", id1)
Log("id2:", id2)
Log("id3:", id3)
Log("并发下单耗时：", endTS - beginTS, "秒")
void main() {
auto beginTS = UnixNano() / 1000000;
json param = R"({"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"})"_json;
auto ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
auto ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
auto ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
json id1 = R"({})"_json;
json id2 = R"({})"_json;
json id3 = R"({})"_json;
ret1.wait(id1);
ret2.wait(id2);
ret3.wait(id3);
auto endTS = UnixNano() / 1000000;
Log("id1:", id1);
Log("id2:", id2);
Log("id3:", id3);
Log("并发下单耗时：", endTS - beginTS, "毫秒");
}
हाँexchange.IO("api", ...)फ़ंक्शन को एक साथ कॉल करेंः
function main() {
var counter = 0
var arr = [] // 用于测试持续引用并发的相关变量
var symbols = ["BTC_USDT", "ETH_USDT", "SOL_USDT", "LTC_USDT", "EOS_USDT"]
while (true) {
var arrRoutine = []
for (var symbol of symbols) {
var r = exchange.Go("GetTicker", symbol)
arrRoutine.push(r) // 记录并发对象用于调用 r.wait() 函数获取结果，每一轮循环都清空
// arr.push(r) // 如果使用这句代码，运行时持续引用并发的对象，无法自动释放，超过2000个并发时，会报错：```InternalError: too many routine wait, max is 2000```。
counter++
}
// 遍历 arrRoutine 调用 r.wait()
LogStatus(_D(), "routine number:", counter)
Sleep(50)
}
}
स्वचालित रिहाई तंत्र के परीक्षण
यह फ़ंक्शन केवल वास्तविक डिस्क पर चल रहे मल्टीथ्रेड निष्पादन कार्यों को बनाता है, और पुनरावृत्ति मल्टीथ्रेड समवर्ती निष्पादन कार्यों का समर्थन नहीं करती है (पुनरावृत्ति उपलब्ध है, लेकिन क्रमबद्ध निष्पादन) ।
当并发的多线程任务执行完毕时，相关变量没有被继续引用，系统底层会自动处理资源回收。
```wait()```方法支持超时参数：
1、不设置超时参数，即```wait()```，或者设置超时参数0，即```wait(0)```。```wait()```函数会阻塞等待，直到并发的线程运行完毕，返回并发线程执行的结果。
2、设置超时参数-1，即```wait(-1)```。```wait()```函数会立即返回，不同编程语言有不同的返回值，具体可以参考本小节的调用例子。
3、设置具体超时参数，即```wait(300)```，```wait()```函数会等待最长300毫秒后返回。
虽然系统底层有自动回收机制，但是如果持续引用相关变量，并发的线程并不会释放。并发的线程数量超过2000个会报错：```"too many routine wait, max is 2000"```。
支持的函数：```GetTicker```，```GetDepth```，```GetTrades```，```GetRecords```，```GetAccount```，```GetOrders```，```GetOrder```，```CancelOrder```，```Buy```，```Sell```，```GetPositions```，```IO```等。
这些函数并发调用时都基于当前{@var/EXCHANGE exchange}交易所对象执行。
Python语言与JavaScript语言中的区别，Python语言中并发对象的```wait()```函数返回两个参数，第一个是异步的api调用返回的结果，第二个表示是异步调用是否完成。
```python
def main():
d = exchange.Go("GetRecords", PERIOD_D1)
# ok是一定返回True的, 除非策略被停止
ret, ok = d.wait()
# 如果等待超时, 或者wait了一个已经结束的实例，ok返回False
ret, ok = d.wait(100)
{@fun/Global/Mail_Go Mail_Go}, {@fun/Global/HttpQuery_Go HttpQuery_Go}, {@fun/Global/EventLoop EventLoop}
查询账户资产信息，查询成功返回{@struct/Account Account}结构，查询失败返回空值。
{@struct/Account Account}、空值
exchange.GetAccount()
```javascript
function main(){
// 切换交易对
exchange.IO("currency", "BTC_USDT")
// 以OKX期货为例，设置合约为当周合约，当前交易对为BTC_USDT，所以当前合约为BTC的U本位当周合约
exchange.SetContractType("this_week")
// 获取当前账户资产数据
var account = exchange.GetAccount()
// USDT作为保证金的可用余额
Log(account.Balance)
// USDT作为保证金的冻结金额
Log(account.FrozenBalance)
// 当前资产权益
Log(account.Equity)
// 当前资产作为保证金的所有持仓的未实现盈亏
Log(account.UPnL)
}
def main():
exchange.IO("currency", "BTC_USDT")
exchange.SetContractType("this_week")
account = exchange.GetAccount()
Log(account["Balance"])
Log(account["FrozenBalance"])
Log(account["Equity"])
Log(account["UPnL"])
void main() {
exchange.IO("currency", "BTC_USDT");
exchange.SetContractType("this_week");
auto account = exchange.GetAccount();
Log(account.Balance);
Log(account.FrozenBalance);
Log(account.Equity);
Log(account.UPnL);
}
ट्रेड जोड़े, अनुबंध कोड, वर्तमान खाता जानकारी सेट करें।
यदि एक्सचेंज का ऑब्जेक्ट क्रिप्टोक्यूरेंसी फ्यूचर्स एक्सचेंज के रूप में सेट किया गया है, औरUSDTजब गारंटी के अनुबंध के रूप में (देखें {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType} फ़ंक्शन), संपत्ति हैUSDTयह {@struct/Account Account} संरचना में दर्ज किया गया है।Balance、FrozenBalanceविशेषता में ।
यदि एक्सचेंज का ऑब्जेक्ट क्रिप्टोक्यूरेंसी फ्यूचर्स कॉन्ट्रैक्ट एक्सचेंज के रूप में सेट किया गया है, और मुद्रा-मूल्य वाले कॉन्ट्रैक्ट में स्विच किया गया है, तो संपत्ति को मुद्रा के रूप में प्रतिभूत किया जाता है और {@struct/Account Account} संरचना में दर्ज किया जाता है।Stocks、FrozenStocksविशेषता में ।
बिनान फ्यूचर्स यूनिफाइड अकाउंट का उपयोग करते समय कॉल करेंexchange.GetAccount()जब फ़ंक्शन खाते की जानकारी का अनुरोध करता है, तो सभी परिसंपत्तियों के लिए डेटा को बंद कर दिया जाता हैयूएसडी{@struct/Account Account} संरचना में दिखाई गई राशिBalanceयदि अन्य परिसंपत्तियों के लिए कटौती राशि का गणना करना आवश्यक है, तो USD कटौती राशि का उपयोग करके कटौती की जाने वाली परिसंपत्ति के सूचकांक मूल्य को घटाकर और गिरवी रखने की दर को घटाकर कटौती की जाने वाली परिसंपत्ति का उपयोग किया जा सकता है।
{@struct/Account Account}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@struct/Account Account}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency},
```exchange.GetAssets()```函数请求数据成功时返回{@struct/Asset Asset}结构数组，请求数据失败时返回空值。
{@struct/Asset Asset}数组、空值
exchange.GetAssets()
```javascript
function main() {
// exchange.SetCurrency("BTC_USDT") // 可以设置交易对
// exchange.SetContractType("swap") // 可以设置合约
var assets = exchange.GetAssets()
Log(assets)
}
def main():
# exchange.SetCurrency("BTC_USDT") # 可以设置交易对
# exchange.SetContractType("swap") # 可以设置合约
assets = exchange.GetAssets()
Log(assets)
void main() {
// exchange.SetCurrency("BTC_USDT"); // 可以设置交易对
// exchange.SetContractType("swap"); // 可以设置合约
auto assets = exchange.GetAssets();
Log(assets);
}
एक बार जब आप एक एक्सचेंज खाते की संपत्ति की जानकारी प्राप्त करते हैं, तो आप एक बार फिर से एक एक्सचेंज खाते की संपत्ति की जानकारी प्राप्त कर सकते हैं।exchange.GetAssets()एक एलिमेंट को एसेट स्ट्रक्चर के लिए एक सरणी देता है।
फ्यूचर्स एक्सचेंजों के विषयGetAssets()फ़ंक्शन वर्तमान लेन-देन के लिए (मुद्रा मूलधन, USDT मूलधन, USDC मूलधन आदि) के तहत संपार्श्विक संपत्ति को लौटाता है।
{@struct/Asset Asset}
```exchange.GetName()```函数返回FMZ量化交易平台定义的交易所名称。
string
exchange.GetName()
```javascript
function main() {
Log("判断交易所对象exchange为币安现货，判断结果为：", exchange.GetName() == "Binance")
}
def main():
Log("判断交易所对象exchange为币安现货，判断结果为：", exchange.GetName() == "Binance")
void main() {
Log("判断交易所对象exchange为币安现货，判断结果为：", exchange.GetName() == "Binance");
}
{@fun/Account/exchange.GetLabel exchange.GetLabel}
### exchange.GetLabel
```exchange.GetLabel()```函数用于获取配置交易所对象时设置的自定义标签。
```exchange.GetLabel()```函数返回配置交易所对象时设置的自定义标签。
string
exchange.GetLabel()
```javascript
function main() {
Log("exchange label:", exchange.GetLabel())
}
def main():
Log("exchange label:", exchange.GetLabel())
void main() {
Log("exchange label:", exchange.GetLabel());
}
सेट टैग के द्वारा नीति कोड में पहचाने जाने वालेexchangeयाexchanges[1]、exchanges[2]उदाहरण के लिए, एक्सचेंज ऑब्जेक्ट।
{@var/EXCHANGE विनिमय}
```exchange.GetCurrency()```函数返回当前{@var/EXCHANGE exchange}交易所对象设置的交易对。
string
exchange.GetCurrency()
```javascript
function main() {
Log("exchange 当前交易对为：", exchange.GetCurrency())
}
def main():
Log("exchange 当前交易对为：", exchange.GetCurrency())
void main() {
Log("exchange 当前交易对为：", exchange.GetCurrency());
}
लेन-देन को बड़े अक्षरों में एक समान प्रारूप में लिखना, नीचे की रेखाओं के साथ अलग करनाbaseCurrencyके साथquoteCurrencyउदाहरण के लिएःBTC_USDT。
{@मज़ा/खाता/विनिमय.सेट करेंसी विनिमय.सेट करेंसी}
exchange.SetCurrency(currency)
```currency```参数用于设置切换的交易对，交易对格式统一为大写，使用下划线分隔```baseCurrency```与```quoteCurrency```，例如：```BTC_USDT```。
currency
true
string
```javascript
function main() {
var ticker = exchange.GetTicker()
Log(ticker)
Log(exchange.GetAccount())
// 切换交易对，注意切换后行情数据，账户信息的变化
exchange.SetCurrency("LTC_USDT")
Log("切换为LTC_USDT")
ticker = exchange.GetTicker()
Log(ticker)
Log(exchange.GetAccount())
}
def main():
ticker = exchange.GetTicker()
Log(ticker)
Log(exchange.GetAccount())
exchange.SetCurrency("LTC_USDT")
Log("切换为LTC_USDT")
ticker = exchange.GetTicker()
Log(ticker)
Log(exchange.GetAccount())
void main() {
auto ticker = exchange.GetTicker();
Log(ticker);
Log(exchange.GetAccount());
exchange.SetCurrency("LTC_USDT");
Log("切换为LTC_USDT");
ticker = exchange.GetTicker();
Log(ticker);
Log(exchange.GetAccount());
}
1. संगतताexchange.IO("currency", "BTC_USDT")इस तरह के परिवर्तन के लिए, {@fun excahnge.IO} देखें।
2, बैक-टेकिंग सिस्टम में स्विच लेनदेन जोड़े का समर्थन करता है, बैक-टेकिंग सिस्टम में स्विच लेनदेन जोड़े के लिए समय-मुद्रांकन मुद्रा नाम नहीं बदल सकते हैं; उदाहरण के लिएःBTC_USDTआप इसे बदल सकते हैंLTC_USDT, को स्विच नहीं कर सकतेLTC_BTC..
3 ⇒ गैर-पुनर्विचार पृष्ठ पर प्रारंभिक सेटिंग के लिए स्विच करने के लिए लेन-देन के लिए बाद के लेन-देन के सिक्कों की संख्या 0 है। उदाहरण के लिएः पुनर्विचार पृष्ठ पर प्रारंभिक सेटिंग के लिए एक लेन-देन जोड़ी के लिएBTC_USDT，BTCयह संख्या तीन है।USDTसंख्या 10000 है. अब तुरंत स्विच करेंLTC_USDT, एक्सचेंज के बाद लेन-देन के सिक्के की संख्या 0 है, यानी खाते मेंLTCसंख्या 0 है, स्विच किए गए लेनदेन के लिए साझा करेंUSDTसंख्या, संख्या 10000 है।
{@मज़ा/खाता/विनिमय.GetCurrency विनिमय.GetCurrency}
```exchange.GetQuoteCurrency()```函数返回当前交易对的计价币名称。
string
exchange.GetQuoteCurrency()
```javascript
function main() {
exchange.SetCurrency("BTC_USDT")
Log("BTC_USDT的计价币名称：", exchange.GetQuoteCurrency())
// exchange.SetCurrency("ETH_BTC")
// Log("ETH_BTC的计价币名称：", exchange.GetQuoteCurrency())
}
def main():
exchange.SetCurrency("BTC_USDT")
Log("BTC_USDT的计价币名称：", exchange.GetQuoteCurrency())
# exchange.SetCurrency("ETH_BTC")
# Log("ETH_BTC的计价币名称：", exchange.GetQuoteCurrency())
void main() {
exchange.SetCurrency("BTC_USDT");
Log("BTC_USDT的计价币名称：", exchange.GetQuoteCurrency());
// exchange.SetCurrency("ETH_BTC")
// Log("ETH_BTC的计价币名称：", exchange.GetQuoteCurrency())
}
उदाहरण के लिएः{@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट के लिए वर्तमान लेनदेन जोड़ीBTC_USDT，exchange.GetQuoteCurrency()फ़ंक्शन वापस आता है.USDT❖ यदि वर्तमान लेन-देन के लिएETH_BTC，exchange.GetQuoteCurrency()फ़ंक्शन वापस आता है.BTC。
{@fun/Account/exchange.GetCurrency exchange.GetCurrency}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Account/exchange.SetCurrency.GetCurrency.GetCurrency.GetCurrency}, {@fun/Account/exchange.SetCurrency.SetCurrency.GetCurrency.GetCurrency.GetCurrency.GetCurrency}, {@fun/Account/exchange.SetCurrency.SetCurrency.GetCurrency.GetCurrency.GetCurrency.GetCurrency}, {@fun/Account/exchange.SetCurrency.SetCurrency.SetCurrency.GetCurrency.GetCurrency.GetCurrency}, {@fun/Account/Account/exchange.GetCurrency.GetCurrency.GetCurrency.GetCurrency.GetC
```exchange.GetPositions()```函数请求数据成功时返回{@struct/Position Position}结构数组，请求数据失败时返回空值。
{@struct/Position Position}数组、空值
exchange.GetPositions()
exchange.GetPositions(symbol)
参数```symbol```用于设置所要查询的**交易品种**或者**交易品种的范围**。
不传```symbol```参数时，默认以当前交易对、合约代码所在维度范围请求所有品种的持仓数据。
symbol
false
string
```javascript
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for (var symbol of arrSymbol) {
exchange.CreateOrder(symbol, "buy", -1, 1)
exchange.CreateOrder(symbol, "sell", -1, 1)
}
var defaultPositions = exchange.GetPositions()
var swapPositions = exchange.GetPositions("USDT.swap")
var futuresPositions = exchange.GetPositions("USDT.futures")
var btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap")
var tbls = []
var arr = [defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions]
var tblDesc = ["defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"]
for (var index in arr) {
var positions = arr[index]
var tbl = {type: "table", title: tblDesc[index], cols: ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"], rows: [] }
for (var pos of positions) {
tbl.rows.push([pos.Symbol, pos.MarginLevel, pos.Amount, pos.FrozenAmount, pos.Price, pos.Profit, pos.Type, pos.ContractType, pos.Margin])
}
tbls.push(tbl)
}
LogStatus("`" + JSON.stringify(tbls) + "`")
// 打印输出一次信息后返回，防止后续回测时订单成交，影响数据观察
return
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for symbol in arrSymbol:
exchange.CreateOrder(symbol, "buy", -1, 1)
exchange.CreateOrder(symbol, "sell", -1, 1)
defaultPositions = exchange.GetPositions()
swapPositions = exchange.GetPositions("USDT.swap")
futuresPositions = exchange.GetPositions("USDT.futures")
btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap")
tbls = []
arr = [defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions]
tblDesc = ["defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"]
for index in range(len(arr)):
positions = arr[index]
tbl = {"type": "table", "title": tblDesc[index], "cols": ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"], "rows": []}
for pos in positions:
tbl["rows"].append([pos["Symbol"], pos["MarginLevel"], pos["Amount"], pos["FrozenAmount"], pos["Price"], pos["Profit"], pos["Type"], pos["ContractType"], pos["Margin"]])
tbls.append(tbl)
LogStatus("`" + json.dumps(tbls) + "`")
return
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
for (const auto& symbol : arrSymbol) {
exchange.CreateOrder(symbol, "buy", -1, 1);
exchange.CreateOrder(symbol, "sell", -1, 1);
}
auto defaultPositions = exchange.GetPositions();
auto swapPositions = exchange.GetPositions("USDT.swap");
auto futuresPositions = exchange.GetPositions("USDT.futures");
auto btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap");
json tbls = R"([])"_json;
std::vector<std::vector<Position>> arr = {defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions};
std::string tblDesc[] = {"defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"};
for (int index = 0; index < arr.size(); index++) {
auto positions = arr[index];
json tbl = R"({
"type": "table",
"cols": ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"],
"rows": []
})"_json;
tbl["title"] = tblDesc[index];
for (const auto& pos : positions) {
json arrJson = R"([])"_json;
arrJson.push_back(pos.Symbol);
arrJson.push_back(pos.MarginLevel);
arrJson.push_back(pos.Amount);
arrJson.push_back(pos.FrozenAmount);
arrJson.push_back(pos.Price);
arrJson.push_back(pos.Profit);
arrJson.push_back(pos.Type);
arrJson.push_back(pos.ContractType);
arrJson.push_back(pos.Margin);
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
}
LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
return;
}
फ्यूचर्स एक्सचेंज के ऑब्जेक्ट का उपयोग करके, कई अलग-अलग ट्रेडिंग जोड़े, अनुबंध कोड के विभिन्न प्रकार के नीचे सूचीबद्ध मूल्य सूची; विभिन्न तरीकों से स्टॉक पूछें।
क्रिप्टोक्यूरेंसी फ्यूचर्स कॉन्ट्रैक्ट क्रिप्टोक्यूरेंसी नकदी से अलग है, नकदी केवल तार्किक रूप से होल्डिंग अवधारणा है। एफएमजेड क्वांटिफाइड ट्रेडिंग प्लेटफॉर्म के सिस्टम में क्रिप्टोक्यूरेंसी फ्यूचर्स कॉन्ट्रैक्ट की विशिष्ट किस्मेंसौदा सही、अनुबंध कोडआम तौर पर पहचाने जाने वाले. आप {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType} फ़ंक्शन को देख सकते हैं.
मेंGetPositionsफ़ंक्शन में, symbol पैरामीटर के उपयोग के परिदृश्यों को संक्षेप में प्रस्तुत किया गया हैः
| एक्सचेंज ऑब्जेक्ट्स का वर्गीकरण | symbol पैरामीटर | पूछताछ का दायरा | नोट्स |
|---|---|---|---|
| वायदा | कोई प्रतीक पैरामीटर नहीं | वर्तमान लेनदेन जोड़े, अनुबंध कोड आयाम के सभी लेनदेन किस्मों की जांच करें | यदि वर्तमान लेन-देन जोड़ी BTC_USDT है, तो कॉन्ट्रैक्ट कोड swap है, यानी सभी USDT स्थानिक स्थायी अनुबंधों का पता लगाएं.GetPositions("USDT.swap") |
| वायदा | विनिमय प्रकार निर्दिष्ट करें, प्रतीक पैरामीटर हैः |
बीटीसी के लिए यूएसडीटी स्थायी ठेके की जांच करें | फ्यूचर्स एक्सचेंज ऑब्जेक्ट के लिए, पैरामीटर प्रतीक प्रारूपःसौदा सहीके साथअनुबंध कोडसंयोजन, अक्षरों के साथ"."यह एक बहुत ही दिलचस्प लेख है। |
| वायदा | 指定交易品种范围，symbol参数为：”USDT.swap” | USDT के सभी स्थायी ठेके देखें | - |
| विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज | कोई प्रतीक पैरामीटर नहीं | सभी विकल्प अनुबंधों के लिए आयाम सीमा पर वर्तमान लेनदेन की जांच करें | यदि वर्तमान ट्रेडिंग जोड़ी BTC_USDT है, तो अनुबंध को विकल्प अनुबंध के रूप में सेट करें, उदाहरण के लिए, बिनान विकल्प अनुबंधः BTC-240108-40000-C |
| विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज | विशिष्ट लेन-देन की किस्में निर्दिष्ट करें | निर्दिष्ट विकल्प अनुबंध की जांच करें | उदाहरण के लिए, विनय वायदा एक्सचेंज के लिए, प्रतीक पैरामीटरः BTC_USDT.BTC-240108-40000-C |
| विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज | 指定交易品种范围，symbol参数为：”USDT.option” | सभी USDT स्थानीय विकल्प अनुबंध देखें | - |
मेंGetPositionsफ़ंक्शन में, फ्यूचर्स एक्सचेंज ऑब्जेक्ट क्वेरी आयाम सीमा को समेकित किया जाता हैः
| symbol पैरामीटर | अनुरोध का दायरा | नोट्स |
|---|---|---|
| USDT.swap | USDT के स्थायी अनुबंध का दायरा। | एक्सचेंज एपीआई इंटरफेस द्वारा समर्थित नहीं किए गए आयामों के लिए, कॉल करने पर एक त्रुटि लौटाई जाएगी। |
| USDT.futures | USDT की स्थानीय विनिमय दर लगभग है। | - |
| USD.swap | इस तरह के एक नए नियम के तहत, मुद्रा विनिमय के लिए स्थायी अनुबंध का दायरा। | - |
| USD.futures | मुद्रा विनिमय दर लगभग दायरे में है। | - |
| USDT.option | USDT स्थानीय विकल्प अनुबंधों का दायरा। | - |
| USD.option | मुद्रा स्थानिक विकल्प अनुबंधों का दायरा। | - |
| USDT.futures_combo | यह एक बहुत ही अच्छा तरीका है। | Futures_Deribit एक्सचेंज |
| USD.futures_ff | मिश्रित प्रतिभूतियों का भुगतान अनुपात लगभग दायरा। | Futures_Kraken एक्सचेंज |
| USD.swap_pf | मिश्रित प्रतिभूतियों के लिए स्थायी अनुबंध का दायरा। | Futures_Kraken एक्सचेंज |
संगतताexchange.GetPosition()कॉल करें।GetPositionके साथGetPositionsयह पूरी तरह से एक जैसा है।
जब एक्सचेंज वस्तुexchangeप्रतिनिधि के खाते मेंपूछताछ के दायरे मेंयाविनिर्दिष्ट व्यापारिक किस्मजब कोई स्टॉक नहीं हैexchange.GetPositions()फ़ंक्शन खाली सरणी देता है, उदाहरण के लिएः[]。
{@struct/Position Position}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@struct/Position Position}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.
exchange.SetMarginLevel(symbol, marginLevel)
exchange.SetMarginLevel(marginLevel)
```symbol```参数用于指定需要调整杠杆值的交易对、合约。```SetMarginLevel()```函数的```symbol```参数的格式与```GetTicker()```函数的```symbol```参数的格式一致。
symbol
false
string
```marginLevel```参数用于设置杠杆值，交易所的杠杆值通常是整数，也支持一些交易所的浮点数杠杆值设置。
marginLevel
true
number
```javascript
function main() {
exchange.SetMarginLevel(10)
// 设置BTC的USDT本位永续合约的杠杆为15
exchange.SetMarginLevel("BTC_USDT.swap", 15)
}
def main():
exchange.SetMarginLevel(10)
exchange.SetMarginLevel("BTC_USDT.swap", 15)
void main() {
exchange.SetMarginLevel(10);
exchange.SetMarginLevel("BTC_USDT.swap", 15);
}
对于加密货币期货合约来说，由于加密货币期货合约交易所的杠杆机制并不统一。 有些交易所期货合约杠杆值是下单接口中的一个参数，这时调用```exchange.SetMarginLevel()```函数并不产生网络请求，仅设置FMZ系统底层中的杠杆变量（用于下单接口传参）。 有些交易所期货合约杠杆值是交易所的一项设置，是需要通过在交易所网站页面设置或者使用API接口设置。 此时调用```exchange.SetMarginLevel()```函数就会产生网络请求，并且有可能设置杠杆失败。 原因可能有很多，例如：当前有持仓、挂单，导致这个交易对、合约无法再设置新的杠杆值。
不支持```exchange.SetMarginLevel()```函数的交易所：
| 函数名 | 不支持的现货交易所 | 不支持的期货交易所 |
| - | - | - |
| SetMarginLevel | -- | Futures_dYdX / Futures_Deribit |
{@var/EXCHANGE exchange}
### exchange.SetDirection
```exchange.SetDirection()```函数用于设置{@fun/Trade/exchange.Buy exchange.Buy}函数、{@fun/Trade/exchange.Sell exchange.Sell}函数进行期货合约下单时的订单方向。
exchange.SetDirection(direction)
```direction```参数用于设置期货合约下单时的方向，可选值为：```"buy"```、```"closesell"```、```"sell"```、```"closebuy"```。
direction
true
string
```javascript
function main(){
// 举例设置为OKX期货当周合约
exchange.SetContractType("this_week")
// 设置杠杆为5倍
exchange.SetMarginLevel(5)
// 设置下单类型为做多
exchange.SetDirection("buy")
// 以10000的价格，合约数量为2张下单
exchange.Buy(10000, 2)
exchange.SetMarginLevel(5)
exchange.SetDirection("closebuy")
exchange.Sell(1000, 2)
}
def main():
exchange.SetContractType("this_week")
exchange.SetMarginLevel(5)
exchange.SetDirection("buy")
exchange.Buy(10000, 2)
exchange.SetMarginLevel(5)
exchange.SetDirection("closebuy")
exchange.Sell(1000, 2)
void main() {
exchange.SetContractType("this_week");
exchange.SetMarginLevel(5);
exchange.SetDirection("buy");
exchange.Buy(10000, 2);
exchange.SetMarginLevel(5);
exchange.SetDirection("closebuy");
exchange.Sell(1000, 2);
}
|下单函数|SetDirection函数的参数设置的方向|备注|
|-|-|-|
|exchange.Buy|"buy"|买入开多仓|
|exchange.Buy|"closesell"|买入平空仓|
|exchange.Sell|"sell"|卖出开空仓|
|exchange.Sell|"closebuy"|卖出平多仓|
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
### exchange.SetContractType
```exchange.SetContractType()```函数用于设置{@var/EXCHANGE exchange}交易所对象当前的合约代码。
```exchange.SetContractType()```函数返回一个结构，其中包含当前合约代码对应的交易所合约代码。 例如币安期货合约交易所，当前合约代码为```quarter```，该函数的返回值结构为：```{"InstrumentID":"BTCUSD_230630","instrument":"BTCUSD_230630"}```。
object
exchange.SetContractType(symbol)
```symbol```参数用于设置合约代码，可选值为：```"this_week"```、```"next_week"```、```"quarter"```、```"next_quarter"```、```"swap"```等。
加密货币期货合约中**交割合约**代码如无特殊说明一般有：
- ```this_week```：当周合约。
- ```next_week```：次周合约。
- ```quarter```：季度合约。
- ```next_quarter```：次季度合约。
加密货币期货合约中**永续合约**代码如无特殊说明一般有：
- ```swap```：永续合约。
symbol
true
string
```javascript
function main() {
// 设置为当周合约
exchange.SetContractType("this_week")
}
def main():
exchange.SetContractType("this_week")
void main() {
exchange.SetContractType("this_week");
}
वर्तमान अनुबंध को सप्ताह के अनुबंध के रूप में सेट करेंः
function main() {
// 默认交易对为BTC_USD，设置合约为当周，合约为币本位合约
exchange.SetContractType("this_week")
Log("ticker:", exchange.GetTicker())
// 切换交易对，然后设置合约，切换成USDT作为保证金的合约，区别于币本位合约
exchange.IO("currency", "BTC_USDT")
exchange.SetContractType("swap")
Log("ticker:", exchange.GetTicker())
}
def main():
exchange.SetContractType("this_week")
Log("ticker:", exchange.GetTicker())
exchange.IO("currency", "BTC_USDT")
exchange.SetContractType("swap")
Log("ticker:", exchange.GetTicker())
void main() {
exchange.SetContractType("this_week");
Log("ticker:", exchange.GetTicker());
exchange.IO("currency", "BTC_USDT");
exchange.SetContractType("swap");
Log("ticker:", exchange.GetTicker());
}
सेटिंग्सUSDTजब एक प्रतिभूति के लिए एक अनुबंध के रूप में, कोड में एक लेनदेन जोड़ी को स्विच करने की आवश्यकता होती है (आप सीधे लेनदेन जोड़ी को भी सेट कर सकते हैं जब आप एक्सचेंज ऑब्जेक्ट जोड़ते हैं):
function main(){
// 设置合约为当周
var ret = exchange.SetContractType("this_week")
// 返回当周合约的信息
Log(ret)
}
def main():
ret = exchange.SetContractType("this_week")
Log(ret)
void main() {
auto ret = exchange.SetContractType("this_week");
Log(ret);
}
मुद्रणexchange.SetContractType()फ़ंक्शन का रिटर्न मानः
क्रिप्टोक्यूरेंसी के लिए एक रणनीति है कि आप एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा के लिए एक विदेशी मुद्रा है।BTC_USDTलेन-देन के लिए उदाहरणः जब उपयोग किया जाता हैexchange.SetCurrency("BTC_USDT")याexchange.IO("currency", "BTC_USDT")फ़ंक्शन स्विच लेन-देन के लिए जोड़े को स्विच करने के बाद उपयोग करने की आवश्यकता होती हैexchange.SetContractType()फ़ंक्शन रीसेट कॉन्ट्रैक्ट नए लेन-देन के लिए उस कॉन्ट्रैक्ट को निर्धारित करता है जिसे वर्तमान में संचालित करने की आवश्यकता होती है। सिस्टम लेन-देन के आधार पर यह निर्धारित करता है किमुद्रा मूल्यों का अनुबंधयाUSDT स्थानीय अनुबंधउदाहरण के लिएः लेन-देन जोड़े को सेट करेंBTC_USDTसमय, उपयोगexchange.SetContractType("swap")फ़ंक्शन सेट अनुबंध कोड हैswapइस समय, यह सेट हैBTCकाUSDT स्थानयदि लेन-देन के लिए एक जोड़ी हैBTC_USD, उपयोगexchange.SetContractType("swap")फ़ंक्शन सेट अनुबंध कोड हैswapइस समय, यह सेट हैBTCकासिक्का मूल्यइस तरह के लोगों के लिए यह एक अच्छा मौका है।
समर्थन किए गए क्रिप्टोक्यूरेंसी वायदा अनुबंध एक्सचेंजों के बारे में विस्तार से, प्रत्येक एक्सचेंज के अनुबंधों के नाम इस प्रकार हैंः
- Futures_OKCoin ((ओकेएक्स)
एक स्थायी अनुबंध के रूप में सेट करेंःexchange.SetContractType("swap")इस सप्ताह के लिए अनुबंध सेट करेंःexchange.SetContractType("this_week")अगले सप्ताह के लिए सेट करेंःexchange.SetContractType("next_week")एक महीने का अनुबंध सेट करेंःexchange.SetContractType("month")अगले महीने के लिए अनुबंध सेट करेंःexchange.SetContractType("next_month")एक तिमाही अनुबंध के रूप में सेट करेंःexchange.SetContractType("quarter")यह अनुबंध अगले तिमाही के लिए निर्धारित हैःexchange.SetContractType("next_quarter")
ओकेएक्स के पास प्री-ट्रेडिंग कॉन्ट्रैक्ट्स हैंः कॉन्ट्रैक्ट की डिलीवरी की तारीख एक निश्चित समय के लिए होती है, एक्सचेंज द्वारा परिभाषित कॉन्ट्रैक्ट कोड उदाहरण हैंःHMSTR-USDT-250207एक आविष्कारक के मंच पर एक व्यापारिक जोड़ी स्थापित करेंHMSTR_USDT, और उपयोग करेंexchange.SetContractType("HMSTR-USDT-250207")इस समझौते को स्थापित करना।
समर्थन के लिएsymbolपैरामीटर के फ़ंक्शन, उदाहरण के लिएःexchange.GetTicker()、exchange.CreateOrder()उदाहरण के लिए.symbolपैरामीटर हैःHMSTR_USDT.HMSTR-USDT-250207इस अनुबंध के लिए बाजार डेटा प्राप्त करने या ऑर्डर करने के लिए ऑपरेशन।
- Futures_HuobiDM (टोकन वायदा)
इस सप्ताह के लिए अनुबंध सेट करेंःexchange.SetContractType("this_week")..
अगले सप्ताह के लिए अनुबंध सेट करेंःexchange.SetContractType("next_week")..
एक तिमाही अनुबंध के रूप में सेट करेंःexchange.SetContractType("quarter")..
यह अनुबंध अगले तिमाही के लिए निर्धारित हैःexchange.SetContractType("next_quarter")..
एक स्थायी अनुबंध के रूप में सेट करेंःexchange.SetContractType("swap")..
समर्थनUSDTइस तरह के एक अनुबंध के रूप में,BTCअनुबंध उदाहरणः उपयोगexchange.IO("currency", "BTC_USDT")इसे इस्तेमाल करने के लिए स्विच करेंUSDTइस तरह के एक समझौते के रूप में, यह एक गारंटी है।
या जब आप अपने वास्तविक डिस्क पैरामीटर को कॉन्फ़िगर करते हैं, या एक्सचेंज ऑब्जेक्ट जोड़ते हैं, तो वर्तमान लेनदेन जोड़ी को सीधे सेट करें।BTC_USDT⇒ लेन-देन के बाद जोड़े को फिर से कॉल करना आवश्यक हैexchange.SetContractType()फ़ंक्शन अनुबंध सेट करता है।
- Futures_BitMEX ((बिटमेक्स)
एक स्थायी अनुबंध के रूप में सेट करेंःexchange.SetContractType("swap")..
Futures_BitMEX एक्सचेंज का सौदा अनुपात लगभग मासिक अनुबंध है, जिसका अनुबंध कोड इस प्रकार है (जनवरी से दिसंबर तक):
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
यह एक बहुत ही अच्छा तरीका है।exchange.SetContractType("December")उदाहरण के लिए, लेन-देन जोड़े को सेट करेंXBT_USDTजब, कॉल करेंexchange.SetContractType("December")फ़ंक्शन सेट करें बीटीसी के USDT स्थान पर दिसंबर में वितरित किए गए अनुबंध ((संदर्भित वास्तविक अनुबंध कोड हैXBTUSDTZ23）。
Futures_BitMEX अनुबंध सूचना संग्रह
Futures_BitMEX द्वारा परिभाषित अनुबंध कोड FMZ में संबंधित ट्रेडों के लिए FMZ में संबंधित अनुबंध कोड नोट्स के लिए है।
∙ ∙ ∙ ∙ ∙ ∙ ∙
DOGEUSD DOGE_USD स्वैप डॉलर मूल्य निर्धारण, एक्सबीटी लेनदेन।
DOGEUSDT DOGE_USDT स्वैप USDT मूल्य निर्धारण, USDT निपटान।
XBTETH XBT_ETH एक्सबीटी_ईटीएच स्वैप ETH मूल्य निर्धारण, एक्सबीटी भुगतान
XBTEUR XBT_EUR स्वैप यूरो मूल्य निर्धारण, XBT भुगतान।
USDTUSDC USDT_USDC swap USDC मूल्य निर्धारण, एक्सबीटी भुगतान
ETHUSD_ETH ETHUSD_ETH स्वैप ETHUSD_ETH डॉलर मूल्य निर्धारण, ETH भुगतान
XBTH24 XBT_USD मार्च समाप्ति की तारीख 24 मार्च, महीने का कोड है H; डॉलर मूल्य, XBT भुगतान।
ETHUSDZ23 ETH_USD दिसंबर समाप्ति तिथि: 23 दिसंबर, महीने का कोडः Z; डॉलर में मूल्य, एक्सबीटी भुगतान।
XBTUSDTZ23 XBT_USDT दिसंबर समाप्ति तिथि: 23 दिसंबर, महीने का कोड हैः Z; USDT मूल्य निर्धारण, USDT भुगतान।
ADAZ23 ADA_XBT दिसंबर समाप्ति तिथि: 23 दिसंबर, महीने का कोड हैः Z; एक्सबीटी मूल्य निर्धारण, एक्सबीटी भुगतान।
P_XBTETFX23 USDT_XXX P_XBTETFX23 समाप्ति तिथि: 23 नवम्बर; प्रतिशत के रूप में मूल्य, USDT भुगतान।
- Futures_GateIO
इस सप्ताह के लिए अनुबंध सेट करेंःexchange.SetContractType("this_week")..
अगले सप्ताह के लिए अनुबंध सेट करेंःexchange.SetContractType("next_week")..
एक तिमाही अनुबंध के रूप में सेट करेंःexchange.SetContractType("quarter")..
यह अनुबंध अगले तिमाही के लिए निर्धारित हैःexchange.SetContractType("next_quarter")..
एक स्थायी अनुबंध के रूप में सेट करेंःexchange.SetContractType("swap")..
समर्थनUSDTइस तरह के एक अनुबंध के रूप में,BTCअनुबंध के उदाहरणexchange.IO("currency", "BTC_USDT")इसे इस्तेमाल करने के लिए स्विच करेंUSDTइस तरह के एक समझौते के रूप में, यह एक गारंटी है।
या जब आप अपने वास्तविक डिस्क पैरामीटर को कॉन्फ़िगर करते हैं, या एक्सचेंज ऑब्जेक्ट जोड़ते हैं, तो वर्तमान लेनदेन जोड़ी को सीधे सेट करें।BTC_USDT⇒ लेन-देन के बाद जोड़े को फिर से कॉल करना आवश्यक हैexchange.SetContractType()फ़ंक्शन अनुबंध सेट करता है।
- फ्यूचर्स_डेरबिट
एक स्थायी अनुबंध के रूप में सेट करेंःexchange.SetContractType("swap")..
डेरिबिट के समर्थन मेंUSDCअनुबंध।
इस तरह की घटनाओं में से एक है।"this_week", "next_week", "month", "quarter", "next_quarter", "third_quarter", "fourth_quarter"..
भविष्य_कॉम्बोः"this_week,swap", "next_week,swap", "next_quarter,this_week", "third_quarter,this_week", "month,next_week"कई तरह के संयोजन हैं।
एक्सचेंज द्वारा परिभाषित विशिष्ट विकल्प अनुबंध कोडों के लिए, जो विकल्प अनुबंधों के लिए आवश्यक हैं, विवरण के लिए Deribit देखें।
- Futures_KuCoin
मुद्रा स्थानिक अनुबंध, जैसे कि व्यापारिक जोड़े के लिए सेटBTC_USDएक बार फिर से, कॉन्ट्रैक्ट कोड सेट करें, यानी, मुद्रा के लिए कॉन्ट्रैक्टः
एक स्थायी अनुबंध के रूप में सेट करेंःexchange.SetContractType("swap")..
इस साल के लिए अनुबंध सेट करेंःexchange.SetContractType("quarter")..
यह अनुबंध अगले तिमाही के लिए निर्धारित हैःexchange.SetContractType("next_quarter")。
USDT एक गारंटी के रूप में एक अनुबंध हैः
उदाहरण के लिए, लेन-देन के लिए सेटBTC_USDTएक बार फिर से, एक कॉन्ट्रैक्ट कोड सेट करें, यानी USDT के लिए एक कॉन्ट्रैक्ट को गारंटी के रूप में।
एक स्थायी अनुबंध के रूप में सेट करेंःexchange.SetContractType("swap")..
- फ्यूचर्स_बाइनेंस
बिआन फ्यूचर्स एक्सचेंज वर्तमान व्यापारिक जोड़े के लिए एक स्थायी अनुबंध को बेनकाब करता है, अनुबंध कोडःswap..
एक स्थायी अनुबंध के रूप में सेट करेंःexchange.SetContractType("swap")बिआन के स्थायी अनुबंध का उपयोगUSDTउदाहरण के लिए, गारंटी के रूप में एक अनुबंधBTCकाUSDTइस स्थायी अनुबंध के लिए, लेन-देन की जोड़ी को सेट किया गया हैBTC_USDTउदाहरण के लिए, बिनायन ने मुद्राओं को प्रतिभूतियों के रूप में स्थायी अनुबंध के रूप में उपयोग करने का भी समर्थन किया है।BTCमुद्रा के लिए एक स्थायी अनुबंध, व्यापार जोड़े के रूप में सेटBTC_USD..
एक तिमाही अनुबंध के रूप में सेट करेंःexchange.SetContractType("quarter"), विनिमय दर के बारे में मुद्रा मूलभूत अनुबंध (यानी, मुद्रा का उपयोग करने के लिए) ।BTCइस तरह के सौदों के लिए, एक तिमाही अनुबंध के लिए, व्यापार जोड़े को सेट किया गया हैःBTC_USDअनुबंध को फिर से स्थापित करेंexchange.SetContractType("quarter"), के रूप में सेटBTCइस तरह के एक नए अनुबंध के लिए, हम पहले से ही एक नया अनुबंध शुरू कर रहे हैं।
यह अनुबंध अगले तिमाही के लिए निर्धारित हैःexchange.SetContractType("next_quarter")उदाहरण के लिएBTCइस तरह के एक नए अनुबंध के लिए, मुद्रा की स्थानीय तिमाही अनुबंध, व्यापार जोड़े के लिए सेट हैःBTC_USDएक बार फिर से समझौताexchange.SetContractType("next_quarter")..
बिनान समर्थन भागUSDTइस तरह के एक सौदे के रूप में गारंटी राशि का अनुपातBTCउदाहरण लेन-देन जोड़े को सेट करेंBTC_USDTऔर फिर से अनुबंध कोड सेट करें।
बिआन ऑप्शन कॉन्ट्रैक्ट का समर्थन करेंः
विकल्प अनुबंध कोड प्रारूप विकल्प अनुबंध कोड के रूप में एक्सचेंज द्वारा परिभाषित किया जाता हैःBTC-241227-15000-C，XRP-240112-0.5-C，BTC-241227-15000-P◎ बिनाइन विकल्प अनुबंध कोडBTC-241227-15000-Pउदाहरण: बीटीसी विकल्प मुद्रा कोड है, 241227 विकल्प दिनांक है, और 15000 विकल्प मूल्य है, पी एक गिरावट विकल्प है, और सी एक बढ़ोतरी विकल्प है।
विकल्पों के प्रकार के बारे में, यूरोपीय विकल्प / अमेरिकी विकल्प के बारे में, आप एक्सचेंज विकल्प अनुबंध से संबंधित जानकारी देख सकते हैं।
एक्सचेंज विकल्प विक्रेताओं को प्रतिबंधित कर सकते हैं और उन्हें अलग से आवेदन करने की आवश्यकता होती है।
- फ्यूचर्स_बिबॉक्स
Bibox के स्थायी अनुबंध का अनुबंध कोडःswap..
एक स्थायी अनुबंध के रूप में सेट करेंःexchange.SetContractType("swap")..
- Futures_Bybit
इस प्रकार, हम एक बार फिर से एक नए प्रकार के अनुबंध का उपयोग कर सकते हैं, जैसे कि एक स्थायी अनुबंध, एक अनुबंध कोडःswap..
इस सप्ताह के लिए अनुबंध कोडःthis_week..
अगले सप्ताह के लिए अनुबंध कोडःnext_week..
तीसरे सप्ताह के लिए अनुबंध कोडःthird_week..
मासिक अनुबंध कोडःmonth..
अगले महीने का अनुबंध कोडःnext_month..
तिमाही अनुबंध कोडःquarter..
अगले तिमाही के लिए अनुबंध कोडःnext_quarter..
तीसरी तिमाही के लिए अनुबंध कोडःthird_quarter..
- फ्यूचर्स_क्रैकेन
इस प्रकार, हम एक बार फिर से एक नए प्रकार के अनुबंध का उपयोग कर सकते हैं, जैसे कि एक स्थायी अनुबंध, एक अनुबंध कोडःswap。
```month```：当月合约。
```quarter```：季度合约。
```next_quarter```：次季合约。
```swap_pf```：混合保证金永续合约。
```quarter_ff```：混合保证金季度合约。
```month_ff```：混合保证金当月合约。
```next_quarter_ff```：混合保证金次季度合约。
- Futures_Bitfinex
默认为当前交易对的永续合约，合约代码：```swap```。
- Futures_Bitget
默认为当前交易对的永续合约，合约代码：```swap```。
交易对设置为```BTC_USD```为币本位合约，交易对设置为```BTC_USDT```为```USDT```结算的合约。模拟合约可以设置交易对为：```SBTC_USD```、```BTC_SUSDT```。
- Futures_dYdX (v4)
dYdX永续合约的合约代码：```swap```。
设置为永续合约：```exchange.SetContractType("swap")```，dYdX仅有```USD.swap```品种维度，使用的保证金为USDC。
- Futures_MEXC
MEXC（抹茶）永续合约的合约代码：```swap```。
设置为永续合约：```exchange.SetContractType("swap")```。交易对设置为```BTC_USD```为币本位合约，交易对设置为```BTC_USDT```为```USDT```结算的合约。
- Futures_Crypto
crypto.com交易所的账户中的代币可以折算为USD计价的额度，用于合约交易的保证金。
设置为永续合约：```exchange.SetContractType("swap")```。举例交易对设置为```BTC_USD```时，调用```exchange.SetContractType("swap")```函数设置BTC的永续合约。
crypto.com交易所交割合约为月度合约，合约代码如下（一月到十二月）：
```code
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
यह एक बहुत ही अच्छा तरीका है।exchange.SetContractType("October")उदाहरण के लिए, लेन-देन जोड़े को सेट करेंBTC_USDजब, कॉल करेंexchange.SetContractType("October")फ़ंक्शन ने बीटीसी का अक्टूबर का लेनदेन दर सेट किया है।
वर्तमान समय के लिए अनुबंध कोड हैःBTCUSD-231027..
- फ्यूचर्स_WOO
Futures_WOO द्वारा समर्थितUSDTइस अनुबंध का कोड है स्थायी अनुबंधswapउदाहरण के लिए, लेन-देन जोड़े को सेट करेंBTC_USDTजब, कॉल करेंexchange.SetContractType("swap")फ़ंक्शन वर्तमान अनुबंध को BTC के USDT स्थान पर स्थायी अनुबंध के रूप में सेट करता है।
{@fun/Futures/exchange.GetContractType exchange.GetContractType}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/Futures/exchange.GetContractType exchange.GetContractType}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Account/exchange.
```exchange.GetContractType()```函数返回FMZ平台定义的合约代码，例如：```this_week```、```swap```等。
string
exchange.GetContractType()
```javascript
function main () {
Log(exchange.SetContractType("this_week"))
Log(exchange.GetContractType())
}
def main():
Log(exchange.SetContractType("this_week"))
Log(exchange.GetContractType())
void main() {
Log(exchange.SetContractType("this_week"));
Log(exchange.GetContractType());
}
{@fun/Futures/exchange.SetContractType exchange.SetContractType}
```exchange.GetFundings()```函数请求数据成功时返回{@struct/Funding Funding}结构数组，请求数据失败时返回空值。
{@struct/Funding Funding}数组、空值
exchange.GetFundings()
exchange.GetFundings(symbol)
参数```symbol```用于设置所要查询的**交易品种**或者**交易品种的范围**。 不传```symbol```参数时，默认以当前交易对、合约代码所在维度范围请求所有品种的当期资金费率数据。
symbol
false
string
```javascript
/*backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
*/
function main() {
// LPT_USDT.swap 4小时周期
var symbols = ["SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"]
for (var symbol of symbols) {
exchange.GetTicker(symbol)
}
var arr = []
var arrParams = ["no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"]
for (p of arrParams) {
if (p == "no param") {
arr.push(exchange.GetFundings())
} else {
arr.push(exchange.GetFundings(p))
}
}
var tbls = []
var index = 0
for (var fundings of arr) {
var tbl = {
"type": "table",
"title": arrParams[index],
"cols": ["Symbol", "Interval", "Time", "Rate"],
"rows": [],
}
for (var f of fundings) {
tbl["rows"].push([f.Symbol, f.Interval / 3600000, _D(f.Time), f.Rate * 100 + " %"])
}
tbls.push(tbl)
index++
}
LogStatus(_D(), "\n 已经请求过的行情品种:", symbols, "\n`" + JSON.stringify(tbls) + "`")
}
'''backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
'''
import json
def main():
# LPT_USDT.swap 4小时周期
symbols = ["SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"]
for symbol in symbols:
exchange.GetTicker(symbol)
arr = []
arrParams = ["no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"]
for p in arrParams:
if p == "no param":
arr.append(exchange.GetFundings())
else:
arr.append(exchange.GetFundings(p))
tbls = []
index = 0
for fundings in arr:
tbl = {
"type": "table",
"title": arrParams[index],
"cols": ["Symbol", "Interval", "Time", "Rate"],
"rows": [],
}
for f in fundings:
tbl["rows"].append([f["Symbol"], f["Interval"] / 3600000, _D(f["Time"]), str(f["Rate"] * 100) + " %"])
tbls.append(tbl)
index += 1
LogStatus(_D(), "\n 已经请求过的行情品种:", symbols, "\n`" + json.dumps(tbls) + "`")
/*backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
*/
void main() {
// LPT_USDT.swap 4小时周期
json arrSymbol = R"([])"_json;
std::string symbols[] = {"SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"};
for (const std::string& symbol : symbols) {
exchange.GetTicker(symbol);
arrSymbol.push_back(symbol);
}
std::vector<std::vector<Funding>> arr = {};
std::string arrParams[] = {"no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"};
for (const std::string& p : arrParams) {
if (p == "no param") {
arr.push_back(exchange.GetFundings());
} else {
arr.push_back(exchange.GetFundings(p));
}
}
json tbls = R"([])"_json;
int index = 0;
for (int i = 0; i < arr.size(); i++) {
auto fundings = arr[i];
json tbl = R"({
"type": "table",
"cols": ["Symbol", "Interval", "Time", "Rate"],
"rows": []
})"_json;
tbl["title"] = arrParams[index];
for (int j = 0; j < fundings.size(); j++) {
auto f = fundings[j];
// json arrJson = {f.Symbol, f.Interval / 3600000, _D(f.Time), string(f.Rate * 100) + " %"};
json arrJson = {f.Symbol, f.Interval / 3600000, _D(f.Time), f.Rate};
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
index++;
}
LogStatus(_D(), "\n 已经请求过的行情品种:", arrSymbol.dump(), "\n`" + tbls.dump() + "`");
}
फ्यूचर्स एक्सचेंज के ऑब्जेक्ट का उपयोग करके रीसेट सिस्टम में कॉल करेंexchange.GetFundings()फ़ंक्शन ⇒ किसी भी फ़ंक्शन को कॉल करने से पहले, GetFundings केवल वर्तमान डिफ़ॉल्ट लेनदेन जोड़े के फंडिंग डेटा को लौटाता है, और फ़ंक्शन को कॉल करने के बाद सभी अनुरोधित किस्मों के फंडिंग डेटा को लौटाता है। निम्नलिखित परीक्षण उदाहरण देखेंः
ऐसे फ्यूचर्स एक्सचेंजों के लिए जो थोक पूर्वावलोकन पूंजीगत दर डेटा का समर्थन नहीं करते हैं, यदि निर्दिष्ट हैsymbolपैरामीटर क्वेरी रेंज के लिए हैं, जैसेःUSDT.swapया नहींsymbolपैरामीटर के दौरान इंटरफ़ेस त्रुटि देता है. इस प्रकार के वायदा विनिमय वस्तुओं का उपयोग करके कॉल करेंGetFundings()फ़ंक्शन को निर्दिष्ट करना होगाsymbolपैरामीटर एक स्थायी अनुबंध की एक विशिष्ट किस्म के लिए है, और उस किस्म के लिए वर्तमान पूंजी दर डेटा का पता लगाने के लिए।
不支持批量获取资金费率数据的交易所：Futures_Bitget、Futures_OKX、Futures_MEXC、Futures_Deribit、Futures_Crypto。需要传入```symbol```参数具体品种代码，例如：```ETH_USDT.swap```。
不支持```exchange.GetFundings()```函数的交易所：
| 函数名 | 不支持的现货交易所 | 不支持的期货交易所 |
| - | - | - |
| GetFundings | -- | Futures_DigiFinex |
{@struct/Funding Funding}
### NetSettings
### exchange.SetBase
```exchange.SetBase()```函数用于设置{@var/EXCHANGE exchange}交易所对象中配置的交易所API接口基地址。
exchange.SetBase(s)
```s```参数用于指定交易所API接口基地址。
s
true
string
```javascript
function main() {
// 使用默认基地址
Log(exchange.GetTicker())
// 切换为https://aws.okx.com
exchange.SetBase("https://aws.okx.com")
Log(exchange.GetTicker())
}
def main():
Log(exchange.GetTicker())
exchange.SetBase("https://aws.okx.com")
Log(exchange.GetTicker())
void main() {
Log(exchange.GetTicker());
exchange.SetBase("https://aws.okx.com");
Log(exchange.GetTicker());
}
रीसेट सिस्टम में एक्सचेंज एपीआई आधार पते को स्विच करने का समर्थन नहीं है क्योंकि रीसेट सिस्टम एक सैंडबॉक्स अनुकरण वातावरण है और वास्तव में एक्सचेंज के एपीआई इंटरफ़ेस तक नहीं पहुंचता है।
{@fun/Trade/exchange.IO exchange.IO}
当前交易所API接口基地址。
string
exchange.GetBase()
```javascript
function main() {
Log(exchange.GetBase())
}
def main():
Log(exchange.GetBase())
void main() {
Log(exchange.GetBase());
}
{@fun/NetSettings/exchange.SetBase exchange.SetBase}
exchange.SetProxy(proxy)
```proxy```参数用于指定代理配置。
proxy
true
string
```javascript
function main() {
exchange.SetProxy("socks5://192.168.1.10:8080")
// 如果访问不到交易所行情接口，设置一个可用的ss5代理，就可以访问到行情接口了
Log(exchange.GetTicker())
}
def main():
exchange.SetProxy("socks5://192.168.1.10:8080")
Log(exchange.GetTicker())
void main() {
exchange.SetProxy("socks5://192.168.1.10:8080");
Log(exchange.GetTicker());
}
{@var/EXCHANGE exchange} विनिमय ऑब्जेक्ट को कॉन्फ़िगर करेंsocks5एजेंटः
function main(){
exchange.SetProxy("ip://10.0.3.15")
// 发出的请求IP地址为10.0.3.15
exchange.GetTicker()
}
def main():
exchange.SetProxy("ip://10.0.3.15")
exchange.GetTicker()
void main() {
exchange.SetProxy("ip://10.0.3.15");
exchange.GetTicker();
}
सिवायवैश्विक निर्दिष्ट करें{@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट द्वारा अनुरोध किए गए आईपी पते का समर्थन किया जाता है, जो कि {@var/EXCHANGE exchange} के आधार पर निर्दिष्ट आईपी पते का समर्थन करता हैः
यदि एजेंट सेटअप विफल हो जाता है, तो कॉल किया जाता हैexchange.SetProxy()फ़ंक्शन के लिए रिक्त लौटाता है.exchange.SetProxy()फ़ंक्शन सेट एजेंट की कार्यक्षमता सीमित हैrestप्रोटोकॉल. प्रत्येक {@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट एक एजेंट सेट कर सकता है, और एजेंट सेट करने के बाद, एक्सचेंज इंटरफेस जो {@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट से बंधे हैं, वे एजेंट के माध्यम से एक्सेस किए जाते हैं।
समर्थन सेटिंग्सsocks5एजेंट, पहले जोड़े गए एक्सचेंज ऑब्जेक्ट {@var/EXCHANGE exchange} के साथःexchanges[0]उदाहरण के लिएः
- एजेंट सेट करें, कोई उपयोगकर्ता नाम, कोई पासवर्ड नहींःexchange.SetProxy("socks5://127.0.0.1:8889")..
- एजेंट सेट करें, उपयोगकर्ता नाम और पासवर्ड दर्ज करेंःexchange.SetProxy("socks5://username:password@127.0.0.1:8889")。usernameउपयोगकर्ता नाम के लिएpasswordपासवर्ड के लिए।
- सामान्य मोड पर स्विच करें, एजेंट का उपयोग न करेंःexchange.SetProxy("")。
{@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट द्वारा अनुरोध करने के लिए आईपी पते को सेट करने का समर्थन करता है।वैश्विक निर्दिष्ट करें。
{@var/EXCHANGE विनिमय}
exchange.SetTimeout(timeout)
```timeout```参数用于指定超时设置的毫秒数。
timeout
true
number
```javascript
function main() {
exchange.SetTimeout(3000)
Log(exchange.GetTicker())
}
def main():
exchange.SetTimeout(3000)
Log(exchange.GetTicker())
void main() {
exchange.SetTimeout(3000);
Log(exchange.GetTicker());
}
पैरामीटरtimeoutएक मिलीसेकंड के लिए मान, 1000 मिलीसेकंड 1 सेकंड के बराबर है; सीमित।restप्रोटोकॉल, स्थापित करने के लिएrestअनुरोध के समय में ओवरटाइम केवल एक बार सेट करने के लिए प्रभावी होता है; उदाहरण के लिएःexchange.SetTimeout(3000), सेट करेंexchangeएक्सचेंजों का उद्देश्यrest3 सेकंड के लिए अनुरोध किया गया है।exchange.GetTicker()यदि कोई फ़ंक्शन नेटवर्क अनुरोध के साथ 3 सेकंड से अधिक समय तक प्रतिक्रिया प्राप्त नहीं करता है, तो फ़ंक्शन कॉल का समय समाप्त हो जाता है और रिक्त लौटाता है।
{@var/EXCHANGE exchange}
### Threads
发明者量化交易平台从系统底层真正支持```JavaScript```语言策略的多线程功能，实现了以下对象：
| 对象 | 说明 | 备注 |
| - | - | - |
| threading | 多线程全局对象 | 成员函数：```Thread```、```getThread```、```mainThread```等。 |
| Thread | 线程对象 | 成员函数：```peekMessage```、```postMessage```、```join```等。 |
| ThreadLock | 线程锁对象 | 成员函数：```acquire```、```release```。可作为线程执行函数的参数传入线程环境。 |
| ThreadEvent | 事件对象 | 成员函数：```set```、```clear```、```wait```、```isSet```。可作为线程执行函数的参数传入线程环境。 |
| ThreadCondition | 条件对象 | 成员函数：```notify```、```notifyAll```、```wait```、```acquire```、```release```。可作为线程执行函数的参数传入线程环境。 |
| ThreadDict | 字典对象 | 成员函数：```get```、```set```。可作为线程执行函数的参数传入线程环境。 |
### threading
```threading```对象作为全局多线程管理工具，提供了创建并发线程、线程锁、条件对象等功能；本章节介绍```threading```对象的成员函数；仅```JavaScript```语言策略支持该对象。
### Thread
```Thread()```函数用于创建并发线程。
```Thread()```函数返回一个```Thread```对象，用于管理创建出的并发线程、线程通信等。
```Thread```对象
Thread(func, ...args)
Thread(...items)
参数```func```是用于并发执行的函数（通过引用传递），支持传入匿名函数。```func```可接受多个参数，这些参数将在并发执行时通过```...args```传入。因此，```func```的参数列表需要与```...args```一致。
func
true
function
参数```arg```是在回调执行时传递给```func```（即并发线程执行函数）的实际参数；参数```arg```可能有多个，```func```的参数列表需要与```...args```一致。
arg
false
string、number、bool、object、array、function、空值等系统支持的所有类型
参数```item```是一个数组，包含待并发执行的函数引用及其参数，调用```Thread```函数时的参数```item```可以传入多组。
item
true
array
```javascript
function test1(a, b, c) {
Log("test1:", a, b, c)
}
function main() {
var t1 = threading.Thread(test1, 1, 2, 3)
var t2 = threading.Thread(function (msg) {
Log("msg:", msg)
}, "Hello thread2")
t1.join()
t2.join()
}
एक ही समय में एक कस्टम फ़ंक्शन और एक अनाम फ़ंक्शन के साथ एक समवर्ती थ्रेड बनाएं।
function test1(msg) {
Log("msg:", msg)
test2("Hello test2")
}
function main() {
var t1 = threading.Thread(
[function(a, b, c) {Log(a, b, c)}, 1, 2, 3],
[test1, "Hello test1"],
[`function test2(msg) {Log("msg:", msg)}`])
t1.join()
}
उपयोगThread(...items)सूत्रों को एक साथ बनाने के लिए, क्रम में कई कार्यों को निष्पादित करने के लिए।
function testFunc1(p) {
Log("testFunc1 p:", p)
}
function main() {
threading.Thread(function(pfn) {
var threadName = threading.currentThread().name()
var threadId = threading.currentThread().id()
pfn(`in thread threadName: ${threadName}, threadId: ${threadId}`)
}, testFunc1).join()
}
समवर्ती निष्पादन फ़ंक्शन के लिए पैरामीटर पास फ़ंक्शन का समर्थन करें.
function ml(input) {
const net = new brain.NeuralNetwork()
net.train([
{ input: [0, 0], output: [0] },
{ input: [0, 1], output: [1] },
{ input: [1, 0], output: [1] },
{ input: [1, 1], output: [0] },
])
return net.run(input)
}
function main() {
var ret = threading.Thread([ml, [1, 0]], [HttpQuery("https://unpkg.com/brain.js")]).join()
// ret: {"id":1,"terminated":false,"elapsed":337636000,"ret":{"0":0.9339330196380615}}
Log(ret)
}
इनपुट फ़ंक्शन संख्यात्मक स्ट्रिंग का समर्थन करता है, जो गतिशील रूप से एक बाहरी संग्रह में आयात किया जा सकता है।
प्रवेशThread()फ़ंक्शन एक साथ निष्पादित किए जाने वाले स्ट्रिंग फ़ंक्शन के लिए उपयोग किया जाता हैfuncएक अलग वातावरण में चल रहा है, इसलिए सीधे थ्रेड के बाहर के चर का संदर्भ नहीं ले सकता है, संदर्भ के दौरान संकलन विफलता; साथ ही, थ्रेड में अन्य समापन कार्यों का संदर्भ लेने का समर्थन नहीं करता है; थ्रेड के भीतर प्लेटफॉर्म द्वारा प्रदान किए गए सभी एपीआई को बुलाया जा सकता है, लेकिन उपयोगकर्ता द्वारा अनुकूलित अन्य कार्यों को नहीं बुलाया जा सकता है।
जब कोई थ्रेड निष्पादित हो जाता है और लगातार संदर्भित नहीं होता है, तो सिस्टम बेसलेयर स्वचालित रूप से थ्रेड से संबंधित संसाधनों को पुनः प्राप्त करता है, बिना किसी स्पष्ट कॉल केjoin()फ़ंक्शन संसाधनों को मुक्त करने के लिए। यदि निरंतर संदर्भ के कारण संसाधनों को मुक्त नहीं किया जा सकता है, तो 2000 से अधिक के साथ-साथ रिलीज़ होने की संख्या में त्रुटि होगीःInternalError: too many routine wait, max is 2000。
समर्थन पुनरावृत्ति प्रणाली, वास्तविक डिस्क वातावरण; सभी समवर्ती धागे से संबंधित कार्य, पुनरावृत्ति प्रणाली में केवल कोड संगतता समर्थन के रूप में, वास्तव में वास्तविक समवर्ती धागे निष्पादन नहीं करते हैं, इस अध्याय में और अधिक चर्चा नहीं की जाएगी।
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop}, {@fun/Threads/threading/eventLoop}
```getThread()```函数返回通过参数指定threadId的```Thread```对象
```Thread```对象
getThread(threadId)
参数```threadId```为线程对象Id，通过指定参数获取对应的线程对象。
threadId
true
number
```javascript
function main() {
var t1 = threading.Thread(function () {
// Thread 对象有方法：id()，用于获取线程的Id，可以查看文档对应Thread对象的章节
var id = threading.currentThread().id()
var thread1 = threading.getThread(id)
Log("id:", id, ", thread1.id():", thread1.id())
Log(`id == thread1.id():`, id == thread1.id())
})
t1.join()
}
अनुमोदितthreadIdनिर्दिष्ट थ्रेड ऑब्जेक्ट प्राप्त करें.
यह एक बहुत ही सुविधाजनक और सुविधाजनक है।
यदि अपेक्षित थ्रेड पहले ही निष्पादित हो चुका है, तो इसे पारित नहीं किया जा सकता हैthreading.getThread(threadId)इस धागे के लिए धागे का ऑब्जेक्ट प्राप्त करें.
{@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threads/Dict Dict}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/eventLoop}
```mainThread()```函数返回主线程的线程对象。
```Thread```对象
mainThread()
```javascript
function main() {
Log("主线程的threadId：", threading.mainThread().id())
}
मुख्य सूत्रों को प्राप्त करने के लिएThreadऑब्जेक्ट, आउटपुट मेन थ्रेडthreadId。
function test() {
Log("test函数中输出主线程Id：", threading.mainThread().id())
}
function main() {
var t1 = threading.Thread(test)
t1.join()
}
समवर्ती थ्रेड में मुख्य थ्रेड के थ्रेड ऑब्जेक्ट भी प्राप्त किए जा सकते हैं।
यह एक बहुत ही सुविधाजनक और सुविधाजनक है।
{@fun/Threads/getThread getThread}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/threading/Lock Lock}, {@fun/Threads/threading/eventLoop}, {@fun/Threads/threads/threading/eventLoop}, {@fun/Threads/threading/eventLoop}
```currentThread()```函数返回当前线程的线程对象。
```Thread```对象
currentThread()
```javascript
function test() {
Log("当前线程的Id：", threading.currentThread().id())
}
function main() {
var t1 = threading.Thread(test)
t1.join()
}
वर्तमान धागे को प्राप्त करेंThreadऑब्जेक्ट, वर्तमान धागे का आउटपुटthreadId。
यह एक बहुत ही सुविधाजनक और सुविधाजनक है।
{@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/threading/Condition Condition}, {@fun/Threads/threading/event Event}, {@fun/Threads/threading/threading/Dict Dict}, {@fun/Threads/threading/threading/eventLoop pending}, {@fun/Threads/threading/eventLoop eventLoop}, {@fun/Threads/threading/eventLoop}, {@fun/Threads/threads/threading/eventLoop}, {@eventLoop}
```Lock()```函数返回一个线程锁对象。
```ThreadLock```对象
Lock()
```javascript
function consumer(productionQuantity, dict, lock) {
for (var i = 0; i < productionQuantity; i++) {
lock.acquire()
var count = dict.get("count")
Log("consumer:", count)
Sleep(1000)
lock.release()
}
}
function producer(productionQuantity, dict, lock) {
for (var i = 0; i < productionQuantity; i++) {
lock.acquire()
dict.set("count", i)
Log("producer:", i)
Sleep(1000)
lock.release()
}
}
function main() {
var dict = threading.Dict()
dict.set("count", -1)
var lock = threading.Lock()
var productionQuantity = 10
var producerThread = threading.Thread(producer, productionQuantity, dict, lock)
var consumerThread = threading.Thread(consumer, productionQuantity, dict, lock)
consumerThread.join()
producerThread.join()
}
दो समवर्ती धागे सार्वजनिक संसाधनों तक पहुंचते हैं।
यह एक बहुत ही सुविधाजनक और सुविधाजनक है।
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threads/threading/ThreadThread}, {@fun/Threads/threads/threading/Condition Condition}, {@fun/Threads/threads/threading/Event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threads/threading/pending pending}, {@fun/Threads/threads/threading/eventLoop}
```Condition()```函数返回一个```ThreadCondition```对象。
```ThreadCondition```对象
Condition()
```javascript
function consumer(productionQuantity, dict, condition) {
for (var i = 0; i < productionQuantity; i++) {
condition.acquire()
while (dict.get("array").length == 0) {
condition.wait()
}
var arr = dict.get("array")
var count = arr.shift()
dict.set("array", arr)
Log("consumer:", count, ", array:", arr)
condition.release()
Sleep(1000)
}
}
function producer(productionQuantity, dict, condition) {
for (var i = 0; i < productionQuantity; i++) {
condition.acquire()
var arr = dict.get("array")
arr.push(i)
dict.set("array", arr)
Log("producer:", i, ", array:", arr)
condition.notify()
condition.release()
Sleep(1000)
}
}
function main() {
var dict = threading.Dict()
dict.set("array", [])
var condition = threading.Condition()
var productionQuantity = 10
var producerThread = threading.Thread(producer, productionQuantity, dict, condition)
var consumerThread = threading.Thread(consumer, productionQuantity, dict, condition)
consumerThread.join()
producerThread.join()
}
दो समवर्ती धागे सार्वजनिक संसाधनों तक पहुंचते हैं।
पुनर्मूल्यांकन प्रणाली इस कार्य को लागू नहीं करती है, केवल परिभाषित करती है।
{@fun/Threads/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop}
```Event()```函数返回一个```ThreadEvent```对象。
```ThreadEvent```对象
Event()
```javascript
function consumer(productionQuantity, dict, pEvent, cEvent) {
for (var i = 0; i < productionQuantity; i++) {
while (dict.get("array").length == 0) {
pEvent.wait()
}
if (pEvent.isSet()) {
pEvent.clear()
}
var arr = dict.get("array")
var count = arr.shift()
dict.set("array", arr)
Log("consumer:", count, ", array:", arr)
cEvent.set()
Sleep(1000)
}
}
function producer(productionQuantity, dict, pEvent, cEvent) {
for (var i = 0; i < productionQuantity; i++) {
while (dict.get("array").length != 0) {
cEvent.wait()
}
if (cEvent.isSet()) {
cEvent.clear()
}
var arr = dict.get("array")
arr.push(i)
dict.set("array", arr)
Log("producer:", i, ", array:", arr)
pEvent.set()
Sleep(1000)
}
}
function main() {
var dict = threading.Dict()
dict.set("array", [])
var pEvent = threading.Event()
var cEvent = threading.Event()
var productionQuantity = 10
var producerThread = threading.Thread(producer, productionQuantity, dict, pEvent, cEvent)
var consumerThread = threading.Thread(consumer, productionQuantity, dict, pEvent, cEvent)
consumerThread.join()
producerThread.join()
}
दो समवर्ती धागे सार्वजनिक संसाधनों तक पहुंचते हैं।
यह एक बहुत ही सुविधाजनक और सुविधाजनक है।
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Thread}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threads/threading/eventLoop}
```Dict()```函数返回一个```ThreadDict```对象。
```ThreadDict```对象
Dict()
```javascript
function threadFun1(obj) {
obj["age"] = 100
while (true) {
Log("threadFun1 obj:", obj)
Sleep(5000)
}
}
function threadFun2(obj) {
while (true) {
Log("threadFun2 obj:", obj)
Sleep(5000)
}
}
function main() {
var obj = {"age": 10}
var t1 = threading.Thread(threadFun1, obj)
var t2 = threading.Thread(threadFun2, obj)
t1.join()
t2.join()
}
समवर्ती धागे के लिए निष्पादन फ़ंक्शन को सामान्य ऑब्जेक्ट में पारित किया जाता है, यह परीक्षण करने के लिए कि क्या ऑब्जेक्ट के कुंजी मूल्य को संशोधित करने के बाद अन्य धागे में ऑब्जेक्ट के कुंजी मूल्य में परिवर्तन होता है या नहीं।
function threadFun1(threadDict) {
threadDict.set("age", 100)
while (true) {
Log(`threadFun1 threadDict.get("age"):`, threadDict.get("age"))
Sleep(5000)
}
}
function threadFun2(threadDict) {
while (true) {
Log(`threadFun2 threadDict.get("age"):`, threadDict.get("age"))
Sleep(5000)
}
}
function main() {
var threadDict = threading.Dict()
threadDict.set("age", 10)
var t1 = threading.Thread(threadFun1, threadDict)
var t2 = threading.Thread(threadFun2, threadDict)
t1.join()
t2.join()
}
समवर्ती धागे के लिए निष्पादन फ़ंक्शन को भेजेंDict()फ़ंक्शन द्वारा बनाया गयाThreadDictऑब्जेक्ट, परीक्षण करता है कि क्या ऑब्जेक्ट के कुंजी मान को संशोधित करने के बाद किसी अन्य धागे में ऑब्जेक्ट कुंजी मान का परिवर्तन होता है।
जब कोई सामान्य वस्तु में एक स्ट्रिंग के साथ-साथ एक फ़ंक्शन आता है, तो इसे एक गहरी प्रति के रूप में पारित किया जाता है, जिससे एक स्ट्रिंग के साथ-साथ कुंजी मानों को संशोधित किया जा सकता है और अन्य स्ट्रिंगों में शब्दकोशों को प्रभावित नहीं किया जा सकता है।
यह एक बहुत ही सुविधाजनक और सुविधाजनक है।
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/event Event}, {@fun/Threads/threading/threading/Thread Thread}, {@fun/Threads/threading/threading/pending pending}, {@fun/Threads/threading/eventLoop}
```pending()```函数返回当前策略程序正在运行的并发线程数。
number
pending()
```javascript
function threadFun1() {
Log("threadFun1")
Sleep(3000)
}
function threadFun2() {
for (var i = 0; i < 3; i++) {
LogStatus(_D(), "print from threadFun2")
Sleep(3000)
}
}
function main() {
Log(`begin -- threading.pending():`, threading.pending())
var t1 = threading.Thread(threadFun1)
var t2 = threading.Thread(threadFun2)
Log(`after threading.Thread -- threading.pending():`, threading.pending())
t1.join()
t2.join()
Log(`after thread.join -- threading.pending():`, threading.pending())
}
एक साथ चलने वाले दो थ्रेड बनाएं, विभिन्न समय बिंदुओं पर कॉल करेंpending()फ़ंक्शन ।
रणनीतिmain()फ़ंक्शन को शुरू होने पर सीधे कॉल करेंpending()फ़ंक्शन 1 लौटाता है, क्योंकि नीतिmain()फ़ंक्शन का मुख्य थ्रेड भी एक लंबित थ्रेड है।
यह एक बहुत ही सुविधाजनक और सुविधाजनक है।
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/eventLoop}
### peekMessage
```peekMessage()```函数用于从线程获取消息。
```peekMessage()```函数返回当前线程对象关联的线程收到的消息。
string、number、bool、object、array、空值等系统支持的所有类型
peekMessage()
peekMessage(timeout)
参数```timeout```为超时设置，会按照该参数设置的毫秒数阻塞等待，返回数据；没有数据并且超时则返回空值。如果```timeout```设置为0或者不传```timeout```参数，则表示一直阻塞等待，直到接收到通道中的数据。如果```timeout```设置为-1，则表示不阻塞并且立即返回数据，没有数据时返回空值。
timeout
false
number
```javascript
function main() {
var t1 = threading.Thread(function() {
for (var i = 0; i < 10; i++) {
Log("thread1 postMessage():", i)
threading.mainThread().postMessage(i)
Sleep(500)
}
})
while (true) {
var msg = threading.currentThread().peekMessage()
Log("main peekMessage():", msg)
if (msg == 9) {
break
}
Sleep(1000)
}
t1.join()
}
एक साथ भेजे जाने वाले धागे में मुख्य धागे को संदेश भेजें।
जब आप प्रोग्राम लिखते हैं तो थ्रेड डेड लॉक के मुद्दे पर ध्यान दें।
{@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/join name}, {@Threads/Threads/eventLoop eventLoop}
postMessage(msg)
参数```msg```为所要发送的消息。
msg
true
string、number、bool、object、array、function、空值等系统支持的任意类型
```javascript
function main() {
var t1 = threading.Thread(function() {
for (var i = 0; i < 10; i++) {
Log("thread1 postMessage():", i)
threading.mainThread().postMessage(i)
Sleep(500)
}
})
for (var i = 0; i < 10; i++) {
var event = threading.mainThread().eventLoop()
Log("main event:", event)
Sleep(500)
}
t1.join()
}
संदेशों को समवर्ती धागे में भेजने के लिए उपयोग किया जाता हैeventLoop()समाचार सूचनाएं प्राप्त करें।
function main() {
threading.mainThread().postMessage(function(msg) {
Log("func from mainThread, msg:", msg)
})
threading.Thread(function() {
var func = threading.mainThread().peekMessage()
func("in " + threading.currentThread().name())
}).join()
}
एक फ़ंक्शन भेजने का समर्थन करता है.
जब एक धागे के निष्पादन कार्य में बुलायाpostMessage()जब फ़ंक्शन सिग्नल या डेटा भेजता है, तो संदेश घटनाएं भी उत्पन्न होती हैं।eventLoop()फ़ंक्शन को संदेश सूचना प्राप्त होती है।
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name join}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/name}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/
[```ThreadRet```对象](https://www.fmz.com/syntax-guide/struct/otherstruct/Thread.join-return)包含执行结果的相关数据，包含的属性如下：
- id: 线程Id。
- terminated: 线程是否被强制结束。
- elapsed: 线程的运行时间(纳秒)。
- ret: 线程函数的返回值。
```ThreadRet```对象
join()
join(timeout)
```timeout```参数用于设置等待线程结束的超时时间，单位为毫秒。```timeout```参数设置为0或者不设置```timeout```参数时```join()```函数会阻塞，等待到线程执行结束。```timeout```参数设置为-1时，```join()```函数会立即返回。
timeout
false
number
```javascript
function main() {
var t1 = threading.Thread(function() {
Log("Hello thread1")
Sleep(5000)
})
var ret = t1.join(1000)
Log("ret:", ret) // ret: undefined
ret = t1.join()
Log("ret:", ret) // ret: {"id":1,"terminated":false,"elapsed":5003252000}
}
परीक्षणjoin()फ़ंक्शन समय से आगे निकल जाता है, और आउटपुट वापस आता है।
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}
### terminate
```terminate()```函数用于强制结束线程，释放创建线程使用的硬件资源。
terminate()
```javascript
function main() {
var t1 = threading.Thread(function() {
for (var i = 0; i < 10; i++) {
Log("thread1 i:", i)
Sleep(1000)
}
})
Sleep(3000)
t1.terminate()
Log("after t1.terminate()")
while (true) {
LogStatus(_D())
Sleep(1000)
}
}
एक थ्रेड के निष्पादन को जबरन समाप्त करना, एक थ्रेड को जबरन समाप्त करने के बाद, लॉग में उस थ्रेड का आउटपुट नहीं है।
के लिएterminate()फ़ंक्शन द्वारा समाप्त किए गए थ्रेड का उपयोग नहीं किया जा सकता हैjoin()फ़ंक्शन समाप्त होने का इंतजार कर रहा है।
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@
```getData()```函数返回当前线程环境中储存的键-值对中```key```参数对应的键值。
string、number、bool、object、array、空值等系统支持的所有类型
getData()
getData(key)
```key```参数为储存的键-值对的键名。
key
true
string
```javascript
function main() {
var t1 = threading.Thread(function() {
for (var i = 0; i < 5; i++) {
threading.currentThread().setData("count", i)
Log(`setData("count"):`, i)
Sleep(1000)
}
})
for (var i = 0; i < 5; i++) {
var count = threading.getThread(t1.id()).getData("count")
Log(`getData("count"):`, count)
Sleep(1000)
}
t1.join()
}
एक साथ चलने वाले धागे के वातावरण में रिकॉर्डिंग कुंजी का नाम हैcountऔर फिर मुख्य धागे में पढ़ेंcountइस तरह के एक महत्वपूर्ण मूल्य के लिए।
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Thread/eventLoop eventLoop}
setData(key, value)
```key```参数用于指定储存的键-值对的键名。
key
true
string
```value```参数用于指定储存的键-值对的键值。
value
true
string、number、bool、object、array、function、空值等系统支持的任意类型
```javascript
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Sleep(1000)
Log(`t1.getData("data"):`, t1.getData("data"))
t1.join()
}
समवर्ती धागे में कुंजी मान जोड़ी सेट करें, और मुख्य धागे में इस कुंजी मान को पढ़ें।
function main() {
threading.mainThread().setData("func2", function(p) {
Log("func2 p:", p)
})
var t1 = threading.Thread(function() {
threading.currentThread().setData("func1", function(p) {
Log("func1 p:", p)
})
var func2 = threading.mainThread().getData("func2")
func2("test2")
})
Sleep(1000)
var func1 = t1.getData("func1")
func1("test1")
t1.join()
}
कुंजी मान फ़ंक्शन का समर्थन करता है.
डेटा स्ट्रिंग निष्पादित नहीं किया गयाjoin()फ़ंक्शन ((विफलता से बाहर निकलने का इंतजार कर रहा है) और निष्पादित नहीं किया गयाterminate()फ़ंक्शन ((कड़ाई से समाप्त करने वाला थ्रेड) के मामले में मान्य है। पैरामीटरvalueमान क्रमबद्ध करने योग्य चर होना चाहिए.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@
```id()```函数的返回值为```threadId```。
number
id()
```javascript
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Log(`t1.id():`, t1.id())
t1.join()
}
एक समवर्ती स्ट्रिंग बनाने के लिए, मुख्य स्ट्रिंग पर इस समवर्ती स्ट्रिंग के आउटपुट के लिएthreadId。
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Threads/setData set}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/thread/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/event
```name()```函数返回值为并发的线程名称。
string
name()
```javascript
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Log(`t1.name():`, t1.name()) // t1.name(): Thread-1
t1.join()
}
एक समवर्ती कार्य करने वाला थ्रेड बनाएं और मुख्य थ्रेड में इस समवर्ती थ्रेड का नाम आउटपुट करें.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Threads/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/
```eventLoop()```函数返回当前线程收到的事件信息，查看[事件信息结构](https://www.fmz.com/syntax-guide/struct/otherstruct/eventloop-return)。
object、空值
eventLoop()
eventLoop(timeout)
参数```timeout```为超时设置，单位为毫秒。参数```timeout```如果设置为0则等待有事件发生才返回，如果大于0就是设置事件等待超时，小于0立即返回最近事件。
timeout
false
number
```javascript
function main() {
var t1 = threading.Thread(function() {
while (true) {
var eventMsg = threading.currentThread().eventLoop() // 阻塞等待
// 2024-11-14 10:14:18 thread1 eventMsg: {"Seq":1,"Event":"thread","ThreadId":0,"Index":1,"Queue":0,"Nano":1731550458699947000}
Log(_D(), "thread1 eventMsg:", eventMsg)
}
})
var t2 = threading.Thread(function() {
while (true) {
var eventMsg = threading.currentThread().eventLoop(-1) // 立即返回
Log(_D(), "thread2 eventMsg:", eventMsg)
Sleep(5000)
}
})
var t3 = threading.Thread(function() {
while (true) {
var eventMsg = threading.currentThread().eventLoop(3000) // 设置3秒超时
Log(_D(), "thread3 eventMsg:", eventMsg)
}
})
t1.postMessage("Hello ", t1.name())
t2.postMessage("Hello ", t2.name())
t3.postMessage("Hello ", t3.name())
t1.join()
t2.join()
t3.join()
}
एक साथ 3 थ्रेड निष्पादित करें, प्राप्त घटना सूचना का आउटपुट करें, समय से बाहर या तुरंत वापस आने पर रिक्त मान का आउटपुट करें।
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}
### ThreadLock
线程锁对象，用于多线程同步处理。
### acquire
```acquire()```函数用于请求一个线程锁（加锁）。
acquire()
范例可以参考```threading.Lock()```章节的内容。
```acquire()```函数用于请求一个线程锁。当一个线程调用某个线程锁对象的```acquire()```函数时，它会尝试获取锁，如果锁当前没有被其它线程占用，调用线程就会成功获得锁并继续执行。如果锁已经被其它线程持有，调用```acquire()```的线程会被阻塞，直到锁被释放。
{@fun/Threads/threading/Lock Lock}, {@fun/Threads/ThreadLock/release release}
### release
```release()```函数用于释放一个线程锁（解锁）。
release()
```javascript
function consumer(productionQuantity, dict, pLock, cLock) {
for (var i = 0; i < productionQuantity; i++) {
pLock.acquire()
cLock.acquire()
var arr = dict.get("array")
var count = arr.shift()
dict.set("array", arr)
Log("consumer:", count, ", array:", arr)
cLock.release()
Sleep(1000)
pLock.release()
}
}
function producer(productionQuantity, dict, pLock, cLock) {
for (var i = 0; i < productionQuantity; i++) {
cLock.acquire() // cLock.acquire() 放在 pLock.acquire() 后不会产生死锁
pLock.acquire()
var arr = dict.get("array")
arr.push(i)
dict.set("array", arr)
Log("producer:", i, ", array:", arr)
pLock.release()
Sleep(1000)
cLock.release()
}
}
function main() {
var dict = threading.Dict()
dict.set("array", [])
var pLock = threading.Lock()
var cLock = threading.Lock()
var productionQuantity = 10
var producerThread = threading.Thread(producer, productionQuantity, dict, pLock, cLock)
var consumerThread = threading.Thread(consumer, productionQuantity, dict, pLock, cLock)
consumerThread.join()
producerThread.join()
}
परीक्षण मृत लॉक दृश्य
यह ध्यान दिया जाना चाहिए कि थ्रेड लॉक का अनुचित उपयोग मृत लॉक का कारण बन सकता है।
{@fun/Threads/threading/Lock Lock}, {@fun/Threads/ThreadLock/acquire acquire}
घटना ऑब्जेक्ट, बहु-थ्रेड घटना सूचना, संकेत के लिए प्रयोग किया जाता है।
set()
可以参考```threading.Event()```章节范例。
如果已经```set()```设置过，不能重复设置，需要清空之后重新设置信号。
{@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}
### clear
```clear()```函数用于清理信号。
clear()
可以参考```threading.Event()```章节范例。
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}
### wait
```wait()```函数用于设置事件（信号）等待，在事件（信号）被设置之前会阻塞；支持设置超时参数。
```wait()```函数返回是否超时，如果超时返回真值。
bool
wait()
wait(timeout)
参数```timeout```用于设置等待超时，单位毫秒。
timeout
false
number
```javascript
function main() {
var event = threading.Event()
var t1 = threading.Thread(function(event) {
var ret = event.wait(100)
Log(`event.wait(100):`, ret)
ret = event.wait()
Log(`event.wait():`, ret)
}, event)
Sleep(1000)
event.set()
t1.join()
}
परीक्षणwait()फ़ंक्शन का लौटाता है।
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/isSet isSet}
```isSet()```函数返回是否已经设置了事件（信号）；如果当前已经设置过事件（信号）则返回真值。
bool
isSet()
可以参考```threading.Event()```章节范例。
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}
### ThreadCondition
条件对象，用于多线程同步。
### notify
```notify()```函数用于唤醒一个正在等待的线程（如果有的话）。只有调用了```wait()```方法的线程才会被唤醒。
notify()
```javascript
function consumer(dict, condition) {
while (true) {
condition.acquire()
while (dict.get("array").length == 0) {
Log(threading.currentThread().name(), "wait()...", ", array:", dict.get("array"))
condition.wait()
}
var arr = dict.get("array")
var num = arr.shift()
Log(threading.currentThread().name(), ", num:", num, ", array:", arr, "#FF0000")
dict.set("array", arr)
Sleep(1000)
condition.release()
}
}
function main() {
var condition = threading.Condition()
var dict = threading.Dict()
dict.set("array", [])
var t1 = threading.Thread(consumer, dict, condition)
var t2 = threading.Thread(consumer, dict, condition)
var t3 = threading.Thread(consumer, dict, condition)
Sleep(1000)
var i = 0
while (true) {
condition.acquire()
var msg = ""
var arr = dict.get("array")
var randomNum = Math.floor(Math.random() * 5) + 1
if (arr.length >= 3) {
condition.notifyAll()
msg = "notifyAll"
} else {
arr.push(i)
dict.set("array", arr)
if (randomNum > 3 && arr.length > 0) {
condition.notify()
msg = "notify"
} else {
msg = "pass"
}
i++
}
Log(_D(), "randomNum:", randomNum, ", array:", arr, ", msg:", msg)
condition.release()
Sleep(1000)
}
}
उपयोगnotify()फ़ंक्शन प्रतीक्षा में थ्रेड को जगाता है।
```notify()```函数唤醒一个线程时，这个线程会重新获取线程锁。
{@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
### notifyAll
```notifyAll()```函数会唤醒所有正在等待的线程。
notifyAll()
范例可以参考```ThreadCondition.notify()```章节的内容。
```notifyAll()```函数逐个唤醒所有等待中的线程，被唤醒的线程重新获取线程锁。
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
### wait
```wait()```函数用于在某些设计的条件下让线程等待。
wait()
范例可以参考```ThreadCondition.notify()```章节的内容。
```wait()```函数会释放线程锁，当被唤醒时重新获取线程锁。
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
### acquire
```acquire()```函数用于请求一个线程锁（加锁）。
acquire()
范例可以参考```ThreadCondition.notify()```章节的内容。
在使用```wait()```之前需要请求当前条件对象的线程锁（加锁）。
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/release release}
### release
```release()```函数用于释放一个线程锁（解锁）。
release()
范例可以参考```ThreadCondition.notify()```章节的内容。
在使用```wait()```之后需要释放当前条件对象的线程锁（解锁）。
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}
### ThreadDict
字典对象，用于数据共享。
### get
```get()```函数用于获取字典对象中记录的键值。
```get()```函数返回通过参数```key```指定的键值。
string、number、bool、object、array、空值等系统支持的所有类型
get(key)
参数```key```用于指定要获取的键对应的键名。
key
true
string
```javascript
function main() {
var event = threading.Event()
var dict = threading.Dict()
dict.set("data", 100)
var t1 = threading.Thread(function(dict, event) {
Log(`thread1, dict.get("data"):`, dict.get("data"))
event.set()
event.clear()
event.wait()
Log(`after main change data, thread1 dict.get("data"):`, dict.get("data"))
dict.set("data", 0)
}, dict, event)
event.wait()
dict.set("data", 99)
event.set()
event.clear()
t1.join()
Log(`main thread, dict.get("data"):`, dict.get("data"))
}
घटना ऑब्जेक्ट सूचना थ्रेड का उपयोग करके डेटा को पढ़ना, संशोधित करना।
{@fun/Threads/ThreadDict/set set}
set(key, value)
参数```key```用于设置需要修改的键名。
key
true
string
参数```value```用于设置需要修改的键值。
value
true
string、number、bool、object、array、function、空值等系统支持的所有类型
```javascript
function main() {
var dict1 = threading.Dict()
dict1.set("func1", function(p) {
Log("func1 p:", p)
})
threading.Thread(function(dict1) {
var func1 = dict1.get("func1")
func1("test")
}, dict1).join()
}
कुंजी मान फ़ंक्शन का समर्थन करता है.
{@fun/Threads/ThreadDict/get get} {@fun/Threads/ThreadDict/get get}
आविष्कारक क्वांटिफाइड ट्रेडिंग प्लेटफॉर्म मुख्य रूप सेexchange.IO()फ़ंक्शन ब्लॉकचेन से संबंधित विभिन्न कार्यों, कॉलों को लागू करता है।exchange.IO()फ़ंक्शनों को उनके कार्यों के अनुसार अलग-अलग वर्णित किया जाता है।exchange.IO("abi", ...)फ़ंक्शन का उपयोग एबीआई पंजीकरण के लिए किया जाता है।
exchange.IO(k, पता, abiContent)
k
true
string
```address```参数用于指定智能合约的地址。
address
true
string
```abiContent```参数用于指定智能合约的```ABI```。
abiContent
true
string
```javascript
function main() {
// register Uniswap SwapRouter02 abi
var routerAddress = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var abi = `[{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactOutputParams","name":"params","type":"tuple"}],"name":"exactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"}]`
// abi只使用了局部的exactOutput方法的内容，完整的abi可以在网上搜索
exchange.IO("abi", routerAddress, abi)
}
स्मार्ट कॉन्ट्रैक्ट विधि को कॉल करने के लिए पंजीकरण की आवश्यकता नहीं है यदि यह मानक ERC20 विधि है।
अनुबंध प्राप्त करनाABIसामग्री को नीचे दिए गए URL से प्राप्त किया जा सकता है, केवलresultउदाहरण के लिएः
https://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
```exchange.IO("api", "eth", ...)```函数返回调用的RPC方法的返回值。
string、number、bool、object、array、空值等系统支持的所有类型
exchange.IO(k, blockChain, rpcMethod)
exchange.IO(k, blockChain, rpcMethod, ...args)
```k```参数用于设置```exchange.IO()```函数的功能，设置为```"api"```表示该函数用于扩展调用请求。
k
true
string
```blockChain```参数用于设置```exchange.IO()```函数的功能，设置为```"eth"```表示该函数用于以太坊网络的RPC方法调用。
blockChain
true
string
```rpcMethod```参数用于设置```exchange.IO()```函数调用的RPC方法。
rpcMethod
true
string
```arg```参数用于指定所要调用的RPC方法的参数。 ```arg```参数可能有多个，```arg```参数的类型与个数根据```rpcMethod```参数指定的RPC方法而定。
arg
false
string、number、bool、object、array、function、空值等系统支持的所有类型
```javascript
function main() {
// "owner" 需要替换为具体钱包地址
// "latest"字符串位置的参数标签：'latest'、'earliest'或'pending'，参考https://eth.wiki/json-rpc/API#the-default-block-parameter
// 返回值 ethBalance 为十六进制字符串：0x9b19ce56113070
var ethBalance = exchange.IO("api", "eth", "eth_getBalance", "owner", "latest")
// ETH的精度单位为1e18
var ethDecimal = 18
// 由于JavaScript语言精度原因，需要使用系统底层封装的函数BigInt、BigDecimal处理
// 将ethBalance转换为可读数量，0x9b19ce56113070转换为0.043656995388076145
Log(Number((BigDecimal(BigInt(ethBalance))/BigDecimal(Math.pow(10, ethDecimal))).toString()))
}
ईटीएच का बैलेंस पता करने के लिएः
function mian() {
// ETH的精度单位为1e18
var ethDecimal = 18
// 转账数量，可读的数量例如：0.01个ETH
var sendAmount = 0.01
// 由于JavaScript语言精度原因，需要使用系统底层封装的函数BigInt、BigDecimal处理，并且将可读数量转换为链上处理的数据
var toAmount = (BigDecimal(sendAmount)*BigDecimal(Math.pow(10, ethDecimal))).toFixed(0)
// "toAddress"为转账时接收方的ETH钱包地址，需要具体填写，toAmount为转账数量
exchange.IO("api", "eth", "send", "toAddress", toAmount)
}
ईटीएच हस्तांतरण, आवश्यकताओं के अनुसार सेट किया जा सकता है{gasPrice: 11, gasLimit: 111, nonce: 111}पैरामीटर, जो कि पैरामीटर पर सेट किया गया हैexchange.IO()फ़ंक्शन के अंतिम पैरामीटर पर.nonceसिस्टम के डिफ़ॉल्ट मान का उपयोग करें या सेट न करेंgasLimit/gasPrice/nonce, सभी सिस्टम डिफ़ॉल्ट का उपयोग करते हैं.
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s))/BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
var gasPrice = exchange.IO("api", "eth", "eth_gasPrice")
Log("gasPrice:", toAmount(gasPrice, 0)) // 5000000000 , in wei (5 gwei)
}
जांचेंgasPrice：
function toAmount(s, decimals) {
// toAmount函数可以把hex编码的数值转换为十进制数值
return Number((BigDecimal(BigInt(s))/BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
// 编码approve（授权）方法的调用
var data = exchange.IO("encode", "0x111111111117dC0aa78b770fA6A738034120C302", "approve", "0xe592427a0aece92de3edee1f18e0157c05861564", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
Log("data:", data)
var gasPrice = exchange.IO("api", "eth", "eth_gasPrice")
Log("gasPrice:", toAmount(gasPrice, 0))
var obj = {
"from" : "0x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // walletAddress
"to" : "0x111111111117dC0aa78b770fA6A738034120C302",
"gasPrice" : gasPrice,
"value" : "0x0",
"data" : "0x" + data,
}
var gasLimit = exchange.IO("api", "eth", "eth_estimateGas", obj)
Log("gasLimit:", toAmount(gasLimit, 0))
Log("gas fee", toAmount(gasLimit, 0) * toAmount(gasPrice, 0) / 1e18)
}
जांचेंeth_estimateGas：
{@fun BigDecimal}, {@fun BigInt}
### exchange.IO("encode", ...)
```exchange.IO("encode", ...)```函数的调用方式用于数据编码。
```exchange.IO("encode", ...)```函数返回编码后的数据。
string
exchange.IO(k, dataFormat, ...args)
exchange.IO(k, address, dataFormat)
exchange.IO(k, address, dataFormat, ...args)
```k```参数用于设置```exchange.IO()```函数的功能，设置为```"encode"```表示该函数用于数据编码。
k
true
string
```address```参数用于设置智能合约的地址。 在调用```exchange.IO("encode", ...)```函数时，如果传入```address```参数表示编码（encode）智能合约上的方法调用。 在调用```exchange.IO("encode", ...)```函数时，如果未传入```address```参数，则该函数用于编码指定的类型顺序，功能等同```Solidity```中的```abi.encode```。
address
false
string
```dataFormat```参数用于指定编码数据的方法、类型、顺序。
dataFormat
true
string
```arg```参数用于指定与```dataFormat```参数匹配的具体数据值。 ```arg```参数可能有多个，```arg```参数的类型与个数根据```dataFormat```参数设置而定。
arg
false
string、number、tuple、array等系统支持的所有类型
```javascript
function main() {
// ContractV3SwapRouterV2 主网地址 : 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
// 调用unwrapWETH9方法需要先注册ABI，此处省略注册
// "owner"代表钱包地址，需要具体填写，1代表解包装数量，把一个WETH解包装为ETH
var data = exchange.IO("encode", "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45", "unwrapWETH9(uint256,address)", 1, "owner")
Log(data)
}
कोडिंगunwrapWETH9उदाहरण के लिए, विधि का उपयोगः
function main() {
var x = 10
var address = "0x02a5fBb259d20A3Ad2Fdf9CCADeF86F6C1c1Ccc9"
var str = "Hello World"
var array = [1, 2, 3]
var ret = exchange.IO("encode", "uint256,address,string,uint256[]", x, address, str, array) // uint 即 uint256 , FMZ上需要指定类型长度
Log("ret:", ret)
/*
000000000000000000000000000000000000000000000000000000000000000a // x
00000000000000000000000002a5fbb259d20a3ad2fdf9ccadef86f6c1c1ccc9 // address
0000000000000000000000000000000000000000000000000000000000000080 // str 的偏移
00000000000000000000000000000000000000000000000000000000000000c0 // array 的偏移
000000000000000000000000000000000000000000000000000000000000000b // str 的长度
48656c6c6f20576f726c64000000000000000000000000000000000000000000 // str 数据
0000000000000000000000000000000000000000000000000000000000000003 // array 的长度
0000000000000000000000000000000000000000000000000000000000000001 // array 第一个数据
0000000000000000000000000000000000000000000000000000000000000002 // array 第二个数据
0000000000000000000000000000000000000000000000000000000000000003 // array 第三个数据
*/
}
बराबरSolidityमध्यabi.encodeएक कोड का उदाहरणः
function main() {
var types = "tuple(a uint256,b uint8,c address),bytes"
var ret = exchange.IO("encode", types, {
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}, "0011")
Log("encode: ", ret)
}
एक टपल या उस प्रकार के अनुक्रम कोडिंग का समर्थन करता है जिसमें एक टपल शामिल है, और एक टपल के लिए एक प्रकार का अनुक्रम कोड है।
यह प्रकार क्रम हैtuple、bytesरचना, तो कॉल कर रहे हैंexchange.IO()एन्कोडिंग के लिए दो पैरामीटर जारी रखने की आवश्यकता होती हैः
{
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}
इनपुट पैरामीटर को भीtupleयह एक बहुत ही महत्वपूर्ण विषय है, और यह एक बहुत ही महत्वपूर्ण विषय है।typesपैरामीटर में परिभाषित रूपःtuple(a uint256,b uint8,c address)..
-2, इसी तरह।bytesचर का प्रकारः
"0011"
function main() {
var path = ["0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", "0xdac17f958d2ee523a2206206994597c13d831ec7"] // ETH address, USDT address
var ret = exchange.IO("encode", "address[]", path)
Log("encode: ", ret)
}
किसी भी प्रकार के अनुक्रमिक कोड को समर्थित करता है जो किसी भी प्रकार के सरणी या सरणी के साथ आता हैः
编码智能合约上的方法调用时，需要先注册对应的ABI。
### exchange.IO("encodePacked", ...)
```exchange.IO("encodePacked", ...)```函数的调用方式用于```encodePacked```编码。
```exchange.IO("encodePacked", ...)```函数返回```encodePacked```编码后的数据。
string
exchange.IO(k, dataFormat, ...args)
```k```参数用于设置```exchange.IO()```函数的功能，设置为```"encodePacked"```表示该函数用于数据```encodePacked```编码。
k
true
string
```dataFormat```参数用于指定```encodePacked```编码数据的类型、顺序。
dataFormat
true
string
```arg```参数用于指定与```dataFormat```参数匹配的具体数据值。 ```arg```参数可能有多个，```arg```参数的类型与个数根据```dataFormat```参数设置而定。
arg
true
string、number、tuple、array等系统支持的所有类型
```javascript
function main() {
var fee = exchange.IO("encodePacked", "uint24", 3000)
var tokenInAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
var tokenOutAddress = "0x6b175474e89094c44da98b954eedeac495271d0f"
var path = tokenInAddress.slice(2).toLowerCase()
path += fee + tokenOutAddress.slice(2).toLowerCase()
Log("path:", path)
}
उपयोगUniswap V3जब आप रूपांतरण पथ जैसे पैरामीटर भेजने की आवश्यकता होती है, तो इसका उपयोग किया जाता हैencodePackedकोड ऑपरेशनः
```exchange.IO("decode", ...)```函数返回解码后的数据。 当```dataFormat```参数指定的数据只有一个时返回一个字符串。 当```dataFormat```参数指定的数据有多个时返回一个数组。
array、string
exchange.IO(k, dataFormat, data)
```k```参数用于设置```exchange.IO()```函数的功能，设置为```"decode"```表示该函数用于数据解码。
k
true
string
```dataFormat```参数用于指定解码数据的类型、顺序。
dataFormat
true
string
```data```参数用于设置所要解码的数据。
data
true
string
```javascript
function main() {
var types = "tuple(a uint256,b uint8,c address),bytes"
var ret = exchange.IO("encode", types, {
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}, "0011")
Log("encode: ", ret)
var rawData = exchange.IO("decode", types, ret)
Log("decode:", rawData)
}
```javascript
function main() {
// register SwapRouter02 abi
var walletAddress = "0x398a93ca23CBdd2642a07445bCD2b8435e0a373f"
var routerAddress = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var abi = `[{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactOutputParams","name":"params","type":"tuple"}],"name":"exactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"}]`
exchange.IO("abi", routerAddress, abi) // abi只使用了局部的exactOutput方法的内容，完整的abi可以在网上搜索
// encode path
var fee = exchange.IO("encodePacked", "uint24", 3000)
var tokenInAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
var tokenOutAddress = "0xdac17f958d2ee523a2206206994597c13d831ec7"
var path = tokenInAddress.slice(2).toLowerCase()
path += fee + tokenOutAddress.slice(2).toLowerCase()
Log("path:", path)
var dataTuple = {
"path" : path,
"recipient" : walletAddress,
"amountOut" : 1000,
"amountInMaximum" : 1,
}
// encode SwapRouter02 exactOutput
var rawData = exchange.IO("encode", routerAddress, "exactOutput", dataTuple)
Log("method hash:", rawData.slice(0, 8)) // 09b81346
Log("params hash:", rawData.slice(8))
// decode exactOutput params
var decodeRaw = exchange.IO("decode", "tuple(path bytes,recipient address,amountOut uint256,amountInMaximum uint256)", rawData.slice(8))
Log("decodeRaw:", decodeRaw)
}
नीचे दिए गए उदाहरण सबसे पहलेpathपैरामीटर के साथ किया जाता हैencodePackedऔर यह एक बहुत अच्छा तरीका है।exactOutputविधि कॉल की आवश्यकताpathएक पैरामीटर के रूप में.encodeमार्ग अनुबंधexactOutputएक विधि है कि केवल एक पैरामीटर है, और पैरामीटर प्रकार हैtupleटाइप करें।exactOutputइस विधि के नाम के बाद कोड हैः0x09b81346, उपयोगexchange.IO("decode", ...)कैसे पता करेंdecodeRaw, और चरdataTupleएकजुटता।
यह एक बहुत ही महत्वपूर्ण जानकारी है।exchange.IO()यह फ़ंक्शन न केवल एन्कोडिंग का समर्थन करता है, बल्कि डिकोडिंग का भी समर्थन करता है।
exchange.IO(k, key)
```k```参数用于设置```exchange.IO()```函数的功能，设置为```"key"```表示该函数用于切换私钥。
k
true
string
```key```参数用于设置私钥。
key
true
string
```javascript
function main() {
exchange.IO("key", "Private Key") // "Private Key"代表私钥字符串，需要具体填写
}
### exchange.IO("api", ...)
```exchange.IO("api", ...)```函数的调用方式用于调用智能合约的方法。
```exchange.IO("api", ...)```函数返回所调用的智能合约方法的返回值。
string、number、bool、object、array、空值等系统支持的所有类型
exchange.IO(k, address, method)
exchange.IO(k, address, method, ...args)
exchange.IO(k, address, method, value, ...args)
```k```参数用于设置```exchange.IO()```函数的功能，设置为```"api"```表示该函数用于扩展调用请求。
k
true
string
```address```参数用于指定智能合约的地址。
address
true
string
```method```参数用于指定所要调用的智能合约的方法。
method
true
string
```value```参数用于设置发送的ETH数量。 所要执行的智能合约方法的```stateMutability```属性是```payable```，则需要传```value```参数。 ```"stateMutability":"payable"```属性可以从ABI中查看，```exchange.IO()```函数会根据已经注册的ABI中的```stateMutability```属性判断所需要的参数， 如果```stateMutability```属性是```nonpayable```则不需要传```value```参数。
value
false
number、string
```arg```参数用于指定所要调用智能合约的方法的参数。 ```arg```参数可能有多个，```arg```参数的类型与个数根据所要调用的智能合约的方法而定。
arg
false
string、number、bool等系统支持的所有类型
```javascript
function main(){
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302" // 代币的合约地址，例子中的代币为1INCH
Log(exchange.IO("api", tokenAddress, "decimals")) // 查询，打印1INCH代币的精度指数为18
}
```javascript
function main(){
// 代币的合约地址，例子中的代币为1INCH
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
// 例如查询得出1000000000000000000，除以该token的精度单位1e18，得出当前交易所对象绑定的钱包给spender地址授权了1个1INCH数量
Log(exchange.IO("api", tokenAddress, "allowance", "owner", "spender"))
}
```owner```：钱包地址，例子中以字符串"owner"代替，实际使用需要具体填写地址。 ```spender```：被授权的合约地址，例子中以字符串"spender"代替，实际使用需要具体填写地址，例如可以是```Uniswap V3 router v1```地址。
```javascript
function main(){
// 代币的合约地址，例子中的代币为1INCH
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
// 授权量的十六进制字符串: 0xde0b6b3a7640000 , 对应的十进制字符串: 1e18 , 1e18除以该token的精度单位，即1个代币数量 , 所以这里指授权一个代币
Log(exchange.IO("api", tokenAddress, "approve", "spender", "0xde0b6b3a7640000"))
}
```spender```：被授权的合约地址，例子中以字符串"spender"代替，实际使用需要具体填写地址，例如可以是```Uniswap V3 router v1```地址。 ```0xde0b6b3a7640000```：授权数量，这里使用的是十六进制字符串表示，对应的十进制数值为1e18，除以例子中的token精度单位（即1e18）， 得出授权了1个token。 ```exchange.IO()```函数的第三个参数传入方法名```approve```，也可以写methodId的形式，例如："0x571ac8b0"。 也可以写完整标准方法名，例如："approve(address,uint256)"。
```javascript
function main() {
var ContractV3SwapRouterV2 = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var tokenInName = "ETH"
var amountIn = 0.01
var options = {gasPrice: 5000000000, gasLimit: 21000, nonce: 100} // 此处为举例，具体要根据实际场景设置
var data = "" // 编码后的数据，此处为空字符串，具体要根据实际场景设置
var tx = exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", (tokenInName == 'ETH' ? amountIn : 0), (new Date().getTime() / 1000) + 3600, data, options || {})
}
```multicall```方法可能有多种传参方式，具体可以查询包含该方法的ABI，调用该方法之前需要先注册ABI。返回值：txid。
具体的```multicall```方法调用例子，可以参考平台公开的[「Uniswap V3 交易类库」模板](https://www.fmz.com/strategy/397260)
这里使用伪代码来描述一些细节：
exchange.IO ((
```ContractV3SwapRouterV2```：Uniswap V3的router v2地址。
```value```：转账的ETH数量，如果兑换操作的tokenIn代币不是ETH，则设置为0。
```deadline```：```deadline```是```multicall```方法的参数，可以设置为(new Date().getTime() / 1000) + 3600，表示一小时内有效。
```data```：```data```是```multicall```方法的参数，需要执行的打包操作数据。
与```exchange.IO("api", "eth", "send", "toAddress", toAmount)```类似，在调用```multicall```方法时也可以指定方法调用的```gasLimit/gasPrice/nonce```设置，
同样使用伪代码来描述：
exchange.IO ((
可以根据具体需求设置```{gasPrice: 11, gasLimit: 111, nonce: 111}```参数，该参数设置在```exchange.IO()```函数的最后一个参数上。
可以省略其中的```nonce```使用系统默认的值，或者不设置```gasLimit/gasPrice/nonce```，全部使用系统默认值。
### exchange.IO("address")
```exchange.IO("address")```函数的调用方式用于获取{@var/EXCHANGE exchange}交易所对象配置的钱包的地址。
```exchange.IO("address")```函数返回配置的钱包地址。
string
exchange.IO(k)
```k```参数用于设置```exchange.IO()```函数的功能，设置为```"address"```表示该函数用于获取配置的钱包地址。
k
true
string
```javascript
function main() {
Log(exchange.IO("address")) // 打印exchange交易所对象上配置的私钥的钱包地址
}
exchange.IO(k, address)
```k```参数用于设置```exchange.IO()```函数的功能，设置为```"base"```表示该函数用于切换RPC节点。
k
true
string
```address```参数用于设置RPC节点地址。
address
true
string
```javascript
function main() {
var chainRpc = "https://bsc-dataseed.binance.org"
e.IO("base", chainRpc) // 切换到BSC链
}
```TA.MACD()```函数的返回值为二维数组，结构为：```[DIF, DEA, MACD]```。
array
TA.MACD(inReal)
TA.MACD(inReal, optInFastPeriod, optInSlowPeriod, optInSignalPeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInFastPeriod```参数用于设置快周期。
optInFastPeriod
false
number
```optInSlowPeriod```参数用于设置慢周期。
optInSlowPeriod
false
number
```optInSignalPeriod```参数用于设置信号周期。
optInSignalPeriod
false
number
```javascript
function main(){
// 可以填入不同k线周期，比如PERIOD_M1,PERIOD_M30,PERIOD_H1......
var records = exchange.GetRecords(PERIOD_M15)
var macd = TA.MACD(records, 12, 26, 9)
// 观看日志可得知返回三个数组，分别对应DIF，DEA，MACD
Log("DIF:", macd[0], "DEA:", macd[1], "MACD:", macd[2])
}
def main():
r = exchange.GetRecords(PERIOD_M15)
macd = TA.MACD(r, 12, 26, 9)
Log("DIF:", macd[0], "DEA:", macd[1], "MACD:", macd[2])
void main() {
auto r = exchange.GetRecords(PERIOD_M15);
auto macd = TA.MACD(r, 12, 26, 9);
Log("DIF:", macd[0], "DEA:", macd[1], "MACD:", macd[2]);
}
आविष्कारक द्वारा मात्रात्मकTAसंकेतक संग्रह, सामान्य संकेतक एल्गोरिदम का अनुकूलन किया गया है.JavaScript、Python、C++भाषा की रणनीति का उपयोग करनाओपन सोर्स टीए लाइब्रेरी कोड。
{@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
### TA.KDJ
```TA.KDJ()```函数用于计算**随机指标**。
```TA.KDJ()```函数的返回值为二维数组，结构为：```[K, D, J]```。
array
TA.KDJ(inReal)
TA.KDJ(inReal, period, kPeriod, dPeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```period```参数用于设置周期1。
period
false
number
```kPeriod```参数用于设置周期2。
kPeriod
false
number
```dPeriod```参数用于设置周期3。
dPeriod
false
number
```javascript
function main(){
var records = exchange.GetRecords(PERIOD_M15)
var kdj = TA.KDJ(records, 9, 3, 3)
Log("k:", kdj[0], "d:", kdj[1], "j:", kdj[2])
}
def main():
r = exchange.GetRecords(PERIOD_M15)
kdj = TA.KDJ(r, 9, 3, 3)
Log("k:", kdj[0], "d:", kdj[1], "j:", kdj[2])
void main() {
auto r = exchange.GetRecords();
auto kdj = TA.KDJ(r, 9, 3, 3);
Log("k:", kdj[0], "d:", kdj[1], "j:", kdj[2]);
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
### TA.RSI
```TA.RSI()```函数用于计算**强弱指标**。
```TA.RSI()```函数的返回值为：一维数组。
array
TA.RSI(inReal)
TA.RSI(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期。
optInTimePeriod
false
number
```javascript
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var rsi = TA.RSI(records, 14)
Log(rsi)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
rsi = TA.RSI(r, 14)
Log(rsi)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto rsi = TA.RSI(r, 14);
Log(rsi);
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
### TA.ATR
```TA.ATR()```函数用于计算**平均真实波幅指标**。
```TA.ATR()```函数的返回值为：一维数组。
array
TA.ATR(inPriceHLC)
TA.ATR(inPriceHLC, optInTimePeriod)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期。
optInTimePeriod
false
number
```javascript
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var atr = TA.ATR(records, 14)
Log(atr)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
atr = TA.ATR(r, 14)
Log(atr)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto atr = TA.ATR(r, 14);
Log(atr);
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
### TA.OBV
```TA.OBV()```函数用于计算**能量潮指标**。
```TA.OBV()```函数的返回值为：一维数组。
array
TA.OBV(inReal)
TA.OBV(inReal, inPriceV)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```inPriceV```参数用于指定成交量数据。
inPriceV
false
{@struct/Record Record}结构数组
```javascript
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var obv = TA.OBV(records)
Log(obv)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
obv = TA.OBV(r)
Log(obv)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto obv = TA.OBV(r);
Log(obv);
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.MA TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator. TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.MA TA.MA TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA.BOLL TA.BOLL}, {@fun/TA/TA.ALIGATOR. TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/
```TA.MA()```函数的返回值为：一维数组。
array
TA.MA(inReal)
TA.MA(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期。
optInTimePeriod
false
number
```javascript
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var ma = TA.MA(records, 14)
Log(ma)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
ma = TA.MA(r, 14)
Log(ma)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto ma = TA.MA(r, 14);
Log(ma);
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
### TA.EMA
```TA.EMA()```函数用于计算**指数平均数指标**。
```TA.EMA()```函数的返回值为：一维数组。
array
TA.EMA(inReal)
TA.EMA(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期。
optInTimePeriod
false
number
```javascript
function main(){
var records = exchange.GetRecords()
// 判断K线bar数量是否满足指标计算周期
if (records && records.length > 9) {
var ema = TA.EMA(records, 9)
Log(ema)
}
}
def main():
r = exchange.GetRecords()
if r and len(r) > 9:
ema = TA.EMA(r, 9)
Log(ema)
void main() {
auto r = exchange.GetRecords();
if(r.Valid && r.size() > 9) {
auto ema = TA.EMA(r, 9);
Log(ema);
}
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA TA.MA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
### TA.BOLL
```TA.BOLL()```函数用于计算**布林带指标**。
```TA.BOLL()```函数的返回值为二维数组，结构为：```[upLine, midLine, downLine]```。
array
TA.BOLL(inReal)
TA.BOLL(inReal, period, multiplier)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```period```参数用于设置周期。
period
false
number
```multiplier```参数用于设置乘数。
multiplier
false
number
```javascript
function main() {
var records = exchange.GetRecords()
if(records && records.length > 20) {
var boll = TA.BOLL(records, 20, 2)
var upLine = boll[0]
var midLine = boll[1]
var downLine = boll[2]
Log(upLine)
Log(midLine)
Log(downLine)
}
}
def main():
r = exchange.GetRecords()
if r and len(r) > 20:
boll = TA.BOLL(r, 20, 2)
upLine = boll[0]
midLine = boll[1]
downLine = boll[2]
Log(upLine)
Log(midLine)
Log(downLine)
void main() {
auto r = exchange.GetRecords();
if(r.Valid && r.size() > 20) {
auto boll = TA.BOLL(r, 20, 2);
auto upLine = boll[0];
auto midLine = boll[1];
auto downLine = boll[2];
Log(upLine);
Log(midLine);
Log(downLine);
}
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
### TA.Alligator
```TA.Alligator()```函数用于计算**鳄鱼线指标**。
```TA.Alligator()```函数的返回值为二维数组，结构为：```[jawLine, teethLine, lipsLine]```。
array
TA.Alligator(inReal)
TA.Alligator(inReal, jawLength, teethLength, lipsLength)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```jawLength```参数用于设置下颚周期。
jawLength
false
number
```teethLength```参数用于设置牙齿周期。
teethLength
false
number
```lipsLength```参数用于设置上唇周期。
lipsLength
false
number
```javascript
function main(){
var records = exchange.GetRecords()
var alligator = TA.Alligator(records)
Log("jawLine:", alligator[0])
Log("teethLine:", alligator[1])
Log("lipsLine:", alligator[2])
}
def main():
records = exchange.GetRecords()
alligator = TA.Alligator(records)
Log("jawLine:", alligator[0])
Log("teethLine:", alligator[1])
Log("lipsLine:", alligator[2])
void main() {
auto records = exchange.GetRecords();
auto alligator = TA.Alligator(records);
Log("jawLine:", alligator[0]);
Log("teethLine:", alligator[1]);
Log("lipsLine:", alligator[2]);
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
### TA.CMF
```TA.CMF()```函数用于计算**蔡金货币流量指标**。
```TA.CMF()```函数的返回值为：一维数组。
array
TA.CMF(inReal)
TA.CMF(inReal, inPriceV)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```inPriceV```参数用于指定成交量数据。
inPriceV
false
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var cmf = TA.CMF(records)
Log(cmf)
}
def main():
records = exchange.GetRecords()
cmf = TA.CMF(records)
Log(cmf)
void main() {
auto records = exchange.GetRecords();
auto cmf = TA.CMF(records);
Log(cmf);
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.ATR TA.ATR TA.OBV}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.ALligator TA.Alligator}, {@fun/TA/TA
```TA.Highest()```函数返回最近一定周期内的某个属性的最大值，不包含当前Bar。
number
TA.Highest(inReal)
TA.Highest(inReal, period, attr)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```period```参数用于设置周期。
period
false
number
```attr```参数用于设置属性，可选：```Open```、```Close```、```Low```、```High```、```Volume```、```OpenInterest```。
attr
false
string
```javascript
function main() {
var records = exchange.GetRecords()
var highestForOpen = TA.Highest(records, 10, "Open")
Log(highestForOpen)
}
def main():
records = exchange.GetRecords()
highestForOpen = TA.Highest(records, 10, "Open")
Log(highestForOpen)
void main() {
auto records = exchange.GetRecords();
auto highestForOpen = TA.Highest(records.Open(), 10);
Log(highestForOpen);
}
उदाहरण के लिए,TA.Highest(records, 30, "High")फ़ंक्शन, यदि चक्र पैरामीटरperiodसेट करें0, गणना का मतलब हैinRealसभी K-रेखा डेटा जो पैरामीटर के माध्यम से पारित किया गया हैBar; यदि विशेषता पैरामीटरattrबिना निर्दिष्ट किए, इसे माना जाता हैinRealपैरामीटर के लिए K-रेखा डेटा आम सरणी है।
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.ALIGATOR TA.ALIGATOR}, {@fun/TA/TA.CMF.CMF}, {@fun/TA/TA.Lowest TA.Lowest}, {@fun/TA.ALIGATOR TA.ALIGATOR}, {@fun/TA/TA.CMF.CMF}, {@fun/TA.Lowest TA.Lowest}, {@fun/TA.
```TA.Lowest()```函数返回最近一定周期内的某个属性的最小值，不包含当前Bar。
number
TA.Lowest(inReal)
TA.Lowest(inReal, period, attr)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```period```参数用于设置周期。
period
false
number
```attr```参数用于设置属性，可选：```Open```、```Close```、```Low```、```High```、```Volume```、```OpenInterest```。
attr
false
string
```javascript
function main() {
var records = exchange.GetRecords()
var lowestForOpen = TA.Lowest(records, 10, "Open")
Log(lowestForOpen)
}
def main():
records = exchange.GetRecords()
lowestForOpen = TA.Lowest(records, 10, "Open")
Log(lowestForOpen)
void main() {
auto records = exchange.GetRecords();
auto lowestForOpen = TA.Lowest(records.Open(), 10);
Log(lowestForOpen);
}
उदाहरण के लिए,TA.Lowest(records, 30, "Low")फ़ंक्शन, यदि चक्र पैरामीटरperiodसेट करें0, गणना का मतलब हैinRealसभी K-रेखा डेटा जो पैरामीटर के माध्यम से पारित किया गया हैBar; यदि विशेषता पैरामीटरattrबिना निर्दिष्ट किए, इसे माना जाता हैinRealपैरामीटर के लिए K-रेखा डेटा आम सरणी है।
并且第一个参数传入的不是```auto r = exchange.GetRecords()```函数调用时获取的K线数据```r```。
需要调用```r```的方法，传入具体属性数据。例如传入```r.Close()```收盘价数据。
```Close```、```High```、```Low```、```Open```、```Volume```如同```r.Close()```调用方式。
```C++```语言策略的测试范例：
खाली मुख्य (() { रिकॉर्ड r; r.Valid = सच; के लिए (ऑटो i = 0; i < 10; i++) { रिकॉर्ड ele; ele.Time = i * 100000; ele.High = i * 10000; ele.Low = i * 1000; ele.Close = i * 100; ele.Open = i * 10; ele.Volume = i * 1; r.push_back ((ele); }
for(int j = 0; j < r.size(); j++){
Log(r[j]);
}
// 注意：第一个参数传入的不是r，需要调用r.Close()
auto highest = TA.Highest(r.Close(), 8);
Log(highest);
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}
### TA.SMA
```TA.SMA()```函数用于计算**简单移动平均指标**。
```TA.SMA()```函数的返回值为：一维数组。
array
TA.SMA(inReal)
TA.SMA(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期。
optInTimePeriod
false
number
```javascript
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var sma = TA.SMA(records, 14)
Log(sma)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
sma = TA.SMA(r, 14)
Log(sma)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto sma = TA.SMA(r, 14);
Log(sma);
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
### Talib
### talib.CDL2CROWS
```talib.CDL2CROWS()```函数用于计算**Two Crows (K线图--两只乌鸦)**。
```talib.CDL2CROWS()```函数的返回值为：一维数组。
array
talib.CDL2CROWS(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL2CROWS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL2CROWS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL2CROWS(records);
Log(ret);
}
对于```Python```语言中的调用来说，传参有所不同，需要根据以上描述中的：```Records[Open,High,Low,Close]```传参。
举例把一个变量```records```（即参数```inPriceOHLC```，类型为{@struct/Record Record}结构数组）拆分成：
```Open```列表：在Python中写为```records.Open```。
```High```列表：在Python中写为```records.High```。
```Low```列表：在Python中写为```records.Low```。
```Close```列表：在Python中写为```records.Close```。
Python策略代码中调用：
talib.CDL2CROWS ((रिकॉर्ड.ओपन,रिकॉर्ड.उच्च,रिकॉर्ड.लो,रिकॉर्ड.क्लोज)
其它```talib```指标以此类推，不再赘述。
### talib.CDL3BLACKCROWS
```talib.CDL3BLACKCROWS()```函数用于计算**Three Black Crows (K线图--3只黑乌鸦)**。
```talib.CDL3BLACKCROWS()```函数的返回值为：一维数组。
array
talib.CDL3BLACKCROWS(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3BLACKCROWS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3BLACKCROWS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3BLACKCROWS(records);
Log(ret);
}
### talib.CDL3INSIDE
```talib.CDL3INSIDE()```函数用于计算**Three Inside Up/Down (K线图:3内上下震荡)**。
```talib.CDL3INSIDE()```函数的返回值为：一维数组。
array
talib.CDL3INSIDE(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3INSIDE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3INSIDE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3INSIDE(records);
Log(ret);
}
### talib.CDL3LINESTRIKE
```talib.CDL3LINESTRIKE()```函数用于计算**Three-Line Strike (K线图:3线震荡)**。
```talib.CDL3LINESTRIKE()```函数的返回值为：一维数组。
array
talib.CDL3LINESTRIKE(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3LINESTRIKE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3LINESTRIKE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3LINESTRIKE(records);
Log(ret);
}
### talib.CDL3OUTSIDE
```talib.CDL3OUTSIDE()```函数用于计算**Three Outside Up/Down (K线图:3外下震荡)**。
```talib.CDL3OUTSIDE()```函数的返回值为：一维数组。
array
talib.CDL3OUTSIDE(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3OUTSIDE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3OUTSIDE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3OUTSIDE(records);
Log(ret);
}
### talib.CDL3STARSINSOUTH
```talib.CDL3STARSINSOUTH()```函数用于计算**Three Stars In The South (K线图:南方三星)**。
```talib.CDL3STARSINSOUTH()```函数的返回值为：一维数组。
array
talib.CDL3STARSINSOUTH(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3STARSINSOUTH(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3STARSINSOUTH(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3STARSINSOUTH(records);
Log(ret);
}
### talib.CDL3WHITESOLDIERS
```talib.CDL3WHITESOLDIERS()```函数用于计算**Three Advancing White Soldiers (K线图:三白兵)**。
```talib.CDL3WHITESOLDIERS()```函数的返回值为：一维数组。
array
talib.CDL3WHITESOLDIERS(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3WHITESOLDIERS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3WHITESOLDIERS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3WHITESOLDIERS(records);
Log(ret);
}
### talib.CDLABANDONEDBABY
```talib.CDLABANDONEDBABY()```函数用于计算**Abandoned Baby (K线图:弃婴)**。
```talib.CDLABANDONEDBABY()```函数的返回值为：一维数组。
array
talib.CDLABANDONEDBABY(inPriceOHLC)
talib.CDLABANDONEDBABY(inPriceOHLC, optInPenetration)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```optInPenetration```参数用于设置Penetration，默认值为0.3。
optInPenetration
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLABANDONEDBABY(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLABANDONEDBABY(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLABANDONEDBABY(records);
Log(ret);
}
### talib.CDLADVANCEBLOCK
```talib.CDLADVANCEBLOCK()```函数用于计算**Advance Block (K线图:推进)**。
```talib.CDLADVANCEBLOCK()```函数的返回值为：一维数组。
array
talib.CDLADVANCEBLOCK(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLADVANCEBLOCK(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLADVANCEBLOCK(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLADVANCEBLOCK(records);
Log(ret);
}
### talib.CDLBELTHOLD
```talib.CDLBELTHOLD()```函数用于计算**Belt-hold (K线图:带住)**。
```talib.CDLBELTHOLD()```函数的返回值为：一维数组。
array
talib.CDLBELTHOLD(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLBELTHOLD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLBELTHOLD(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLBELTHOLD(records);
Log(ret);
}
### talib.CDLBREAKAWAY
```talib.CDLBREAKAWAY()```函数用于计算**Breakaway (K线图:分离)**。
```talib.CDLBREAKAWAY()```函数的返回值为：一维数组。
array
talib.CDLBREAKAWAY(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLBREAKAWAY(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLBREAKAWAY(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLBREAKAWAY(records);
Log(ret);
}
### talib.CDLCLOSINGMARUBOZU
```talib.CDLCLOSINGMARUBOZU()```函数用于计算**Closing Marubozu (K线图:收盘光头光脚)**。
```talib.CDLCLOSINGMARUBOZU()```函数的返回值为：一维数组。
array
talib.CDLCLOSINGMARUBOZU(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLCLOSINGMARUBOZU(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLCLOSINGMARUBOZU(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLCLOSINGMARUBOZU(records);
Log(ret);
}
### talib.CDLCONCEALBABYSWALL
```talib.CDLCONCEALBABYSWALL()```函数用于计算**Concealing Baby Swallow (K线图:藏婴吞没形态)**。
```talib.CDLCONCEALBABYSWALL()```函数的返回值为：一维数组。
array
talib.CDLCONCEALBABYSWALL(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLCONCEALBABYSWALL(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLCONCEALBABYSWALL(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLCONCEALBABYSWALL(records);
Log(ret);
}
### talib.CDLCOUNTERATTACK
```talib.CDLCOUNTERATTACK()```函数用于计算**Counterattack (K线图:反击)**。
```talib.CDLCOUNTERATTACK()```函数的返回值为：一维数组。
array
talib.CDLCOUNTERATTACK(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLCOUNTERATTACK(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLCOUNTERATTACK(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLCOUNTERATTACK(records);
Log(ret);
}
### talib.CDLDARKCLOUDCOVER
```talib.CDLDARKCLOUDCOVER()```函数用于计算**Dark Cloud Cover (K线图:乌云盖)**。
```talib.CDLDARKCLOUDCOVER()```函数的返回值为：一维数组。
array
talib.CDLDARKCLOUDCOVER(inPriceOHLC)
talib.CDLDARKCLOUDCOVER(inPriceOHLC, optInPenetration)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```optInPenetration```参数用于设置Penetration，默认值为0.5。
optInPenetration
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLDARKCLOUDCOVER(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLDARKCLOUDCOVER(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLDARKCLOUDCOVER(records);
Log(ret);
}
### talib.CDLDOJI
```talib.CDLDOJI()```函数用于计算**Doji (K线图:十字星 )**。
```talib.CDLDOJI()```函数的返回值为：一维数组。
array
talib.CDLDOJI(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLDOJI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLDOJI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLDOJI(records);
Log(ret);
}
### talib.CDLDOJISTAR
```talib.CDLDOJISTAR()```函数用于计算**Doji Star (K线图:十字星)**。
```talib.CDLDOJISTAR()```函数的返回值为：一维数组。
array
talib.CDLDOJISTAR(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLDOJISTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLDOJISTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLDOJISTAR(records);
Log(ret);
}
### talib.CDLDRAGONFLYDOJI
```talib.CDLDRAGONFLYDOJI()```函数用于计算**Dragonfly Doji (K线图:蜻蜓十字星)**。
```talib.CDLDRAGONFLYDOJI()```函数的返回值为：一维数组。
array
talib.CDLDRAGONFLYDOJI(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLDRAGONFLYDOJI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLDRAGONFLYDOJI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLDRAGONFLYDOJI(records);
Log(ret);
}
### talib.CDLENGULFING
```talib.CDLENGULFING()```函数用于计算**Engulfing Pattern (K线图:吞没)**。
```talib.CDLENGULFING()```函数的返回值为：一维数组。
array
talib.CDLENGULFING(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLENGULFING(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLENGULFING(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLENGULFING(records);
Log(ret);
}
### talib.CDLEVENINGDOJISTAR
```talib.CDLEVENINGDOJISTAR()```函数用于计算**Evening Doji Star (K线图:黄昏十字星)**。
```talib.CDLEVENINGDOJISTAR()```函数的返回值为：一维数组。
array
talib.CDLEVENINGDOJISTAR(inPriceOHLC)
talib.CDLEVENINGDOJISTAR(inPriceOHLC, optInPenetration)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```optInPenetration```参数用于设置Penetration，默认值为0.3。
optInPenetration
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLEVENINGDOJISTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLEVENINGDOJISTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLEVENINGDOJISTAR(records);
Log(ret);
}
### talib.CDLEVENINGSTAR
```talib.CDLEVENINGSTAR()```函数用于计算**Evening Star (K线图:黄昏之星)**。
```talib.CDLEVENINGSTAR()```函数的返回值为：一维数组。
array
talib.CDLEVENINGSTAR(inPriceOHLC)
talib.CDLEVENINGSTAR(inPriceOHLC, optInPenetration)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```optInPenetration```参数用于设置Penetration，默认值为0.3。
optInPenetration
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLEVENINGSTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLEVENINGSTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLEVENINGSTAR(records);
Log(ret);
}
### talib.CDLGAPSIDESIDEWHITE
```talib.CDLGAPSIDESIDEWHITE()```函数用于计算**Up/Down-gap side-by-side white lines (K线图:上/下间隙并排的白色线条)**。
```talib.CDLGAPSIDESIDEWHITE()```函数的返回值为：一维数组。
array
talib.CDLGAPSIDESIDEWHITE(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLGAPSIDESIDEWHITE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLGAPSIDESIDEWHITE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLGAPSIDESIDEWHITE(records);
Log(ret);
}
### talib.CDLGRAVESTONEDOJI
```talib.CDLGRAVESTONEDOJI()```函数用于计算**Gravestone Doji (K线图:墓碑十字线)**。
```talib.CDLGRAVESTONEDOJI()```函数的返回值为：一维数组。
array
talib.CDLGRAVESTONEDOJI(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLGRAVESTONEDOJI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLGRAVESTONEDOJI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLGRAVESTONEDOJI(records);
Log(ret);
}
### talib.CDLHAMMER
```talib.CDLHAMMER()```函数用于计算**Hammer (K线图:锤)**。
```talib.CDLHAMMER()```函数的返回值为：一维数组。
array
talib.CDLHAMMER(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHAMMER(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHAMMER(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHAMMER(records);
Log(ret);
}
### talib.CDLHANGINGMAN
```talib.CDLHANGINGMAN()```函数用于计算**Hanging Man (K线图:吊人)**。
```talib.CDLHANGINGMAN()```函数的返回值为：一维数组。
array
talib.CDLHANGINGMAN(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHANGINGMAN(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHANGINGMAN(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHANGINGMAN(records);
Log(ret);
}
### talib.CDLHARAMI
```talib.CDLHARAMI()```函数用于计算**Harami Pattern (K线图:阴阳线)**。
```talib.CDLHARAMI()```函数的返回值为：一维数组。
array
talib.CDLHARAMI(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHARAMI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHARAMI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHARAMI(records);
Log(ret);
}
### talib.CDLHARAMICROSS
```talib.CDLHARAMICROSS()```函数用于计算**Harami Cross Pattern (K线图:交叉阴阳线)**。
```talib.CDLHARAMICROSS()```函数的返回值为：一维数组。
array
talib.CDLHARAMICROSS(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHARAMICROSS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHARAMICROSS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHARAMICROSS(records);
Log(ret);
}
### talib.CDLHIGHWAVE
```talib.CDLHIGHWAVE()```函数用于计算**High-Wave Candle (K线图:长脚十字线 )**。
```talib.CDLHIGHWAVE()```函数的返回值为：一维数组。
array
talib.CDLHIGHWAVE(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHIGHWAVE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHIGHWAVE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHIGHWAVE(records);
Log(ret);
}
### talib.CDLHIKKAKE
```talib.CDLHIKKAKE()```函数用于计算**Hikkake Pattern (K线图:陷阱)**。
```talib.CDLHIKKAKE()```函数的返回值为：一维数组。
array
talib.CDLHIKKAKE(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHIKKAKE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHIKKAKE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHIKKAKE(records);
Log(ret);
}
### talib.CDLHIKKAKEMOD
```talib.CDLHIKKAKEMOD()```函数用于计算**Modified Hikkake Pattern (K线图:改良的陷阱)**。
```talib.CDLHIKKAKEMOD()```函数的返回值为：一维数组。
array
talib.CDLHIKKAKEMOD(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHIKKAKEMOD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHIKKAKEMOD(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHIKKAKEMOD(records);
Log(ret);
}
### talib.CDLHOMINGPIGEON
```talib.CDLHOMINGPIGEON()```函数用于计算**Homing Pigeon (K线图:信鸽)**。
```talib.CDLHOMINGPIGEON()```函数的返回值为：一维数组。
array
talib.CDLHOMINGPIGEON(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHOMINGPIGEON(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHOMINGPIGEON(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHOMINGPIGEON(records);
Log(ret);
}
### talib.CDLIDENTICAL3CROWS
```talib.CDLIDENTICAL3CROWS()```函数用于计算**Identical Three Crows (K线图:相同的三只乌鸦)**。
```talib.CDLIDENTICAL3CROWS()```函数的返回值为：一维数组。
array
talib.CDLIDENTICAL3CROWS(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLIDENTICAL3CROWS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLIDENTICAL3CROWS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLIDENTICAL3CROWS(records);
Log(ret);
}
### talib.CDLINNECK
```talib.CDLINNECK()```函数用于计算**In-Neck Pattern (K线图:颈纹)**。
```talib.CDLINNECK()```函数的返回值为：一维数组。
array
talib.CDLINNECK(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLINNECK(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLINNECK(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLINNECK(records);
Log(ret);
}
### talib.CDLINVERTEDHAMMER
```talib.CDLINVERTEDHAMMER()```函数用于计算**Inverted Hammer (K线图:倒锤)**。
```talib.CDLINVERTEDHAMMER()```函数的返回值为：一维数组。
array
talib.CDLINVERTEDHAMMER(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLINVERTEDHAMMER(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLINVERTEDHAMMER(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLINVERTEDHAMMER(records);
Log(ret);
}
### talib.CDLKICKING
```talib.CDLKICKING()```函数用于计算**Kicking (K线图:踢)**。
```talib.CDLKICKING()```函数的返回值为：一维数组。
array
talib.CDLKICKING(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLKICKING(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLKICKING(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLKICKING(records);
Log(ret);
}
### talib.CDLKICKINGBYLENGTH
```talib.CDLKICKINGBYLENGTH()```函数用于计算**Kicking - bull/bear determined by the longer marubozu (K线图:踢牛/踢熊)**。
```talib.CDLKICKINGBYLENGTH()```函数的返回值为：一维数组。
array
talib.CDLKICKINGBYLENGTH(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLKICKINGBYLENGTH(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLKICKINGBYLENGTH(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLKICKINGBYLENGTH(records);
Log(ret);
}
### talib.CDLLADDERBOTTOM
```talib.CDLLADDERBOTTOM()```函数用于计算**Ladder Bottom (K线图:梯底)**。
```talib.CDLLADDERBOTTOM()```函数的返回值为：一维数组。
array
talib.CDLLADDERBOTTOM(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLLADDERBOTTOM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLLADDERBOTTOM(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLLADDERBOTTOM(records);
Log(ret);
}
### talib.CDLLONGLEGGEDDOJI
```talib.CDLLONGLEGGEDDOJI()```函数用于计算**Long Legged Doji (K线图:长腿十字线)**。
```talib.CDLLONGLEGGEDDOJI()```函数的返回值为：一维数组。
array
talib.CDLLONGLEGGEDDOJI(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLLONGLEGGEDDOJI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLLONGLEGGEDDOJI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLLONGLEGGEDDOJI(records);
Log(ret);
}
### talib.CDLLONGLINE
```talib.CDLLONGLINE()```函数用于计算**Long Line Candle (K线图:长线)**。
```talib.CDLLONGLINE()```函数的返回值为：一维数组。
array
talib.CDLLONGLINE(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLLONGLINE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLLONGLINE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLLONGLINE(records);
Log(ret);
}
### talib.CDLMARUBOZU
```talib.CDLMARUBOZU()```函数用于计算**Marubozu (K线图:光头光脚)**。
```talib.CDLMARUBOZU()```函数的返回值为：一维数组。
array
talib.CDLMARUBOZU(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMARUBOZU(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMARUBOZU(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMARUBOZU(records);
Log(ret);
}
### talib.CDLMATCHINGLOW
```talib.CDLMATCHINGLOW()```函数用于计算**Matching Low (K线图:匹配低)**。
```talib.CDLMATCHINGLOW()```函数的返回值为：一维数组。
array
talib.CDLMATCHINGLOW(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMATCHINGLOW(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMATCHINGLOW(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMATCHINGLOW(records);
Log(ret);
}
### talib.CDLMATHOLD
```talib.CDLMATHOLD()```函数用于计算**Mat Hold (K线图:垫住)**。
```talib.CDLMATHOLD()```函数的返回值为：一维数组。
array
talib.CDLMATHOLD(inPriceOHLC)
talib.CDLMATHOLD(inPriceOHLC, optInPenetration)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```optInPenetration```参数为可选参数，用于指定上升/下降趋势线的宽度占比，默认值为0.5。
optInPenetration
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMATHOLD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMATHOLD(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMATHOLD(records);
Log(ret);
}
### talib.CDLMORNINGDOJISTAR
```talib.CDLMORNINGDOJISTAR()```函数用于计算**Morning Doji Star (K线图:早晨十字星)**。
```talib.CDLMORNINGDOJISTAR()```函数的返回值为：一维数组。
array
talib.CDLMORNINGDOJISTAR(inPriceOHLC)
talib.CDLMORNINGDOJISTAR(inPriceOHLC, optInPenetration)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```optInPenetration```参数用于指定验证开盘价和实体部分重合的程度，默认值为0.3。
optInPenetration
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMORNINGDOJISTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMORNINGDOJISTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMORNINGDOJISTAR(records);
Log(ret);
}
### talib.CDLMORNINGSTAR
```talib.CDLMORNINGSTAR()```函数用于计算**Morning Star (K线图:晨星)**。
```talib.CDLMORNINGSTAR()```函数的返回值为：一维数组。
array
talib.CDLMORNINGSTAR(inPriceOHLC)
talib.CDLMORNINGSTAR(inPriceOHLC, optInPenetration)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```optInPenetration```参数为趋势确认所需价格浮动百分比阈值，取值范围[0,1]，默认值为0.3。
optInPenetration
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMORNINGSTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMORNINGSTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMORNINGSTAR(records);
Log(ret);
}
### talib.CDLONNECK
```talib.CDLONNECK()```函数用于计算**On-Neck Pattern (K线图:颈型)**。
```talib.CDLONNECK()```函数的返回值为：一维数组。
array
talib.CDLONNECK(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLONNECK(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLONNECK(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLONNECK(records);
Log(ret);
}
### talib.CDLPIERCING
```talib.CDLPIERCING()```函数用于计算**Piercing Pattern (K线图:穿孔模式)**。
```talib.CDLPIERCING()```函数的返回值为：一维数组。
array
talib.CDLPIERCING(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLPIERCING(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLPIERCING(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLPIERCING(records);
Log(ret);
}
### talib.CDLRICKSHAWMAN
```talib.CDLRICKSHAWMAN()```函数用于计算**Rickshaw Man (K线图:车夫)**。
```talib.CDLRICKSHAWMAN()```函数的返回值为：一维数组。
array
talib.CDLRICKSHAWMAN(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLRICKSHAWMAN(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLRICKSHAWMAN(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLRICKSHAWMAN(records);
Log(ret);
}
### talib.CDLRISEFALL3METHODS
```talib.CDLRISEFALL3METHODS()```函数用于计算**Rising/Falling Three Methods (K线图:上升/下降三法)**。
```talib.CDLRISEFALL3METHODS()```函数的返回值为：一维数组。
array
talib.CDLRISEFALL3METHODS(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLRISEFALL3METHODS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLRISEFALL3METHODS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLRISEFALL3METHODS(records);
Log(ret);
}
### talib.CDLSEPARATINGLINES
```talib.CDLSEPARATINGLINES()```函数用于计算**Separating Lines (K线图:分割线)**。
```talib.CDLSEPARATINGLINES()```函数的返回值为：一维数组。
array
talib.CDLSEPARATINGLINES(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSEPARATINGLINES(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSEPARATINGLINES(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSEPARATINGLINES(records);
Log(ret);
}
### talib.CDLSHOOTINGSTAR
```talib.CDLSHOOTINGSTAR()```函数用于计算**Shooting Star (K线图:流星)**。
```talib.CDLSHOOTINGSTAR()```函数的返回值为：一维数组。
array
talib.CDLSHOOTINGSTAR(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSHOOTINGSTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSHOOTINGSTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSHOOTINGSTAR(records);
Log(ret);
}
### talib.CDLSHORTLINE
```talib.CDLSHORTLINE()```函数用于计算**Short Line Candle (K线图:短线)**。
```talib.CDLSHORTLINE()```函数的返回值为：一维数组。
array
talib.CDLSHORTLINE(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSHORTLINE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSHORTLINE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSHORTLINE(records);
Log(ret);
}
### talib.CDLSPINNINGTOP
```talib.CDLSPINNINGTOP()```函数用于计算**Spinning Top (K线图:陀螺)**。
```talib.CDLSPINNINGTOP()```函数的返回值为：一维数组。
array
talib.CDLSPINNINGTOP(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSPINNINGTOP(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSPINNINGTOP(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSPINNINGTOP(records);
Log(ret);
}
### talib.CDLSTALLEDPATTERN
```talib.CDLSTALLEDPATTERN()```函数用于计算**Stalled Pattern (K线图:停滞模式)**。
```talib.CDLSTALLEDPATTERN()```函数的返回值为：一维数组。
array
talib.CDLSTALLEDPATTERN(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSTALLEDPATTERN(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSTALLEDPATTERN(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSTALLEDPATTERN(records);
Log(ret);
}
### talib.CDLSTICKSANDWICH
```talib.CDLSTICKSANDWICH()```函数用于计算**Stick Sandwich (K线图:棍子三明治)**。
```talib.CDLSTICKSANDWICH()```函数的返回值为：一维数组。
array
talib.CDLSTICKSANDWICH(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSTICKSANDWICH(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSTICKSANDWICH(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSTICKSANDWICH(records);
Log(ret);
}
### talib.CDLTAKURI
```talib.CDLTAKURI()```函数用于计算**Takuri (Dragonfly Doji with very long lower shadow) (K线图:托里)**。
```talib.CDLTAKURI()```函数的返回值为：一维数组。
array
talib.CDLTAKURI(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLTAKURI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLTAKURI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLTAKURI(records);
Log(ret);
}
### talib.CDLTASUKIGAP
```talib.CDLTASUKIGAP()```函数用于计算**Tasuki Gap (K线图:翼隙)**。
```talib.CDLTASUKIGAP()```函数的返回值为：一维数组。
array
talib.CDLTASUKIGAP(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLTASUKIGAP(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLTASUKIGAP(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLTASUKIGAP(records);
Log(ret);
}
### talib.CDLTHRUSTING
```talib.CDLTHRUSTING()```函数用于计算**Thrusting Pattern (K线图:推模式)**。
```talib.CDLTHRUSTING()```函数的返回值为：一维数组。
array
talib.CDLTHRUSTING(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLTHRUSTING(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLTHRUSTING(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLTHRUSTING(records);
Log(ret);
}
### talib.CDLTRISTAR
```talib.CDLTRISTAR()```函数用于计算**Tristar Pattern (K线图:三星模式)**。
```talib.CDLTRISTAR()```函数的返回值为：一维数组。
array
talib.CDLTRISTAR(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLTRISTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLTRISTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLTRISTAR(records);
Log(ret);
}
### talib.CDLUNIQUE3RIVER
```talib.CDLUNIQUE3RIVER()```函数用于计算**Unique 3 River (K线图:独特的3河)**。
```talib.CDLUNIQUE3RIVER()```函数的返回值为：一维数组。
array
talib.CDLUNIQUE3RIVER(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLUNIQUE3RIVER(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLUNIQUE3RIVER(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLUNIQUE3RIVER(records);
Log(ret);
}
### talib.CDLUPSIDEGAP2CROWS
```talib.CDLUPSIDEGAP2CROWS()```函数用于计算**Upside Gap Two Crows (K线图:双飞乌鸦)**。
```talib.CDLUPSIDEGAP2CROWS()```函数的返回值为：一维数组。
array
talib.CDLUPSIDEGAP2CROWS(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLUPSIDEGAP2CROWS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLUPSIDEGAP2CROWS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLUPSIDEGAP2CROWS(records);
Log(ret);
}
### talib.CDLXSIDEGAP3METHODS
```talib.CDLXSIDEGAP3METHODS()```函数用于计算**Upside/Downside Gap Three Methods (K线图:上行/下行缺口三方法)**。
```talib.CDLXSIDEGAP3METHODS()```函数的返回值为：一维数组。
array
talib.CDLXSIDEGAP3METHODS(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLXSIDEGAP3METHODS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLXSIDEGAP3METHODS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLXSIDEGAP3METHODS(records);
Log(ret);
}
### talib.AD
```talib.AD()```函数用于计算**Chaikin A/D Line (线随机指标)**。
```talib.AD()```函数的返回值为：一维数组。
array
talib.AD(inPriceHLCV)
```inPriceHLCV```参数用于指定K线数据。
inPriceHLCV
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.AD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.AD(records.High, records.Low, records.Close, records.Volume)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.AD(records);
Log(ret);
}
### talib.ADOSC
```talib.ADOSC()```函数用于计算**Chaikin A/D Oscillator (佳庆指标)**。
```talib.ADOSC()```函数的返回值为：一维数组。
array
talib.ADOSC(inPriceHLCV)
talib.ADOSC(inPriceHLCV, optInFastPeriod, optInSlowPeriod)
```inPriceHLCV```参数用于指定K线数据。
inPriceHLCV
true
{@struct/Record Record}结构数组
```optInFastPeriod```参数用于设置快周期。
optInFastPeriod
false
number
```optInSlowPeriod```参数用于设置慢周期。
optInSlowPeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.ADOSC(records, 3, 10)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ADOSC(records.High, records.Low, records.Close, records.Volume, 3, 10)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ADOSC(records, 3, 10);
Log(ret);
}
### talib.OBV
```talib.OBV()```函数用于计算**On Balance Volume (能量潮)**。
```talib.OBV()```函数的返回值为：一维数组。
array
talib.OBV(inReal)
talib.OBV(inReal, inPriceV)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```inPriceV```参数用于指定K线数据。
inPriceV
false
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.OBV(records, records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.OBV(records.Close, records.Volume)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.OBV(records);
Log(ret);
}
### talib.ACOS
```talib.ACOS()```函数用于计算**Vector Trigonometric ACos (反余弦函数)**。
```talib.ACOS()```函数的返回值为：一维数组。
array
talib.ACOS(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var data = [-1, 0, 1]
var ret = talib.ACOS(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.ACOS(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.ACOS(data);
Log(ret);
}
### talib.ASIN
```talib.ASIN()```函数用于计算**Vector Trigonometric ASin (反正弦函数)**。
```talib.ASIN()```函数的返回值为：一维数组。
array
talib.ASIN(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var data = [-1, 0, 1]
var ret = talib.ASIN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.ASIN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.ASIN(data);
Log(ret);
}
### talib.ATAN
```talib.ATAN()```函数用于计算**Vector Trigonometric ATan (反正切函数)**。
```talib.ATAN()```函数的返回值为：一维数组。
array
talib.ATAN(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var data = [-3.14/2, 0, 3.14/2]
var ret = talib.ATAN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-3.14/2, 0, 3.14/2]
ret = talib.ATAN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-3.14/2, 0, 3.14/2};
auto ret = talib.ATAN(data);
Log(ret);
}
### talib.CEIL
```talib.CEIL()```函数用于计算**Vector Ceil (取整函数)**。
```talib.CEIL()```函数的返回值为：一维数组。
array
talib.CEIL(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CEIL(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CEIL(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CEIL(records);
Log(ret);
}
### talib.COS
```talib.COS()```函数用于计算**Vector Trigonometric Cos (余弦函数)**。
```talib.COS()```函数的返回值为：一维数组。
array
talib.COS(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var data = [-3.14, 0, 3.14]
var ret = talib.COS(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-3.14, 0, 3.14]
ret = talib.COS(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-3.14, 0, 3.14};
auto ret = talib.COS(data);
Log(ret);
}
### talib.COSH
```talib.COSH()```函数用于计算**Vector Trigonometric Cosh (双曲余弦值)**。
```talib.COSH()```函数的返回值为：一维数组。
array
talib.COSH(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var data = [-1, 0, 1]
var ret = talib.COSH(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.COSH(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.COSH(data);
Log(ret);
}
### talib.EXP
```talib.EXP()```函数用于计算**Vector Arithmetic Exp (指数函数)**。
```talib.EXP()```函数的返回值为：一维数组。
array
talib.EXP(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var data = [0, 1, 2]
var ret = talib.EXP(data) // e^0, e^1, e^2
Log(ret)
}
import talib
import numpy as np
def main():
data = [0, 1.0, 2.0]
ret = talib.EXP(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {0, 1.0, 2.0};
auto ret = talib.EXP(data);
Log(ret);
}
### talib.FLOOR
```talib.FLOOR()```函数用于计算**Vector Floor (向下取整)**。
```talib.FLOOR()```函数的返回值为：一维数组。
array
talib.FLOOR(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.FLOOR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.FLOOR(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.FLOOR(records);
Log(ret);
}
### talib.LN
```talib.LN()```函数用于计算**Vector Log Natural (自然对数)**。
```talib.LN()```函数的返回值为：一维数组。
array
talib.LN(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var data = [1, 2, 3]
var ret = talib.LN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [1.0, 2.0, 3.0]
ret = talib.LN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {1, 2, 3};
auto ret = talib.LN(data);
Log(ret);
}
### talib.LOG10
```talib.LOG10()```函数用于计算**Vector Log10 (对数函数)**。
```talib.LOG10()```函数的返回值为：一维数组。
array
talib.LOG10(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var data = [10, 100, 1000]
var ret = talib.LOG10(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [10.0, 100.0, 1000.0]
ret = talib.LOG10(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {10, 100, 1000};
auto ret = talib.LOG10(data);
Log(ret);
}
### talib.SIN
```talib.SIN()```函数用于计算**Vector Trigonometric Sin (正弦值)**。
```talib.SIN()```函数的返回值为：一维数组。
array
talib.SIN(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var data = [-3.14/2, 0, 3.14/2]
var ret = talib.SIN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-3.14/2, 0, 3.14/2]
ret = talib.SIN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-3.14/2, 0, 3.14/2};
auto ret = talib.SIN(data);
Log(ret);
}
### talib.SINH
```talib.SINH()```函数用于计算**Vector Trigonometric Sinh (双曲正弦函数)**。
```talib.SINH()```函数的返回值为：一维数组。
array
talib.SINH(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var data = [-1, 0, 1]
var ret = talib.SINH(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.SINH(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.SINH(data);
Log(ret);
}
### talib.SQRT
```talib.SQRT()```函数用于计算**Vector Square Root (平方根)**。
```talib.SQRT()```函数的返回值为：一维数组。
array
talib.SQRT(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var data = [4, 64, 100]
var ret = talib.SQRT(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [4.0, 64.0, 100.0]
ret = talib.SQRT(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {4, 64, 100};
auto ret = talib.SQRT(data);
Log(ret);
}
### talib.TAN
```talib.TAN()```函数用于计算**Vector Trigonometric Tan (正切)**。
```talib.TAN()```函数的返回值为：一维数组。
array
talib.TAN(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var data = [-1, 0, 1]
var ret = talib.TAN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.TAN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.TAN(data);
Log(ret);
}
### talib.TANH
```talib.TANH()```函数用于计算**Vector Trigonometric Tanh (双曲正切函数)**。
```talib.TANH()```函数的返回值为：一维数组。
array
talib.TANH(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var data = [-1, 0, 1]
var ret = talib.TANH(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.TANH(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.TANH(data);
Log(ret);
}
### talib.MAX
```talib.MAX()```函数用于计算**Highest value over a specified period (最大值)**。
```talib.MAX()```函数的返回值为：一维数组。
array
talib.MAX(inReal)
talib.MAX(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MAX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MAX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MAX(records);
Log(ret);
}
### talib.MAXINDEX
```talib.MAXINDEX()```函数用于计算**Index of highest value over a specified period (最大值索引)**。
```talib.MAXINDEX()```函数的返回值为：一维数组。
array
talib.MAXINDEX(inReal)
talib.MAXINDEX(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MAXINDEX(records, 5)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MAXINDEX(records.Close, 5)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MAXINDEX(records, 5);
Log(ret);
}
### talib.MIN
```talib.MIN()```函数用于计算**Lowest value over a specified period (最小值)**。
```talib.MIN()```函数的返回值为：一维数组。
array
talib.MIN(inReal)
talib.MIN(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MIN(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MIN(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MIN(records);
Log(ret);
}
### talib.MININDEX
```talib.MININDEX()```函数用于计算**Index of lowest value over a specified period (最小值索引)**。
```talib.MININDEX()```函数的返回值为：一维数组。
array
talib.MININDEX(inReal)
talib.MININDEX(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MININDEX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MININDEX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MININDEX(records);
Log(ret);
}
### talib.MINMAX
```talib.MINMAX()```函数用于计算**Lowest and highest values over a specified period (最小最大值)**。
```talib.MINMAX()```函数的返回值为：二维数组。该二维数组的第一个元素为最小值数组，第二个元素为最大值数组。
array
talib.MINMAX(inReal)
talib.MINMAX(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MINMAX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MINMAX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MINMAX(records);
Log(ret);
}
### talib.MINMAXINDEX
```talib.MINMAXINDEX()```函数用于计算**Indexes of lowest and highest values over a specified period (最小最大值索引)**。
```talib.MINMAXINDEX()```函数的返回值为：二维数组。该二维数组的第一个元素为最小值索引数组，第二个元素为最大值索引数组。
array
talib.MINMAXINDEX(inReal)
talib.MINMAXINDEX(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MINMAXINDEX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MINMAXINDEX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MINMAXINDEX(records);
Log(ret);
}
### talib.SUM
```talib.SUM()```函数用于计算**Summation (求和)**。
```talib.SUM()```函数的返回值为：一维数组。
array
talib.SUM(inReal)
talib.SUM(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.SUM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.SUM(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.SUM(records);
Log(ret);
}
### talib.HT_DCPERIOD
```talib.HT_DCPERIOD()```函数用于计算**Hilbert Transform - Dominant Cycle Period (希尔伯特变换, 主周期)**。
```talib.HT_DCPERIOD()```函数的返回值为：一维数组。
array
talib.HT_DCPERIOD(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_DCPERIOD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_DCPERIOD(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_DCPERIOD(records);
Log(ret);
}
### talib.HT_DCPHASE
```talib.HT_DCPHASE()```函数用于计算**Hilbert Transform - Dominant Cycle Phase (希尔伯特变换,主阶段)**。
```talib.HT_DCPHASE()```函数的返回值为：一维数组。
array
talib.HT_DCPHASE(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_DCPHASE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_DCPHASE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_DCPHASE(records);
Log(ret);
}
### talib.HT_PHASOR
```talib.HT_PHASOR()```函数用于计算**Hilbert Transform - Phasor Components (希尔伯特变换,相成分)**。
```talib.HT_PHASOR()```函数的返回值为：二维数组。
array
talib.HT_PHASOR(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_PHASOR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_PHASOR(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_PHASOR(records);
Log(ret);
}
### talib.HT_SINE
```talib.HT_SINE()```函数用于计算**Hilbert Transform - SineWave (希尔伯特变换,正弦波)**。
```talib.HT_SINE()```函数的返回值为：二维数组。
array
talib.HT_SINE(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_SINE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_SINE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_SINE(records);
Log(ret);
}
### talib.HT_TRENDMODE
```talib.HT_TRENDMODE()```函数用于计算**Hilbert Transform - Trend vs Cycle Mode (希尔伯特变换-趋势与周期模式)**。
```talib.HT_TRENDMODE()```函数的返回值为：一维数组。
array
talib.HT_TRENDMODE(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_TRENDMODE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_TRENDMODE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_TRENDMODE(records);
Log(ret);
}
### talib.ATR
```talib.ATR()```函数用于计算**Average True Range (平均真实波幅)**。
```talib.ATR()```函数的返回值为：一维数组。
array
talib.ATR(inPriceHLC)
talib.ATR(inPriceHLC, optInTimePeriod)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.ATR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ATR(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ATR(records);
Log(ret);
}
### talib.NATR
```talib.NATR()```函数用于计算**Normalized Average True Range (归一化平均值范围)**。
```talib.NATR()```函数的返回值为：一维数组。
array
talib.NATR(inPriceHLC)
talib.NATR(inPriceHLC, optInTimePeriod)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.NATR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.NATR(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.NATR(records);
Log(ret);
}
### talib.TRANGE
```talib.TRANGE()```函数用于计算**True Range (真实范围)**。
```talib.TRANGE()```函数的返回值为：一维数组。
array
talib.TRANGE(inPriceHLC)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.TRANGE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TRANGE(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TRANGE(records);
Log(ret);
}
### talib.BBANDS
```talib.BBANDS()```函数用于计算**Bollinger Bands (布林带)**。
```talib.BBANDS()```函数的返回值为：二维数组。该数组包含三个元素分别是：上线数组、中线数组、下线数组。
array
talib.BBANDS(inReal)
talib.BBANDS(inReal, optInTimePeriod)
talib.BBANDS(inReal, optInTimePeriod, optInNbDevUp)
talib.BBANDS(inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn)
talib.BBANDS(inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn, optInMAType)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为5。
optInTimePeriod
false
number
```optInNbDevUp```参数用于设置上线乘数，默认值为2。
optInNbDevUp
false
number
```optInNbDevDn```参数用于设置下线乘数，默认值为2。
optInNbDevDn
false
number
```optInMAType```参数用于设置均线类型，默认值为0。
optInMAType
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.BBANDS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.BBANDS(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.BBANDS(records);
Log(ret);
}
### talib.DEMA
```talib.DEMA()```函数用于计算**Double Exponential Moving Average (双指数移动平均线)**。
```talib.DEMA()```函数的返回值为：一维数组。
array
talib.DEMA(inReal)
talib.DEMA(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.DEMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.DEMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.DEMA(records);
Log(ret);
}
### talib.EMA
```talib.EMA()```函数用于计算**Exponential Moving Average (指数移动平均线)**。
```talib.EMA()```函数的返回值为：一维数组。
array
talib.EMA(inReal)
talib.EMA(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.EMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.EMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.EMA(records);
Log(ret);
}
### talib.HT_TRENDLINE
```talib.HT_TRENDLINE()```函数用于计算**Hilbert Transform - Instantaneous Trendline (希尔伯特变换,瞬时趋势)**。
```talib.HT_TRENDLINE()```函数的返回值为：一维数组。
array
talib.HT_TRENDLINE(inReal)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_TRENDLINE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_TRENDLINE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_TRENDLINE(records);
Log(ret);
}
### talib.KAMA
```talib.KAMA()```函数用于计算**Kaufman Adaptive Moving Average (适应性移动平均线)**。
```talib.KAMA()```函数的返回值为：一维数组。
array
talib.KAMA(inReal)
talib.KAMA(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.KAMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.KAMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.KAMA(records);
Log(ret);
}
### talib.MA
```talib.MA()```函数用于计算**Moving average (移动平均线)**。
```talib.MA()```函数的返回值为：一维数组。
array
talib.MA(inReal)
talib.MA(inReal, optInTimePeriod)
talib.MA(inReal, optInTimePeriod, optInMAType)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```optInMAType```参数用于设置均线类型，默认值为0。
optInMAType
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MA(records);
Log(ret);
}
### talib.MAMA
```talib.MAMA()```函数用于计算**MESA Adaptive Moving Average (MESA 移动平均线)**。
```talib.MAMA()```函数的返回值为：二维数组。
array
talib.MAMA(inReal)
talib.MAMA(inReal, optInFastLimit)
talib.MAMA(inReal, optInFastLimit, optInSlowLimit)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInFastLimit```参数用于设置Fast Limit，默认值为0.5。
optInFastLimit
false
number
```optInSlowLimit```参数用于设置Slow Limit，默认值为0.05。
optInSlowLimit
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MAMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MAMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MAMA(records);
Log(ret);
}
### talib.MIDPOINT
```talib.MIDPOINT()```函数用于计算**MidPoint over period (中点)**。
```talib.MIDPOINT()```函数的返回值为：一维数组。
array
talib.MIDPOINT(inReal)
talib.MIDPOINT(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MIDPOINT(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MIDPOINT(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MIDPOINT(records);
Log(ret);
}
### talib.MIDPRICE
```talib.MIDPRICE()```函数用于计算**Midpoint Price over period (中点价格)**。
```talib.MIDPRICE()```函数的返回值为：一维数组。
array
talib.MIDPRICE(inPriceHL)
talib.MIDPRICE(inPriceHL, optInTimePeriod)
```inPriceHL```参数用于指定K线数据。
inPriceHL
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MIDPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MIDPRICE(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MIDPRICE(records);
Log(ret);
}
### talib.SAR
```talib.SAR()```函数用于计算**Parabolic SAR (抛物线转向)**。
```talib.SAR()```函数的返回值为：一维数组。
array
talib.SAR(inPriceHL)
talib.SAR(inPriceHL, optInAcceleration)
talib.SAR(inPriceHL, optInAcceleration, optInMaximum)
```inPriceHL```参数用于指定K线数据。
inPriceHL
true
{@struct/Record Record}结构数组
```optInAcceleration```参数用于设置Acceleration Factor，默认值为0.02。
optInAcceleration
false
number
```optInMaximum```参数用于设置AF Maximum，默认值为0.2。
optInMaximum
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.SAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.SAR(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.SAR(records);
Log(ret);
}
### talib.SAREXT
```talib.SAREXT()```函数用于计算**Parabolic SAR - Extended (增强型抛物线转向)**。
```talib.SAREXT()```函数的返回值为：一维数组。
array
talib.SAREXT(inPriceHL)
talib.SAREXT(inPriceHL, optInStartValue)
talib.SAREXT(inPriceHL, optInStartValue, optInOffsetOnReverse)
talib.SAREXT(inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong)
talib.SAREXT(inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong)
talib.SAREXT(inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong)
talib.SAREXT(inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort)
talib.SAREXT(inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort, optInAccelerationShort)
talib.SAREXT(inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort, optInAccelerationShort, optInAccelerationMaxShort)
```inPriceHL```参数用于指定K线数据。
inPriceHL
true
{@struct/Record Record}结构数组
```optInStartValue```参数用于设置Start Value，默认值为0。
optInStartValue
false
number
```optInOffsetOnReverse```参数用于设置Offset on Reverse，默认值为0。
optInOffsetOnReverse
false
number
```optInAccelerationInitLong```参数用于设置AF Init Long，默认值为0.02。
optInAccelerationInitLong
false
number
```optInAccelerationLong```参数用于设置AF Long，默认值为0.02。
optInAccelerationLong
false
number
```optInAccelerationMaxLong```参数用于设置AF Max Long，默认值为0.2。
optInAccelerationMaxLong
false
number
```optInAccelerationInitShort```参数用于设置AF Init Short，默认值为0.02。
optInAccelerationInitShort
false
number
```optInAccelerationShort```参数用于设置AF Short，默认值为0.02。
optInAccelerationShort
false
number
```optInAccelerationMaxShort```参数用于设置AF Max Short，默认值为0.2。
optInAccelerationMaxShort
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.SAREXT(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.SAREXT(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.SAREXT(records);
Log(ret);
}
### talib.SMA
```talib.SMA()```函数用于计算**Simple Moving Average (简单移动平均)**。
```talib.SMA()```函数的返回值为：一维数组。
array
talib.SMA(inReal)
talib.SMA(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.SMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.SMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.SMA(records);
Log(ret);
}
### talib.T3
```talib.T3()```函数用于计算**Triple Exponential Moving Average (T3) (三指数移动平均)**。
```talib.T3()```函数的返回值为：一维数组。
array
talib.T3(inReal)
talib.T3(inReal, optInTimePeriod)
talib.T3(inReal, optInTimePeriod, optInVFactor)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为5。
optInTimePeriod
false
number
```optInVFactor```参数用于设置Volume Factor，默认值为0.7。
optInVFactor
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.T3(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.T3(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.T3(records);
Log(ret);
}
### talib.TEMA
```talib.TEMA()```函数用于计算**Triple Exponential Moving Average (三指数移动平均)**。
```talib.TEMA()```函数的返回值为：一维数组。
array
talib.TEMA(inReal)
talib.TEMA(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.TEMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TEMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TEMA(records);
Log(ret);
}
### talib.TRIMA
```talib.TRIMA()```函数用于计算**Triangular Moving Average (三指数移动平均)**。
```talib.TRIMA()```函数的返回值为：一维数组。
array
talib.TRIMA(inReal)
talib.TRIMA(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.TRIMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TRIMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TRIMA(records);
Log(ret);
}
### talib.WMA
```talib.WMA()```函数用于计算**Weighted Moving Average (加权移动平均)**。
```talib.WMA()```函数的返回值为：一维数组。
array
talib.WMA(inReal)
talib.WMA(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.WMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.WMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.WMA(records);
Log(ret);
}
### talib.LINEARREG
```talib.LINEARREG()```函数用于计算**Linear Regression (线性回归)**。
```talib.LINEARREG()```函数的返回值为：一维数组。
array
talib.LINEARREG(inReal)
talib.LINEARREG(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.LINEARREG(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.LINEARREG(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.LINEARREG(records);
Log(ret);
}
### talib.LINEARREG_ANGLE
```talib.LINEARREG_ANGLE()```函数用于计算**Linear Regression Angle (线性回归的角度)**。
```talib.LINEARREG_ANGLE()```函数的返回值为：一维数组。
array
talib.LINEARREG_ANGLE(inReal)
talib.LINEARREG_ANGLE(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.LINEARREG_ANGLE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.LINEARREG_ANGLE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.LINEARREG_ANGLE(records);
Log(ret);
}
### talib.LINEARREG_INTERCEPT
```talib.LINEARREG_INTERCEPT()```函数用于计算**Linear Regression Intercept (线性回归截距)**。
```talib.LINEARREG_INTERCEPT()```函数的返回值为：一维数组。
array
talib.LINEARREG_INTERCEPT(inReal)
talib.LINEARREG_INTERCEPT(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.LINEARREG_INTERCEPT(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.LINEARREG_INTERCEPT(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.LINEARREG_INTERCEPT(records);
Log(ret);
}
### talib.LINEARREG_SLOPE
```talib.LINEARREG_SLOPE()```函数用于计算**Linear Regression Slope (线性回归斜率)**。
```talib.LINEARREG_SLOPE()```函数的返回值为：一维数组。
array
talib.LINEARREG_SLOPE(inReal)
talib.LINEARREG_SLOPE(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.LINEARREG_SLOPE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.LINEARREG_SLOPE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.LINEARREG_SLOPE(records);
Log(ret);
}
### talib.STDDEV
```talib.STDDEV()```函数用于计算**Standard Deviation (标准偏差)**。
```talib.STDDEV()```函数的返回值为：一维数组。
array
talib.STDDEV(inReal)
talib.STDDEV(inReal, optInTimePeriod)
talib.STDDEV(inReal, optInTimePeriod, optInNbDev)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为5。
optInTimePeriod
false
number
```optInNbDev```参数用于设置Deviations，默认值为1。
optInNbDev
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.STDDEV(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.STDDEV(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.STDDEV(records);
Log(ret);
}
### talib.TSF
```talib.TSF()```函数用于计算**Time Series Forecast (时间序列预测)**。
```talib.TSF()```函数的返回值为：一维数组。
array
talib.TSF(inReal)
talib.TSF(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.TSF(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TSF(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TSF(records);
Log(ret);
}
### talib.VAR
```talib.VAR()```函数用于计算**Variance (方差)**。
```talib.VAR()```函数的返回值为：一维数组。
array
talib.VAR(inReal)
talib.VAR(inReal, optInTimePeriod)
talib.VAR(inReal, optInTimePeriod, optInNbDev)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为5。
optInTimePeriod
false
number
```optInNbDev```参数用于设置Deviations，默认值为1。
optInNbDev
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.VAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.VAR(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.VAR(records);
Log(ret);
}
### talib.ADX
```talib.ADX()```函数用于计算**Average Directional Movement Index (平均趋向指数)**。
```talib.ADX()```函数的返回值为：一维数组。
array
talib.ADX(inPriceHLC)
talib.ADX(inPriceHLC, optInTimePeriod)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.ADX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ADX(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ADX(records);
Log(ret);
}
### talib.ADXR
```talib.ADXR()```函数用于计算**Average Directional Movement Index Rating (评估指数)**。
```talib.ADXR()```函数的返回值为：一维数组。
array
talib.ADXR(inPriceHLC)
talib.ADXR(inPriceHLC, optInTimePeriod)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.ADXR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ADXR(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ADXR(records);
Log(ret);
}
### talib.APO
```talib.APO()```函数用于计算**Absolute Price Oscillator (绝对价格振荡指数)**。
```talib.APO()```函数的返回值为：一维数组。
array
talib.APO(inReal)
talib.APO(inReal, optInFastPeriod)
talib.APO(inReal, optInFastPeriod, optInSlowPeriod)
talib.APO(inReal, optInFastPeriod, optInSlowPeriod, optInMAType)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInFastPeriod```参数用于设置快周期，默认值为12。
optInFastPeriod
false
number
```optInSlowPeriod```参数用于设置慢周期，默认值为26。
optInSlowPeriod
false
number
```optInMAType```参数用于设置均线类型，默认值为0。
optInMAType
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.APO(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.APO(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.APO(records);
Log(ret);
}
### talib.AROON
```talib.AROON()```函数用于计算**Aroon (阿隆指标)**。
```talib.AROON()```函数的返回值为：二维数组。
array
talib.AROON(inPriceHL)
talib.AROON(inPriceHL, optInTimePeriod)
```inPriceHL```参数用于指定K线数据。
inPriceHL
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.AROON(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.AROON(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.AROON(records);
Log(ret);
}
### talib.AROONOSC
```talib.AROONOSC()```函数用于计算**Aroon Oscillator (阿隆震荡线)**。
```talib.AROONOSC()```函数的返回值为：一维数组。
array
talib.AROONOSC(inPriceHL)
talib.AROONOSC(inPriceHL, optInTimePeriod)
```inPriceHL```参数用于指定K线数据。
inPriceHL
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.AROONOSC(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.AROONOSC(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.AROONOSC(records);
Log(ret);
}
### talib.BOP
```talib.BOP()```函数用于计算**Balance Of Power (均势指标)**。
```talib.BOP()```函数的返回值为：一维数组。
array
talib.BOP(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.BOP(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.BOP(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.BOP(records);
Log(ret);
}
### talib.CCI
```talib.CCI()```函数用于计算**Commodity Channel Index (顺势指标)**。
```talib.CCI()```函数的返回值为：一维数组。
array
talib.CCI(inPriceHLC)
talib.CCI(inPriceHLC, optInTimePeriod)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CCI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CCI(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CCI(records);
Log(ret);
}
### talib.CMO
```talib.CMO()```函数用于计算**Chande Momentum Oscillator (钱德动量摆动指标)**。
```talib.CMO()```函数的返回值为：一维数组。
array
talib.CMO(inReal)
talib.CMO(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.CMO(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CMO(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CMO(records);
Log(ret);
}
### talib.DX
```talib.DX()```函数用于计算**Directional Movement Index (动向指数)**。
```talib.DX()```函数的返回值为：一维数组。
array
talib.DX(inPriceHLC)
talib.DX(inPriceHLC, optInTimePeriod)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.DX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.DX(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.DX(records);
Log(ret);
}
### talib.MACD
```talib.MACD()```函数用于计算**Moving Average Convergence/Divergence (指数平滑移动平均线)**。
```talib.MACD()```函数的返回值为：二维数组。
array
talib.MACD(inReal)
talib.MACD(inReal, optInFastPeriod)
talib.MACD(inReal, optInFastPeriod, optInSlowPeriod)
talib.MACD(inReal, optInFastPeriod, optInSlowPeriod, optInSignalPeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInFastPeriod```参数用于设置快周期，默认值为12。
optInFastPeriod
false
number
```optInSlowPeriod```参数用于设置慢周期，默认值为26。
optInSlowPeriod
false
number
```optInSignalPeriod```参数用于设置信号周期，默认值为9。
optInSignalPeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MACD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MACD(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MACD(records);
Log(ret);
}
### talib.MACDEXT
```talib.MACDEXT()```函数用于计算**MACD with controllable MA type (MA型可控 MACD)**。
```talib.MACDEXT()```函数的返回值为：二维数组。
array
talib.MACDEXT(inReal)
talib.MACDEXT(inReal, optInFastPeriod)
talib.MACDEXT(inReal, optInFastPeriod, optInFastMAType)
talib.MACDEXT(inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod)
talib.MACDEXT(inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType)
talib.MACDEXT(inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType, optInSignalPeriod)
talib.MACDEXT(inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType, optInSignalPeriod, optInSignalMAType)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInFastPeriod```参数用于设置快周期，默认值为12。
optInFastPeriod
false
number
```optInFastMAType```参数用于设置快均线类型，默认值为0。
optInFastMAType
false
number
```optInSlowPeriod```参数用于设置慢周期，默认值为26。
optInSlowPeriod
false
number
```optInSlowMAType```参数用于设置慢均线类型，默认值为0。
optInSlowMAType
false
number
```optInSignalPeriod```参数用于设置信号周期，默认值为9。
optInSignalPeriod
false
number
```optInSignalMAType```参数用于设置信号均线类型，默认值为0。
optInSignalMAType
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MACDEXT(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MACDEXT(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MACDEXT(records);
Log(ret);
}
### talib.MACDFIX
```talib.MACDFIX()```函数用于计算**Moving Average Convergence/Divergence Fix 12/26 (移动平均收敛/发散修复12/26)**。
```talib.MACDFIX()```函数的返回值为：二维数组。
array
talib.MACDFIX(inReal)
talib.MACDFIX(inReal, optInSignalPeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInSignalPeriod```参数用于设置信号周期，默认值为9。
optInSignalPeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MACDFIX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MACDFIX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MACDFIX(records);
Log(ret);
}
### talib.MFI
```talib.MFI()```函数用于计算**Money Flow Index (货币流量指数)**。
```talib.MFI()```函数的返回值为：一维数组。
array
talib.MFI(inPriceHLCV)
talib.MFI(inPriceHLCV, optInTimePeriod)
```inPriceHLCV```参数用于指定K线数据。
inPriceHLCV
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MFI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MFI(records.High, records.Low, records.Close, records.Volume)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MFI(records);
Log(ret);
}
### talib.MINUS_DI
```talib.MINUS_DI()```函数用于计算**Minus Directional Indicator (负向指标)**。
```talib.MINUS_DI()```函数的返回值为：一维数组。
array
talib.MINUS_DI(inPriceHLC)
talib.MINUS_DI(inPriceHLC, optInTimePeriod)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MINUS_DI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MINUS_DI(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MINUS_DI(records);
Log(ret);
}
### talib.MINUS_DM
```talib.MINUS_DM()```函数用于计算**Minus Directional Movement (负向运动)**。
```talib.MINUS_DM()```函数的返回值为：一维数组。
array
talib.MINUS_DM(inPriceHL)
talib.MINUS_DM(inPriceHL, optInTimePeriod)
```inPriceHL```参数用于指定K线数据。
inPriceHL
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MINUS_DM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MINUS_DM(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MINUS_DM(records);
Log(ret);
}
### talib.MOM
```talib.MOM()```函数用于计算**Momentum (动量)**。
```talib.MOM()```函数的返回值为：一维数组。
array
talib.MOM(inReal)
talib.MOM(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为10。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MOM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MOM(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MOM(records);
Log(ret);
}
### talib.PLUS_DI
```talib.PLUS_DI()```函数用于计算**Plus Directional Indicator (更向指示器)**。
```talib.PLUS_DI()```函数的返回值为：一维数组。
array
talib.PLUS_DI(inPriceHLC)
talib.PLUS_DI(inPriceHLC, optInTimePeriod)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.PLUS_DI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.PLUS_DI(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.PLUS_DI(records);
Log(ret);
}
### talib.PLUS_DM
```talib.PLUS_DM()```函数用于计算**Plus Directional Movement (定向运动)**。
```talib.PLUS_DM()```函数的返回值为：一维数组。
array
talib.PLUS_DM(inPriceHL)
talib.PLUS_DM(inPriceHL, optInTimePeriod)
```inPriceHL```参数用于指定K线数据。
inPriceHL
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.PLUS_DM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.PLUS_DM(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.PLUS_DM(records);
Log(ret);
}
### talib.PPO
```talib.PPO()```函数用于计算**Percentage Price Oscillator (价格振荡百分比)**。
```talib.PPO()```函数的返回值为：一维数组。
array
talib.PPO(inReal)
talib.PPO(inReal, optInFastPeriod)
talib.PPO(inReal, optInFastPeriod, optInSlowPeriod)
talib.PPO(inReal, optInFastPeriod, optInSlowPeriod, optInMAType)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInFastPeriod```参数用于设置快周期，默认值为12。
optInFastPeriod
false
number
```optInSlowPeriod```参数用于设置慢周期，默认值为26。
optInSlowPeriod
false
number
```optInMAType```参数用于设置均线类型，默认值为0。
optInMAType
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.PPO(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.PPO(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.PPO(records);
Log(ret);
}
### talib.ROC
```talib.ROC()```函数用于计算**Rate of change : ((price/prevPrice)-1)*100 (变动率指标)**。
```talib.ROC()```函数的返回值为：一维数组。
array
talib.ROC(inReal)
talib.ROC(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为10。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.ROC(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ROC(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ROC(records);
Log(ret);
}
### talib.ROCP
```talib.ROCP()```函数用于计算**Rate of change Percentage: (price-prevPrice)/prevPrice (价格变化率)**。
```talib.ROCP()```函数的返回值为：一维数组。
array
talib.ROCP(inReal)
talib.ROCP(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为10。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.ROCP(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ROCP(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ROCP(records);
Log(ret);
}
### talib.ROCR
```talib.ROCR()```函数用于计算**Rate of change ratio: (price/prevPrice) (价格变化率)**。
```talib.ROCR()```函数的返回值为：一维数组。
array
talib.ROCR(inReal)
talib.ROCR(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为10。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.ROCR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ROCR(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ROCR(records);
Log(ret);
}
### talib.ROCR100
```talib.ROCR100()```函数用于计算**Rate of change ratio 100 scale: (price/prevPrice)*100 (价格变化率)**。
```talib.ROCR100()```函数的返回值为：一维数组。
array
talib.ROCR100(inReal)
talib.ROCR100(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为10。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.ROCR100(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ROCR100(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ROCR100(records);
Log(ret);
}
### talib.RSI
```talib.RSI()```函数用于计算**Relative Strength Index (相对强弱指标)**。
```talib.RSI()```函数的返回值为：一维数组。
array
talib.RSI(inReal)
talib.RSI(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.RSI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.RSI(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.RSI(records);
Log(ret);
}
### talib.STOCH
```talib.STOCH()```函数用于计算**Stochastic (STOCH指标)**。
```talib.STOCH()```函数的返回值为：二维数组。
array
talib.STOCH(inPriceHLC)
talib.STOCH(inPriceHLC, optInFastK_Period)
talib.STOCH(inPriceHLC, optInFastK_Period, optInSlowK_Period)
talib.STOCH(inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType)
talib.STOCH(inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType, optInSlowD_Period)
talib.STOCH(inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType, optInSlowD_Period, optInSlowD_MAType)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```optInFastK_Period```参数用于设置Fast-K周期，默认值为5。
optInFastK_Period
false
number
```optInSlowK_Period```参数用于设置Slow-K周期，默认值为3。
optInSlowK_Period
false
number
```optInSlowK_MAType```参数用于设置Slow-K均线类型，默认值为0。
optInSlowK_MAType
false
number
```optInSlowD_Period```参数用于设置Slow-D周期，默认值为3。
optInSlowD_Period
false
number
```optInSlowD_MAType```参数用于设置Slow-D均线类型，默认值为0。
optInSlowD_MAType
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.STOCH(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.STOCH(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.STOCH(records);
Log(ret);
}
### talib.STOCHF
```talib.STOCHF()```函数用于计算**Stochastic Fast (快速STOCH指标)**。
```talib.STOCHF()```函数的返回值为：二维数组。
array
talib.STOCHF(inPriceHLC)
talib.STOCHF(inPriceHLC, optInFastK_Period)
talib.STOCHF(inPriceHLC, optInFastK_Period, optInFastD_Period)
talib.STOCHF(inPriceHLC, optInFastK_Period, optInFastD_Period, optInFastD_MAType)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```optInFastK_Period```参数用于设置Fast-K周期，默认值为5。
optInFastK_Period
false
number
```optInFastD_Period```参数用于设置Fast-D周期，默认值为3。
optInFastD_Period
false
number
```optInFastD_MAType```参数用于设置Fast-D均线类型，默认值为0。
optInFastD_MAType
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.STOCHF(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.STOCHF(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.STOCHF(records);
Log(ret);
}
### talib.STOCHRSI
```talib.STOCHRSI()```函数用于计算**Stochastic Relative Strength Index (随机强弱指数)**。
```talib.STOCHRSI()```函数的返回值为：二维数组。
array
talib.STOCHRSI(inReal)
talib.STOCHRSI(inReal, optInTimePeriod)
talib.STOCHRSI(inReal, optInTimePeriod, optInFastK_Period)
talib.STOCHRSI(inReal, optInTimePeriod, optInFastK_Period, optInFastD_Period)
talib.STOCHRSI(inReal, optInTimePeriod, optInFastK_Period, optInFastD_Period, optInFastD_MAType)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```optInFastK_Period```参数用于设置Fast-K周期，默认值为5。
optInFastK_Period
false
number
```optInFastD_Period```参数用于设置Fast-D周期，默认值为3。
optInFastD_Period
false
number
```optInFastD_MAType```参数用于设置Fast-D均线类型，默认值为0。
optInFastD_MAType
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.STOCHRSI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.STOCHRSI(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.STOCHRSI(records);
Log(ret);
}
### talib.TRIX
```talib.TRIX()```函数用于计算**1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (三重指数平滑平均线)**。
```talib.TRIX()```函数的返回值为：一维数组。
array
talib.TRIX(inReal)
talib.TRIX(inReal, optInTimePeriod)
```inReal```参数用于指定K线数据。
inReal
true
{@struct/Record Record}结构数组、数值数组
```optInTimePeriod```参数用于设置周期，默认值为30。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.TRIX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TRIX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TRIX(records);
Log(ret);
}
### talib.ULTOSC
```talib.ULTOSC()```函数用于计算**Ultimate Oscillator (极限振子)**。
```talib.ULTOSC()```函数的返回值为：一维数组。
array
talib.ULTOSC(inPriceHLC)
talib.ULTOSC(inPriceHLC, optInTimePeriod1)
talib.ULTOSC(inPriceHLC, optInTimePeriod1, optInTimePeriod2)
talib.ULTOSC(inPriceHLC, optInTimePeriod1, optInTimePeriod2, optInTimePeriod3)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```optInTimePeriod1```参数用于设置第一周期，默认值为7。
optInTimePeriod1
false
number
```optInTimePeriod2```参数用于设置第二周期，默认值为14。
optInTimePeriod2
false
number
```optInTimePeriod3```参数用于设置第三周期，默认值为28。
optInTimePeriod3
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.ULTOSC(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ULTOSC(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ULTOSC(records);
Log(ret);
}
### talib.WILLR
```talib.WILLR()```函数用于计算**Williams' %R (威廉指标)**。
```talib.WILLR()```函数的返回值为：一维数组。
array
talib.WILLR(inPriceHLC)
talib.WILLR(inPriceHLC, optInTimePeriod)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```optInTimePeriod```参数用于设置周期，默认值为14。
optInTimePeriod
false
number
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.WILLR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.WILLR(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.WILLR(records);
Log(ret);
}
### talib.AVGPRICE
```talib.AVGPRICE()```函数用于计算**Average Price (平均价格)**。
```talib.AVGPRICE()```函数的返回值为：一维数组。
array
talib.AVGPRICE(inPriceOHLC)
```inPriceOHLC```参数用于指定K线数据。
inPriceOHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.AVGPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.AVGPRICE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.AVGPRICE(records);
Log(ret);
}
### talib.MEDPRICE
```talib.MEDPRICE()```函数用于计算**Median Price (中位数价格)**。
```talib.MEDPRICE()```函数的返回值为：一维数组。
array
talib.MEDPRICE(inPriceHL)
```inPriceHL```参数用于指定K线数据。
inPriceHL
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.MEDPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MEDPRICE(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MEDPRICE(records);
Log(ret);
}
### talib.TYPPRICE
```talib.TYPPRICE()```函数用于计算**Typical Price (典型价格)**。
```talib.TYPPRICE()```函数的返回值为：一维数组。
array
talib.TYPPRICE(inPriceHLC)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.TYPPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TYPPRICE(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TYPPRICE(records);
Log(ret);
}
### talib.WCLPRICE
```talib.WCLPRICE()```函数用于计算**Weighted Close Price (加权收盘价)**。
```talib.WCLPRICE()```函数的返回值为：一维数组。
array
talib.WCLPRICE(inPriceHLC)
```inPriceHLC```参数用于指定K线数据。
inPriceHLC
true
{@struct/Record Record}结构数组
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.WCLPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.WCLPRICE(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.WCLPRICE(records);
Log(ret);
}
WCLPRICE()तालिब के दस्तावेज़ में फ़ंक्शन का वर्णन इस प्रकार हैःWCLPRICE(Records[High,Low,Close]) = Array(outReal)