시스템의 현재 버전 번호를 반환합니다.
현재 시스템 버전 번호3.6...
문자열
버전
function main() {
Log("version:", Version())
}
def main():
Log("version:", Version())
void main() {
Log("version:", Version());
}
시스템 버전 번호는 도커의 프로그램의 버전 번호입니다.
수면 기능, 일정 기간 동안 프로그램을 멈추게 만드는
잠자리 (밀리초)
이millisecond이 매개 변수는 수면 기간과 밀리 초수를 설정하는 데 사용됩니다.
밀리초
사실
번호
function main() {
Sleep(1000 * 10) // Wait for 10 seconds
Log("Waited for 10 seconds")
}
def main():
Sleep(1000 * 10)
Log("Waited for 10 seconds")
void main() {
Sleep(1000 * 10);
Log("Waited for 10 seconds");
}
예를 들어,Sleep(1000)기능, 프로그램은 1 초 동안 잠자리에있을 것입니다. 그것은 1 밀리 초 이하의 잠자리 시간, 예를 들어 설정Sleep(0.1)최소 매개 변수를 지원합니다.0.000001즉, 1나노초가1e-6밀리 초입니다.
전략 작성에 있어서Python언어,Sleep(millisecond)이 기능은 투표 간격, 대기 시간 작업에 사용되어야 합니다.time.sleep(second)기능Python's 'time도서관입니다.time.sleep(second)전략의 함수는 전략 프로그램이 백테스팅을 할 때 (백테스팅 시스템의 시간 계열을 건너뛰지 않고) 실제로 일정 기간 동안 기다리게 합니다. 따라서 전략이 매우 느리게 백테스트를 하게 됩니다.
전략의 실행 환경이 백테스팅 시스템인지 여부를 결정합니다.
전략은 실제 값을 반환합니다. 예를 들어:true백테스팅 시스템 환경에서 실행될 때 전략은 잘못된 값을 반환합니다. 예를 들어:false실시간 거래 환경에서 실행될 때
bool
가상 (virtual)
function main() {
if (IsVirtual()) {
Log("The current backtest system environment.")
} else {
Log("The current live trading environment.")
}
}
def main():
if IsVirtual():
Log("The current backtest system environment.")
else:
Log("The current live trading environment.")
void main() {
if (IsVirtual()) {
Log("The current backtest system environment.");
} else {
Log("The current live trading environment.");
}
}
현재 실행 환경이 백테스팅 시스템인지 결정합니다. 백테스팅과 실시간 거래의 차이에 호환되도록 사용됩니다.
메일 보내
성공적인 이메일 전달은 실제 값을 반환합니다. 예를 들어,true, 그리고 실패한 배달은 잘못된 값을 반환합니다. 예를 들어,false...
bool
메일 ((smtp서버, smtp사용자명, smtp신호, mailTo, 제목, 본)
사용된SMTP이메일 발신자의 서비스 주소
smtp서버
사실
문자열
이메일 발신자의 이메일 주소를 지정하는 데 사용됩니다.
smtp사용자명
사실
문자열
의SMTP메일 발신자의 메일박스의 비밀번호.
smtpPassword
사실
문자열
이메일 수신자의 이메일 주소를 지정하는 데 사용됩니다.
메일To
사실
문자열
이메일 제목
제목
사실
문자열
이메일 본체
몸
사실
문자열
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");
}
이smtpPassword매개 변수SMTP메일박스 비밀번호가 아니라
설정할 때smtpServer매개 변수, 당신이 포트를 변경해야 하는 경우, 당신은 매개 변수에 직접 포트 번호를 추가 할 수 있습니다smtpServer예를 들어: QQ 메일smtp.qq.com:587, 테스트를 위해 사용할 수 있습니다.
오류가 보고되면:unencryped connection, 당신은 변경해야 합니다smtpServer의Mail함수입니다. 매개 변수 형식은:ssl://xxx.com:xxx예를 들어,ssl방법SMTPQQ 메일:ssl://smtp.qq.com:465또는smtp://xxx.com:xxx...
백테스팅 시스템에서는 작동하지 않습니다.
{@fun/Global/Mail_Go 메일_Go}
비동기 버전Mail function.
이Mail_Go함수는 동시 객체를 즉시 반환하고,wait메일 배달의 결과를 얻기 위해 동시 객체의 메서드를 사용한다.true, 그리고 실패한 배달은 잘못된 값을 반환합니다. 예를 들어,false...
물체
Mail_Go ((smtp서버, smtp사용자명, smtp 비밀번호, mailTo, 제목, 본체)
이 용어는SMTP이메일 발신자의 서비스 주소
smtp서버
사실
문자열
이메일 발신자의 이메일 주소를 지정하는 데 사용됩니다.
smtp사용자명
사실
문자열
의SMTP메일 발신자의 메일박스의 비밀번호.
smtpPassword
사실
문자열
이메일 수신자의 이메일 주소를 지정하는 데 사용됩니다.
메일To
사실
문자열
이메일 제목
제목
사실
문자열
이메일 본체
몸
사실
문자열
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)
}
# Not supported.
// Not supported.
백테스팅 시스템에서는 작동하지 않습니다.
{@fun/Global/Mail Mail}
필터 오류 로그
SetErrorFilter (필터 설정)
정규 표현식 문자열 필터 사실 문자열
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() {
// A random query for a non-existent order with an id of 123, allowing the interface to report an error deliberately
var order = exchange.GetOrder("123")
Log(order)
// Filter http502 errors, GetOrder interface errors, after setting the error filter, the second call to GetOrder will no longer report errors
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(""). 필터 로그는 더 이상 docker 디렉토리의 라이브 거래 ID에 대응하는 데이터베이스 파일에 기록되지 않습니다. 빈번한 오류 보고가 데이터베이스 파일을 부풀어 올리는 것을 방지하기 위해.
라이브 거래 프로세스 아이디를 얻으십시오.
라이브 거래 프로세스 ID를 반환합니다. 문자열
GetPid ((()
function main(){
var id = GetPid()
Log(id)
}
def main():
id = GetPid()
Log(id)
void main() {
auto id = GetPid();
Log(id);
}
마지막 오류 메시지가 왔어
마지막 오류 메시지 문자열
GETLastError()
function main(){
// Because the order number 123 does not exist, so there will be an error.
exchange.GetOrder("123")
var error = GetLastError()
Log(error)
}
def main():
exchange.GetOrder("123")
error = GetLastError()
Log(error)
void main() {
// Order ID type: TId, so you can't pass in a string, we place an order that doesn't meet the exchange specification to trigger
exchange.GetOrder(exchange.Buy(1, 1));
auto error = GetLastError();
Log(error);
}
백테스팅 시스템에서는 작동하지 않습니다.
전략 상호작용 명령을 받습니다.
반환 명령어의 형식은ControlName:Data. ControlName제어물의 이름이고,Data컨트롤에 입력된 데이터입니다. 인터랙티브 컨트롤에 입력 상자, 드롭다운 상자 및 다른 구성 요소가 없다면 (예를 들어 입력 상자 없는 버튼 컨트롤) 반환 명령어 형식은ControlName, 컨트롤 이름만 반환합니다.
문자열
GetCommand (() 를 받아보세요
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("Buy, the control without number")
} else if (arr[0] == "sell") {
Log("Sell, the control with the number of:", arr[1])
} else {
Log("Other controls trigger:", arr)
}
}
Sleep(1000)
}
}
def main():
while True:
LogStatus(_D())
cmd = GetCommand()
if cmd:
Log("cmd:", cmd)
arr = cmd.split(":")
if arr[0] == "buy":
Log("Buy, the control without number")
elif arr[0] == "sell":
Log("Sell, the control with the number of:", arr[1])
else:
Log("Other controls trigger:", 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("Buy, the control without number");
} else if (arr[0] == "sell") {
Log("Sell, the control with the number of:", arr[1]);
} else {
Log("Other controls trigger:", arr);
}
}
Sleep(1000);
}
}
예를 들어, 전략 인터랙티브 컨트롤은 입력 상자가 없는 컨트롤을 추가합니다. 인터랙티브 컨트롤의 이름은:buy, 제어 설명 정보는:buy, 버튼 컨트롤입니다. 입력 상자를 가진 컨트롤을 추가하여 계속합니다. 상호 작용 컨트롤은 이름:sell그리고 제어 설명 메시지는:sell, 이것은 버튼과 입력 상자의 조합을 가진 인터랙티브 컨트롤입니다. 인터랙션 코드는 전략에서 다른 인터랙션 컨트롤에 대응하도록 설계되었습니다:
백테스팅 시스템에서는 작동하지 않습니다.
전략 등록 코드를 생성 할 때 메타의 값을 작성하십시오.
Meta데이터
문자열
GetMeta (메타)
function main() {
// The maximum asset value of the denominated currency allowed by the strategy.
var maxBaseCurrency = null
// Get the metadata when creating the registration code.
var level = GetMeta()
// Detecting the conditions corresponding to Meta.
if (level == "level1") {
// -1 for unrestricted
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()
// Detect asset values
var acc = exchange.GetAccount()
if (maxBaseCurrency != -1 && maxBaseCurrency < acc.Stocks + acc.FrozenStocks) {
// Stop executing strategy trading logic
LogStatus(_D(), "level:", level, "Positions exceeding the usage limit of the registration code will no longer execute the strategy trading logic!")
continue
}
// Other trading logic
// Normal output of status bar information
LogStatus(_D(), "level:", level, "The strategy is working properly! ticker data: \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, "Positions exceeding the usage limit of the registration code will no longer execute the strategy trading logic!")
continue
# Other trading logic
# Normal output of status bar information
LogStatus(_D(), "level:", level, "The strategy is working properly! ticker data: \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) {
// Stop execution strategy trading logic.
LogStatus(_D(), "level:", level, "Positions exceeding the usage limit of the registration code will no longer execute the strategy trading logic!");
continue;
}
// Other trading logic
// Normal output of status bar information
LogStatus(_D(), "level:", level, "The strategy is working properly! ticker data: \n", ticker);
}
}
응용 시나리오 예: 사용Meta전략에 의해 운영되는 자산의 양을 제한하는 것.
적용 시나리오: 다른 전략 임대자에 대한 자본 제한을 할 필요가 있습니다.Meta등록 코드를 생성 할 때 설정된 값은 190 문자를 초과 할 수 없으며GetMeta()이 기능은 라이브 거래만 지원합니다.Meta(주) 전략 등록 코드를 생성 할 때 설정됩니다.GetMeta()함수는 null을 반환합니다. 백테스팅 시스템에서는 작동하지 않습니다.
원시적인Socket접근, 지원tcp, udp, tls, unix프로토콜 4개의 일반적인 통신 프로토콜을 지원합니다.mqtt, nats, amqp, kafka데이터베이스 연결을 지원합니다:sqlite3, mysql, postgres, clickhouse.
이Dial()함수는 시간이 끝나면 null을 반환합니다. 정상적인 호출은 세 가지 메소드를 가진 연결 객체를 반환합니다.read, write그리고close.read이 방법은 데이터를 읽기 위해 사용됩니다.write이 방법은 데이터를 전송하고close이 방법은 연결을 닫는 데 사용됩니다.
의read이 방법은 다음과 같은 매개 변수를 지원합니다.
ws.read().ws.read(2000)2초 (2000밀리초) 의 타임아웃을 지정합니다.-1함수는 메시지가 존재하거나 없더라도 즉시 반환하는 것을 의미합니다. 예를 들어:ws.read(-1)...
매개 변수를 전달-2함수는 메시지와 함께 또는 메시지가 없이 즉시 반환하지만, 최신 메시지가 반환되고 버퍼된 메시지가 폐기된다는 것을 의미합니다. 예를 들어,ws.read(-2).read()함수 버퍼 설명:
웹소켓 프로토콜에 의해 밀어 입력 데이터는 전략 사이의 시간 간격이read()함수 호출이 너무 길다. 이 데이터는 버퍼에 저장되며, 최대 2000의 대기열의 데이터 구조를 가지고 있습니다. 2000이 초과되면 가장 새로운 데이터가 버퍼에 입력되고 가장 오래된 데이터가 삭제됩니다.
| 시나리오 | 매개 변수가 없습니다. | 파라미터: -1 | 파라미터: -2 | 매개 변수: 2000 밀리 초 |
|---|---|---|---|---|
| 이미 버퍼에 있는 데이터 | 가장 오래된 데이터를 즉시 반환 | 가장 오래된 데이터를 즉시 반환 | 최신 데이터를 즉시 반환 | 가장 오래된 데이터를 즉시 반환 |
| 버퍼에 데이터가 없습니다. | 데이터로 차단된 경우 반환 | 즉시 null을 반환합니다 | 즉시 null을 반환합니다 | 2000ms를 기다립니다. 데이터가 없다면 null을 반환합니다. 데이터가 있다면 null을 반환합니다. |
| 웹소켓 연결이 연결이 끊어지고 또는 기본에 의해 다시 연결 | read() 함수는 빈 문자열을 반환합니다. 즉: |
물체
전화번호 (주소) 전화 (주소, 시간)
주소 요청 주소 사실 문자열 타임아웃 초, 타임아웃 거짓 번호
function main(){
// Dial supports tcp://，udp://，tls://，unix://protocol, you can add a parameter to specify the number of seconds for the timeout
var client = Dial("tls://www.baidu.com:443")
if (client) {
// write can be followed by a numeric parameter to specify the timeout, write returns the number of bytes successfully sent
client.write("GET / HTTP/1.1\nConnection: Closed\n\n")
while (true) {
// read can be followed by a numeric parameter specifying the timeout in milliseconds. Returning null indicates an error or timeout or that the socket has been closed
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("Connecting...")
// Accessing WebSocket interface of Binance
var client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr")
if (!client) {
Log("Connection failed, program exited")
return
}
while (true) {
// read returns only the data retrieved after the read call
var buf = client.read()
if (!buf) {
break
}
var table = {
type: 'table',
title: 'Ticker Chart',
cols: ['Currency', 'Highest', 'Lowest', 'Buy 1', 'Sell 1', 'Last traded price', 'Volume', 'Update time'],
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("Connecting...")
client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr")
if not client:
Log("Connection failed, program exited")
return
while True:
buf = client.read()
if not buf:
break
table = {
"type" : "table",
"title" : "Ticker Chart",
"cols" : ['Currency', 'Highest', 'Lowest', 'Buy 1', 'Sell 1', 'Last traded price', 'Volume', 'Update time'],
"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("Connecting...");
auto client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr");
if(!client.Valid) {
Log("Connection failed, program exited");
return;
}
while(true) {
auto buf = client.read();
if(buf == "") {
break;
}
json table = R"({
"type" : "table",
"title" : "Ticker Chart",
"cols" : ["Currency", "Highest", "Lowest", "Buy 1", "Sell 1", "Last traded price", "Volume", "Update time"],
"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();
}
바이낸스의 웹소켓 틱어 인터페이스에 액세스하려면:
var ws = null
function main(){
var param = {
"op": "subscribe",
"args": [{
"channel": "tickers",
"instId": "BTC-USDT"
}]
}
// When calling Dial function, specify reconnect=true to set reconnection mode and payload to be the message sent when reconnecting. When the WebSocket connection is disconnected, it will reconnect and send messages automatically.
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("Send : ping", "#FF0000")
}
LogStatus("Current time:", _D())
Sleep(1000)
}
}
}
function onexit() {
ws.close()
Log("exit")
}
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("Send: ping", "#FF0000")
LogStatus("Current time:", _D())
Sleep(1000)
def onexit():
ws.close()
Log("exit")
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("Send: ping", "#FF0000");
}
LogStatus("Current time:", _D());
Sleep(1000);
}
}
}
void onexit() {
objWS.close();
Log("exit");
}
OKX
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)
// Respond to heartbeat packet operations
try {
var jsonRet = JSON.parse(ret)
if(typeof(jsonRet.ping) == "number") {
var strPong = JSON.stringify({"pong" : jsonRet.ping})
ws.write(strPong)
Log("Respond to ping, send pong:", strPong, "#FF0000")
}
} catch(e) {
Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
}
LogStatus("Current time:", _D())
Sleep(1000)
}
}
}
function onexit() {
ws.close()
Log("Execute the ws.close() function")
}
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)
# Respond to heartbeat packet operations
try:
jsonRet = json.loads(ret)
if "ping" in jsonRet and type(jsonRet["ping"]) == int:
strPong = json.dumps({"pong" : jsonRet["ping"]})
ws.write(strPong)
Log("Respond to ping, send pong:", strPong, "#FF0000")
except Exception as e:
Log("e:", e)
LogStatus("Current time:", _D())
Sleep(1000)
def onexit():
ws.close()
Log("Execute the ws.close() function")
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);
// Respond to heartbeat packet operations
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("Respond to ping, send pong:", strPong, "#FF0000");
}
} catch(exception &e)
{
Log("e:", e.what());
}
LogStatus("Current time:", _D());
Sleep(1000);
}
}
}
void onexit() {
// ws.close();
Log("Execute the ws.close() function");
}
Huobi의 웹소켓 틱어 인터페이스에 액세스:
function getLogin(pAccessKey, pSecretKey, pPassphrase) {
// Signature function for login
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 has been deprecated and is temporarily supported. Please use the latest exchange.Encode function instead.
}]
}
return login
}
var client_private = null
function main() {
// Because the read function uses a timeout setting, filtering the timeout reports errors that would otherwise be output with redundant errors
SetErrorFilter("timeout")
// Position channel subscription information
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) // When logging in, you cannot subscribe to private channels immediately, you need to wait for server response
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)
}
// Detect disconnection, reconnect
if (buf == "" && client_private.write(JSON.stringify(posSubscribe)) == 0) {
Log("Disconnection detected, close connection, reconnect")
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))
}
// Send heartbeat packets
var nowPingTS = new Date().getTime()
if (nowPingTS - lastPingTS > 10 * 1000) {
client_private.write("ping")
lastPingTS = nowPingTS
}
}
}
}
function onexit() {
var ret = client_private.close()
Log("Close the connection!", 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("Disconnection detected, close connection, reconnect")
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("Close the connection!", 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("Disconnection detected, close connection, reconnect");
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("exit");
}
OKX
var client = null
function main() {
// client = Dial("sqlite3://:memory:") // Using an in-memory database
client = Dial("sqlite3://test1.db") // Open/connect to the database file in the docker's directory
// record handle
var sqlite3Handle = client.fd()
Log("sqlite3Handle:", sqlite3Handle)
// Querying tables in the database
var ret = client.exec("SELECT name FROM sqlite_master WHERE type='table'")
Log(ret)
}
function onexit() {
Log("Execute client.close()")
client.close()
}
// Not supported
// Not supported
데이터베이스에 연결할 때 다이얼 함수가 반환하는 연결 객체는 두 가지 고유한 메소드 함수를 가지고 있습니다.
exec(sqlString): SQL 명령어를 실행하는 데 사용DBExec() function.fd():fd()함수는 다른 스레드가 다시 연결하기 위해 사용할 수 있는 핸들을 반환합니다. (디얼에 의해 생성된 객체가 실행에 의해 이미 닫혀있더라도)close()연결을 닫는 기능)Dial()예를 들어,Dial(handle)재사용 연결
다음은 다이얼 기능의 예를sqlite3 database.세부 사항address매개 변수,|정상 주소 다음의 기호:wss://ws.okx.com:8443/ws/v5/public만약|매개 변수 문자열의 문자, 그리고||분기 기호로 사용됩니다. 그 다음 부분은 몇 가지 함수 매개 변수 설정입니다.&예를 들어,ss5프록시와 압축 매개 변수는 다음과 같이 함께 설정될 수 있습니다.Dial("wss://ws.okx.com:8443/ws/v5/public|proxy=socks5://xxx:9999&compress=gzip_raw&mode=recv")
| 다이얼 함수의 주소 매개 변수로 지원되는 함수 | 매개 변수 설명 |
|---|---|
| 웹소켓 프로토콜 데이터 압축과 관련된 매개 변수: compress=parameter value | 압축은 압축 메소드, 압축 매개 변수 옵션은: gzip_raw, gzip, 등입니다. gzip 메소드가 표준 gzip이 아닌 경우 확장 메소드를 사용할 수 있습니다: gzip_raw |
| 웹소켓 프로토콜 데이터 압축과 관련된 매개 변수: mode=parameter value | 모드는 압축 모드, 모드 매개 변수는 듀얼이 될 수 있습니다. 전송, recv. 듀얼은 양방향 압축, 압축 데이터를 전송, 압축 데이터를 수신합니다. 전송은 압축 데이터를 전송합니다. recv는 압축 데이터를 수신합니다. 지역 압축 해제. |
| 웹소켓 프로토콜은 기본 자동 재연결 관련 매개 변수를 설정합니다: reconnect=parameter value | reconnect는 reconnect를 설정할 것인지, reconnect=true는 reconnect를 활성화할 것인지입니다. 이 매개 변수가 설정되지 않은 경우 기본값은 reconnect가 없습니다. |
| 웹소켓 프로토콜은 기본 자동 재연결 관련 매개 변수를 설정합니다: interval=parameter value | interval는 재시험 간격입니다. 밀리초로, interval=10000는 10초의 재시험 간격입니다. 기본값은 1초입니다. |
| 웹소켓 프로토콜은 기본 자동 재연결 관련 매개 변수를 설정합니다: payload=parameter value | payload는 웹소켓이 다시 연결될 때 보내야 하는 구독 메시지입니다. 예를 들어: payload=okokok |
| 소크스5 프록시와 관련된 매개 변수: 프록시=파라미터 값 | proxy는 ss5 proxy 설정, 매개 변수 값 형식: socks5://name:pwd@192.168.0.1:1080, 이름은 ss5 서버 사용자 이름, pwd는 ss5 서버 로그인 비밀번호, 1080는 ss5 서비스 포트입니다. |
이Dial()이 기능은 라이브 트레이딩에서만 지원됩니다.
다이얼 함수를 사용하여 데이터베이스에 연결할 때, 연결 문자열은 각 데이터베이스의 go 언어 드라이버 프로젝트에 참조하여 작성됩니다.
| 지원되는 데이터베이스 | 추진 프로젝트 | 연결 문자열 | 언급 |
|---|---|---|---|
| 스클라이트3 | 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) / 당신의 데이터베이스?차르셋=utf8mb4 | – |
| 포스트그레스 | github.com/lib/pq | postgres://user=postgres dbname=yourdatabase sslmode=disable password=yourpassword 호스트=localhost 포트=5432 | – |
| 클릭하우스 | github.com/ClickHouse/clickhouse-go | clickhouse://tcp://host:9000?username=username&password=yourpassword&database=youdatabase | – |
참고로,payload내용address매개 변수는 문자를 포함합니다.=또는 다른 특수 문자, 그것은 분석에 영향을 미칠 수 있습니다address매개 변수Dial다음 예시처럼
backPack Exchange 웹소켓 개인 인터페이스 호출 예제:
var client = null
function main() {
// Base64-encoded public key of the key pair, i.e. the access key configured on FMZ
var base64ApiKey = "xxx"
var ts = String(new Date().getTime())
var data = "instruction=subscribe×tamp=" + ts + "&window=5000"
// Since signEd25519 returns a base64 encoding, it contains the character "="
var signature = signEd25519(data)
// The payload may contain the character "=" after being encoded by 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("Connection failed, program exited")
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:
// We need to configure and deploy proxy servers for each protocol first.
// For the sake of demonstration, the subscription (read operation) and publishing (write operation) of the topic test_topic are all performed in the current strategy.
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]
// Write data
conn.write(name + ", time: " + _D() + ", test msg.")
// Read data
var readMsg = conn.read(1000)
Log(name + " readMsg: ", readMsg, "#FF0000")
}
Sleep(1000)
}
}
function onexit() {
for (var i in arrConn) {
arrConn[i].close()
Log("close", arrName[i], "connect")
}
}
자세한 문서 참조:FMZ를 탐구: 라이브 거래 전략 사이의 통신 프로토콜의 연습
Http 요청을 보내십시오.
요청의 응답 데이터를 반환합니다. 반환 값이 a인 경우JSON문자열, 그것은 분석 될 수 있습니다JSON.parse()기능JavaScript언어 전략,json::parse()기능C++언어 전략. 디버그는 옵션 구조에서 true로 설정되면 반환 값은 객체 (JSON); 디버그는 false로 설정되면 반환 값은 문자열입니다.
문자열, 대상
HttpQuery (URL) HttpQuery (URL, 옵션)
Http 요청 URL url 사실 문자열 예를 들어, 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_:"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_:"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_:"mms_ios",
mesh_:"mesh_ios", "mesh_ios_1", "mesh_ios_2", "mesh_android", "mesh_android_1", "mesh_android_2",
확인된 것"confirmed_ios", "confirmed_android",
좋아요."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(){
// An example of GET access without parameters
var info = JSON.parse(HttpQuery("https://www.okx.com/api/v5/public/time"))
Log(info)
// An example of GET access with parameters
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 does not support Python, you can use the urllib/urllib2 library instead
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);
}
OKX 공개 틱어 API 인터페이스에 액세스하는 예제.
function main() {
// Setting proxy and sending an http request for this time, no username, no password, this http request will be sent through the proxy
HttpQuery("socks5://127.0.0.1:8889/http://www.baidu.com/")
// Setting proxy and sending an http request for this time, enter the user name and password, only the current call to HttpQuery takes effect, and then call HttpQuery again ("http://www.baidu.com") so that the proxy will not be used.
HttpQuery("socks5://username:password@127.0.0.1:8889/http://www.baidu.com/")
}
# HttpQuery does not support Python, you can use the urllib/urllib2 library instead
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 함수는 프록시 설정을 사용합니다.
이HttpQuery()기능만 지원합니다JavaScript, C++언어Python언어를 사용할 수 있습니다urllibHttp 요청을 직접 전송할 수 있습니다.HttpQuery()주로 시그니처 정보와 같은 공개 인터페이스와 같이 서명이 필요하지 않은 교환의 인터페이스에 액세스하는 데 사용됩니다.HttpQuery()백테스팅 시스템에서 요청을 보내기 위해 사용할 수 있습니다.GET백테스팅은 20번의 방문으로 제한됩니다.URLs, 그리고HttpQuery()방문은 데이터를 캐시합니다.URL두 번째 접속이 되면,HttpQuery()함수는 캐시된 데이터를 반환하고 더 이상 실제 네트워크 요청이 발생하지 않습니다.
{@fun/Global/HttpQuery_Go HttpQuery_Go}
HTTP 요청을 보내기 위해,HttpQuery function.
이HttpQuery_Go()이 함수는 Http 요청의 결과를 얻기 위해 사용할 수 있는 동시 객체를 즉시 반환합니다.wait의 방법JSON.parse()함수를 사용할 수 있습니다JSON.parse()기능JavaScript언어의 전략
물체
HttpQuery_Go (URL) HttpQuery_Go (URL, 옵션)
Http 요청 URL url 사실 문자열 예를 들어, HTTP 요청 관련 설정은 다음과 같이 구성될 수 있습니다.
{
method: "POST",
body: "a=10&b=20&c=30",
charset: "UTF-8",
cookie: "session_id=12345; lang=en",
// profile: "",
debug: false,
headers: {"TEST-HTTP-QUERY": "123"},
timeout: 1000
}
tls fingerprints.true이HttpQuery_Go함수 호출은 전체 응답 메시지를 반환합니다.false, 단지 데이터Body응답 메시지가 반환됩니다.profile이 분야는 방치될 수 있습니다.옵션 거짓 물체
function main() {
// Create the first asynchronous thread
var r1 = HttpQuery_Go("https://www.okx.com/api/v5/market/tickers?instType=SPOT")
// Create the second asynchronous thread
var r2 = HttpQuery_Go("https://api.huobi.pro/market/tickers")
// Get the return value of the first asynchronous thread call
var tickers1 = r1.wait()
// Get the return value of the second asynchronous thread call
var tickers2 = r2.wait()
// Print results
Log("tickers1:", tickers1)
Log("tickers2:", tickers2)
}
# Not supported
// Not supported
종합적인 틱어 데이터에 대한 거래소의 공개 인터페이스에 비동기 액세스.
이HttpQuery_Go()기능만 지원합니다JavaScript, 그Python언어는urllibHttp 요청을 직접 전송할 수 있습니다.HttpQuery_Go()주로 교환에 서명이 필요하지 않은 인터페이스에 액세스하는 데 사용됩니다.HttpQuery_Go기능은 백테스팅 시스템에서 지원되지 않습니다.
{@fun/Global/HttpQuery HttpQuery}
이 함수는 입력된 매개 변수에 따라 데이터를 암호화합니다.
이Encode이 함수는 암호화와 암호화 후에 데이터를 반환합니다.
문자열
엔코드 (algo, inputFormat, outputFormat, data) 엔코드 (algo, inputFormat, outputFormat, data, key)
매개 변수algo은 암호화 계산에 사용되는 알고리즘입니다. 지원 설정은:raw(알고리즘이 사용되지 않습니다), "표지", algo또한: algo또한: algoed25519.seed계산
뭔가
사실
문자열
데이터 형식을 지정하는 데 사용됩니다.data매개 변수inputFormat매개 변수는 다음 중 하나로 설정할 수 있습니다:raw, hex, base64, string.hex암호화된 경우, base64암호화된 것이고, outputFormat매개 변수는 다음 중 하나로 설정할 수 있습니다:raw, hex, base64, string.hex암호화된 경우, base64암호화된 것이고, data처리해야 할 데이터입니다.
데이터
사실
문자열
데이터 형식을 지정하는 데 사용됩니다.key매개 변수key매개 변수는 다음 중 하나로 설정할 수 있습니다:raw, hex, base64, string.hex암호화된 경우, base64암호화된 것이고, key비밀 키는HMAC암호화, 매개 변수key매개 변수algo설정되어 있습니다sign또는signTx.key매개 변수는 사용되지 않습니다HMAC암호화algo매개 변수는
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
}
엑코드 함수 호출 예제
function main(){
var ret1 = Encode("text.encoder.utf8", "raw", "hex", "hello") // e4bda0e5a5bd
Log(ret1)
var ret2 = Encode("text.decoder.utf8", "hex", "string", ret1)
Log(ret2)
var ret3 = Encode("text.encoder.gbk", "raw", "hex", "hello") // c4e3bac3
Log(ret3)
var ret4 = Encode("text.decoder.gbk", "hex", "string", ret3)
Log(ret4)
}
def main():
ret1 = Encode("text.encoder.utf8", "raw", "hex", "hello", "", "") # e4bda0e5a5bd
Log(ret1)
ret2 = Encode("text.decoder.utf8", "hex", "string", ret1, "", "")
Log(ret2)
ret3 = Encode("text.encoder.gbk", "raw", "hex", "hello", "", "") # c4e3bac3
Log(ret3)
ret4 = Encode("text.decoder.gbk", "hex", "string", ret3, "", "")
Log(ret4)
void main(){
auto ret1 = Encode("text.encoder.utf8", "raw", "hex", "hello"); // e4bda0e5a5bd
Log(ret1);
auto ret2 = Encode("text.decoder.utf8", "hex", "string", ret1);
Log(ret2);
auto ret3 = Encode("text.encoder.gbk", "raw", "hex", "hello"); // c4e3bac3
Log(ret3);
auto ret4 = Encode("text.decoder.gbk", "hex", "string", ret3);
Log(ret4);
}
매개 변수algo또한:
이Encode()이 기능은 라이브 거래에만 지원됩니다.key그리고keyFormat매개 변수가 통과되지 않는 경우key암호화가 사용되지 않습니다.
현재 순간의 나노초 시간표를 얻으십시오.
이UnixNano()이 함수는 나노초 시간표를 반환합니다.
번호
유닉스나노 (UNIXNANO))
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 UNIX}
현재 순간의 시간표를 2층에서 가져와
두 번째 레벨의 시간표를 반환합니다. 번호
유닉스 ((()
function main() {
var t = Unix()
Log(t)
}
def main():
t = Unix()
Log(t)
void main() {
auto t = Unix();
Log(t);
}
{@fun/Global/UnixNano 유닉스나노}
도커가 있는 장치의 시스템 정보를 얻으십시오.
시스템 정보 문자열
GetOS()
function main() {
Log("GetOS:", GetOS())
}
def main():
Log("GetOS:", GetOS())
void main() {
Log("GetOS:", GetOS());
}
예를 들어,GetOS()도커에서 실행되는 함수맥 OS운영 체제가 반환 할 수 있습니다:darwin/amd64왜냐하면 애플 컴퓨터는 여러 하드웨어 아키텍처를 가지고 있기 때문입니다.darwin의 이름입니다맥 OS system.
매개 변수의 MD5 해시를 계산합니다.data.
MD5 해시 값 문자열
MD5 (데이터)
MD5 계산이 필요한 데이터입니다. 데이터 사실 문자열
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/Encode Encode}
데이터베이스 인터페이스 기능
a의 실행 결과를 포함하는 객체sql예를 들어,
{"columns":["TS","HIGH","OPEN","LOW","CLOSE","VOLUME"],"values":[[1518970320000,100,99.1,90,100,12345.6]]}
물체
DBExec ((sql)
sql명령어 문자열 sql 사실 문자열
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)
// Add a piece of data
Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
// Query data
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)
# Add a piece of data
Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
# Query data
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);
// Add a piece of data
Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"));
// Query data
Log(DBExec(":SELECT * FROM TEST_TABLE;"));
}
메모리 데이터베이스 지원,DBExec기능 매개 변수, 만약sql문장 시작:이 경우 메모리에 있는 데이터베이스에서 동작할 수 있습니다. 파일 쓰기 없이도 더 빨라집니다.
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))
// Add a piece of data
Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
// Query data
Log(DBExec("SELECT * FROM TEST_TABLE;"))
// Modify data
Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000))
// Delete data
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))
# Add a piece of data
Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
# Query data
Log(DBExec("SELECT * FROM TEST_TABLE;"))
# Modify data
Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000))
# Delete data
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));
// Add a piece of data
Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"));
// Query data
Log(DBExec("SELECT * FROM TEST_TABLE;"));
// Modify data
Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000));
// Delete data
Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110));
}
테이블에 레코드를 추가, 삭제, 확인 및 변경.
기능DBExec()라이브 거래 데이터베이스 (SQLite 데이터베이스) 를 패러미터를 전달하여 작동 할 수 있습니다. 라이브 거래 데이터베이스에서 데이터 추가, 삭제, 확인 및 변경 작업을 실현, 지원SQLite문법. 시스템 라이브 거래 데이터베이스에 테이블을 예약:kvdb, cfg, log, profit, chart이 테이블에서 작업하지 마십시오.거래지원되지 않으며 시스템에서 충돌을 일으킬 수 있는 그러한 작업을 수행하는 것은 권장되지 않습니다.DBExec()이 기능은 라이브 트레이딩에서만 지원됩니다.
#############
UUID를 생성합니다.
32비트 UUID 문자열
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);
}
이UUID()이 기능은 라이브 거래만 지원합니다.
사건에 대한 귀를 기울이고, 그것은 어떤 경우에 돌아옵니다WebSocket가독 가능한 데이터 또는 동시에 수행되는 작업,exchange.Go(), HttpQuery_Go(), 등이 완료됩니다.
반환 객체가 null 값이 아니라면,Event반환 컨텐츠에 포함된 것은 이벤트 트리거 타입입니다. 예를 들어 다음 반환 값 구조:
{"Seq":1,"Event":"Exchange_GetTrades","ThreadId":0,"Index":3,"Nano":1682068771309583400}
물체
이벤트 루프 ((() 이벤트 루프 (타임아웃)
매개 변수timeout타임아웃 설정, 밀리초입니다.timeout0로 설정된 경우 이벤트가 발생하기 전에 발생을 기다립니다. 0보다 크면 타임아웃을 기다리도록 설정하고 0보다 작으면 가장 최근의 이벤트를 즉시 반환합니다.
타임아웃
거짓
번호
function main() {
var routine_getTicker = exchange.Go("GetTicker")
var routine_getDepth = exchange.Go("GetDepth")
var routine_getTrades = exchange.Go("GetTrades")
// Sleep(2000), if the Sleep statement is used here, it will cause the subsequent EventLoop function to miss the previous events, because after waiting for 2 seconds, the concurrent function has received the data, and the subsequent EventLoop listening mechanism started, it misses these events.
// These events will not be missed unless EventLoop(-1) is called at the beginning of the first line of code to first initialize the EventLoop's listening mechanism.
// Log("GetDepth:", routine_getDepth.wait()) If the wait function is called in advance to retrieve the result of a concurrent call to the GetDepth function, the event that the GetDepth function receives the result of the request will not be returned in the EventLoop function.
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("The first concurrent task completed was:", _D(ts1), ret1)
Log("The second concurrent task completed was:", _D(ts2), ret2)
Log("The third concurrent task completed was:", _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("The first concurrent task completed was:", _D(ts1), ret1)
Log("The second concurrent task completed was:", _D(ts2), ret2)
Log("The third concurrent task completed was:", _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("The first concurrent task completed was:", _D(ts1), ret1);
Log("The second concurrent task completed was:", _D(ts2), ret2);
Log("The third concurrent task completed was:", _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()함수는 기본 시스템 WebSocket의 캐시 대기열 또는 같은 동시 함수의 캐시에 영향을 미치지 않습니다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}
이__Serve이 함수는 Http 서비스, TCP 서비스, 웹소켓 서비스 (Http 프로토콜을 기반으로) 를 생성하는 데 사용됩니다.
생성된 서비스의 IP 주소와 포트를 기록하는 문자열을 반환합니다. 예를 들어:127.0.0.1:8088, [::]:8089.
문자열
__서비스 (서비스URI, 관리자) __서비스 (서비스 (SERVURI, 핸들러,...args)
이serveURI이 매개 변수는 프로토콜, IP 주소, 포트 및 서비스 결합의 다른 설정을 구성하는 데 사용됩니다.http://0.0.0.0:8088?gzip=true, 즉,http://:8088?gzip=true.
serveURI파라미터 설정,tcp://127.0.0.1:6666?tls=true; 당신은 인증서와 개인 키를 추가할 수 있습니다.tls=true&cert_pem=xxxx&cert_key_pem=xxxx.serveURI파라미터 설정,http://127.0.0.1:6666?gzip=true; 압축 설정을 설정할 수 있습니다:gzip=true...
의serveURIHttps를 위한 매개 변수입니다.https://127.0.0.1:6666?tls=true&gzip=true; 당신은 추가 할 수 있습니다cert_pem그리고cert_key_pem인증서를 로드하는 매개 변수serveURI
사실
문자열
의handler이 매개 변수는 라우팅 처리 함수 (Http 프로토콜), 메시지 처리 함수 (TCP 프로토콜), 스트림 처리 함수 (Websocket) 에서 전달하는 데 사용됩니다.
매개 변수에서 전달된 콜백 함수handler여러 매개 변수를 정의할 수 있는데 첫 번째 매개 변수는 ctx 객체 (context object) 입니다.
관리자
사실
기능
콜백 함수의 실제 매개 변수는 매개 변수로 전달handler여러 매개 변수가 있을 수 있습니다.arg예를 들어:
__Serve("http://:8088", function(ctx, a, b, c) {
Log(`ctx.host():`, ctx.host(), ", a=", a, ", b=", b, ", c=", c)
}, 1, 2, 3)
매개 변수1, 2, 3전화 할 때 통과__Serve()함수는 매개 변수와 일치합니다a, b, c콜백 함수에서 통과했습니다.
아그 거짓 문자열, 숫자, bool, 객체, 배열, 함수, null 값 및 시스템에서 지원되는 다른 유형
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)
}
}
# Unsupported
// Unsupported
WebsocketHttp 프로토콜에 기반하여 구현됩니다. 경로에서 라우팅 브랜치를 설정하고 실행 코드를 설계할 수 있습니다Websocket이 섹션에서 샘플 코드를 참조 할 수 있습니다.매개 변수에서 전달된 콜백 함수handler수락ctx매개 변수ctx매개 변수 는 다음 방법 으로 데이터를 얻고 기록 하기 위해 사용되는 컨텍스트 객체 입니다.
HTTP/1.1, tcp.http://127.0.0.1:8088?num=123, 그리고 매개 변수에 의해 전달된 호출 역 처리 함수handler수익"123"언제ctx.query("num")라고 불립니다.User-Agent현재 요청의 제목에:ctx.header("User-Agent").GET, POST, 등등ctx컨텍스트 객체에 웹소켓 프로토콜; 귀환 boolean 값 (진짜) 전환이 성공하면, 그리고 boolean 값 (거짓) 실패하면.read이 방법은 일반적인 HTTP 프로토콜에서 지원되지 않습니다. 당신은 타임 아웃 매개 변수를 지정할 수 있습니다timeout_ms밀리 초에JSON.stringify()JSON 객체를 문자열로 인코딩하고WebSocket프로토콜, 이 방법을 사용하여 암호화된 문자열을 클라이언트에 전달할 수 있습니다.{@fun/Global/HttpQuery HttpQuery}, {@fun/Global/HttpQuery_Go HttpQuery_Go}
지속적으로 데이터를 저장, 함수는 저장 할 수있는 글로벌 사전 함수를 구현합니다. 데이터 구조는 도커의 로컬 데이터베이스 파일에 영구적으로 저장되는 KV 테이블입니다.
계속 저장된 키 값 데이터k-v키-값 쌍
문자열, 숫자, bool, 객체, 배열, null 값
_G() _G(k) _G(k, v)
매개 변수k저장된 키-값 쌍의 키의 이름이고 대소문 감수성이 없습니다.
k
거짓
문자열, null 값
매개 변수v저장된 키-값 쌍의 키 값입니다.JSON시리즈화 된 것입니다.
v
거짓
문자열, 숫자, bool, 객체, 배열, null 값
function main(){
// Set a global variable num with a value of 1
_G("num", 1)
// Change a global variable num to the value of the string ok
_G("num", "ok")
// Delete the global variable num
_G("num", null)
// Returns the value of the global variable num
Log(_G("num"))
// Delete all global variables
_G(null)
// Return to live trading 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);
// Not support auto robotId = _G();
}
각 라이브 거래에 대한 별도의 데이터베이스,_G()함수는 항상 전략이 다시 시작되거나 도커가 실행을 중단하면있을 것입니다. 백테스팅이 완료되면 백테스팅 시스템에 저장된 데이터는_G()이 기능을 사용 하 여_G()저장된 데이터를 유지하기 위한 기능, 하드웨어 장치의 메모리 및 하드 디스크 공간에 따라 합리적으로 사용되어야 하며, 남용되어서는 안 됩니다.
전화할 때_G()라이브 거래에서 기능 및 어떤 매개 변수가 전달되지 않습니다,_G()함수는Id현재 라이브 거래._G()함수, 매개 변수v0으로 전달되면k-v키-값 쌍을 호출할 때_G()함수, 단지 매개 변수k문자열에 전달됩니다, 그리고_G()함수는 저장된 매개 변수에 대응하는 키 값을 반환k전화할 때_G()함수, 단지 매개 변수k0값으로 전달됩니다.k-v키-값 쌍이 삭제됩니다.k-v키값 쌍이 지속적으로 저장된 경우,_G()함수는 다시 호출되고 매개 변수로 지속적으로 저장된 키의 이름을 전달합니다.k. 새로운 키 값을 매개 변수로 전달v업데이트 할 것입니다.k-v키-값 쌍
{@fun/Global/DBExec DBExec}
밀리초 시간표 또는Date시간 문자열에 대한 객체입니다.
시간 줄. 문자열
_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():
# Running this code on a server in Beijing time: 2019-11-29 10:13:26 , a docker on another server in another region results in: 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 is timestamped in seconds.
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++다음 예제에서 보여준 바와 같이 언어
매개 변수를 전달하지 않고 현재 시간 문자열을 반환합니다._D()기능Python전략, 당신은 통과 매개 변수 두 번째 수준의 타임 스탬프 (자바스크립트와 C ++ 전략에서 밀리 초 수준 타임 스탬프, 1 초 1000 밀리 초에 해당하는) 이다._D()실시간 거래에서 읽을 수 있는 시간표가 있는 시간 문자열을 분석하기 위해, 당신은 도커 프로그램이 위치하는 운영 체제의 시간대와 시간 설정에 주의를 기울여야 합니다._D()함수는 도커
UNIX UNIX UNIX UNIX UNIX UNIX
부동 소수점 번호를 포맷하세요.
정밀 설정에 따라 포맷된 부동 소수점 번호 번호
_N() _N(num) _N (num, 정밀)
형식이 필요한 부동 소수점 번호
수
사실
번호
포맷의 정밀 설정, 매개 변수precision정수이고 매개 변수는precision기본값은 4입니다
정확성
거짓
번호
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)
// Check the logs and see that it is 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자리들을 0으로 바꾸면 이렇게 쓸 수 있습니다
매개 변수precision양 పూర్수는 될 수 있고, 음 పూర్수는 될 수 있습니다
{@fun/Trade/exchange.SetPrecision exchange.SetPrecision}
인터페이스 오류 용도 기능을 다시 시도합니다.
콜백 함수가 실행될 때 반환되는 값 모든 타입은 시스템에서 지원됩니다.논리적인 잘못된 값그리고null 값.
_C(pfn) _C ((pfn,...args)
매개 변수pfn함수 참조입니다.콜백 함수...
pfn
사실
기능
매개 변수콜백 함수, 한 개 이상의 매개 변수가 있을 수 있습니다.arg- 파라미터의 종류와 수arg그 매개 변수에 따라콜백 함수- 네
아그
거짓
문자열, 숫자, bool, 객체, 배열, 함수, 모든 유형은 null 값과 같이 시스템에서 지원됩니다.
function main(){
var ticker = _C(exchange.GetTicker)
// Adjust _C() function retry interval to 2 seconds
_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("Eligible!", "#FF0000")
return true
}
Log("Retry!", "#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("Eligible!", "#FF0000")
return True
Log("Retry!", "#FF0000")
return False
def main():
ret = _C(test, 1, 5)
Log(ret)
// C++ does not support fault tolerance for custom functions in this way
또한 사용자 정의 함수의 오류 허용에 사용할 수 있습니다:
이_C()function는 지정된 함수를 호출할 수 있습니다.pfn수익null또는거짓호출되면 다시 호출을 시도합니다.pfn예를 들어_C(exchange.GetTicker). 기본 재시험 간격은 3 초입니다, 당신은 호출 할 수 있습니다_CDelay()재시험 간격을 설정하는 기능입니다. 예를 들어,_CDelay(1000)재시험 간격을 변경하기 위한 수단_C()1초로 작동합니다.
결함 허용은 다음 기능에 적용될 수 있지만 제한되지 않습니다.
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()).배열의 교차점 수를 반환합니다.arr1그리고 배열arr2.
배열의 교차기점 수arr1그리고 배열arr2...
번호
_십자 (arr1,arr2)
요소는 타입의 배열입니다.number...
arr1
사실
배열
요소는 타입의 배열입니다.number...
arr2
사실
배열
// Fast line indicator
var arr1 = [1,2,3,4,5,6,8,8,9]
// Slow line indicator
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) 함수를 테스트 할 수 있습니다.
만약_Cross()이 함수 는 양수 이면 상향 진입 기간 을 나타내고, 이 함수 이 음수 이면 하향 진입 기간 을 나타내고, 0 은 현재 가격 과 동일 합니다. 사용 지침:내장 기능에 대한 분석 및 사용 지침 _ 크로스.
기능JSONParse()분석하는 데 사용됩니다.JSON strings.
JSON물체.
물체
JSONParse ((s)
JSON끈.
s
사실
문자열
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)); // The function is not supported.
auto s2 = "{\"num\":123}";
Log("json::parse:", json::parse(s2));
// Log("JSONParse:", JSONParse(s2)); // The function is not supported.
}
큰 값의 JSON 문자열을 올바르게 분석할 수 있고, 큰 값을 문자열 유형으로 분석할 것입니다.JSONParse()backtest 시스템에서 기능이 지원되지 않습니다.
출력 로그
로그 (...msgs)
매개 변수msg출력의 내용, 그리고 매개 변수msg한 개 이상 통과할 수 있습니다.
msg
거짓
문자열, 숫자, bool, 객체, 배열, 시스템에서 지원하는 모든 타입, 예를 들어 null
function main() {
Log("msg1", "msg2", "msg3")
}
def main():
Log("msg1", "msg2", "msg3")
void main() {
Log("msg1", "msg2", "msg3");
}
다수msg매개 변수를 전달할 수 있습니다:
function main() {
Log("Hello, FMZ Quant!@")
Sleep(1000 * 5)
// Add #ff0000 to the string to print the log in red and push the message
Log("Hello, #ff0000@")
}
def main():
Log("Hello, FMZ Quant!@")
Sleep(1000 * 5)
Log("Hello, #ff0000@")
void main() {
Log("Hello, FMZ Quant!@");
Sleep(1000 * 5);
Log("Hello, #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`");
}
이Log()기능 인쇄 지원base64코딩된 이미지,`그리고 끝나는`예를 들어:
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
Log(plt)
이Log()기능은 직접 인쇄를 지원합니다Python's 'matplotlib.pyplot객체. 객체가 포함 한 한savefig이 방법은 직접 인쇄 할 수 있습니다.Log기능, 예를 들어:
function main() {
Log("[trans]中文|abc[/trans]")
}
def main():
Log("[trans]中文|abc[/trans]")
void main() {
Log("[trans]中文|abc[/trans]");
}
이Log()언어 전환을 지원합니다.Log()함수는 플랫폼 페이지의 언어 설정에 따라 해당 언어로 자동으로 전환되는 텍스트를 출력합니다. 예를 들어:
이Log()이 함수는 라이브 거래 또는 백테스팅 시스템의 로그 영역에 로그 메시지를 출력하고 라이브 거래가 실행되는 경우 로그는 라이브 거래 데이터베이스에 저장됩니다.Log()이 함수에서 로그 메시지가 나오고@문자, 이 로그는 메시지 푸시 대기열에 입력합니다. 이메일 주소, 웹 WebHookGolang:
package main
import (
"fmt"
"net/http"
)
func Handle (w http.ResponseWriter, r *http.Request) {
defer func() {
fmt.Println("req:", *r)
}()
}
func main () {
fmt.Println("listen http://localhost:9090")
http.HandleFunc("/data", Handle)
http.ListenAndServe(":9090", nil)
}
세트WebHook안쪽설정 버튼: http://XXX.XX.XXX.XX:9090/data?data=Hello_FMZ...
작성된 것을 실행 한 후Golang서비스 프로그램, 우리는 라이브 거래 전략을 실행 시작, 다음은 전략입니다JavaScript언어, 전략은Log()기능과 메시지를 밀어:
function main() {
Log("msg", "@")
}
서비스 프로그램Golang언어는 푸시를 받고 서비스 프로그램은 메시지를 인쇄합니다:
listen http://localhost:9090
req: {GET /data?data=Hello_FMZ HTTP/1.1 1 1 map[User-Agent:[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/xx.x.xxxx.xxx Safari/537.36] Accept-Encoding:[gzip]] {} <nil> 0 [] false 1XX.XX.X.XX:9090 map[] map[] <nil> map[] XXX.XX.XXX.XX:4xxx2 /data?data=Hello_FMZ <nil> <nil> <nil> 0xc420056300
{@fun/Log/LogReset LogReset}, {@fun/Log/LogVacuum LogVacuum}
P&L 값을 기록하고 P&L 값을 인쇄하고 P&L 값을 기반으로 수익 곡선을 그리십시오.
로그이익 (이익) LogProfit (이익,...args)
매개 변수profit전략의 설계 알고리즘과 계산에 의해 주어지는 수익 데이터입니다.
이익
사실
번호
매출 로그에 부수적인 정보를 출력하는 확장된 매개 변수arg한 개 이상의 매개 변수를 전달할 수 있습니다.
아그
거짓
문자열, 숫자, bool, 객체, 배열, 시스템에서 지원하는 모든 타입, 예를 들어 null
function main() {
// Print 30 points on the earnings chart
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);
}
}
이LogProfitfunction, 만약 그 문자가 끝나면&예를 들어:
{@fun/Log/LogProfitReset 로그프로프트리셋}
모든 수입 기록, 수입 차트들을 삭제하세요.
로그프로프트리셋 (Reset) LogProfitReset (재장)
이remain매개 변수는 보관해야 할 로그 항목 (전수 값) 의 수를 지정하는 데 사용됩니다.
남아있어요
거짓
번호
function main() {
// Print 30 points on the revenue chart, then reset and keep only the last 10 points
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 로그프로프트}
백테스팅 시스템 또는 라이브 거래 페이지의 상태 표시줄에서 출력 정보.
로그Status(...msgs)
매개 변수msg출력의 내용, 그리고 매개 변수msg한 개 이상 통과할 수 있습니다.
msg
거짓
문자열, 숫자, bool, 객체, 배열, 시스템에서 지원하는 모든 타입, 예를 들어 null
function main() {
LogStatus('This is a general status alert')
LogStatus('This is a status alert in red font #ff0000')
LogStatus('This is a multi-line status message \n I am the second line')
}
def main():
LogStatus('This is a general status alert')
LogStatus('This is a status alert in red font #ff0000')
LogStatus('This is a multi-line status message \n I am the second line')
void main() {
LogStatus("This is a general status alert");
LogStatus("This is a status alert in red font #ff0000");
LogStatus("This is a multi-line status message \n I am the second line");
}
그것은 출력 콘텐츠의 색상을 설정하는 것을 지원합니다:
function main() {
var table = {type: 'table', title: 'Position information', cols: ['Column 1', 'Column 2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
// JSON serialization with the ` character on both sides, as a complex message format (support tables currently)
LogStatus('`' + JSON.stringify(table) + '`')
// Table information can also appear in multiple rows
LogStatus('First line of message\n`' + JSON.stringify(table) + '`\n third line of message')
// It supports multiple tables at the same time, will be displayed in a group with TAB
LogStatus('`' + JSON.stringify([table, table]) + '`')
// You can also construct a button in the form, and use the GetCommand strategy to receive the contents of the cmd attribute
var table = {
type: 'table',
title: 'Position operations',
cols: ['Column 1', 'Column 2', 'Action'],
rows: [
['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': 'Close out positions'}]
]
}
LogStatus('`' + JSON.stringify(table) + '`')
// Or construct a separate button
LogStatus('`' + JSON.stringify({'type':'button', 'cmd': 'coverAll', 'name': 'Close out positions'}) + '`')
// Customizable button style (bootstrap's button attribute)
LogStatus('`' + JSON.stringify({'type':'button', 'class': 'btn btn-xs btn-danger', 'cmd': 'coverAll', 'name': 'Close out positions'}) + '`')
}
import json
def main():
table = {"type": "table", "title": "Position information", "cols": ["Column 1", "Column 2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]}
LogStatus('`' + json.dumps(table) + '`')
LogStatus('First line of message\n`' + json.dumps(table) + '`\n third line of message')
LogStatus('`' + json.dumps([table, table]) + '`')
table = {
"type" : "table",
"title" : "Position operations",
"cols" : ["Column 1", "Column 2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "Close out positions"}]
]
}
LogStatus('`' + json.dumps(table) + '`')
LogStatus('`' + json.dumps({"type": "button", "cmd": "coverAll", "name": "Close out positions"}) + '`')
LogStatus('`' + json.dumps({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "Close out positions"}) + '`')
void main() {
json table = R"({"type": "table", "title": "Position information", "cols": ["Column 1", "Column 2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
LogStatus("`" + table.dump() + "`");
LogStatus("First line of message\n`" + table.dump() + "`\n third line of message");
json arr = R"([])"_json;
arr.push_back(table);
arr.push_back(table);
LogStatus("`" + arr.dump() + "`");
table = R"({
"type" : "table",
"title" : "Position operations",
"cols" : ["Column 1", "Column 2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "Close out positions"}]
]
})"_json;
LogStatus("`" + table.dump() + "`");
LogStatus("`" + R"({"type": "button", "cmd": "coverAll", "name": "Close out positions"})"_json.dump() + "`");
LogStatus("`" + R"({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "Close out positions"})"_json.dump() + "`");
}
상태 표시줄의 데이터 출력 예제:
function main() {
var table = {
type: "table",
title: "status bar button style",
cols: ["default", "original", "success", "info", "warning", "danger"],
rows: [
[
{"type":"button", "class": "btn btn-xs btn-default", "name": "default"},
{"type":"button", "class": "btn btn-xs btn-primary", "name": "original"},
{"type":"button", "class": "btn btn-xs btn-success", "name": "success"},
{"type":"button", "class": "btn btn-xs btn-info", "name": "info"},
{"type":"button", "class": "btn btn-xs btn-warning", "name": "warning"},
{"type":"button", "class": "btn btn-xs btn-danger", "name": "danger"}
]
]
}
LogStatus("`" + JSON.stringify(table) + "`")
}
import json
def main():
table = {
"type": "table",
"title": "status bar button style",
"cols": ["default", "original", "success", "info", "warning", "danger"],
"rows": [
[
{"type":"button", "class": "btn btn-xs btn-default", "name": "default"},
{"type":"button", "class": "btn btn-xs btn-primary", "name": "original"},
{"type":"button", "class": "btn btn-xs btn-success", "name": "success"},
{"type":"button", "class": "btn btn-xs btn-info", "name": "info"},
{"type":"button", "class": "btn btn-xs btn-warning", "name": "warning"},
{"type":"button", "class": "btn btn-xs btn-danger", "name": "danger"}
]
]
}
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type": "table",
"title": "status bar button style",
"cols": ["default", "original", "success", "info", "warning", "danger"],
"rows": [
[
{"type":"button", "class": "btn btn-xs btn-default", "name": "default"},
{"type":"button", "class": "btn btn-xs btn-primary", "name": "original"},
{"type":"button", "class": "btn btn-xs btn-success", "name": "success"},
{"type":"button", "class": "btn btn-xs btn-info", "name": "info"},
{"type":"button", "class": "btn btn-xs btn-warning", "name": "warning"},
{"type":"button", "class": "btn btn-xs btn-danger", "name": "danger"}
]
]
})"_json;
LogStatus("`" + table.dump() + "`");
}
상태 표시줄 (옛 버튼 구조) 에서 버튼 컨트롤을 설계할 수 있도록 지원합니다:
function main() {
var table = {
type: "table",
title: "Status bar button disable, description function test",
cols: ["Column 1", "Column 2", "Column 3"],
rows: []
}
var button1 = {"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button"}
var button2 = {"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button, set to disabled", "disabled": true}
var button3 = {"type": "button", "name": "button3", "cmd": "button3", "description": "This is the third button, set to enable", "disabled": false}
table.rows.push([button1, button2, button3])
LogStatus("`" + JSON.stringify(table) + "`")
}
import json
def main():
table = {
"type": "table",
"title": "Status bar button disable, description function test",
"cols": ["Column 1", "Column 2", "Column 3"],
"rows": []
}
button1 = {"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button"}
button2 = {"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button, set to disabled", "disabled": True}
button3 = {"type": "button", "name": "button3", "cmd": "button3", "description": "This is the third button, set to enable", "disabled": False}
table["rows"].append([button1, button2, button3])
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type": "table",
"title": "Status bar button disable, description function test",
"cols": ["Column 1", "Column 2", "Column 3"],
"rows": []
})"_json;
json button1 = R"({"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button"})"_json;
json button2 = R"({"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button, set to disabled", "disabled": true})"_json;
json button3 = R"({"type": "button", "name": "button3", "cmd": "button3", "description": "This is the third button, set to enable", "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("Calling custom functions")
}
function main() {
while (true) {
var table = {
type: 'table',
title: 'operation',
cols: ['column1', 'column2', 'Action'],
rows: [
['a', '1', {
'type': 'button',
'cmd': "CoverAll",
'name': 'Close out positions'
}],
['b', '1', {
'type': 'button',
'cmd': 10,
'name': 'Send values'
}],
['c', '1', {
'type': 'button',
'cmd': _D(),
'name': 'Calling functions'
}],
['d', '1', {
'type': 'button',
'cmd': 'test1',
'name': 'Calling custom functions'
}]
]
}
LogStatus(_D(), "\n", '`' + JSON.stringify(table) + '`')
var str_cmd = GetCommand()
if (str_cmd) {
Log("Received interaction data str_cmd:", "type:", typeof(str_cmd), "value:", str_cmd)
if(str_cmd == "test1") {
test1()
}
}
Sleep(500)
}
}
import json
def test1():
Log("Calling custom functions")
def main():
while True:
table = {
"type": "table",
"title": "operation",
"cols": ["column1", "column2", "Action"],
"rows": [
["a", "1", {
"type": "button",
"cmd": "CoverAll",
"name": "Close out positions"
}],
["b", "1", {
"type": "button",
"cmd": 10,
"name": "Send values"
}],
["c", "1", {
"type": "button",
"cmd": _D(),
"name": "Calling functions"
}],
["d", "1", {
"type": "button",
"cmd": "test1",
"name": "Calling custom functions"
}]
]
}
LogStatus(_D(), "\n", "`" + json.dumps(table) + "`")
str_cmd = GetCommand()
if str_cmd:
Log("Received interaction data str_cmd:", "type:", typeof(str_cmd), "value:", str_cmd)
if str_cmd == "test1":
test1()
Sleep(500)
void test1() {
Log("Calling custom functions");
}
void main() {
while(true) {
json table = R"({
"type": "table",
"title": "operation",
"cols": ["column1", "column2", "Action"],
"rows": [
["a", "1", {
"type": "button",
"cmd": "CoverAll",
"name": "Close out positions"
}],
["b", "1", {
"type": "button",
"cmd": 10,
"name": "Send values"
}],
["c", "1", {
"type": "button",
"cmd": "",
"name": "Calling functions"
}],
["d", "1", {
"type": "button",
"cmd": "test1",
"name": "Calling custom functions"
}]
]
})"_json;
table["rows"][2][2]["cmd"] = _D();
LogStatus(_D(), "\n", "`" + table.dump() + "`");
auto str_cmd = GetCommand();
if(str_cmd != "") {
Log("Received interaction data str_cmd:", "type:", typeof(str_cmd), "value:", str_cmd);
if(str_cmd == "test1") {
test1();
}
}
Sleep(500);
}
}
이 연구와 함께GetCommand()함수, 상태 표시줄 버튼 상호 작용 함수를 구성 (옛 버튼 구조):
function main() {
var tbl = {
type: "table",
title: "operation",
cols: ["column1", "column2"],
rows: [
["Open position operation", {"type": "button", "cmd": "open", "name": "open position", "input": {"name": "number of open positions", "type": "number", "defValue": 1}}],
["Close position operation", {"type": "button", "cmd": "coverAll", "name": "close all positions"}]
]
}
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": "operation",
"cols": ["column1", "column2"],
"rows": [
["Open position operation", {"type": "button", "cmd": "open", "name": "open position", "input": {"name": "number of open positions", "type": "number", "defValue": 1}}],
["Close position operation", {"type": "button", "cmd": "coverAll", "name": "close all positions"}]
]
}
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": "operation",
"cols": ["column1", "column2"],
"rows": [
["Open position operation", {"type": "button", "cmd": "open", "name": "open position", "input": {"name": "number of open positions", "type": "number", "defValue": 1}}],
["Close position operation", {"type": "button", "cmd": "coverAll", "name": "close all positions"}]
]
})"_json;
LogStatus(_D(), "\n", "`" + tbl.dump() + "`");
while(true) {
auto cmd = GetCommand();
if(cmd != "") {
Log("cmd:", cmd);
}
Sleep(1000);
}
}
입력 데이터는 또한 상호 작용을 위해 상태 표시줄 버튼을 구성 할 때 지원되며 상호 작용 명령어는GetCommand()함수를 추가합니다.input아이템 (옛 버튼 구조) 는 상태 표시줄에 있는 버튼 컨트롤의 데이터 구조, 예를 들어 추가"input": {"name": "number of open positions", "type": "number", "defValue": 1}에{"type": "button", "cmd": "open", "name": "open position"}버튼을 누르면 입력 상자 컨트롤이 있는 팝업 상자가 나타날 것입니다. (입기 상자의 기본 값은 1,defValue). 버튼 명령어와 함께 전송될 데이터를 입력할 수 있습니다. 예를 들어, 다음 테스트 코드가 실행되면, "open positionGetCommand()이 함수는 다음 메시지를 캡처합니다:open:111.
function main() {
var tbl = {
type: "table",
title: "Demonstrate grouping button control",
cols: ["operation"],
rows: []
}
// Creating a grouping button control structure
var groupBtn = {
type: "button",
cmd: "open",
name: "open positions",
group: [
{"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "market order|pending order"},
{"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
{"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
{"name": "boolean", "description": "yes/no|boolean", "type": "boolean", "defValue": true}
]
}
// test button 1
var testBtn1 = {"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button."}
var testBtn2 = {"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button.", "input": {"name": "number of positions opened", "type": "number", "defValue": 1}}
// Add groupBtn to tbl
tbl.rows.push([groupBtn])
// It supports multiple buttons in a cell of a status bar table, i.e. the data in a cell is an array of button structures: [testBtn1, testBtn2].
tbl.rows.push([[testBtn1, testBtn2]])
while (true) {
LogStatus("`" + JSON.stringify(tbl) + "`", "\n", "The grouping button control can also be set directly on the status bar in addition to being set on the status bar form:", "`" + JSON.stringify(groupBtn) + "`")
var cmd = GetCommand()
if (cmd) {
Log("cmd:", cmd)
}
Sleep(5000)
}
}
import json
def main():
tbl = {
"type": "table",
"title": "Demonstrate grouping button control",
"cols": ["operation"],
"rows": []
}
groupBtn = {
"type": "button",
"cmd": "open",
"name": "open positions",
"group": [
{"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "market order|pending order"},
{"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
{"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
{"name": "boolean", "description": "yes/no|boolean", "type": "boolean", "defValue": True}
]
}
testBtn1 = {"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button."}
testBtn2 = {"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button.", "input": {"name": "number of positions opened", "type": "number", "defValue": 1}}
tbl["rows"].append([groupBtn])
tbl["rows"].append([[testBtn1, testBtn2]])
while True:
LogStatus("`" + json.dumps(tbl) + "`", "\n", "The grouping button control can also be set directly on the status bar in addition to being set on the status bar form:", "`" + json.dumps(groupBtn) + "`")
cmd = GetCommand()
if cmd:
Log("cmd:", cmd)
Sleep(5000)
void main() {
json tbl = R"({
"type": "table",
"title": "Demonstrate grouping button control",
"cols": ["operation"],
"rows": []
})"_json;
json groupBtn = R"({
"type": "button",
"name": "open positions",
"cmd": "open",
"group": [
{"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "market order|pending order"},
{"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
{"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
{"name": "boolean", "description": "yes/no|boolean", "type": "boolean", "defValue": true}
]})"_json;
json testBtn1 = R"({"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button."})"_json;
json testBtn2 = R"({"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button.", "input": {"name": "number of positions opened", "type": "number", "defValue": 1}})"_json;
tbl["rows"].push_back({groupBtn});
tbl["rows"].push_back({{testBtn1, testBtn2}});
while(true) {
LogStatus("`" + tbl.dump() + "`", "\n", "The grouping button control can also be set directly on the status bar in addition to being set on the status bar form:", "`" + groupBtn.dump() + "`");
auto cmd = GetCommand();
if(cmd != "") {
Log("cmd:", cmd);
}
Sleep(5000);
}
}
그것은 그룹 버튼 제어 (옛 버튼 구조) 를 지원 합니다.데이터 입력 지원 상태 표시줄 버튼(GetCommand()그 차이점은"group"필드 설정, 버튼을 클릭하면 상호 작용을 유발, 페이지에 팝업 대화 상자는그룹데이터 그룹을 한 번에 입력하도록 설정된 입력 컨트롤.
몇 가지 주목해야 할 사항"group"상태 표시줄 버튼 컨트롤과 그룹 버튼 컨트롤의 구조의 필드:
type그룹에 속성 다음 네 가지 유형만 지원하고,defValueproperty는 기본값입니다.
|각 옵션을 설정된 대로 드롭다운 박스에서 분리하는 기호입니다.
"name": "tradePrice@orderType==1"설정, 그것은거래 가격입력 제어순서 타입드롭다운 컨트롤은미결 명령.|중국어와 영어로 된 설명의 내용을 구분하는 기호.name, description그룹 및name, description버튼 구조에서 같은 필드 이름을 가지고 있지만 같은 정의를 가지고 있지 않습니다.
정의name또한 그룹에 대한 정의와 다릅니다name입력으로Log("cmd:", cmd)다음 시험 예시에서 표기:cmd: open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}, 즉,GetCommand()상호작용이 발생했을 때 기능:open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}.type버튼 컨트롤의 속성은 오직:"button"- 네
입력 데이터를 지원하는 버튼 제어 장치, 즉input속성 집합,type구성 정보의 속성input이 필드는 여러 컨트롤 타입을 지원합니다.
다음 예 를 참조 하십시오.function main() {
// Status bar button control (set input field to implement) testBtn1 button triggered by the page in the drop-down box control using the options field to set options, using the defValue field to set the default options. This is different from the other examples in this chapter, which use defValue to set the options directly.
var testBtn1 = {
type: "button",
name: "testBtn1",
cmd: "cmdTestBtn1",
input: {name: "testBtn1ComboBox", type: "selected", options: ["A", "B"], defValue: 1}
}
/*
Status bar button control (set input field implementation) testBtn2 button triggered by the page in the drop-down box control using the options field to set the options, options field in the options field not only supports the string,
the use of the ```{text: "description", value: "value"}``` structure is also supported. Use the defValue field to set the default option, which can be multiple choice (multiple choice via array structure). Multiple choice requires setting the additional field multiple to a true value.
*/
var testBtn2 = {
type: "button",
name: "testBtn2",
cmd: "cmdTestBtn2",
input: {
name: "testBtn2MultiComboBox",
type: "selected",
description: "Implementing dropdown box multi-selection",
options: [{text: "Option A", value: "A"}, {text: "Option B", value: "B"}, {text: "Option C", value: "C"}],
defValue: ["A", "C"],
multiple: true
}
}
// Status bar grouping button control (set group field implementation) testBtn3 button triggered by the page in the drop-down box control using the options field to set options, also supports the direct use of defValue set options.
var testBtn3 = {
type: "button",
name: "testBtn3",
cmd: "cmdTestBtn3",
group: [
{name: "comboBox1", label: "labelComboBox1", description: "Dropdown box 1", type: "selected", defValue: 1, options: ["A", "B"]},
{name: "comboBox2", label: "labelComboBox2", description: "Dropdown box 2", type: "selected", defValue: "A|B"},
{name: "comboBox3", label: "labelComboBox3", description: "Dropdown box 3", type: "selected", defValue: [0, 2], multiple: true, options: ["A", "B", "C"]},
{
name: "comboBox4",
label: "labelComboBox4",
description: "Dropdown box 4",
type: "selected",
defValue: ["A", "C"],
multiple: true,
options: [{text: "Option A", value: "A"}, {text: "Option B", value: "B"}, {text: "Option C", value: "C"}, {text: "Option 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": "Implementing dropdown box multi-selection",
"options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}],
"defValue": ["A", "C"],
"multiple": True
}
}
testBtn3 = {
"type": "button",
"name": "testBtn3",
"cmd": "cmdTestBtn3",
"group": [
{"name": "comboBox1", "label": "labelComboBox1", "description": "Dropdown box 1", "type": "selected", "defValue": 1, "options": ["A", "B"]},
{"name": "comboBox2", "label": "labelComboBox2", "description": "Dropdown box 2", "type": "selected", "defValue": "A|B"},
{"name": "comboBox3", "label": "labelComboBox3", "description": "Dropdown box 3", "type": "selected", "defValue": [0, 2], "multiple": True, "options": ["A", "B", "C"]},
{
"name": "comboBox4",
"label": "labelComboBox4",
"description": "Dropdown box 4",
"type": "selected",
"defValue": ["A", "C"],
"multiple": True,
"options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}, {"text": "Option 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": "Implementing dropdown box multi-selection",
"options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}],
"defValue": ["A", "C"],
"multiple": true
}
})"_json;
json testBtn3 = R"({
"type": "button",
"name": "testBtn3",
"cmd": "cmdTestBtn3",
"group": [
{"name": "comboBox1", "label": "labelComboBox1", "description": "Dropdown box 1", "type": "selected", "defValue": 1, "options": ["A", "B"]},
{"name": "comboBox2", "label": "labelComboBox2", "description": "Dropdown box 2", "type": "selected", "defValue": "A|B"},
{"name": "comboBox3", "label": "labelComboBox3", "description": "Dropdown box 3", "type": "selected", "defValue": [0, 2], "multiple": true, "options": ["A", "B", "C"]},
{
"name": "comboBox4",
"label": "labelComboBox4",
"description": "Dropdown box 4",
"type": "selected",
"defValue": ["A", "C"],
"multiple": true,
"options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}, {"text": "Option 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": "Open a position and place an order",
"group": [{
"type": "selected",
"name": "tradeType",
"label": "Order type",
"description": "Market order, limit order",
"default": 0,
"group": "Trading setup",
"settings": {
"options": ["Market order", "Limit order"],
"required": true,
}
}, {
"type": "selected",
"name": "direction",
"label": "Trading direction",
"description": "Buy, sell",
"default": "buy",
"group": "Trading setup",
"settings": {
"render": "segment",
"required": true,
"options": [{"name": "buy", "value": "buy"}, {"name": "sell", "value": "sell"}],
}
}, {
"type": "number",
"name": "price",
"label": "price",
"description": "The price of the order",
"group": "Trading setup",
"filter": "tradeType==1",
"settings": {
"required": true,
}
}, {
"type": "number",
"name": "amount",
"label": "Order quantity",
"description": "Order quantity",
"group": "Trading setup",
"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": "Trading instruments", "default": m["symbol"], "settings": {"required": true}}])
tbl["rows"].push([m["symbol"], btnOpen])
})
var cmd = GetCommand()
if (cmd) {
Log("Receive interaction:", cmd)
// Parsing interaction messages: open:{"symbol":"LTC_USDT.swap","tradeType":0,"direction":"buy","amount":111}
// According to the first colon: the previous instruction determines which button template triggers the message
var arrCmd = cmd.split(":", 2)
if (arrCmd[0] == "open") {
var msg = JSON.parse(cmd.slice(5))
Log("Trading instruments:", msg["symbol"], ", Trading direction:", msg["direction"], ", Order type:", msg["tradeType"] == 0 ? "Market order" : "Limit order", msg["tradeType"] == 0 ? ", Order price: current market price" : ", Order price:" + msg["price"], ", Order quantity:", 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": "Open a position and place an order",
"group": [{
"type": "selected",
"name": "tradeType",
"label": "Order type",
"description": "Market order, limit order",
"default": 0,
"group": "Trading setup",
"settings": {
"options": ["Market order", "Limit order"],
"required": True,
}
}, {
"type": "selected",
"name": "direction",
"label": "Trading direction",
"description": "Buy, sell",
"default": "buy",
"group": "Trading Setup",
"settings": {
"render": "segment",
"required": True,
"options": [{"name": "买入", "value": "buy"}, {"name": "卖出", "value": "sell"}],
}
}, {
"type": "number",
"name": "price",
"label": "price",
"description": "The price of the order",
"group": "Trading Setup",
"filter": "tradeType==1",
"settings": {
"required": True,
}
}, {
"type": "number",
"name": "amount",
"label": "Order quantity",
"description": "Order quantity",
"group": "Trading Setup",
"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("Receive interaction:", cmd)
# Parsing interaction messages: open:{"symbol":"LTC_USDT.swap","tradeType":0,"direction":"buy","amount":111}
# According to the first colon: the previous instruction determines which button template triggers the message
arrCmd = cmd.split(":")
if arrCmd[0] == "open":
msg = json.loads(cmd[5:])
Log("Trading instruments:", msg["symbol"], ", Trading direction:", msg["direction"], ", Order type:", "Market order" if msg["tradeType"] == 0 else "Limit order", ", Order price: current market price" if msg["tradeType"] == 0 else ", Order price:" + str(msg["price"]), ", Order quantity:", msg["amount"])
# Output status bar information
LogStatus(_D(), "\n", "`" + json.dumps(tbl) + "`")
Sleep(1000)
// Omit...
최신 버튼 구조를 사용하여 상태 표시줄 테이블의 버튼을 구성합니다. 상호 작용을 시작하려면 버튼을 클릭하면 멀티 컨트롤 팝업 창이 팝업됩니다. 더 자세한 내용은 다음을 참조하십시오:사용자 가이드 - 상태 표시줄의 인터랙티브 컨트롤.
function main() {
var table = {
type: 'table',
title: 'position operation',
cols: ['column1', 'column2', 'Action'],
rows: [
['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': 'close positions'}]
]
}
var ticker = exchange.GetTicker()
// Add a row of data, merge the first and second cells, and output the ticker variable in the merged cell
table.rows.push([{body : JSON.stringify(ticker), colspan : 2}, "abc"])
LogStatus('`' + JSON.stringify(table) + '`')
}
import json
def main():
table = {
"type" : "table",
"title" : "position operation",
"cols" : ["column1", "column2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "close positions"}]
]
}
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" : "position operation",
"cols" : ["column1", "column2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "close positions"}]
]
})"_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: 'table demo',
cols: ['columnA', 'columnB', 'columnC'],
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 is merged by the first cell in the previous row
table.rows.push(["B4", "C4"])
// A2 is merged by the first cell of the previous row
table.rows.push(["B5", "C5"])
table.rows.push(["A6", "B6", "C6"])
LogStatus('`' + JSON.stringify(table) + '`')
}
import json
def main():
table = {
"type" : "table",
"title" : "table demo",
"cols" : ["columnA", "columnB", "columnC"],
"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" : "table demo",
"cols" : ["columnA", "columnB", "columnC"],
"rows" : [
["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
]
})"_json;
// For testing purposes, the code is short and easy to read, and the constructed data is used here
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: ['column1', 'column2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
var table2 = {type: 'table', title: 'table2', cols: ['column1', 'column2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
LogStatus('`' + JSON.stringify([table1, table2]) + '`')
}
import json
def main():
table1 = {"type": "table", "title": "table1", "cols": ["column1", "column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
table2 = {"type": "table", "title": "table2", "cols": ["column1", "column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
LogStatus("`" + json.dumps([table1, table2]) + "`")
void main() {
json table1 = R"({"type": "table", "title": "table1", "cols": ["column1", "column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
json table2 = R"({"type": "table", "title": "table2", "cols": ["column1", "column2"], "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 : "table1",
cols : ["1", "2"],
rows : []
}
var tab2 = {
type : "table",
title : "table2",
cols : ["1", "2", "3"],
rows : []
}
var tab3 = {
type : "table",
title : "table3",
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": "table1",
"cols": ["1", "2"],
"rows": []
}
tab2 = {
"type": "table",
"title": "table2",
"cols": ["1", "2", "3"],
"rows": []
}
tab3 = {
"type": "table",
"title": "table3",
"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": "table1",
"cols": ["1", "2"],
"rows": []
})"_json;
json tab2 = R"({
"type": "table",
"title": "table2",
"cols": ["1", "2", "3"],
"rows": []
})"_json;
json tab3 = R"({
"type": "table",
"title": "table3",
"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()기능 인쇄 지원base64코딩된 이미지,`그리고 끝나는`예를 들어:LogStatus("`data:image/png;base64,AAAA`")...
의LogStatus()기능이 통과를 지원합니다.matplotlib.pyplot물체를 직접Python, 객체가 포함되는 한savefig방법, 그것은 매개 변수로 전달 될 수 있습니다LogStatus()기능, 예를 들어:
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
LogStatus(plt)
전략이 라이브 트레이딩을 실행할 때, 당신이 라이브 트레이딩 페이지에서 역사를 통해 이동하면, 상태 표시줄은 잠자고 업데이트를 중지합니다. 상태 표시줄 데이터만 로그가 첫 페이지에있을 때 갱신됩니다. 그것은 출력 지원base64상태 표시줄에 암호화된 이미지를, 그리고 또한 출력 지원base64상태 표시줄에 표시되는 테이블에서 암호화된 이미지. 암호화된 이미지의 문자열 데이터가 일반적으로 매우 길기 때문에 샘플 코드는 표시되지 않습니다.
{@fun/Global/GetCommand GetCommand}
주문 정보 로깅을 켜거나 끄세요.
EnableLog (동원)
만약enable매개 변수가 false 값으로 설정되면, 예를 들어false, 주문 로그 (즉,exchange.Buy()) 는 인쇄되지 않으며 라이브 거래 데이터베이스에 기록되지 않습니다.
허용
사실
bool
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}
차트 그리기 기능을 사용자 정의합니다.
그래프 객체 물체
차트 (선택)
이options매개 변수는 차트 구성입니다.Chart()함수 매개 변수options이JSON연쇄화 가능HighStocks매개 변수Highcharts.StockChart추가로__isStock네이티브 매개 변수 위에 속성이 추가되고, 만약__isStock:false정해진 경우, 그것은 정상적인 차트로 표시됩니다.__isStock속성이 false 값으로 설정됩니다.false즉, 사용된 차트는Highcharts차트.__isStock속성은 true 값으로 설정됩니다. 예를 들어true즉, 사용된 차트는Highstocks차트 (디폴트)__isStock사실입니다. 예를 들어true) 를 문의하실 수 있습니다.하이스톡 차트 라이브러리...
옵션
사실
객체, 객체 배열
function main() {
var cfgA = {
extension: {
layout: 'single', // No grouping, display separately, default to group 'group'
height: 300, // Specify the height
},
title: {
text: 'handicap chart'
},
xAxis: {
type: 'datetime'
},
series: [{
name: 'buy one',
data: [],
}, {
name: 'sell one',
data: [],
}]
}
var cfgB = {
title: {
text: 'spread chart'
},
xAxis: {
type: 'datetime'
},
series: [{
name: 'spread',
type: 'column',
data: [],
}]
}
var cfgC = {
__isStock: false,
title: {
text: 'pie chart'
},
series: [{
type: 'pie',
name: 'one',
data: [
["A", 25],
["B", 25],
["C", 25],
["D", 25],
] // Instead of updating the initial data with the add function, the sequence can be updated by changing the chart configuration directly.
}]
};
var cfgD = {
extension: {
layout: 'single',
col: 8, // Specify the cell value for the width, the total value is 12
height: '300px',
},
title: {
text: 'handicap chart'
},
xAxis: {
type: 'datetime'
},
series: [{
name: 'buy one',
data: [],
}, {
name: 'sell one',
data: [],
}]
}
var cfgE = {
__isStock: false,
extension: {
layout: 'single',
col: 4,
height: '300px',
},
title: {
text: 'pie chart2'
},
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 a number of points to the pie chart, add can only update the data points added by add, built-in data points cannot be updated later.
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: 'buy one ' + ticker.Buy + ', sell one ' + ticker.Sell,
};
cfgB.subtitle = {
text: 'spread ' + diff,
};
chart.add([0, [new Date().getTime(), ticker.Buy]]);
chart.add([1, [new Date().getTime(), ticker.Sell]]);
// Equivalent to updating the first data series of the second chart
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 is actually the same as resetting the chart's configuration
chart.update([cfgA, cfgB, cfgC, cfgD, cfgE]);
}
}
import random
import time
def main():
cfgA = {
"extension" : {
"layout" : "single",
"height" : 300,
"col" : 8
},
"title" : {
"text" : "handicap chart"
},
"xAxis" : {
"type" : "datetime"
},
"series" : [{
"name" : "buy one",
"data" : []
}, {
"name" : "sell one",
"data" : []
}]
}
cfgB = {
"title" : {
"text" : "spread chart"
},
"xAxis" : {
"type" : "datetime",
},
"series" : [{
"name" : "spread",
"type" : "column",
"data" : []
}]
}
cfgC = {
"__isStock" : False,
"title" : {
"text" : "pie chart"
},
"series" : [{
"type" : "pie",
"name" : "one",
"data" : [
["A", 25],
["B", 25],
["C", 25],
["D", 25],
]
}]
}
cfgD = {
"extension" : {
"layout" : "single",
"col" : 8,
"height" : "300px"
},
"title" : {
"text" : "handicap chart"
},
"series" : [{
"name" : "buy one",
"data" : []
}, {
"name" : "sell one",
"data" : []
}]
}
cfgE = {
"__isStock" : False,
"extension" : {
"layout" : "single",
"col" : 4,
"height" : "300px"
},
"title" : {
"text" : "pie chart2"
},
"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" : "buy one" + str(ticker["Buy"]) + "sell one" + str(ticker["Sell"])
}
cfgB["subtitle"] = {
"text" : "spread " + 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" : "handicap chart"
},
"xAxis" : {
"type" : "datetime"
},
"series" : [{
"name" : "buy one",
"data" : []
}, {
"name" : "sell one",
"data" : []
}]
})"_json;
json cfgB = R"({
"title" : {
"text" : "spread chart"
},
"xAxis" : {
"type" : "datetime"
},
"series" : [{
"name" : "spread",
"type" : "column",
"data" : []
}]
})"_json;
json cfgC = R"({
"__isStock" : false,
"title" : {
"text" : "pie chart"
},
"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" : "handicap chart"
},
"series" : [{
"name" : "buy one",
"data" : []
}, {
"name" : "sell one",
"data" : []
}]
})"_json;
json cfgE = R"({
"__isStock" : false,
"extension" : {
"layout" : "single",
"col" : 4,
"height" : "300px"
},
"title" : {
"text" : "pie chart2"
},
"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("buy one %f , sell one %f", ticker.Buy, ticker.Sell);
cfgA["subtitle"] = cfgASubTitle;
json cfgBSubTitle = R"({"text" : ""})"_json;
cfgBSubTitle["text"] = format("spread %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개의 셀의 폭을 차지합니다.// This chart is an object in the JavaScript language, and before using the Chart function, we need to declare an object variable chart to configure the chart. var chart = {
// This field marks whether the chart is a general chart or not, if you are interested, you can change it to false and run it.
__isStock: true,
// Scaling tool
tooltip: {xDateFormat: '%Y-%m-%d %H:%M:%S, %A'},
// title
title : { text : 'spread analysis chart'},
// selection range
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
},
// Coordinate axis horizontal axis that is: x-axis, the current setting type is: time
xAxis: { type: 'datetime'},
// Coordinate axis vertical axis that is: y-axis, default value adjusted with the size of the data
yAxis : {
// title
title: {text: 'spread'},
// Whether to enable the right vertical axis
opposite: false
},
// Data series, this sttribute holds the individual data series (lines, K-charts, labels, etc...)
series : [
// The index is 0, and the data array holds the data of the index series
{name : "line1", id : "line1,buy1Price", data : []},
// Index is 1, set dashStyle:'shortdash' i.e.: set the dashed line
{name : "line2", id : "line2,lastPrice", dashStyle : 'shortdash', data : []}
]
} function main(){
// Call the Chart function to initialize the chart
var ObjChart = Chart(chart)
// Clear out
ObjChart.reset()
while(true){
// Gets the timestamp of this poll, i.e. a millisecond timestamp. It's used to determine the position of the X-axis written to the chart.
var nowTime = new Date().getTime()
// Get the ticker data
var ticker = _C(exchange.GetTicker)
// Get buy one price from the return value of the ticker data
var buy1Price = ticker.Buy
// To obtain the final transaction price, we add 1 in order not to overlap the 2 lines
var lastPrice = ticker.Last + 1
// Data sequence with timestamp as X-value and buy one price as Y-value passed into index 0
ObjChart.add(0, [nowTime, buy1Price])
// ditto
ObjChart.add(1, [nowTime, lastPrice])
Sleep(2000)
}
}```
```python
import time
chart = {
"__isStock" : True,
"tooltip" : {"xDateFormat" : "%Y-%m-%d %H:%M:%S, %A"},
"title" : {"text" : "spread analysis chart"},
"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": "spread"},
"opposite": False
},
"series": [{
"name": "line1", "id": "line1,buy1Price", "data": []
}, {
"name": "line2", "id": "line2,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() {
// When writing strategies in C++, try not to declare global variables that are not of the base type, so the chart configuration object is declared inside the main function.
json chart = R"({
"__isStock" : true,
"tooltip" : {"xDateFormat" : "%Y-%m-%d %H:%M:%S, %A"},
"title" : {"text" : "spread analysis chart"},
"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": "spread"},
"opposite": false
},
"series": [{
"name": "line1", "id": "line1,buy1Price", "data": []
}, {
"name": "line2", "id": "line2,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);
}
}
간단한 그림의 예:
// Objects used to initialize the chart
var chart = {
// Chart title
title: {text: "line value triggers the plotLines value"},
// Y-axis related settings
yAxis: {
// A horizontal line perpendicular to the Y-axis, used as a trigger line, is a structural array that can set multiple trigger lines
plotLines: [{
// The value of the trigger line, how much it set, this line will be displayed in the corresponding value position
value: 0,
// Set the color of the trigger line
color: 'red',
// Width
width: 2,
// Displaying labels
label: {
// Label text
text: 'Trigger value',
// Centered label position
align: 'center'
}
}]
},
// X-axis related settings, here the setting type is time axis
xAxis: {type: "datetime"},
series: [
{name: "sin", type: "spline", data: []},
// This is an important data series, you can set multiple data series, according to the array index control
{name: "cos", type: "spline", data: []}
]
}
function main(){
// Circumference
var pi = 3.1415926535897
// Variables for recording timestamps
var time = 0
// Angle
var angle = 0
// Coordinate y values for receiving sine and cosine values
var y = 0
// Call the API interface to initialize the chart with the chart object
var objChart = Chart(chart)
// Initially, clear the chart
objChart.reset()
// Set the value of the trigger line to 1
chart.yAxis.plotLines[0].value = 1
// Loop
while(true){
// Get the timestamp of the current moment
time = new Date().getTime()
// Angle increases by 5 degrees every 500ms and calculates the sine value
y = Math.sin(angle * 2 * pi / 360)
// Write the calculated y value to the data series of the corresponding index of the chart, the first parameter of the add function is the specified data series index
objChart.add(0, [time, y])
// Calculate the cosine value
y = Math.cos(angle * 2 * pi / 360)
objChart.add(1, [time, y])
// Increase by 5 degrees
angle += 5
// Pause for 5 seconds to avoid drawing too often and growing data too fast
Sleep(5000)
}
}
import math
import time
chart = {
"title": {"text": "line value triggers the plotLines value"},
"yAxis": {
"plotLines": [{
"value": 0,
"color": "red",
"width": 2,
"label": {
"text": "trigger value",
"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 value triggers the plotLines value"},
"yAxis": {
"plotLines": [{
"value": 0,
"color": "red",
"width": 2,
"label": {
"text": "trigger value",
"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)데이터를 업데이트한 후, 다음과 같이:
이Chart()함수는 4개의 메소드를 가진 차트 객체를 반환합니다.add(), reset(), update(), del().
update()방법:
의update()이 방법의 매개 변수는 Chart Configuration Object (JSON) 이다.del()방법:
의del()이 방법은 전달된 일련 매개 변수를 기반으로 지정된 인덱스의 데이터 시리즈를 삭제할 수 있습니다.add()방법:
의add()이 방법은 차트에 다음 매개 변수 순서로 데이터를 쓸 수 있습니다.series: 정수인 데이터 시리즈 인덱스를 설정하는 데 사용됩니다.data: 쓰기 위한 특정 데이터를 설정하는 데 사용됩니다.index(선택): 데이터 인덱스를 설정하는 데 사용됩니다. 그것은 정수입니다. 수정 된 데이터의 특정 인덱스 위치를 지정하고 부정적인 숫자를 지원합니다. 설정은-1데이터 세트의 마지막 데이터에 해당합니다.
예를 들어, 선을 그리면, 선의 마지막 점의 데이터를 수정합니다.chart.add(0, [1574993606000, 13.5], -1), 즉, 차트의 penultimate 첫 번째 점에 데이터를 변경series[0].data...
의index매개 변수가 설정되지 않았기 때문에 데이터가 현재 데이터 시리즈의 마지막 점에 추가됩니다.reset()방법:
의reset()이 방법은 차트 데이터를 비우는 데 사용됩니다.reset()메소드는 매개 변수를 취할 수 있습니다remain유지되는 항목의 수를 지정하기 위해remain모든 데이터를 삭제하기 위해 전달됩니다.{@fun/Log/KLineChart KLineChart}
이 함수는 전략 실행 시간에Pine language.
차트 객체.KLineChart()이 함수는 여러 메소드로 그래프 객체를 반환합니다.begin()그리고close()도출 작업은begin()함수 호출 및 a와 끝close()그리기 동작을 수행하기 위해 KLline 데이터를 통과할 때 함수 호출.
물체
KLineChart (선택)
이options매개 변수는 차트 구성입니다.
옵션
사실
객체, 객체 배열
function main() {
// Call the KLineChart function to create a chart control object c
let c = KLineChart({
overlay: true
})
// Use the Spot Exchange object test to get K-line data. If you use the futures exchange object test, you need to set up the contract first.
let bars = exchange.GetRecords()
if (!bars) {
return
}
// Execute the drawing operation by traversing over the K-line data. The drawing operation must start with the ```c.begin(bar)``` function call and end with the ```c.close()``` function call.
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():
# Call the KLineChart function to create a chart control object c
c = KLineChart({
"overlay": True
})
# Use the Spot Exchange object test to get K-line data. If you use the futures exchange object test, you need to set up the contract first.
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()
// Not supported for now
전략 사용자 지정 도면 영역에서 그리기 위해 차트 제어 객체가 필요한 경우,KLineChart()객체를 생성하는 함수입니다.KLineChart()함수는 차트 구성 구조이고, 참조 코드에서 사용되는 것은 간단합니다.{overlay: true}이 차트 구성 구조는 주요 차트에서 출력 될 그림 콘텐츠만 설정합니다.overlayfalse 값으로 설정됩니다.false, 차트의 콘텐츠는 2차 차트에 출력됩니다. 당신은 주요 차트에 그리기 그림을 함수를 지정해야 하는 경우, 당신은 또한 매개 변수를 지정할 수 있습니다overlay특정 함수 호출의 진정한 값으로, 예를 들어:true.
c.barcolor(bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(0, 0, 0, 0.2)') // Use the example illustrated in the reference code in this example, without further ado
c.barcolor('rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(0, 0, 0, 0.2)')
// Not supported for now
도면 인터페이스 기능Pine도영 작업에 지원되는 언어는:barcolor, K-라인 색을 설정합니다.
barcolor ((color, offset, 편집 가능, show_last, title, display) 표시 매개 변수는 선택 사항입니다:
아무도 , 모든
c.bgcolor('rgba(0, 255, 0, 0.5)')
c.bgcolor('rgba(0, 255, 0, 0.5)')
// Not supported for now
bgcolor, 지정된 색으로 K-라인의 배경을 채웁니다.
bgcolor ((color, offset, 편집가능, show_last, title, display, overlay) 표시 매개 변수는 선택 사항입니다:
아무도 , 모든
c.plot(bar.High, 'high')
c.plot(bar.Open < bar.Close ? NaN : bar.Close, "Close", {style: "linebr"}) // Support for drawing discontinuous data lines
h = c.plot(bar.High, 'high')
h = c.plot(None if bar.Open < bar.Close else bar.Close, "Close", style = "linebr") # Support for drawing discontinuous data lines
// Not supported for now
plot, 차트에 일련의 데이터를 그려줍니다.
plot ((series, title, color, linewidth, style, trackprice, histbase, offset, join, editable, show_last, display) 그라운드, 제목, 색상, 줄 너비, 스타일, 트랙 프라이스, 히스트베이스, 오프셋, 결합, 편집, 쇼_라스트, 디스플레이) 스타일 매개 변수는 선택 사항입니다:
stepline_diamond , stepline , cross , areabr , area , circles , columns , histogram , linebr , line 표시 매개 변수는 선택 사항입니다.
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)'})
// Not supported for now
fill, 두 개의 플롯 사이에 배경을 채우거나hline제공된 색상으로
Fill (프리플), HLine (프리플), HLine (프리플), Color (프리플), Title (프리플), Editable (프리플), Fill (프리플), Display (프리플) 표시 매개 변수는 선택 사항입니다:
아무도 , 모든
그 이후JavaScript언어는 함수의 이름을 기반으로 입력 매개 변수를 지정할 수 없습니다 공식 매개 변수를, 이 문제를 해결하기 위해,{key: value}특정 형식적 매개 변수 이름에 전달되는 매개 변수를 지정하는 구조.
예를 들어, 참조 코드는{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0, 0.2)'}정해집니다color매개 변수fill기능.
연속적인 형태 매개 변수 이름을 가진 여러 매개 변수를 지정해야 하는 경우,{key1: value1, key2: value2, key3: value3}...
예를 들어, 이 예에서, 추가title매개 변수가 지정되어 있습니다:{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0, 0.2)', title: 'fill'}...
색값은'rgba(255, 0, 0, 0, 0.2)'또는'#FF0000'.
c.hline(bar.High)
c.hline(bar.High)
// Not supported for now
hline, 수평선은 정해진 가격 수준에서 나타납니다.
hline ((가격, 제목, 색상, 라인 스타일, 라인 너비, 편집 가능, 표시) 라인 스타일 매개 변수는 선택적입니다:
dashed , dotted , solid 표시 매개 변수는 선택 사항입니다: 아무도 , 모든
c.plotarrow(bar.Close - bar.Open)
c.plotarrow(bar.Close - bar.Open)
// Not supported for now
plotarrow, 차트에 위아래 화살표를 그려
plotarrow ((시리즈, 제목, 컬러업, 컬러다운, 오프셋, 미인높이, 최대높이, 편집 가능, show_last, display) 표시 매개 변수는 선택 사항입니다:
아무도 , 모든
c.plotshape(bar.Low, {style: 'diamond'})
c.plotshape(bar.Low, style = 'diamond')
// Not supported for now
plotshape, 차트에 시각적인 모양을 그리십시오.
plotshape (시리즈, 제목, 스타일, 위치, 색상, 오프셋, 텍스트, 텍스트 색상, 편집, 크기, show_last, 표시) 스타일 매개 변수는 선택 사항입니다:
다이아몬드 size.auto크기가 작습니다. 표시 매개 변수는 선택 사항입니다:, 제곱 , 라벨_다운 , 라벨_업 , 화살_다운 , 화살_업 , 원 , 깃발 , 삼각형_다운 , 삼각형_업 , 십자 , x 십자 위치 매개 변수는 선택 사항입니다: 상단 , 아래단 , 상단 , 아래단 , 결정 크기 매개 변수는 선택 사항입니다: 10px , 14px , 20px , 40px , 80px , Pine 언어에서 size.tiny, size.small, size.normal, size.large, size.huge를 비교합니다. 아무도 , 모든
c.plotchar(bar.Close, {char: 'X'})
c.plotchar(bar.Close, char = 'X')
// Not supported for now
plotchar, 주어진 유니코드 문자를 사용하여 차트에 시각적인 모양을 그리십시오.
plotchar ((시리즈, 제목, char, 위치, 색상, 오프셋, 텍스트, 텍스트색, 편집, 크기, show_last, display) 위치 매개 변수는 선택 사항입니다:
상단 size.auto크기가 작습니다. 표시 매개 변수는 선택 사항입니다:, 아래단 , 상단 , 아래단 , 결정 크기 매개 변수는 선택 사항입니다: 10px , 14px , 20px , 40px , 80px , 사이즈.티니, 사이즈.스몰, 사이즈.노름, 사이즈.러그, 사이즈.거대 아무도 , 모든
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)
// Not supported for now
plotcandle, 차트에 K-라인 차트를 그려라.
plotcandle (열린, 높은, 낮은, 닫는, 제목, 색상, wickcolor, 편집, show_last, bordercolor, display) 표시 매개 변수는 선택 사항입니다:
아무도 , 모든
c.signal("long", bar.High, 1.5)
c.signal("long", bar.High, 1.5)
// Not supported for now
signal파이어 언어에서 사용할 수 없는 함수는 여기서 구매 및 판매 신호를 그리는데 사용됩니다.
신호 (방향, 가격, qty, id) 매개 변수
long 는 거래 방향을 표시하는 데 전달됩니다, 당신은 long , closelong , short , closeshort 를 선택할 수 있습니다. 매개 변수 bar.High마커 신호의 Y축 위치입니다. 전달된 매개 변수 1.5는 신호의 거래 수를 나타냅니다. 네 번째 매개 변수는 도출된 기본 텍스트 콘텐츠를 대체하기 위해 전달 될 수 있으며, 도출된 신호 마커의 기본 텍스트는 거래 방향입니다. 예를 들어closelong
c.reset()
c.reset()
// Not supported for now
reset, 파인 언어에서 사용할 수 없는 함수는 차트 데이터를 비어 사용된다.
재설정 (재정) 의
reset()방법은 하나의 매개 변수를 취할 수 있습니다.remain, 보관해야 하는 데이터의 수를 지정하기 위해.remain모든 데이터를 삭제하는 것을 의미합니다.
전략 사용자 정의 그림은 방법 중 하나를 사용할 수 있습니다KLineChart()기능 또는Chart()기능. 일부 색상 및 스타일 설정에 사용KLineChart()함수 호출, 참조하십시오KLineChart 함수를 사용하여 전략 그리기 디자인을 더 쉽게.
{@fun/Log/Chart Chart}
로그를 비워
로그 리셋 (재장)
이remain이 매개 변수는 보관해야 할 최근 로그 항목의 수를 설정하는 데 사용됩니다.
남아있어요
거짓
번호
function main() {
// Keep the last 10 logs and clear the rest
LogReset(10)
}
def main():
LogReset(10)
void main() {
LogReset(10);
}
전략 라이브 트레이딩의 각 시작에 대한 시작 로그는 하나로 간주되므로 매개 변수가 전달되지 않고 전략의 시작에 로그 출력이 없으면 로그가 전혀 표시되지 않으며 도커 로그가 반환되도록 기다립니다. (특례가 아닙니다.)
{@fun/Log Log}, {@fun/Log/LogVacuum LogVacuum}
소재의 저장 공간을 복구하는 데 사용됩니다.SQLite호출 후 데이터를 삭제할 때LogReset()로그를 청소하는 기능입니다.
로그바큐움
function main() {
LogReset()
LogVacuum()
}
def main():
LogReset()
LogVacuum()
void main() {
LogReset()
LogVacuum()
}
그 이유는SQLite데이터를 삭제할 때 점유된 공간을 되찾지 않고 실행해야 합니다.VACUUM이 함수를 호출할 때 파일 이동 동작이 발생하고, 지연이 크기 때문에 적절한 시간 간격으로 호출하는 것이 좋습니다.
{@fun/Log/LogReset 로그리셋}
그것은 라이브 거래 페이지에서 123456, 그console.log기능 출력 디버깅 라이브 거래 페이지에 정보를, 그리고 동시에, 확장자를 가진 로그 파일을 생성.log그리고 디버깅 정보를/logs/storage/123456/라이브 트레이딩이 속한 도커 디렉토리에서 파일 이름 앞자리로stdout_.
콘솔. 로그
매개 변수msg출력의 내용, 그리고 매개 변수msg한 개 이상 통과할 수 있습니다.
msg
거짓
문자열, 숫자, bool, object, array, null 및 시스템에서 지원하는 다른 타입
function main() {
console.log("test console.log")
}
# Not supported
// Not supported
JavaScript언어는 이 기능을 지원합니다.[object Object], 그래서 가능한 많은 가독 가능한 정보를 출력하려고 노력합니다.{@fun/Log/console.error 콘솔.error}
라이브 거래 페이지의 123456, 그console.error이 함수는 이 확장자를 가진 로그 파일을 생성합니다.log에/logs/storage/123456/라이브 거래가 속하는 도커의 디렉토리, 그리고 앞자리로 오류 출력을 기록stderr_.
콘솔 오류...msgs
매개 변수msg출력의 내용, 그리고 매개 변수msg한 개 이상 통과할 수 있습니다.
msg
거짓
문자열, 숫자, bool, object, array, null 및 시스템에서 지원하는 다른 타입
function main() {
console.error("test console.error")
}
# Not supported
// Not supported
JavaScript언어는 이 기능을 지원합니다.[object Object], 그래서 가능한 많은 가독 가능한 정보를 출력하려고 노력합니다.{@fun/Log/console.log 콘솔.log}
현재 설정된 거래 쌍, 계약 코드, 즉 티커 데이터에 해당하는 스팟 또는 계약의 {@struct/Ticker Ticker} 구조를 얻으십시오.GetTicker ()함수는 교환 객체 {@var/EXCHANGE exchange}의 멤버 함수입니다.exchange객체 구성원 함수 (방법) 는exchange이 문서에서는 반복되지 않을 것입니다.
이exchange.GetTicker()function는 데이터 요청이 성공할 때 {@struct/Ticker Ticker} 구조를 반환하고 데이터 요청이 실패할 때 null 값을 반환합니다.
{@struct/Ticker Ticker}, null 값
교환.GetTicker() 교환.GetTicker (기호)
매개 변수symbol요청된 {@struct/Ticker Ticker} 데이터에 대응하는 특정 거래 쌍 및 계약 코드를 지정하는 데 사용됩니다. 이 매개 변수가 전달되지 않으면 현재 설정된 거래 쌍 및 계약 코드의 시장 데이터가 기본적으로 요청됩니다.
전화할 때exchange.GetTicker(symbol)기능exchange즉석 교환 대상이 됩니다. USDT로 표기된 통화와 BTC로 거래되는 통화로 시장 데이터를 요청해야 하는 경우, 매개 변수symbol이 경우:"BTC_USDT", 그리고 형식은 FMZ 플랫폼에 의해 정의된 거래 쌍 형식입니다.
전화할 때exchange.GetTicker(symbol)기능exchange미래에셋 거래소 객체입니다. BTCsymbol이 경우:"BTC_USDT.swap", 그리고 형식은거래 쌍그리고계약 코드FMZ 플랫폼에 의해 정의되며, exchange.GetTicker(symbol)기능exchange만약 당신이 BTCsymbol이 경우:"BTC_USDT.BTC-240108-40000-C"(Binance 옵션 BTC-240108-40000-C를 예로 들면), 형식은거래 쌍FMZ 플랫폼에서 정의하고 거래소에서 정의한 특정 옵션 계약 코드,
기호 거짓 문자열
function main(){
// If it is a futures exchange object, set the contract code first, e.g. set it as a perpetual contract
// exchange.SetContractType("swap")
var ticker = exchange.GetTicker()
/*
The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
At this point, the ticker is null, and it will cause an error when accessing ticker.High, so when testing this code, make sure that the exchange interface can be accessed.
*/
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특정 기호에 대한 시장 데이터를 요청하는 매개 변수 (스팟 기호)
이Ticker이 자료는exchange.GetTicker()배후 테스트 시스템에서 기능.High그리고Low시뮬레이션 값, 판매 한 것에서 가져와 그 때 시장에서 하나를 구입합니다.Ticker이 자료는exchange.GetTicker()실제 시장에서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}
현재 설정된 거래 쌍, 계약 코드, 즉 주문록 데이터에 대응하는 스팟 또는 계약의 {@struct/Depth Depth} 구조를 얻으십시오.
이exchange.GetDepth()이 함수는 데이터 요청이 성공하면 {@struct/Depth Depth} 구조를 반환하고 데이터 요청이 실패하면 null을 반환합니다.
{@struct/Depth Depth}, null 값
교환.그트데프스 (GetDepth)) 교류.GetDepth (신호)
매개 변수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미래에셋 거래소 객체입니다. BTCsymbol이 경우:"BTC_USDT.BTC-240108-40000-C"(Binance 옵션 BTC-240108-40000-C를 예로 들면), 형식은거래 쌍FMZ 플랫폼에서 정의하고 거래소에서 정의한 특정 옵션 계약 코드,
기호
거짓
문자열
function main(){
var depth = exchange.GetDepth()
/*
The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
At this point, the depth is null, which will cause an error when accessing depth.Asks[1].Price, so make sure you can access the exchange interface when testing the code.
*/
var price = depth.Asks[1].Price
Log("Sell 2 price is:", price)
}
def main():
depth = exchange.GetDepth()
price = depth["Asks"][1]["Price"]
Log("Sell 2 price is:", price)
void main() {
auto depth = exchange.GetDepth();
auto price = depth.Asks[1].Price;
Log("Sell 2 price is:", price);
}
테스트exchange.GetDepth()기능:
function main() {
// BTC U-based perpetual contract
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()기능을 사용할 때틱을 시뮬레이션백테스팅 시스템에서는,exchange.GetDepth()기능을 사용할 때진짜 틱백테스팅은 두 번째 레벨의 심층 스냅샷입니다.
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.GetRecords exchange.GetRecords}
현재 설정된 거래 쌍, 계약 코드, 즉 시장 거래 데이터에 대응하는 스팟 또는 계약의 {@struct/Trade Trade} 구조 배열을 얻으십시오.
이exchange.GetTrades()함수는 데이터 요청이 성공하면 {@struct/Trade Trade} 구조의 배열을 반환하고 데이터 요청이 실패하면 null 값을 반환합니다.
{@struct/Trade Trade} 배열, null 값
거래소.GetTrades 교환.GetTrades (신호)
매개 변수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미래에셋 거래소 객체입니다. BTCsymbol이 경우:"BTC_USDT.BTC-240108-40000-C"(Binance 옵션 BTC-240108-40000-C를 예로 들면), 형식은거래 쌍FMZ 플랫폼에서 정의하고 거래소에서 정의한 특정 옵션 계약 코드,
기호
거짓
문자열
function main(){
var trades = exchange.GetTrades()
/*
The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
At this point, trade is null. When accessing trade[0].Id, it will cause an error. Therefore, when testing this code, ensure that you can access the exchange interface.
*/
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's U-based perpetual contract
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특정 기호 (미래 기호) 에 대한 시장 거래 기록 데이터를 요청하는 매개 변수
exchange.GetTrades()현재 거래 쌍, 시장의 거래 역사 (자신의 것이 아닌) 를 계약에 대응하는 기능을 얻기 위해. 일부 거래소는이 기능을 지원하지 않으며, 반환된 특정 데이터는 거래 기록의 범위가 거래소에 얼마나 의존하고 특정 상황에 따라 처리되어야하는지입니다. 반환 데이터는 배열입니다.exchange.GetRecords ()함수는 같은 순서의 데이터를 반환합니다. 즉, 배열의 마지막 요소는 현재 시간으로 가장 가까운 데이터입니다.
의exchange.GetTrades()함수는 사용 하 여 빈 배열을 반환틱을 시뮬레이션백테스팅 시스템에서 백테스팅.exchange.GetTrades()사용 시 기능진짜 틱백테스팅 시스템에서 백테스팅은 주문 흐름 스냅샷 데이터, 즉 {@struct/Trade Trade} 구조 배열입니다.
지원하지 않는 거래소exchange.GetTrades()기능:
| 함수 이름 | 지원되지 않는 스팟 교환 | 지원되지 않은 선물 거래 |
|---|---|---|
| GetTrades | – | 퓨처스_비트마트 / 퓨처스_비박스 |
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetRecords exchange.GetRecords}
현재 설정된 거래 쌍, 계약 코드, 즉 K-라인 데이터에 대응하는 스팟 또는 계약의 {@struct/Record Record} 구조 배열을 얻으십시오.
이exchange.GetRecords()function는 데이터 요청이 성공할 때 {@struct/Record Record} 구조의 배열을 반환하고, 데이터 요청이 실패할 때 null 값을 반환합니다.
{@struct/Record Record} 배열, null 값
교환.GetRecords() 교환.GetRecords (기호) exchange.GetRecords (표자, 점) exchange.GetRecords (기호, 지점, 제한) 교환.GetRecords (정기) 교환.GetRecords (기간, 제한)
매개 변수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미래에셋 거래소 객체입니다. BTCsymbol이 경우:"BTC_USDT.BTC-240108-40000-C"(Binance 옵션 BTC-240108-40000-C를 예로 들면), 형식은거래 쌍FMZ 플랫폼에서 정의하고 거래소에서 정의한 특정 옵션 계약 코드,
기호
거짓
문자열
매개 변수period요청된 K-라인 데이터의 기간을 지정합니다. 예를 들어: {@var/PERIOD/PERIOD_M1 PERIOD_M1}, {@var/PERIOD/PERIOD_M5 PERIOD_M5}, {@var/PERIOD/PERIOD_M15 PERIOD_M15} 등period정의된 표준 기간뿐만 아니라 정수 값도 초로 통과 할 수 있습니다. 이 매개 변수가 통과되지 않으면 기본적으로 요청되는 K-라인 데이터의 기간은 현재 전략 실시간 / 백테스트 구성의 기본 K-라인 기간입니다.
기간
거짓
번호
매개 변수limit요청된 K-라인 데이터의 길이를 지정하는 데 사용됩니다. 이 매개 변수가 전달되지 않으면 기본 요청 길이는 교환 K-라인 인터페이스의 한 시간에 요청되는 최대 K-라인 바 수입니다. 이 매개 변수는 교환 K-라인 데이터를 검색하는 페이징을 유발할 수 있으며 페이징 질의 중에 함수 호출의 시간 소모가 증가합니다.
한계
거짓
번호
function main() {
// Print K-line data with a K-line period of 120 seconds (2 minutes)
Log(exchange.GetRecords(60 * 2))
// Print K-line data with a K-line period of 5 minutes
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]);
}
맞춤형 기간에 대한 K-라인 데이터를 가져와
function main() {
var records = exchange.GetRecords(PERIOD_H1)
/*
The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
At this point, records is null. When accessing records[0].Time, it will cause an error. Therefore, when testing this code, ensure that you can access the exchange interface.
*/
Log("The first k-line data is Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High)
Log("The second k-line data is Time:", records[1].Time ,"Close:", records[1].Close)
Log("Current K-line (latest)", records[records.length-1], "Previous K-line", records[records.length-2])
}
def main():
records = exchange.GetRecords(PERIOD_H1)
Log("The first k-line data is Time:", records[0]["Time"], "Open:", records[0]["Open"], "High:", records[0]["High"])
Log("The second k-line data Time:", records[1]["Time"], "Close:", records[1]["Close"])
Log("Current K-line (latest)", records[-1], "Previous K-line", records[-2])
void main() {
auto records = exchange.GetRecords(PERIOD_H1);
Log("The first k-line data is Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High);
Log("The second k-line data Time:", records[1].Time, "Close:", records[1].Close);
Log("Current K-line (latest)", records[records.size() - 1], "Previous K-line", 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 바입니다. K-라인 데이터가 K-라인 바 축적 제한에 도달하면 K-라인 바를 추가하고 가장 오래된 K-라인 바를 삭제하여 업데이트됩니다. 일부 거래소는 K-라인 인터페이스를 제공하지 않으므로 도커는 시장 거래 기록 데이터를 수집합니다 (Trade구조화된 배열) 를 실시간으로 K선을 생성합니다.
만약 교환의 K-라인 인터페이스가 페이징 쿼리를 지원한다면, 여러 API 요청이exchange.SetMaxBarLen()더 큰 K-선 길이를 설정하는 함수입니다.
그 때exchange.GetRecords()함수는 초기 K-라인 데이터로 호출되면 얻은 K-라인 바의 수는 백테스팅과 실제 거래에 따라 다릅니다. - 백테스팅 시스템은 백테스팅 시간 범위가 시작되기 전에 일정 수의 K-라인 바를 미리 얻을 것입니다. (예정값은 5000, 백테스팅 시스템의 설정 및 데이터 양은 반환된 최종 숫자에 영향을 줄 것입니다.) - 실제 거래 중에 얻은 K-라인 바의 수는 거래소의 K-라인 인터페이스에서 얻을 수있는 최대 데이터 양에 기반합니다.
의period매개 변수가 5로 설정되면, 5초의 기간으로 K-라인 데이터를 얻기 위한 요청입니다.period매개 변수는 60으로 나눌 수 없습니다 (즉, 표시된 기간은 분으로 나눌 수 없습니다). 기본 시스템은exchange.GetTrades()거래 기록 데이터를 얻고 필요한 K-라인 데이터를 합성합니다.period이 매개 변수는 60으로 나눌 수 있습니다. 그러면 필요한 K-라인 데이터는 최소 1분 K-라인 데이터를 사용하여 합성됩니다. 가능하면 필요한 K-라인 데이터는 더 큰 기간을 사용하여 합성됩니다.
백테스팅 시스템에서 시뮬레이션 레벨 백테스팅은 기본 K-라인 기간을 설정해야 합니다 (백테스팅 시스템이 레벨 백테스팅을 시뮬레이션할 때, 대응하는 K-라인 데이터는 기본 K-라인 기간에 따라 Tick 데이터를 생성하는 데 사용됩니다). 전략에서 얻은 K-라인 데이터의 기간이 기본 K-라인 기간보다 작지 않아야 한다는 점에 유의해야 합니다. 시뮬레이션 레벨 백테스팅에서 백테스팅 시스템 내의 각 기간의 K-라인 데이터는 기본 K-라인 기간의 K-라인 데이터로부터 합성됩니다.
의C++이 언어는 다음과 같은 코드 예제를 가지고 있습니다.
#include <sstream>
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);
}
// Output display: Records[10]
Log(r);
auto ma = TA.MA(r,10);
// Output display: [nan,nan,nan,nan,nan,nan,nan,nan,nan,450]
Log(ma);
}
거래소를 지원하지 않는 거래소exchange.GetRecords()기능:
| 함수 이름 | 지원되지 않는 스팟 교환 | 지원되지 않은 선물 거래 |
|---|---|---|
| GetRecords | 자이프 / 코인체크 / 비트플라이어 | 퓨처스_에보 |
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.SetMaxBarLen exchange.SetMaxBarLen}
FMZ 양자 거래 플랫폼 웹 사이트 페이지에서 설정된 K-라인 기간을 얻으십시오 라이브 거래에서 역 테스트 및 전략을 실행 할 때, 즉 기본 K-라인 기간을 호출 할 때 사용exchange.GetRecords()매개 변수를 전달하지 않고 작동합니다.
K-선 기간은 초, 정수 값은 초입니다. 번호
교환.GetPeriod (()
function main() {
// For example, the K-line period set on the website page of the FMZ Quant Trading platform during backtesting and live trading is 1 hour.
var period = exchange.GetPeriod()
Log("K-line period:", period / (60 * 60), "hours")
}
def main():
period = exchange.GetPeriod()
Log("K-line period:", period / (60 * 60), "hours")
void main() {
auto period = exchange.GetPeriod();
Log("K-line period:", period / (60 * 60.0), "hours");
}
{@fun/Market/exchange.GetRecords exchange.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]);
}
이exchange.SetMaxBarLen()이 기능은 암호화폐 전략 실행시간에 두 가지 측면에 영향을 미칩니다.
{@fun/Market/exchange.GetRecords exchange.GetRecords}
원래 콘텐츠를 마지막에 반환rest현재 교환 객체에 대한 요청 ({@var/EXCHANGE exchange}, {@var/EXCHANGE/exchanges exchanges}).
응답 데이터rest요청.
문자열
교환.GetRawJSON (()
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++ does not support the GetRawJSON function
Log(obj);
}
이exchange.GetRawJSON()이 기능은 실제 거래에만 지원됩니다.C++ language.
{@var/EXCHANGE 교환}
교환 대상에 대해 현재 설정된 환율을 얻으십시오.
교환 대상의 환율의 현재 값 번호
교환.GetRate()
function main(){
Log(exchange.GetTicker())
// Set up exchange rate conversion
exchange.SetRate(7)
Log(exchange.GetTicker())
Log("Current exchange rate:", exchange.GetRate())
}
def main():
Log(exchange.GetTicker())
exchange.SetRate(7)
Log(exchange.GetTicker())
Log("Current exchange rate:", exchange.GetRate())
void main() {
Log(exchange.GetTicker());
exchange.SetRate(7);
Log(exchange.GetTicker());
Log("Current exchange rate:", exchange.GetRate());
}
만약exchange.SetRate()회환율을 정하도록 부름을 받지 않았다면,exchange.GetRate()함수는 1의 기본 비율 값을 반환 합니다. 즉, 현재 표시된 통화 (quoteCurrency) 와 관련된 데이터가 변환되지 않았습니다.
환율 값이exchange.SetRate()예를 들어,exchange.SetRate(7)그 다음 모든 가격 정보, 예를 들어 코팅, 깊이, 주문 가격exchange교환 대상은 설정된 환율에 곱하여 변환됩니다7...
만약exchangeUSD를 통역 통화로 교환하는 것과 일치합니다.exchange.SetRate(7), 라이브 시장의 모든 가격은 CNY에 가까운 가격으로 변환됩니다.7이 시점에서 환율 값은exchange.GetRate()이7.
{@fun/Trade/exchange.SetRate exchange.SetRate}
이exchange.SetData()이 함수는 전략이 실행될 때 로딩되는 데이터를 설정하는 데 사용됩니다.
매개 변수 다음 문자열의 길이는valueJSON 코딩
번호
exchange.SetData (키, 값)
데이터 수집의 이름
키
사실
문자열
데이터 로딩exchange.SetData()함수는 배열의 데이터 구조를 가지고 있습니다. 데이터 구조는 배열에 의해 요청 된 데이터 형식과 동일합니다.exchange.GetData()외부 데이터를 요청할 때 기능, 즉:"schema": ["time", "data"]...
가치
사실
배열
/*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, 그리고 전략 프로그램이 이 시간이 지나면 실행되면,exchange.GetData()다음 데이터 시간표 전에 데이터를 얻기 위한 함수1579708800000, 즉, 시간2020-01-23 00:00:00당신이 얻는 것은[1579622400000, 123]그 데이터의 내용, 프로그램이 계속 실행됨에 따라, 시간이 변경되고, 등등으로 항목별로 데이터 항목을 얻을 수 있습니다. 다음 예제에서, 실행 시간 (백테스팅 또는 라이브 거래) 에서, 현재 순간은 시간표에 도달하거나 초과1579795200000, 그exchange.GetData()함수가 호출되고 반환 값은:{"Time":1579795200000,"Data":["abc", 123,{"price":123}]}. "Time":1579795200000해당됩니다1579795200000데이터에서[1579795200000, ["abc", 123, {"price": 123}]]. "Data":["abc", 123, {"price": 123}]데이터와 일치합니다.["abc", 123, {"price": 123}]]안쪽[1579795200000, ["abc", 123, {"price": 123}]].
로드 된 데이터는 모든 수치화 가능한 정보의 전략 정량 평가에 사용되는 모든 경제 지표, 산업 데이터, 관련 지표 등이 될 수 있습니다.
{@fun/Market/exchange.GetData exchange.GetData}
이exchange.GetData()함수는 데이터 로딩을 얻기 위해 사용됩니다.exchange.SetData()기능 또는 외부 링크에 의해 제공됩니다.
데이터 수집에 있는 기록 물체
교환.GetData (키) 교환.GetData (키, 타임아웃)
데이터 수집의 이름 키 사실 문자열 캐시 타임아웃을 밀리초로 설정하는데 사용되는데, 실시간 거래에 1분 캐시 타임아웃으로 설정되죠. 타임아웃 거짓 번호
/*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속성
저장된 것은data이 속성은 데이터의 본체이며, 각 항목은 밀리초 수준 타임 스탬프와 데이터 내용 (어떤 JSON 코딩 데이터도 될 수 있다) 으로 구성됩니다.
테스트를 위한 서비스 프로그램, Go로 작성된:
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")) // The xxx part of the link is the code of the query data, here xxx is an example.
}
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"));
}
플랫폼에서 생성된 질의에 대한 요청 데이터데이터데이터, 응답의 데이터 형식이 (시간, 스케마에 설명 된 데이터 필드가 있어야합니다):
{
"data": [],
"schema": ["time", "data"]
}
exchange.GetData()함수가 호출되면 JSON 객체가 반환됩니다. 예를 들어:{"Time":1579795200000, "Data":"..."}.
백테스팅을 위해 데이터를 한 번에 얻고 실시간 거래에 대한 데이터를 1 분 캐시합니다. 백테스팅 시스템에서 액세스 인터페이스를 사용하여 데이터를 요청할 때 백테스팅 시스템은 자동으로 추가합니다.from(초로 표시된 시간),to(초로 시간표) 요청, 파라미터period(K-라인 기간, 밀리초로 시간표) 는 데이터를 획득해야 할 시간 프레임을 결정하는 데 사용됩니다.
{@fun/Market/exchange.SetData exchange.SetData}
이exchange.GetMarkets()이 함수는 환율 시장 정보를 얻기 위해 사용됩니다.
{@struct/Market Market} 구조를 포함하는 사전. 물체
거래소.GetMarkets
function main() {
var markets = exchange.GetMarkets()
var currency = exchange.GetCurrency()
// Get the current contract code can also use exchange.GetContractType() function
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는 현재 기본 거래 쌍의 시장 데이터를만 반환합니다. 시장 함수를 호출 한 후, 모든 요청 된 품종의 시장 데이터를 반환합니다. 다음 테스트 예제를 참조 할 수 있습니다:
이exchange.GetMarkets()함수는 거래 품종의 이름을 지은 키로 사전을 반환하고, 거래 쌍으로 포맷된 스팟 수정에 대해, 예를 들어:
{
"BTC_USDT" : {...}, // The key value is the Market structure
"LTC_USDT" : {...},
...
}
미래에셋 계약 거래소에서, 같은 종류에 대한 여러 계약이 있을 수 있기 때문에, 예를 들어BTC_USDT거래 쌍, 영구 계약, 분기 계약 등이 있습니다.exchange.GetMarkets()함수는 계약 코드와 결합된 쌍의 키 이름을 가진 사전을 반환합니다. 예를 들어:
{
"BTC_USDT.swap" : {...}, // The key value is the Market structure
"BTC_USDT.quarter" : {...},
"LTC_USDT.swap" : {...},
...
}
exchange.GetMarkets()기능은 라이브 트레이딩, 백테스팅 시스템을 지원합니다exchange.GetMarkets()이 함수는 거래소에서 온라인 상거래되는 품종에 대한 시장 정보를 반환합니다.exchange.GetMarkets()이 함수는 옵션 계약을 지원하지 않습니다.거래소를 지원하지 않는 거래소exchange.GetMarkets()기능:
| 함수 이름 | 지원되지 않는 스팟 교환 | 지원되지 않은 선물 거래 |
|---|---|---|
| GetMarkets | 코인체크 / 비트럼브 / 비트플라이어 | – |
{@struct/시장시장}
이exchange.GetTickers()이 함수는 교환 집계된 틱어 데이터를 얻기 위해 사용된다. {@struct/Ticker Ticker} 구조의 배열.exchange스팟 거래 대상이 될 때 모든 거래 쌍에 대한 틱어 데이터를 반환합니다.exchange선물 거래 대상일 때 모든 계약에 대한 틱어 데이터를 반환합니다.
이exchange.GetTickers()함수는 데이터를 요청하는 데 성공할 때 {@struct/Ticker Ticker} 구조의 배열을 반환하고 실패할 때 null을 반환합니다.
{@struct/Ticker Ticker} 배열, null 값
교환.GetTickers()
function main() {
var tickers = exchange.GetTickers()
if (tickers && tickers.length > 0) {
Log("Number of tradable items on the exchange:", tickers.length)
}
}
def main():
tickers = exchange.GetTickers()
if tickers and len(tickers) > 0:
Log("Number of tradable items on the exchange:", len(tickers))
void main() {
auto tickers = exchange.GetTickers();
if (tickers.Valid && tickers.size() > 0) {
Log("Number of tradable items on the exchange:", 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"]
// Before requesting other trading pair market data, call Get Tickers
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])
}
// Request market data for other trading pairs
for (var symbol of arrSymbol) {
exchange.GetTicker(symbol)
}
// Call GetTickers again
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 / 선물_dYdX / 선물_데리빗 / 선물_비박스 / 선물_에보 |
{@struct/TickerTicker}, {@fun/Market/exchange.GetTicker 교환.GetTicker}
이exchange.Buy()이 기능은 구매 주문을 배치하는 데 사용됩니다.Buy()함수는 교환 객체 {@var/EXCHANGE exchange}의 멤버 함수입니다.Buy()함수는 교환 대상과 연결된 교환 계좌에서 작동합니다.exchange의 구성원 기능 (방법) 의 목적exchange객체와만 관련이 있습니다.exchange, 그리고 문서화 후에 반복되지 않을 것입니다.
성공한 명령은 명령 Id를 반환하고 실패한 명령은 null 값을 반환합니다.
속성IdFMZ 플랫폼의 순서 {@struct/Order Order} 구조는 교환 제품 코드와 교환 원본 주문 ID로 구성되어 있으며 영어 koma로 분리됩니다. 예를 들어, 속성Id포트 거래 쌍의 형식ETH_USDTOKX 거래소의 순서는ETH-USDT,1547130415509278720...
전화할 때exchange.Buy()주문을 할 수 있는 함수, 반환 값 주문Id의 내용과 일치합니다.Id명령어 {@struct/Order Order} 구조의 속성.
문자열, null 값
교환.구매 (가격, 금액) 교환.구매 (가격, 금액,...args)
이price매개 변수는 주문 가격을 설정하는 데 사용됩니다.
가격
사실
번호
의amount매개 변수는 주문 금액을 설정하는 데 사용됩니다.
금액
사실
번호
이 주문 로그에 첨부 정보를 출력할 수 있는 확장된 매개 변수arg한 개 이상의 매개 변수를 전달할 수 있습니다.
아그
거짓
문자열, 숫자, bool, 객체, 배열, null 및 시스템에서 지원하는 다른 유형
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);
}
반환된 순서 번호exchange.Buy()주문 정보를 검색하고 주문을 취소하는 데 사용할 수 있습니다.
// The following is an error call
function main() {
exchange.SetContractType("quarter")
// Set the shorting direction
exchange.SetDirection("sell")
// If you place a buy order, an error will be reported, and shorting can only be sold
var id = exchange.Buy(50, 1)
// Set the long direction
exchange.SetDirection("buy")
// If you place a sell order, it will report an error, go long, only buy
var id2 = exchange.Sell(60, 1)
// Set direction to close long positions
exchange.SetDirection("closebuy")
// If you place a buy order, it will report an error, close long, only sell
var id3 = exchange.Buy(-1, 1)
// Set direction to close short positions
exchange.SetDirection("closesell")
// If you place a sell order, it will report an error, close short, only buy
var id4 = exchange.Sell(-1, 1)
}
# The following is an error call
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)
// The following is an error call
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
// For example, the trading pair: ETH_BTC, place a buy order at the market price
function main() {
// Place a buy order at the market price and buy ETH coins with a value of 0.1 BTC (denominated currency)
exchange.Buy(-1, 0.1)
}
def main():
exchange.Buy(-1, 0.1)
void main() {
exchange.Buy(-1, 0.1);
}
현금 시장 주문.
선물 계약에 대한 주문을 할 때, 거래 방향과 거래 기능이 일치하지 않으면 오류가 보고되기 때문에 거래 방향이 올바르게 설정되었는지에주의를 기울여야합니다. 암호화폐 선물 계약의 주문 크기는 지정되지 않은 경우 계약 수입니다.
매개 변수price설정되어 있습니다-1시장 주문을 배치하기 위해, 거래소의 주문 배치 인터페이스가 시장 주문을 지원하도록 요구합니다.amount화폐 선물 계약에 대한 시장 주문을 할 때, 금액 매개 변수amount계약의 수입니다. 라이브 거래 중에 시장 주문 인터페이스를 지원하지 않는 몇 개의 암호화폐 거래소가 있습니다. 일부 스팟 거래소에서 시장 구매 주문의 주문 양은 거래 코인의 수입니다.교환에 관한 특별 지침자세한 내용은 Id의exchange.Buy()함수는 명령의 반환 값과 다를 수 있습니다Id현재 문서에 설명되어 있습니다.
{@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
이exchange.Sell()이 함수는 판매 주문을 하기 위해 사용 됩니다.
성공한 명령은 명령 Id를 반환, 실패한 명령은 null 값을 반환. 속성IdFMZ 플랫폼의 순서 {@struct/Order Order} 구조는 교환 제품 코드와 교환 원본 주문 ID로 구성되어 있으며 영어 koma로 분리됩니다. 예를 들어, 속성Id포트 거래 쌍의 형식ETH_USDTOKX 거래소의 순서는ETH-USDT,1547130415509278720전화할 때exchange.Sell()주문을 할 수 있는 함수, 반환 값 주문Id의 내용과 일치합니다.Id명령어 {@struct/Order Order} 구조의 속성.
문자열, null 값
교환.판매 (가격, 금액) 교환.판매 (가격, 금액,...args)
이price매개 변수는 주문 가격을 설정하는 데 사용됩니다.
가격
사실
번호
의amount매개 변수는 주문 금액을 설정하는 데 사용됩니다.
금액
사실
번호
이 주문 로그에 첨부 정보를 출력할 수 있는 확장된 매개 변수arg한 개 이상의 매개 변수를 전달할 수 있습니다.
아그
거짓
문자열, 숫자, bool, 객체, 배열, null 및 시스템에서 지원하는 다른 유형
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);
}
반환된 순서 번호exchange.Sell()주문 정보를 검색하고 주문을 취소하는 데 사용할 수 있습니다.
// The following is an error call
function main() {
exchange.SetContractType("quarter")
// Set the shorting direction
exchange.SetDirection("sell")
// If you place a buy order, an error will be reported, and shorting can only be sold
var id = exchange.Buy(50, 1)
// Set the long direction
exchange.SetDirection("buy")
// If you place a sell order, it will report an error, go long, only buy
var id2 = exchange.Sell(60, 1)
// Set direction to close long positions
exchange.SetDirection("closebuy")
// If you place a buy order, it will report an error, close long, only sell
var id3 = exchange.Buy(-1, 1)
// Set direction to close short positions
exchange.SetDirection("closesell")
// If you place a sell order, it will report an error, close short, only buy
var id4 = exchange.Sell(-1, 1)
}
# The following is an error call
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)
// The following is an error call
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
// For example, the trading pair: ETH_BTC, place a sell order at the market price
function main() {
// Note: place a market order to sell, sell 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계약의 수입니다. 라이브 거래 중에 시장 주문 인터페이스를 지원하지 않는 몇 개의 암호화폐 거래소가 있습니다.
당신이 도커의 오래된 버전을 사용하는 경우, 순서의 반환 값Id의exchange.Sell()함수는 명령의 반환 값과 다를 수 있습니다Id현재 문서에 설명되어 있습니다.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
이exchange.CreateOrder()함수는 주문을 하기 위해 사용 됩니다.
주문이 성공적으로 배치되면 주문 ID가 반환됩니다. 주문이 실패하면 null 값이 반환됩니다.IdFMZ 플랫폼의 순서 {@struct/Order Order} 구조는 교환 제품 코드와 교환 원본 주문 ID로 구성되어 있으며 영어 koma로 분리됩니다. 예를 들어, 속성Id스팟 거래 쌍의 주문 형식ETH_USDTOKX 거래소의 경우:ETH-USDT,1547130415509278720전화할 때exchange.CreateOrder(symbol, side, price, amount)주문을 할 수 있는 함수, 주문의 반환 값Id의 내용과 일치합니다.Id명령어 {@struct/Order Order} 구조의 속성.
문자열, null 값
exchange.CreateOrder (표자, 측면, 가격, 금액) exchange.CreateOrder ((기호, 측면, 가격, 금액,...args)
매개 변수symbol주문의 특정 거래 쌍 및 계약 코드를 지정하는 데 사용됩니다.exchange.CreateOrder(symbol, side, price, amount)주문을 하는 기능exchange즉석 교환 대상이 됩니다. 주문의 화폐가 USDT이고 거래 화폐가 BTC라면,symbol이 경우:"BTC_USDT", FMZ 플랫폼에 의해 정의 거래 쌍의 형식으로.exchange.CreateOrder(symbol, side, price, amount)주문을 하는 기능exchange선물 거래 대상입니다. 주문이 BTCsymbol이 경우:"BTC_USDT.swap", 그리고 형식은거래 쌍그리고계약 코드FMZ 플랫폼에 의해 정의, 문자 exchange.CreateOrder(symbol, side, price, amount)주문을 하는 기능exchange선물 거래 대상입니다. 주문이 BTCsymbol이 경우:"BTC_USDT.BTC-240108-40000-C"(예를 들어 Binance Option BTC-240108-40000-C를 사용 하 여), 그리고 형식은거래 쌍FMZ 플랫폼에서 정의하고 거래소에서 정의한 특정 옵션 계약 코드,
기호
사실
문자열
의side매개 변수는 명령의 거래 방향을 지정하는 데 사용됩니다.
스팟 교환 대상의 경우,side매개 변수는 다음과 같습니다.buy, sell. buy구매를 의미하며,sell판매하는 것을 의미합니다.
미래에셋 거래 대상의 경우,side매개 변수는 다음과 같습니다.buy, closebuy, sell, closesell. buy긴 포지션을 개설하는 것을 의미합니다.closebuy긴 포지션을 닫는 것을 의미합니다.sell단기 포지션 개설을 의미하며,closesell즉, 짧은 포지션을 닫는 것을 의미합니다.
옆면
사실
문자열
매개 변수price명령의 가격을 설정하는 데 사용됩니다. -1의 가격은 명령이 시장 명령이라는 것을 나타냅니다.
가격
사실
번호
매개 변수amount주문 양을 설정하는 데 사용됩니다. 주문이 시장 구매 주문이라면, 주문 양은 구매 금액이며, 일부 스팟 거래소의 시장 구매 주문의 주문 양은 거래 코인의 수입니다. 자세한 내용은교환에 관한 특별 지침arg매개 변수를 전달할 수 있습니다.
아그
거짓
문자열, 숫자, bool, 객체, 배열, null 값 등과 같은 시스템에서 지원되는 모든 유형
function main() {
var id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01) // Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
// var id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01) // Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id)
}
def main():
id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01) # Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
# id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01) # Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id)
void main() {
auto id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01); // Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
// auto id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01); // Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id);
}
스팟 거래 대상과 미래에셋 거래 대상exchange.CreateOrder()주문을 하는 기능입니다.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
이exchange.CancelOrder()함수는 주문을 취소하는 데 사용됩니다.
속성IdFMZ 플랫폼의 순서 {@struct/Order Order} 구조는 교환 제품 코드와 교환 원본 주문 ID로 구성되어 있으며 영어 koma로 분리됩니다. 예를 들어, 속성Id스팟 거래 쌍의 주문 형식ETH_USDTOKX 거래소의 경우:ETH-USDT,1547130415509278720...
매개 변수orderId전화 할 때 통과exchange.CancelOrder()주문을 취소하는 기능이Id명령어 {@struct/Order Order} 구조의 속성.
이exchange.CancelOrder()함수는 실제 값을 반환, 예를 들어true취소 주문 요청이 성공적으로 전송되었다는 것을 의미합니다.false, 취소 주문 요청이 전송되지 않았다는 것을 의미합니다. 반환 값은 교환이 주문을 취소하는지 여부를 결정하기 위해 전송 요청의 성공 또는 실패를 나타냅니다.exchange.GetOrders()명령이 취소되었는지 여부를 결정하기 위해서입니다.
bool
교환. 주문 취소 (orderId) 교환. 주문 취소 (orderId,...args)
이orderId이 매개 변수는 취소될 주문을 지정하는 데 사용됩니다.
명령
사실
숫자, 문자열
확장된 매개 변수, 당신은 이 철회 로그에 첨부 정보를 출력 할 수 있습니다,arg한 개 이상의 매개 변수를 전달할 수 있습니다.
아그
거짓
문자열, 숫자, bool, 객체, 배열, null 및 시스템에서 지원하는 다른 유형
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("Set the contract as: perpetual contract, set the trade direction as: open long position.")
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, "Cancelled orders:", orders[i])
Sleep(500)
}
}
def main():
if exchange.GetName().find("Futures_") != -1:
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.")
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"], "Cancelled orders:", orders[i])
Sleep(500)
void main() {
if (exchange.GetName().find("Futures_") != std::string::npos) {
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.");
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, "Cancelled orders:", orders[i]);
Sleep(500);
}
}
FMZ API 함수들은 다음과 같은 로그 출력 함수를 생성할 수 있습니다.Log(), exchange.Buy(), exchange.CancelOrder()필요한 매개 변수에 따라 몇 가지 동반 출력 매개 변수가 따라갈 수 있습니다. 예를 들어:exchange.CancelOrder(orders[i].Id, orders[i]), 그래서 주문을 취소 할 때orders[i].Id즉, {@struct/Order Order} 구조의orders[i].
만약 당신이 더 오래된 버전의 도커를 사용한다면, exchange.CancelOrder() 함수의 orderId 매개 변수는 현재 문서에서 설명된 orderId와 다를 수 있습니다.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}
이exchange.GetOrder()함수는 주문 정보를 얻기 위해 사용됩니다.
질서 번호에 따라 순서 세부 정보를 검색하고 질서가 성공하면 {@struct/Order Order} 구조를 반환하거나 질서가 실패하면 null을 반환합니다. {@struct/Order Order}, null 값
교환.GetOrder
이orderId매개 변수는 질의 할 순서를 지정하는 데 사용됩니다.
속성IdFMZ 플랫폼의 순서 {@struct/Order Order} 구조는 교환 제품 코드와 교환 원본 주문 ID로 구성되어 있으며 영어 koma로 분리됩니다. 예를 들어, 속성Id스팟 거래 쌍의 주문 형식ETH_USDTOKX 거래소의 경우:ETH-USDT,1547130415509278720...
매개 변수orderId전화 할 때 통과exchange.GetOrder()명령어에 대한 쿼리 함수가Id명령어 {@struct/Order Order} 구조의 속성.
명령 사실 문자열
function main(){
var id = exchange.Sell(1000, 1)
// Parameter id is the order number, you need to fill in the number of the order you want to query
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()이 기능은 일부 거래소에서 지원되지 않습니다.AvgPrice반환 값의 {@struct/Order Order} 구조의 속성은 트랜잭션의 평균 가격입니다. 일부 거래소는 이 필드를 지원하지 않으며, 그렇지 않으면 0로 설정됩니다.
더 오래된 버전의 도커를 사용하는 경우,orderId매개 변수exchange.GetOrder()기능이orderId현재 문서에 설명되어 있습니다.
거래소를 지원하지 않는 거래소exchange.GetOrder()기능:
| 함수 이름 | 지원되지 않는 스팟 교환 | 지원되지 않은 선물 거래 |
|---|---|---|
| GetOrder | 자이프 / 코인체크 / 비트스탬프 | – |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}
이exchange.GetOrders()이 함수는 미수된 주문을 얻기 위해 사용됩니다.
이exchange.GetOrders()이 함수는 데이터 요청이 성공하면 {@struct/Order Order} 구조의 배열을 반환하고, 데이터 요청이 실패하면 null 값을 반환합니다.
{@struct/Order Order} 배열, null 값
교환.GetOrders() 교환.GetOrders (신호)
매개 변수symbol사용 됩니다거래 기호또는거래 기호 범위조사를 받을 수 있습니다.
스팟 교환 대상을 위해,symbol매개 변수가 전달되지 않으면 모든 스팟 제품의 완료되지 않은 주문 데이터가 요청됩니다.
미래에셋 거래 대상의 경우symbol매개 변수가 전달되지 않으면, 기본값은 현재 거래 쌍과 계약 코드 차원의 모든 품종의 완료되지 않은 주문 데이터를 요청하는 것입니다.
기호 거짓 문자열
/*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) + "`")
// Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
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) + "`")
// Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
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)); // The Id attribute type in the Order structure is TId, which is encoded using a C++ function to_string built into the FMZ platform.
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") // Examples of spot products
// var orders = exchange.GetOrders("BTC_USDT.swap") // Examples of futures products
Log("orders:", orders)
}
def main():
orders = exchange.GetOrders("BTC_USDT") # Examples of spot products
# orders = exchange.GetOrders("BTC_USDT.swap") # Examples of futures products
Log("orders:", orders)
void main() {
auto orders = exchange.GetOrders("BTC_USDT"); // Examples of spot products
// auto orders = exchange.GetOrders("BTC_USDT.swap"); // Examples of futures products
Log("orders:", orders);
}
전화할 때exchange.GetOrders()기능, 통과Symbol특정 거래 쌍 및 계약 코드에 대한 주문 데이터를 요청하는 매개 변수
이 지역에서는GetOrders함수, 기호 매개 변수의 사용 시나리오는 다음과 같이 요약됩니다.
| 교환 객체 분류 | 기호 매개 변수 | 쿼리 범위 | 언급 |
|---|---|---|---|
| 스팟 | 기호 매개 변수를 전달하지 마십시오 | 모든 스팟 거래 쌍을 검색합니다. | 모든 호출 시나리오에 대해, 교환 인터페이스가 지원하지 않으면 오류가 보고되고 null 값이 반환됩니다. 더 이상의 설명은 주어지지 않습니다. |
| 스팟 | 거래 유형을 지정합니다. 기호 매개 변수는: |
지정된 BTC_USDT 거래 쌍을 검색 | 스팟 거래소 개체에 대한 기호 매개 변수 형식은: |
| 선물 | 기호 매개 변수를 전달하지 마십시오 | 현재 거래 쌍 및 계약 코드 차원 범위 내의 모든 거래 제품을 검색합니다. | 현재 거래 쌍이 BTC_USDT이고 계약 코드가 swap인 경우, USDT 마진을 가진 모든 영구 계약이 검색됩니다.GetOrders("USDT.swap") |
| 선물 | 거래 유형을 지정합니다. 기호 매개 변수는: |
특정 BTC에 대한 USDT 기반 상시계약을 검색 | 미래에셋 거래소 대상의 경우 매개 변수 기호 형식은:거래 쌍그리고계약 코드FMZ 플랫폼에 의해 정의되며, 문자로 구분됩니다.".. |
| 선물 | 거래 상품 범위를 지정합니다. 기호 매개 변수는: |
모든 USDT 기반 상시계약을 검색합니다. | - |
| 옵션을 지원하는 선물 거래소 | 기호 매개 변수를 전달하지 마십시오 | 현재 거래 쌍 차원 범위 내의 모든 옵션 계약을 검색 | 현재 거래 쌍이 BTC_USDT인 경우 계약은 옵션 계약으로 설정됩니다. 예를 들어 Binance 옵션 계약: BTC-240108-40000-C |
| 옵션을 지원하는 선물 거래소 | 특정 거래 상품을 지정 | 지정된 옵션 계약을 검색 | 예를 들어, 바이낸스 선물 거래소에서 기호 매개 변수는: BTC_USDT.BTC-240108-40000-C |
| 옵션을 지원하는 선물 거래소 | 거래 상품 범위를 지정합니다. 기호 매개 변수는: |
모든 USDT 기반 옵션 계약을 검색 | - |
이 지역에서는GetOrders함수, 선물 거래소 객체 질의
차원 범위는 다음과 같이 요약됩니다.
| 기호 매개 변수 | 요청 범위 정의 | 언급 |
|---|---|---|
| USDT.swap | USDT 기반의 영구계약 범위 | 에 대해 |
교환 API 인터페이스에서 지원되지 않는 차원, 오류가 보고되고 null 값이 반환됩니다. 전화합니다. ♫ USDT.futures ♫ ♫ USDT 기반 배송 계약 범위 ♫ ♫ USDT 기반 배달 계약 범위 ♫ ♫ USDT.futures ♫ USD.swap. 계약입니다. USD.futures. 통화 기반의 배송 범위 계약입니다. USDT 옵션 USDT 기반 옵션 계약 범위 USD 옵션 통화 기반 옵션 계약 범위 USDT.futures_combo CFD 조합의 범위 퓨처스_데리빗 거래소 USD.futures_ff 혼합 마진 배송 계약의 범위. 미래_크래켄 거래소 USD.swap_pf. 혼합 마진 영구 계약의 범위. ∙∙미래_크래켄 거래소
교환 대상으로 대표되는 계좌가exchange그 안에 대기 명령이 없습니다질의 범위또는특정 거래 도구이 함수를 호출하면 빈 배열을 반환합니다.[]- 네
다음 교환은 현재 완료되지 않은 주문을 검색 할 때 도구가 도구 매개 변수에 전달되도록 요구합니다. 이러한 교환에서 GetOrders 함수를 호출 할 때, 도구 매개 변수가 전달되지 않으면 현재 도구의 완료되지 않은 주문만 요청되며 모든 도구의 완료되지 않은 주문이 요청되지 않습니다. (교환 인터페이스가 이것을 지원하지 않기 때문에).
자이프, MEXC, LBank, 코르비트, 코인, 비트마트, 비트럼브, 비트플라이어, 빅온
거래소를 지원하지 않는 거래소exchange.GetOrders()기능:
| 함수 이름 | 지원되지 않는 스팟 교환 | 지원되지 않은 선물 거래 |
|---|---|---|
| GetOrders | – | 퓨처스_비박스 |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}
이exchange.GetHistoryOrders()이 함수는 현재 거래 쌍, 계약에 대한 역사적 주문을 얻기 위해 사용됩니다. 특정 거래 품종의 사양을 지원합니다.
이exchange.GetHistoryOrders()function는 데이터 요청이 성공하면 {@struct/Order Order} 구조의 배열을 반환하고 요청이 실패하면 null을 반환합니다.
{@struct/Order Order} 배열, null 값
교환.GetHistoryOrders() 교환.GetHistoryOrders (신호) exchange.GetHistoryOrders (기호, 이후) exchange.GetHistoryOrders (표자, 이후, 제한) 교환.GetHistoryOrders (그때부터) exchange.GetHistoryOrders (역시, 제한)
이symbol매개 변수를 사용 하 여 상표 를 지정 합니다.BTC_USDT예를 들어,exchange즉석 교환 객체입니다.symbol이BTC_USDT· 만약 선물 거래 대상인 경우, 예를 들어 상시계약으로,symbol이 경우:BTC_USDT.swap- 네
옵션 계약의 주문 데이터를 검색하는 경우, 매개 변수를 설정symbol에"BTC_USDT.BTC-240108-40000-C"(예를 들어 Binance Option BTC-240108-40000-C를 사용합니다.)거래 쌍FMZ 플랫폼에서 정의하고 거래소에서 정의한 특정 옵션 계약 코드,
이 매개 변수가 통과되지 않으면 현재 설정된 거래 쌍과 계약 코드의 주문 데이터가 기본적으로 요청됩니다.
기호
거짓
문자열
의since매개 변수는 질의의 시작 시간표를 밀리 초로 지정하는 데 사용됩니다.
그 이후로
거짓
번호
의limit매개 변수는 질의 할 명령의 수를 지정하는 데 사용됩니다.
한계
거짓
번호
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()기능:
| 함수 이름 | 지원되지 않는 스팟 교환 | 지원되지 않은 선물 거래 |
|---|---|---|
| GetHistory 명령어 | Zaif / Upbit / Coincheck / Bitstamp / Bithumb / BitFlyer / BigONE | 선물_dYdX / 선물_비박스 / 선물_아폴로X |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}
exchange.SetPrecision()함수는 정밀도를 설정하는 데 사용됩니다exchange교환 대상가격그리고주문 금액, 설정 후, 시스템은 과도한 데이터를 자동으로 무시합니다.
교환.SetPrecision ((가격Precision, 금액Precision)
이pricePrecision이 매개 변수는 가격 데이터의 정확성을 제어하는 데 사용됩니다.
가격정확성
사실
번호
의amountPrecision이 매개 변수는 주문해야 하는 데이터 양의 정확성을 제어하는 데 사용됩니다.
금액정확성
사실
번호
function main(){
// Set the decimal precision of price to 2 bits, and the decimal precision of variety order amount to 3 bits
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}
교환 대상의 현재 환율을 설정합니다.
교환.SetRate (비율)
이rate변수는 전환 환율을 지정하는 데 사용됩니다.
비율
사실
번호
function main(){
Log(exchange.GetTicker())
// Set exchange rate conversion
exchange.SetRate(7)
Log(exchange.GetTicker())
// Set to 1, no conversion
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), 실시간 시장에서의 모든 가격은CNY7로 곱하면
{@fun/Market/exchange.GetRate exchange.GetRate}
이exchange.IO()이 함수는 교환 객체와 관련된 다른 인터페이스 호출에 사용됩니다.
이exchange.IO()함수는 교환 객체와 관련된 다른 인터페이스를 호출하고, 성공적인 호출에서 요청된 응답 데이터를 반환하고 실패한 호출에서 null을 반환합니다.
문자열, 숫자, bool, 객체, 배열, null 및 시스템에서 지원하는 다른 유형
exchange.IO(k,...args)
이k매개 변수는 호출 유형을 설정하는 데 사용되며 선택값이 있습니다."api", "currency", "base", "trade_margin", "trade_normal", "public_base", "mbase", selfTradePreventionMode, simulate, cross, dual, unified그리고 그 밖의 것들이죠.
k
사실
문자열
확장된 매개 변수, 특정 호출 시나리오에 따라 통과,arg매개 변수는 하나 이상의 전달 될 수 있습니다.exchange.IO()기능, 다른 매개 변수 설정은 다른 기능에 대응합니다.exchange.IO()기능이 불분명합니다.
아그
사실
문자열, 숫자, bool, 객체, 배열, null 및 시스템에서 지원하는 다른 유형
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"}
]
// Call exchange.IO to access the exchange's bulk order interface directly
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("api", httpMethod, resource, params, raw)청원 형태exchange.IO()기능, 교환의 API 인터페이스를 이해하고 관련 문서를 먼저 확인하는 것이 필요합니다. 이것은 FMZ 플랫폼에 추가되지 않은 기능을 확장 할 수 있습니다.POST요청은 당신이 해당 매개 변수를 채우면 아래쪽에 이미 FMZ에 의해 처리되는 매개 변수를 암호화, 서명 또는 확인하는 것에 대해 걱정할 필요가 없습니다. 당신은 대량 순서 예제를 참조할 수 있습니다OKX 거래소선물 계약, 그리고 매개 변수를 사용raw순서 매개 변수를 전달하기 위해:
var amount = 1
var price = 10
var basecurrency = "ltc"
function main () {
// Note that both amount.toString() and price.toString() have a ' character on the left and right side
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);
}
그것은 완전한 url 매개 변수를 전달하는 것을 지원합니다.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() {
// For example, if you set the current trading pair of the exchange object to BTC_USDT at the beginning of the live trading, print the current trading pair tickers
Log(exchange.GetTicker())
// Switch the trading pair to 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] is the first exchange object added when the live trading is created
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");
}```
For example, the default base address when the exchange object is wrapped is ```https://api.huobipro.com```, and when you need to switch to ```https://api.huobi.pro```, use the following code to switch:
```javascript
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").
I. 암호화폐 중심의 거래소에서 다른 API 인터페이스 호출을 위해k설정"api":
exchange.IO("api", httpMethod, resource, params, raw)
POST, GET, 등등URL.이exchange.IO("api", httpMethod, resource, params, raw)함수 호출은 교환 인터페이스에 액세스하고 호출이 실패하고 오류가 발생하면 null을 반환합니다.
오직 실제 거래는exchange.IO("api", httpMethod, resource, params, raw) function.
II. 거래 쌍을 전환하는 경우k설정되어 있습니다"currency":
exchange.IO("currency", currency)
currency: 매개 변수는 통일된 대문자 형식을 가진 문자열 타입이며,baseCurrency에서quoteCurrency, 예를 들어BTC_USDT.
ETH_BTC그냥 켜면 됩니다LTC_BTC, 아니LTC_USDT.exchange.IO("currency", currency)거래 쌍을 바꾸기 위해서요.III. 암호화폐 스팟 거래소 객체 레버리지드 계정 모드를 전환하는 데 사용됩니다.
k설정되어 있습니다"trade_margin"현금 레버리지 계정 모드로 전환합니다. 주문을 배치하고 계정 자산을 획득하면 거래소의 현금 레버리지 인터페이스에 액세스 할 수 있습니다.
만약 거래소가 스팟 레버리지에서 전체 마진과 격리된 마진을 구분한다면,exchange.IO("trade_super_margin")레버레이드 계좌의 전체 마진으로 전환하고,exchange.IO("trade_margin")레버레이드 계좌의 격리된 마진으로 전환합니다.k설정되어 있습니다"trade_normal"정상 스팟 계좌로 전환하기 위해레버레이드 계정 모델의 전환을 지원하는 스팟 거래소:
| 교환 | 특별 언급 |
|---|---|
| OKX | 레버레이드 계정 모드에서 거래 쌍은 정상적인 것과 다릅니다. 일부 거래 쌍은 그렇지 않을 수 있습니다.exchange.IO("trade_super_margin")레버레이드 계좌의 전체 지점으로 전환하고 사용exchange.IO("trade_margin")위치별로 위치로 전환합니다.trade_normal정상 스팟 모드로 전환합니다.exchange.IO("tdMode", "cross")레버리지 모드를 직접 지정하기 위해서 |
| 후오비 | 레버리지드 계정 모드 거래 쌍은 정상적인 거래 쌍과 다르며 일부 거래 쌍에는 그렇지 않을 수 있습니다. Huobi 레버리지드 계정에는 전체 위치와 위치별로 위치가 있습니다. 사용trade_margin지점별로 레버리지 계좌로 전환하기 위해,trade_super_margin레버리지 계좌 전체 위치로 전환하기 위해.trade_normal통상 통화-화폐 모드로 전환합니다. |
| 바이낸스 | 레버레이드 계정 모드는 포지션별로 포지션과 전체 포지션, 사용trade_margin위치별로 위치로 전환, 사용trade_super_margin전체 위치로 전환하려면, 사용trade_normal통상 통화-화폐 모드로 전환합니다. |
| 게이트IO | 레버레이드 계정 모드는 포지션별로 포지션과 전체 포지션, 사용trade_margin위치별로 위치로 전환, 사용trade_super_margin전체 위치로 전환하려면, 사용trade_normal통상 통화-화폐 모드로 전환합니다. |
| AscendEx | 사용exchange.IO("trade_margin")레버리지 계정으로 전환하고exchange.IO("trade_normal")정상 계정 모드로 돌아가기 위해 |
| 와우 | 사용exchange.IO("trade_margin")레버리지 계정으로 전환하고exchange.IO("trade_normal")정상 계정 모드로 돌아가기 위해 |
| 코인 엑스 | 사용exchange.IO("trade_margin")레버레이드 계정으로 전환하고exchange.IO("trade_normal")정상 계정 모드로 돌아가기 위해 |
다른 스위치 기능:이봐요exchange.IO()함수다른 스위치 기능사용 설명서에서
{@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@var EXCHANGE_OP_IO_CONTROL}
이exchange.Log()이 함수는 로그 열 영역에서 주문 배치 및 철수의 로그를 출력하는 데 사용됩니다. 호출되면 주문이 배치되지 않으며 거래 로그만 출력되고 기록됩니다.
교환.예약기록 (order log) 종류, 가격, 금액 교환.오더 로그 (오더 타입, 가격, 금액,...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}.
순서 타입
사실
번호
의price이 매개 변수는 출력 로그에 표시되는 가격을 설정하는 데 사용됩니다.
가격
사실
번호
의amount이 매개 변수는 출력 로그에 표시되는 주문 수를 설정하는 데 사용됩니다.
금액
사실
번호
이 로그에 첨부 정보를 출력할 수 있는 확장된 매개 변수,arg한 개 이상의 매개 변수를 전달할 수 있습니다.
아그
거짓
문자열, 숫자, bool, 객체, 배열, null 및 시스템에서 지원하는 다른 유형
var id = 123
function main() {
// Order type buy, price 999, amount 0.1
exchange.Log(LOG_TYPE_BUY, 999, 0.1)
// Cancel the order
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.IOexchange.IO} 함수는 조건부 주문을 생성하기 위해 거래소 인터페이스에 액세스 할 수 있지만exchange.IO()이 함수는 실시간 거래 로그 기록에서 거래 로그 정보를 출력하지 않습니다.exchange.Log()이 함수는 출력 로그를 보완하여 주문 배치 정보를 기록할 수 있고, 주문 철회 작업에도 마찬가지입니다.
그 때orderType매개 변수는LOG_TYPE_CANCEL, 그price매개 변수는 철회된 주문의 순서 Id입니다.exchange.IO()기능.exchange.Log()function는 {@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()이 함수는 서명 암호화 계산에 사용됩니다.
이exchange.Encode()함수는 계산된 해시 값의 인코딩을 반환합니다.
문자열
exchange.Encode ((algo, inputFormat, outputFormat, data) 를 입력할 수 있습니다. exchange.Encode ((algo, inputFormat, outputFormat, data, keyFormat, key) 를 입력할 수 있습니다.
매개 변수algoalgo또한 지원합니다: algo또한: algoed25519.seed계산
뭔가
사실
문자열
데이터 형식을 지정하는 데 사용됩니다.data매개 변수inputFormat이 매개 변수는 hex암호화된 경우, base64암호화된 것이고, outputFormat이 매개 변수는 다음 설정을 지원합니다: hex암호화된 경우, base64암호화된 것이고, data처리해야 할 데이터입니다.
데이터
사실
문자열
데이터 형식을 지정하는 데 사용됩니다.key매개 변수key이 매개 변수는 hex암호화된 경우, base64암호화된 것이고, key이 매개 변수는 서명 계산에 사용되는 키를 지정하는 데 사용됩니다. 이 매개 변수는 평문 문자열로 사용될 수 있습니다."{{accesskey}}", "{{secretkey}}"에 대한 언급accessKey그리고secretKey{@var/EXCHANGE exchange} 교환 객체에서 구성됩니다.
키
거짓
문자열
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("test");
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}
멀티 스레드 어시크론 지원 기능은 모든 지원 기능의 동작을 어시크론 동시 실행으로 전환할 수 있습니다.
이exchange.Go()함수는 동시 객체를 즉시 반환하고,wait()동시 요청의 결과를 얻기 위해 동시 객체의 메소드.
물체
교환.Go (방법) 교환.Go (방법,...args)
이method이 매개 변수는 함수의 이름을 지정하는 데 사용됩니다. 매개 변수는 함수 이름 문자열이므로 함수 참조가 아닙니다.
방법
사실
문자열
매개 변수동시에 기능을 실행하는, 한 개 이상의 매개 변수가 있을 수 있습니다.arg파라미터의 종류와 번호arg그 매개 변수에 따라동시 실행 기능- 네
아그
거짓
문자열, 숫자, bool, 객체, 배열, 함수, null 및 시스템에서 지원하는 다른 모든 유형
function main(){
// The following four operations are concurrently executed asynchronously by multiple threads and do not take time and return immediately
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)
// Call the wait method to wait for the return of the ticker results asynchronously
var ticker = a.wait()
// Returns the depth, or null if it fails
var depth = b.wait()
// return order number, limited to 1 second timeout, if timeout, returns undefined, the object can continue to call wait if the last wait timeout
var orderId = c.wait(1000)
if(typeof(orderId) == "undefined") {
// Timeout, reacquire
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);
}
Exchange.Go()함수 사용 예제, 결정undefined사용typeof(xx) === "undefined"왜냐하면null == undefined자바스크립트에서 유효합니다.
function main() {
var d = exchange.Go("GetRecords", PERIOD_H1)
// Waiting for K-line results
var records = d.wait()
// Here waits an asynchronous operation that has been waited and finished, it will return null, and log the error message
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: "ticker",
cols: ["index", "name", "latest-deal-price"],
rows: []
}
for(var i = 0; i < arrTicker.length; i++) {
tbl.rows.push([i, arrName[i], arrTicker[i].Last])
}
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", endTS - beginTS, "millisecond", "\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": "ticker",
"cols": ["index", "name", "latest-deal-price"],
"rows": []
}
for i in range(len(arrTicker)):
tbl["rows"].append([i, arrName[i], arrTicker[i]["Last"]])
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", endTS - beginTS, "second", "\n", "`" + json.dumps(tbl) + "`")
Sleep(500)
void main() {
while(true) {
int length = exchanges.size();
auto beginTS = UnixNano() / 1000000;
Ticker arrTicker[length] = {};
string arrName[length] = {};
// Note that to add several exchange objects, several exchanges[n].Go functions have to be executed here, this example is to add four exchange objects, the details can be modified
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": "ticker",
"cols": ["index", "name", "latest-deal-price"],
"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(), "Total time taken to obtain tickers from multiple exchanges concurrently:", format("%d", endTS - beginTS), "millisecond", "\n", "`" + tbl.dump() + "`");
Sleep(500);
}
}
여러 교환 틱에 동시에 액세스:
function main() {
/*
Testing with OKX futures order interface
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("Concurrent order placement time consumption:", endTS - beginTS, "millisecond")
}
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("Concurrent order placement time consumption:", endTS - beginTS, "second")
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("Concurrent order placement time consumption:", endTS - beginTS, "millisecond");
}
동시 발탁exchange.IO("api", ...)기능:
이 함수는 실제 거래에서 실행될 때만 다중 스레드 실행 작업을 생성합니다. 백테스팅은 다중 스레드 동시에 작업 실행을 지원하지 않습니다.
그 후exchange.Go()함수는 객체를 반환합니다.wait()함수는 스레드에서 반환된 데이터를 얻기 위해 그 객체를 통해 호출됩니다.wait()스레드가 자동으로 풀리기 전에 데이터를 얻기 위해 함수가 호출되어야 합니다.wait()이 함수는 정해진 경우, 타임아웃이 발생하더라도 스레드는 자동으로 풀리지 않습니다. 스레드의 결과는 자동으로 풀리기 전에 얻어야 합니다 (동시 접속을 위한 인터페이스 호출의 성공 또는 실패와 상관없이). 간단하게 말하면, 요청된 스레드는wait()실행이 성공하거나 실패하든 상관없이, 그리고 스레드의 리소스가exchange.Go()함수는 도커에 의해 자동으로 풀어야 합니다.
의wait()메소드는 타임아웃 매개 변수를 지원합니다.
타임아웃 파라미터 없이,wait(), 또는 타임아웃 매개 변수가 0이거나,wait(0).wait()함수 블록 및 동시 스레드가 실행을 완료할 때까지 기다립니다. 동시 스레드wait(-1).wait()함수는 다른 프로그래밍 언어에 대한 다른 반환 값으로 즉시 반환합니다. 예를 들어 이 하위 섹션을 참조하십시오.
특정 타임아웃 파라미터 설정,wait(300), 그리고wait()이 기능은 복귀하기 전에 최대 300 밀리초를 기다립니다.
만약 최종 결과를 반환wait()이 함수가 이루어지지 않으면 스레드 자원이 자동으로 풀리지 않을 것이고, 이는 요청된 스레드의 축적으로 이어질 것이고, 2000 이상의 스레드가 오류를 보고할 것입니다."too many routine wait, max is 2000"...
지원 함수:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO이 모든 함수는 동시 호출할 때 현재 {@var/EXCHANGE exchange} 교환 객체에 기초하여 실행됩니다.
파이썬 언어와 자바스크립트 언어의 차이점은wait()파이썬 언어의 동시 객체의 함수는 두 개의 매개 변수를 반환합니다. 첫 번째 매개 변수는 비동기 API 호출에 의해 반환 된 결과이며 두 번째 매개 변수는 비동기 호출이 완료되었는지 여부를 나타냅니다.
def main():
d = exchange.Go("GetRecords", PERIOD_D1)
# ok will return True definitely, unless the strategy is stopped
ret, ok = d.wait()
# If the wait times out, or if it waits for an instance that has already ended, ok returns False
ret, ok = d.wait(100)
{@fun/Global/Mail_Go Mail_Go}, {@fun/Global/HttpQuery_Go HttpQuery_Go}, {@fun/Global/EventLoop EventLoop}
이exchange.GetAccount()교환 계좌 정보를 요청하는 기능입니다.GetAccount()함수는 교환 객체의 멤버 함수입니다. 교환의 멤버 함수 (방법) 의 목적은exchange객체와만 관련이 있습니다.exchange, 그리고 문서화 후에 반복되지 않을 것입니다.
계정 자산 정보를 쿼리하고 쿼리가 성공하면 {@struct/Account Account} 구조를 반환하거나 실패하면 null을 반환합니다. {@struct/계정계정}, null 값
교환.GetAccount ((()
function main(){
// Switching trading pairs
exchange.IO("currency", "BTC_USDT")
// Take OKX futures as an example, set the contract as the current week's contract, the current trading pair is BTC_USDT, so the current contract is BTC's U-nominal current week contract
exchange.SetContractType("this_week")
// Get current account asset data
var account = exchange.GetAccount()
// Available balance of USDT as margin
Log(account.Balance)
// USDT freeze amount as margin
Log(account.FrozenBalance)
// Current asset equity
Log(account.Equity)
// The unrealized profit and loss of all positions held with the current asset as margin
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이분양으로, 이분양은Balance, FrozenBalance{@struct/Account Account} 구조의 속성
거래 대상이 암호화폐 선물 계약 거래소에 설정되고 통화 기반 계약으로 전환되면 자산은 화폐로 마진으로 기록됩니다.Stocks, FrozenStocks{@struct/Account Account} 구조의 속성
바이낸스 선물 통일 계정을 사용할 때,exchange.GetAccount()계정 정보를 요청하는 기능, 캡슐화된 데이터는 모든 자산으로 변환 된 금액입니다미국 달러이 표지판은Balance{@struct/Account Account} 구조의 필드. 다른 자산의 전환 금액을 계산해야 한다면, USD 전환 금액을 인덱스 가격 (환산 자산의) 에 나누고 그 다음 채권율 (환산 자산의) 에 나누어서 계산할 수 있습니다.
{@struct/Account Account}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}
이exchange.GetAssets이 함수는 교환 계좌 자산 정보를 요청하는 데 사용됩니다.
이exchange.GetAssets()function는 데이터 요청이 성공하면 {@struct/Asset Asset} 구조의 배열을 반환하거나 요청이 실패하면 null을 반환합니다.
{@struct/Asset Asset} 배열, null 값
교환.GetAssets
function main() {
// exchange.SetCurrency("BTC_USDT") // You can set up trading pairs
// exchange.SetContractType("swap") // You can set up contracts
var assets = exchange.GetAssets()
Log(assets)
}
def main():
# exchange.SetCurrency("BTC_USDT") # You can set up trading pairs
# exchange.SetContractType("swap") # You can set up contracts
assets = exchange.GetAssets()
Log(assets)
void main() {
// exchange.SetCurrency("BTC_USDT"); // You can set up trading pairs
// exchange.SetContractType("swap"); // You can set up contracts
auto assets = exchange.GetAssets();
Log(assets);
}
교환 계좌의 자산에 대한 정보를 얻습니다.exchange.GetAssets()재산 구조의 요소를 가진 배열을 반환합니다.
이GetAssets()선물 거래소 객체의 함수는 현재 거래 쌍 (화폐 기반, USDT 기반, USDC 기반 등) 의 마진 자산을 반환합니다.
{@struct/Asset Asset}
이exchange.GetName()이 함수는 현재 교환 객체가 연결된 교환의 이름을 얻기 위해 사용됩니다.
이exchange.GetName()이 함수는 FMZ Quant Trading 플랫폼에 의해 정의된 거래소의 이름을 반환합니다.
문자열
exchange.GetName (환송)
function main() {
Log("The exchange object exchange is judged to be Binance spot, and the result is judged to be:", exchange.GetName() == "Binance")
}
def main():
Log("The exchange object exchange is judged to be Binance spot, and the result is judged to be:", exchange.GetName() == "Binance")
void main() {
Log("The exchange object exchange is judged to be Binance spot, and the result is judged to be:", exchange.GetName() == "Binance");
}
이exchange.GetName()이 함수는 일반적으로 교환 객체를 식별하는 데 사용됩니다.exchange또는exchanges[1], exchanges[2]전략 코드에서. 암호화폐 선물 계약 거래소의 이름은 고정 접두어Futures_.
{@fun/Account/exchange.GetLabel exchange.GetLabel}
이exchange.GetLabel()이 함수는 교환 객체가 구성될 때 설정된 사용자 지정 라벨을 얻기 위해 사용됩니다.
이exchange.GetLabel()이 함수는 교환 객체가 구성될 때 설정된 사용자 지정 레이블을 반환합니다.
문자열
교환.GetLabel()
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()이 함수는 현재 설정된 거래 쌍을 얻기 위해 사용됩니다.
이exchange.GetCurrency()이 함수는 현재 {@var/EXCHANGE exchange} 교환 객체에 의해 설정된 거래 쌍을 반환합니다.
문자열
교환.GetCurrency()
function main() {
Log("the current trading pair of exchange is:", exchange.GetCurrency())
}
def main():
Log("the current trading pair of exchange is:", exchange.GetCurrency())
void main() {
Log("the current trading pair of exchange is:", exchange.GetCurrency());
}
거래 쌍의 형식은 거문자로 균일하게 되어 있으며, 하문자를 사용하여baseCurrency그리고quoteCurrency, 예를 들어BTC_USDT.
{@fun/Account/exchange.SetCurrency exchange.SetCurrency}
이exchange.SetCurrency()이 함수는 교환 객체 {@var/EXCHANGE exchange}의 현재 거래 쌍을 전환하는 데 사용됩니다.
교환.SetCurrency (통화)
이currency이 매개 변수는 전환될 거래 쌍을 설정하는 데 사용됩니다.baseCurrency에서quoteCurrency, 예를 들어BTC_USDT...
화폐
사실
문자열
function main() {
var ticker = exchange.GetTicker()
Log(ticker)
Log(exchange.GetAccount())
// Switching trading pairs, pay attention to the changes of ticker data and account information after switching
exchange.SetCurrency("LTC_USDT")
Log("Switch to 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("Switch to 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("Switch to LTC_USDT");
ticker = exchange.GetTicker();
Log(ticker);
Log(exchange.GetAccount());
}
exchange.IO("currency", "BTC_USDT")전환 방법, 참조하십시오 {@funexcahnge.IO}.BTC_USDT로 전환할 수 있습니다.LTC_USDT, 아니LTC_BTC.BTC_USDT,BTC3입니다.USDT이 시간에는,LTC_USDT즉시, 거래 통화의 수는 전환 후 0입니다.LTC_USDT계산기에는 0이 있습니다.LTC계정에 0이 있고, 전환된 거래 쌍은USDT10만원입니다.{@fun/Account/exchange.GetCurrency exchange.GetCurrency}
이exchange.GetQuoteCurrency()이 함수는 현재 거래 쌍의 화폐의 이름을 얻기 위해 사용됩니다.quoteCurrency.
이exchange.GetQuoteCurrency()이 함수는 현재 거래 쌍의 화폐의 이름을 반환합니다.
문자열
교환.GetQuoteCurrency()
function main() {
exchange.SetCurrency("BTC_USDT")
Log("BTC_USDT denominated currency name:", exchange.GetQuoteCurrency())
// exchange.SetCurrency("ETH_BTC")
// Log("ETH_BTC denominated currency name:", exchange.GetQuoteCurrency())
}
def main():
exchange.SetCurrency("BTC_USDT")
Log("BTC_USDT denominated currency name:", exchange.GetQuoteCurrency())
# exchange.SetCurrency("ETH_BTC")
# Log("ETH_BTC denominated currency name:", exchange.GetQuoteCurrency())
void main() {
exchange.SetCurrency("BTC_USDT");
Log("BTC_USDT denominated currency name:", exchange.GetQuoteCurrency());
// exchange.SetCurrency("ETH_BTC")
// Log("ETH_BTC denominated currency name:", 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}
이exchange.GetPositions()위치 정보를 얻기 위해 사용 됩니다.GetPositions()함수는 교환 객체 {@var/EXCHANGE exchange}의 멤버 함수입니다.GetPositions()함수는 교환 객체와 연결된 교환 계좌의 위치 정보를 얻습니다exchange의 구성원 기능 (방법) 의 목적exchange객체와만 관련이 있습니다.exchange그리고 여기서 반복되지 않을 것입니다.
이exchange.GetPositions()함수는 데이터 요청이 성공하면 {@struct/Position Position} 구조의 배열을 반환하고 데이터 요청이 실패하면 null 값을 반환합니다.
{@struct/Position Position} 배열, null 값
교환.GetPositions() 교환.GetPositions (표)
매개 변수symbol사용 됩니다상거래 기호또는거래 기호 범위조사를 받을 수 있습니다.
만약symbol매개 변수가 전달되지 않는 경우, 기본값은 현재 거래 쌍과 계약 코드 차원의 범위의 모든 기호의 위치 데이터를 요청하는 것입니다.
기호 거짓 문자열
/*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) + "`")
// Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
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;
}
미래에셋 거래소 객체를 사용하여 여러 가지 다른 거래 쌍 및 계약 코드에 대한 시장 주문을 배치합니다. 여러 가지 방법으로 포지션을 검색합니다.
암호화폐 선물 계약은 위치의 논리적 개념만을 가진 암호화폐 스팟과 다릅니다. FMZ 퀀트 트레이딩 플랫폼 시스템에서 특정 유형의 암호화폐 선물 계약은거래 쌍, 계약 코드함께. {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType} 함수를 참조하십시오.
이 지역에서는GetPositions함수, 기호 매개 변수의 사용 시나리오는 다음과 같이 요약됩니다.
| 교환 객체 분류 | 기호 매개 변수 | 쿼리 범위 | 언급 |
|---|---|---|---|
| 선물 | 기호 매개 변수를 전달하지 마십시오 | 현재 거래 쌍 및 계약 코드 차원 범위 내의 모든 거래 제품을 검색합니다. | 현재 거래 쌍이 BTC_USDT이고 계약 코드가 swap인 경우, USDT 기반의 모든 영구계약이 검색됩니다.GetPositions("USDT.swap") |
| 선물 | 거래 상품을 지정합니다. 기호 매개 변수는: |
특정 BTC의 USDT 기반 상시계약을 검색합니다. | 선물 거래소 대상의 경우 매개 변수 기호의 형식은 다음과 같습니다.거래 쌍그리고계약 코드FMZ 플랫폼에 의해 정의되며, 문자로 구분됩니다.".. |
| 선물 | 거래 상품 범위를 지정합니다. 기호 매개 변수는: |
모든 USDT 기반 상시계약을 검색합니다. | - |
| 옵션을 지원하는 선물 거래소 | 기호 매개 변수를 전달하지 마십시오 | 현재 거래 쌍 차원 범위 내의 모든 옵션 계약을 검색 | 현재 거래 쌍이 BTC_USDT인 경우 계약은 옵션 계약으로 설정됩니다. 예를 들어 Binance 옵션 계약: BTC-240108-40000-C |
| 옵션을 지원하는 선물 거래소 | 특정 거래 상품을 지정 | 지정된 옵션 계약을 검색 | 예를 들어, 바이낸스 선물 거래소에서 기호 매개 변수는: BTC_USDT.BTC-240108-40000-C |
| 옵션을 지원하는 선물 거래소 | 거래 상품 범위를 지정합니다. 기호 매개 변수는: |
모든 USDT 기반 옵션 계약을 검색 | - |
이 지역에서는GetPositions함수, 선물 거래 대상
질의 차원 범위는 다음과 같이 요약됩니다.
| 기호 매개 변수 | 요청 범위 정의 | 언급 |
|---|---|---|
| USDT.swap | USDT 기반의 영구계약 범위 | 에 대해 |
교환 API 인터페이스에서 지원되지 않는 차원, 오류가 보고되고 null 값이 반환됩니다. 전화합니다.
♫ USDT.futures ♫ ♫ USDT 기반 배송 계약 범위 ♫ ♫ USDT 기반 배달 계약 범위 ♫ ♫ USDT.futures ♫
USD.swap입니다. 계약입니다.
USD.Futures. 통화 기반 배송의 범위 계약입니다.
USDT 옵션 USDT 기반 옵션 계약 범위
USD 옵션 통화 기반 옵션 계약 범위
USDT.futures_combo CFD 조합의 범위 퓨처스_데리빗 거래소
USD.futures_ff 혼합 마진 배송 계약의 범위 미래_크래켄 거래소
USD.swap_pf 혼합 마진 영구계약 범위 미래_크래켄 거래소
호환성exchange.GetPosition()전화,GetPosition이 값은GetPositions.
교환 대상으로 대표되는 계좌가exchange그 어떤 위치도 가지고 있지 않습니다질의 범위또는특정 거래 도구, 그exchange.GetPositions()함수는 빈 배열을 반환합니다. 예를 들어[].
{@struct/Position Position}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}
이exchange.SetMarginLevel()이 함수는 거래 쌍 또는 계약의 레버리지 값을 설정하는 데 사용됩니다.symbol매개 변수. 매개 변수만 통과하는 것과 호환marginLevel거래 대상인 {@var/EXCHANGE exchange}의 현재 거래 쌍 또는 계약의 레버리지 값을 설정합니다.
exchange.SetMarginLevel ((기호, 마진 레벨) 교환.변경수준을 설정 (변경수준)
이symbol이 매개 변수는 거래 쌍 또는 거래 계약에 대해 레버리지 값을 조정해야 하는 것을 지정하는 데 사용됩니다.symbol매개 변수SetMarginLevel()기능은symbol매개 변수GetTicker()기능.
기호
거짓
문자열
의marginLevel이 매개 변수는 레버리지 값을 설정하는 데 사용됩니다. 일반적으로 거래소에 전체 숫자이며 일부 거래소에 부동 소수점 레버리지 값 설정을 지원합니다.
마진수준
사실
번호
function main() {
exchange.SetMarginLevel(10)
// Set the leverage of BTC’s USDT-margined perpetual contract to 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()기능은 암호화폐 선물 계약 교환 객체만 지원합니다.exchange.SetMarginLevel()레버리지 값을 설정하는 기능입니다.
암호화폐 선물 계약의 경우, 암호화폐 선물 계약 거래소 때문에 레버리지 메커니즘은 균일하지 않습니다. 일부 거래소에서는 선물 계약의 레버리지 값은 주문 배치 인터페이스의 매개 변수입니다.exchange.SetMarginLevel()함수는 네트워크 요청을 생성하지 않고, 기본 FMZ 시스템에서 레버리지 변수를 설정합니다. 이 경우 거래소 웹 사이트 페이지 또는 API 인터페이스를 사용하여 설정해야하는 거래소의 레버리지 값입니다.exchange.SetMarginLevel()이 함수는 네트워크 요청을 생성하고 레버리지를 설정하지 않을 수 있습니다. 예를 들어 현재 위치 또는 대기 주문이 있으므로 이 거래 쌍 또는 계약에 대한 새로운 레버리지 값을 설정하는 것이 불가능합니다.
지원하지 않는 거래소exchange.SetMarginLevel()기능:
| 함수 이름 | 지원되지 않는 스팟 교환 | 지원되지 않은 선물 거래 |
|---|---|---|
| MarginLevel 설정 | – | 선물_dYdX / 선물_데리빗 |
{@var/EXCHANGE 교환}
이exchange.SetDirection()함수는 {@fun/Trade/exchange.Buy exchange.Buy} 함수, {@fun/Trade/exchange.Sell exchange.Sell} 함수의 주문 방향을 설정하는 데 사용됩니다.
교환.SetDirection (방향 설정)
이direction매개 변수는 주문을 할 때 선물 계약의 방향을 설정하는 데 사용됩니다. 선택적 값은:"buy", "closesell", "sell", "closebuy"...
방향
사실
문자열
function main(){
// For example, set to OKX futures contract of this week
exchange.SetContractType("this_week")
// Set leverage to 5 times
exchange.SetMarginLevel(5)
// Set the order type to long
exchange.SetDirection("buy")
// Place an order for 2 contracts at 10,000
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);
}
이exchange.SetDirection()이 함수는 선물 계약 거래 방향과 주문 배치 함수 사이의 대응을 설정합니다.
| 주문 배치 기능 | SetDirection 함수의 매개 변수들에 의해 설정된 방향 | 언급 |
|---|---|---|
| exchange.Buy | 긴 포지션을 구매하고 오픈합니다 | |
| exchange.Buy | 코트 포지션 구매 및 폐쇄 | |
| exchange.Sell | 판매 및 오픈 짧은 위치 | |
| exchange.Sell | 긴 포지션을 팔고 닫습니다. |
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
이exchange.SetContractType()이 함수는 {@var/EXCHANGE exchange} 교환 객체의 현재 계약 코드를 설정하는 데 사용됩니다.
이exchange.SetContractType()이 함수는 현재 계약 코드와 일치하는 거래 계약 코드를 포함하는 구조를 반환합니다. 예를 들어, 바이낸스 선물 계약 거래소에서 현재 계약 코드는quarter이 함수의 반환 값 구조는:{"InstrumentID": "BTCUSD_230630", "instrument": "BTCUSD_230630"}...
물체
exchange.SetContractType (표)
이symbol매개 변수는 계약 코드를 설정하는 데 사용됩니다. 선택 값은:"this_week", "next_week", "quarter", "next_quarter", "swap", 등등
암호화폐 선물 계약배달 계약코드는 지정되지 않은 경우 일반적으로 다음과 같습니다.
this_week: 현 주 계약.next_week다음 주 계약quarter: 분기 계약.next_quarter: 다음 분기 계약.영구 계약암호화폐 선물계약의 코드는 일반적으로 다음을 포함합니다.swap: 영구 계약.기호 사실 문자열
function main() {
// Set to this week contract
exchange.SetContractType("this_week")
}
def main():
exchange.SetContractType("this_week")
void main() {
exchange.SetContractType("this_week");
}
현재 계약은 현재 주 계약으로 설정:
function main() {
// The default trading pair is BTC_USD, set the contract for this week, and the contract is a currency standard contract
exchange.SetContractType("this_week")
Log("ticker:", exchange.GetTicker())
// Switching trading pairs, then setting up contracts, switching to USDT as margin contracts, as opposed to currency standard contracts
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(){
// Set the contract for this week
var ret = exchange.SetContractType("this_week")
// Return information about the current week's contracts
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's '통화 표준영구계약
지원되는 암호화폐 선물계약 거래소의 세부 정보와 각 거래소의 계약명:
미래에셋대우 (OKCoin) (OKX)
영구 계약으로 설정: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")
OKX는 시장 전 거래 계약을 가지고 있습니다: 계약 납품 날짜는 고정 시간입니다. 거래소에서 정의 된 계약 코드는 예를 들어:HMSTR-USDT-250207거래 쌍을HMSTR_USDTFMZ 플랫폼에, 그리고 그 다음 사용exchange.SetContractType("HMSTR-USDT-250207")계약서를 작성하기 위해.
이 기능을 지원하는 기능에 대해symbol파라미터, 예를 들어:exchange.GetTicker(), exchange.CreateOrder(), 등symbol매개 변수:HMSTR_USDT.HMSTR-USDT-250207이 계약에 대한 시장 데이터를 얻거나 주문을 할 수 있습니다.
퓨처스_후오비DM (후오비 퓨처스)
이번 주 계약에 맞춰: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()계약서를 다시 설정하는 기능을 합니다.
퓨처스_비트메크 (BitMEX)
영구 계약으로 설정:exchange.SetContractType("swap")- 네
퓨처스_비트메크스 거래소 배달 계약은 다음 계약 코드 (한வரி부터 12월까지) 를 가진 월간 계약입니다.
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
배송 계약의 수립exchange.SetContractType("December")예를 들어, 거래 쌍이XBT_USDT, 그exchange.SetContractType("December")이 함수는 BTC에 기반한 USDT로 12월 배송 계약을 설정합니다 (BTC의 실제 계약 코드와 일치합니다)XBTUSDTZ23).
퓨처스_비트메크스 계약 정보 요약
| Futures_BitMEX에 의해 정의된 계약 코드 | FMZ에 해당하는 거래 쌍 | FMZ에서 해당 계약 코드 | 언급 |
|---|---|---|---|
| DOGEUSD | DOGE_USD | 교환 | USD로 표기되어 XBT가 결제됩니다. XBT는 BTC입니다. |
| DOGEUSDT | DOGE_USDT | 교환 | USDT로 표결, USDT로 결제 |
| XBTETH | XBT_ETH | 교환 | ETH로 정액, XBT로 정액 |
| XBTEUR | XBT_EUR | 교환 | 유로, XBT로 결제 |
| USDTUSDC | USDT_USDC | 교환 | USDC로 표결하고 XBT로 결산 |
| ETHUSD_ETH | ETH_USD_ETH | 교환 | 미국 달러로 표결하고 ETH로 결제됩니다. |
| XBTH24 | XBT_USD | 3월 | 만료일: 3월 24일, 달 코드는: H; USD로 표정, XBT로 결제. |
| ETHUSDZ23 | ETH_USD | 12월 | 만료일: 12월 23일, 달 코드는: Z; USD로 표기, XBT로 결제. |
| XBTUSDTZ23 | XBT_USDT | 12월 | 만료일: 12월 23일, 달 코드는: Z; USDT로 표결, USDT로 결제. |
| ADAZ23 | ADA_XBT | 12월 | 만료일: 12월 23일, 달 코드는: Z ; XBT 결제, XBT 결제. |
| P_XBTETFX23 | USDT_XXX | P_XBTETFX23 | 만료일: 11/23/23; 비율로 표기되어 USDT로 결산됩니다. |
퓨처스_게이트
이번 주 계약에 맞춰: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"...
CFD (future_combo):"this_week,swap", "next_week,swap", "next_quarter,this_week", "third_quarter,this_week", "month,next_week", 많은 조합이 있습니다.
옵션 계약에 대해서는 거래소에서 정의한 특정 옵션 계약 코드를 입력해야 합니다. 자세한 내용은 Deribit 웹사이트를 참조하십시오.
퓨처스_쿠코인
예를 들어, 거래 쌍이BTC_USD그리고 계약 코드가 설정되면 통화 기반 계약입니다.
영구 계약으로 설정:exchange.SetContractType("swap")...
분기 계약으로 설정:exchange.SetContractType("quarter")- 그래요
다음 분기 계약으로 설정:exchange.SetContractType("next_quarter").
마진 계약으로 USDT:
예를 들어, 거래 쌍이BTC_USDT, 그리고 계약 코드를 설정, 그것은 마진으로 USDT와 계약입니다.
영구 계약으로 설정:exchange.SetContractType("swap").
미래에셋자산
바이낸스 미래에셋 거래소는 현재 거래 쌍의 영구 계약에 기본 설정, 계약 코드:swap...
영구 계약으로 설정:exchange.SetContractType("swap"), 바이낸스의 영구계약은USDT예를 들어,USDT표준 영구 계약BTC마진 계약으로 사용될 수 있고 거래 쌍은BTC_USDT바이낸스는 또한, 예를 들어, 마진으로 동전을 사용하는 영구 계약을 지원합니다.BTCBinance의 표준 영구 계약, 거래 쌍을 설정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, 그 다음 계약 코드를 설정.
바이낸스 옵션 계약 지원:
옵션 계약 코드의 형식은 거래소에서 정의한 옵션 계약 코드 (option contract code) 를 기반으로 합니다.BTC-241227-15000-C, XRP-240112-0.5-C, BTC-241227-15000-P바이낸스 옵션 계약 코드BTC-241227-15000-P예를 들어: BTC는 옵션 통화 코드, 241227는 실행 날짜, 15000은 실행 가격, P는 판매 옵션을, C는 통화 옵션을 나타냅니다.
옵션 유형에 대한 자세한 내용은 유럽 옵션 또는 미국 옵션인지에 대한 자세한 내용은 거래소의 옵션 계약의 관련 정보를 참조하십시오.
거래소는 옵션 판매자를 제한하고 자격을 별도로 신청하도록 요구할 수 있습니다. 바이낸스 옵션은 판매자 자격을 요구합니다.
퓨처스_비박스
비박스 영구 계약 계약 계약 코드:swap...
영구 계약으로 설정:exchange.SetContractType("swap").
퓨처스_비비트
기본 조건은 현재 거래 쌍의 영구 계약, 계약 코드:swap...
이번 주 계약 코드:this_week...
다음주 계약 코드:next_week...
3주 계약 코드:third_week...
월계약 코드:month...
다음 달 계약 코드:next_month- 그래요
분기 계약 코드:quarter- 그래요
다음 분기 계약 코드:next_quarter...
3분기 계약 코드:third_quarter.
미래_크래켄
기본 조건은 현재 거래 쌍의 영구 계약, 계약 코드:swap.
swap: 영구 계약.month: 현달 계약.quarter: 분기 계약.next_quarter다음 분기 계약.swap_pf: 혼합 마진 영구 계약.quarter_ff: 혼합 마진 분기 계약.month_ff: 혼합 마진 현달 계약.next_quarter_ff: 혼합 마진 다음 분기 계약.
퓨처스_비트피넥스
현재 거래 쌍에 대한 상속 계약, 계약 코드:swap.
퓨처스_비트젯
현재 거래 쌍에 대한 상속 계약, 계약 코드:swap...
거래 쌍은BTC_USD통화 표준 계약의 경우, 거래 쌍은BTC_USDT계약에 대해USDT데모 계약은 거래 쌍으로 설정될 수 있습니다.SBTC_USD, BTC_SUSDT.
선물_dYdX
dYdX 상시 계약에 대한 계약 코드:swap...
영구 계약으로 설정:exchange.SetContractType("swap"), dYdX는 USDT 표준 계약만 가지고 있습니다.
퓨처스_MEXC
MEXC 상시계약의 계약 코드:swap...
영구 계약으로 설정:exchange.SetContractType("swap")거래 쌍을BTC_USD, 즉 통화 표준 계약, 그리고 거래 쌍을 설정BTC_USDT, 즉USDT-계약은 끝났어
선물_크립토
토큰에 대한 계좌crypto.com이 거래소에서 거래할 수 있는 마진으로 사용할 수 있는 USD로 표현된 크레딧으로 전환될 수 있습니다.
영구 계약으로 설정:exchange.SetContractType("swap")예를 들어exchange.SetContractType("swap")거래 쌍이 BTC에 대한 영구계약을 설정하는 기능BTC_USD...
의crypto.com교환 배송 계약은 다음 계약 코드 (한월부터 12월까지) 를 가진 월간 계약입니다.
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
배달 계약을 설정:exchange.SetContractType("October")예를 들어, 거래 쌍이BTC_USD, 함수를 호출exchange.SetContractType("October")BTC를 위한 10월 배달 계약을 정하기 위해서요.
현재 해당 계약 코드는:BTCUSD-231027.
미래에셋대우
선물_WOO 교환 지원USDT상시 계약 코드swap예를 들어, 거래 쌍이BTC_USDT, 그 기능exchange.SetContractType("swap")현재 계약은 BTC를 위한 USDT 기반의 영구 계약으로 설정해야 합니다.
{@fun/Futures/exchange.GetContractType exchange.GetContractType}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}
이exchange.GetContractType()이 함수는 {@var/EXCHANGE exchange} 교환 객체의 현재 설정에 대한 계약 코드를 얻기 위해 사용됩니다.
이exchange.GetContractType()함수는 FMZ 플랫폼에 의해 정의된 계약 코드를 반환합니다. 예를 들어:this_week, swap, 등등
문자열
exchange.GetContractType (계약형)
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()이 함수는 현재 기간에 대한 자금 조달율 데이터를 얻기 위해 사용됩니다.
이exchange.GetFundings()함수는 데이터 요청이 성공했을 때 {@struct/Funding Funding} 구조의 배열을 반환하고 데이터 요청이 실패했을 때 null 값을 반환합니다.
{@struct/Funding Funding} 배열, null 값
교환.GetFundings (() 교환.금융을 얻으십시오 (표)
매개 변수symbol사용 됩니다거래 기호또는거래 기호 범위의문을 제기 할 수 있습니다.symbol이 매개 변수가 통과되지 않으면, 현재 거래 쌍과 계약 코드의 차원 범위에서 기본적으로 모든 도구의 현재 자금 조달 비율 데이터가 요청됩니다.
기호 거짓 문자열
/*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-hour period
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 Requested market types:", 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-hour period
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 Requested market types:", 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-hour period
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 Requested market types:", arrSymbol.dump(), "\n`" + tbls.dump() + "`");
}
선물 교환 객체를 사용하여exchange.GetFundings()역 테스트 시스템에서 함수. 어떤 시장 함수를 호출하기 전에, GetFundings는 현재 기본 거래 쌍의 자금 데이터를만 반환합니다. 시장 함수를 호출 한 후, 모든 요청 된 품종의 자금 데이터를 반환합니다. 다음 테스트 예제를 참조 할 수 있습니다:
미래에셋 거래소에서 투자율 데이터를 대량 검색을 지원하지 않는 경우symbol매개 변수는 질의 범위로 지정됩니다. 예를 들어:USDT.swap또는symbol매개 변수가 전달되지 않으면 인터페이스에서 오류를 보고합니다.GetFundings()이 유형의 선물 교환 객체를 사용 함수, 당신은symbol특정 영구계약 유형으로 매개 변수, 해당 유형의 현재 투자율 데이터를 검색하기 위해
의exchange.GetFundings()이 기능은 실제 거래 및 백테스팅 시스템을 지원합니다.
투자율 데이터의 대량 인수를 지원하지 않는 거래소: Futures_Bitget, Futures_OKX, Futures_MEXC, Futures_Deribit, Futures_Cryptosymbol특정 기호 코드를 가진 매개 변수, 예를 들어:ETH_USDT.swap.
거래소를 지원하지 않는 거래소exchange.GetFundings()기능:
| 함수 이름 | 지원되지 않는 스팟 교환 | 지원되지 않은 선물 거래 |
|---|---|---|
| GetFundings | – | 미래에셋대우 |
{@struct/FundingFunding}
이exchange.SetBase()이 함수는 {@var/EXCHANGE exchange} 교환 객체에서 구성된 교환 API 인터페이스의 기본 주소를 설정하는 데 사용됩니다.
교환.SetBase (들)
이s이 매개 변수는 교환 API 인터페이스 기본 주소를 지정하는 데 사용됩니다.
s
사실
문자열
function main() {
// Use default base address
Log(exchange.GetTicker())
// Switch to 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());
}
교환 API 기본 주소를 전환하는 것은 백테스팅 시스템에서 지원되지 않습니다. 왜냐하면 백테스팅 시스템은 샌드박스 시뮬레이션 환경이기 때문에 실제로 교환 API 인터페이스에 액세스하지 않습니다.
{@fun/Trade/exchange.IO exchange.IO}
이exchange.GetBase()이 함수는 현재 교환 API 인터페이스 기본 주소를 얻기 위해 사용됩니다.
현재 교환 API 인터페이스 기본 주소 문자열
교환.GetBase()
function main() {
Log(exchange.GetBase())
}
def main():
Log(exchange.GetBase())
void main() {
Log(exchange.GetBase());
}
{@fun/NetSettings/exchange.SetBase 교환.SetBase}
이exchange.SetProxy()이 함수는 {@var/EXCHANGE exchange} 교환 객체의 프록시 구성을 설정하는 데 사용됩니다.
교환.SetProxy (프로시)
이proxy이 매개 변수는 프록시 구성을 지정하는 데 사용됩니다.
대리자
사실
문자열
function main() {
exchange.SetProxy("socks5://192.168.1.10:8080")
// If you can't access the exchange ticker interface, set up an available ss5 proxy and you can access the ticker interface
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());
}
교환 대상을 구성합니다socks5대리인:
function main(){
exchange.SetProxy("ip://10.0.3.15")
// The requested IP address is 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} 교환 객체로부터 요청되는 IP 주소의 경우, 또한 {@var/EXCHANGE exchange}에 기반한 IP 주소를 지정할 수 있습니다.
프록시 설정이 실패하면,exchange.SetProxy()함수는 호출할 때 null을 반환합니다.exchange.SetProxy()함수rest하나의 프록시 (proxy) 는 각 {@var/EXCHANGE exchange} 교환 객체에 대해 설정할 수 있으며, 프록시 (proxy) 를 설정한 후 {@var/EXCHANGE exchange} 교환 객체에 연결된 교환 인터페이스에 대한 액세스는 프록시 (proxy) 를 통해 액세스됩니다.
설정 지원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} 교환 객체에서 요청의 IP 주소를 설정하는 것을 지원합니다.전체적으로 지정된.
{@var/EXCHANGE 교환}
이exchange.SetTimeout()이 함수는 시간 정지를 설정하는 데 사용됩니다rest{@var/EXCHANGE exchange} 교환 객체에 대한 요청.
교환.SetTimeout (타임아웃)
이timeout매개 변수는 타임아웃 설정에 필요한 밀리초 수를 지정하는 데 사용됩니다.
타임아웃
사실
번호
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), 설정rest시간 정지 요청exchange네트워크 요청과 함께 함수를 호출exchange.GetTicker()3초 이상 응답을 받지 않는 함수 호출은 타임아웃이 되고, 타임아웃을 하는 함수 호출은 null값을 반환합니다.SetTimeout()이 함수는 글로벌 함수가 아니라 {@var/EXCHANGE exchange} 교환 객체의 메소드입니다.
{@var/EXCHANGE 교환}
FMZ 퀀트 트레이딩 플랫폼은 실제로JavaScript언어 전략은 시스템 밑바닥에서 시작하여 다음과 같은 목표를 구현합니다.
| 물체 | 방향 | 언급 |
|---|---|---|
| 스레딩 | 멀티 스레드 글로벌 오브젝트 | 위원들의 역할:Thread, getThread, mainThread, 등등 |
| 스라인 | 스레드 객체 | 위원들의 역할:peekMessage, postMessage, join, 등등 |
| 스레드 잠금 | 스레드 잠금 객체 | 위원들의 역할:acquire, release그들은 스레드 실행 함수의 매개 변수로 스레드 환경에 전달될 수 있습니다. |
| 스레드 이벤트 | 이벤트 객체 | 위원들의 역할:set, clear, wait, isSet그들은 스레드 실행 함수의 매개 변수로 스레드 환경에 전달될 수 있습니다. |
| 스레드 조건 | 조건 객체 | 위원들의 역할:notify, notifyAll, wait, acquire, release그들은 스레드 실행 함수의 매개 변수로 스레드 환경에 전달될 수 있습니다. |
| ThreadDict | 사전 객체 | 위원들의 역할:get, set그들은 스레드 실행 함수의 매개 변수로 스레드 환경에 전달될 수 있습니다. |
이threadingobject는 동시 스레드, 스레드 잠금 및 조건 객체를 생성하는 등의 기능을 제공하는 글로벌 멀티 스레드 관리 도구입니다. 이 섹션에서는 스레드 관리의 구성원 기능을 소개합니다.threading이 객체는JavaScript언어 전략
이Thread()함수는 동시 스레드를 생성하는 데 사용됩니다.
이Thread()함수는 a를 반환합니다Thread생성된 동시 스레드, 스레드 통신 등을 관리하는 데 사용되는 객체
Thread물체
Thread ((func,...args) 스레드 (... 항목)
매개 변수func동시에 실행되는 함수입니다 (리퍼런스에 의해 전달됩니다) 그리고 익명의 함수를 전달하는 것을 지원합니다.func여러 매개 변수를 받아들일 수 있습니다....args동시 실행 중입니다. 따라서,func이 모든 것이...args.
함수
사실
기능
매개 변수arg실제 매개 변수가func(즉 동시 스레드 실행 함수) 콜백이 실행될 때, 여러 매개 변수가 있을 수 있습니다.arg, 그리고 매개 변수 목록func이 모든 것이...args.
아그
거짓
문자열, 숫자, bool, 객체, 배열, 함수, null 값 및 시스템에서 지원되는 다른 유형
매개 변수item함수 참조와 동시에 실행되는 그들의 매개 변수를 포함하는 배열입니다.item매개 변수를 호출 할 때 전달 할 수 있습니다Thread function.
항목 사실 배열
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 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)
}
함수 문자열을 전달하는 것을 지원하고 동시 컴퓨팅을 위해 외부 라이브러리를 동적으로 가져올 수 있습니다.
스레드 함수func이산화탄소Thread()동시 실행을 위한 함수는 격리된 환경에서 실행되므로 스레드 외부의 변수는 직접 참조할 수 없으며, 스레드 내에서 다른 클로저 함수에 대한 참조가 지원되지 않습니다. 플랫폼에서 제공하는 모든 API는 스레드 내에서 호출 될 수 있지만 다른 사용자 정의 함수는 호출 될 수 없습니다.
백테스팅 시스템 및 라이브 거래 환경을 지원합니다. 모든 동시 스레드 관련 기능은 백테스팅 시스템에서 코드 호환성으로만 지원되며 실제로 동시 스레드에서 실행되지 않으므로이 장에서 반복되지 않습니다.
{@fun/Threads/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}
이getThread()함수는 지정된 스레드 ID를 기반으로 스레드 객체를 얻기 위해 사용됩니다.
이getThread()함수는Thread매개 변수에 의해 지정된 스레드Id를 가진 객체
Thread물체
getThread (threadId) 를 입력합니다.
매개 변수threadId스레드 객체 ID입니다. 파라미터를 지정하여 해당 스레드 객체를 얻습니다.
스레드 사실 번호
function main() {
var t1 = threading.Thread(function () {
Log("Hello thread1")
})
// The Thread object has a method: id(), which is used to get the thread ID. You can view the section of the document corresponding to the Thread object.
var threadId = t1.id()
var threadName = t1.name()
Log("threadId:", threadId, ", threadName:", threadName)
var t2 = threading.getThread(threadId)
Log(`threadId == t2.id():`, threadId == t2.id(), `, threadName == t2.name():`, threadName == t2.name())
}
지정된 스레드 객체를 통해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/threading/Lock Lock}, {@fun/Threads/threading/eventLoop}, {@fun/Threads/threads/threading/eventLoop}
이mainThread()이 함수는 주 가닥의 가닥 객체를 얻기 위해 사용됩니다.main()전략의 기능이 위치합니다.
이mainThread()이 함수는 메인 스레드의 스레드 객체를 반환합니다.
Thread물체
mainThread()
function main() {
Log("The threadId of the main thread:", threading.mainThread().id())
}
가져와Thread주요 스레드의 대상과 출력threadId주요 스레드입니다.
function test() {
Log("Output the main thread ID in the test function:", 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}
이currentThread()함수는 현재 스레드의 스레드 객체를 얻기 위해 사용됩니다.
이currentThread()함수는 현재 스레드의 스레드 객체를 반환합니다.
Thread물체
현재 스레드 ((()
function test() {
Log("Id of the current thread:", 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/event Loop}, {@fun/Threads/threads/threading/mainThread mainThread}, {@fun/Threads/threads/threading/threading/threading/thread Thread Lock}, {@fun/Threads/threads/threading/lock Lock}, {@fun/Threads/threading/eventLoop eventLoop}, {@fun/Threads/threads/eventLoop}
이Lock()이 함수는 스레드 잠금 객체를 생성하는 데 사용됩니다.
이Lock()함수는 스레드 잠금 객체를 반환합니다.
ThreadLock물체
잠금 (()
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/Thread Thread}, {@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/threading/eventLoop}, {@fun/Threads/threads/threads/eventLoop}
이Condition()함수는 조건 변수 객체를 생성하는 데 사용되며, 이는 다중 스레드 동시 환경에서 스레드 간의 동기화 및 통신을 달성하는 데 사용됩니다.Condition(), 특정 조건이 충족되지 않을 때 다른 스레드가 조건이 충족되었다는 것을 알릴 때까지 스레드가 기다릴 수 있습니다.
이Condition()함수는 a를 반환합니다ThreadCondition object.
ThreadCondition물체
상태 (()
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/threading/Thread Thread}, {@fun/Threads/threads/threading/Event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/threading/eventLoop}
이Event()함수를 생성하는 데 사용됩니다스레드 이벤트스레드 간의 동기화를 위해 사용되는 객체, 하나의 스레드가 다른 스레드로부터의 알림이나 신호를 기다리는 것을 허용합니다.
이Event()함수는 a를 반환합니다ThreadEvent object.
ThreadEvent물체
이벤트
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/threading/Thread Thread}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/threading/eventLoop eventop},
이Dict()함수는 동시 스레드에 전달하기 위해 사전 객체를 생성하는 데 사용됩니다.
이Dict()함수는 a를 반환합니다ThreadDict object.
ThreadDict물체
딕트 (Dict)
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()
}
놔줘ThreadDict이 객체에 의해 만들어진Dict()동시 스레드 실행 함수와 함수를 연결하고, 객체의 키 값을 수정하면 다른 스레드에서 객체의 키 값을 변경할 수 있는지 테스트합니다.
공통 객체가 동시 스레드 함수로 전달되면, 그것은 딥 코피로 전달됩니다. 동시 스레드에서 키 값을 수정하면 다른 스레드의 사전에 영향을 미치지 않습니다.
백테스팅 시스템과 라이브 거래 환경을 지원합니다.
{@fun/Threads/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함수는 현재 전략 프로그램에서 실행되는 동시 스레드의 수를 얻기 위해 사용됩니다.
이pending()이 함수는 현재 전략 프로그램이 실행 중인 동시 스레드의 수를 반환합니다.
번호
미뤄지고 있습니다.
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}
Thread객체를 생성하거나 반환할 수 있습니다threading.Thread(), threading.getThread(), threading.mainThread(), 그리고threading.currentThread().
이peekMessage()함수는 스레드에서 메시지를 얻기 위해 사용됩니다.
이peekMessage()function는 현재 스레드 객체와 연관된 스레드에 의해 수신된 메시지를 반환합니다.
문자열, 숫자, bool, 객체, 배열, null 값 및 시스템에서 지원되는 다른 유형
peekMessage() peekMessage (시간 정지)
매개 변수timeouttimeout 설정입니다. 매개 변수에서 설정한 밀리초 수를 차단하고 대기하여 데이터를 반환합니다. 데이터가 없으면 타임아웃이 한계를 초과하면 null 값이 반환됩니다.timeout0으로 설정되거나timeout매개 변수가 전달되지 않는 경우, 그것은 프로세스가 차단하고 채널에서 데이터가 수신 될 때까지 기다린다는 것을 의미합니다.timeout-1로 설정되면 프로세스가 즉시 데이터를 차단하고 반환하지 않는다는 것을 의미합니다. 데이터가 없으면 null 값이 반환됩니다.
타임아웃 거짓 번호
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/Threads/thread/join name}, {@Threads/Threads/eventLoop eventLoop}
이postMessage()함수는 스레드에 메시지를 보내는데 사용됩니다.
postMessage ((msg)
매개 변수msg이 메시지가 전달되어야 합니다.
msg 사실 문자열, 숫자, bool, 객체, 배열, null 값 등과 같은 시스템에서 지원되는 모든 유형
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()메시지의 알림을 수신하기 위해
스레드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/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Threads/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}
이join()이 함수는 스레드가 종료되고 시스템 리소스를 검색할 때까지 기다리기 위해 사용됩니다.
이ThreadRet물체실행 결과에 대한 데이터를 포함합니다. 속성은 다음을 포함합니다:
ThreadRet물체
합시다. join (타임오웃)
이timeout패러미터는 스레드가 끝날 때까지 기다리는 밀리 초에 타임아웃을 설정하는 데 사용됩니다.timeout매개 변수가 0으로 설정되거나timeout매개 변수가 설정되지 않은 경우,join()이 함수는 스레드가 실행을 마칠 때까지 기다립니다.timeout매개 변수가 -1로 설정되면,join()기능이 즉시 회복됩니다.
타임아웃 거짓 번호
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()타임아웃 함수와 반환 값을 출력합니다.
이join()함수 출구 및 반환 시간undefined.
{@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/Threads/Thread/name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}
이terminate()이 함수는 스레드를 강제로 종료하고 생성된 스레드가 사용하는 하드웨어 자원을 풀어주는 데 사용됩니다.
종료 (()
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/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}
이getData()이 함수는 스레드 환경에서 기록된 변수에 액세스하는 데 사용됩니다. 스레드가 스레드를 실행하지 않았을 때 데이터가 유효합니다.join()기능 (출출 성공을 기다리고) 를 실행하지 않았습니다terminate()함수 (강력으로 스레드를 끝내는 것)
이getData()함수는key현재 스레드 컨텍스트에 저장된 키-값 쌍의 매개 변수
문자열, 숫자, bool, 객체, 배열, null 값 및 시스템에서 지원되는 다른 유형
getData (데이터) getData (키)
이key매개 변수는 저장된 키값 쌍의 키 이름입니다.
키 사실 문자열
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}, {@fun/Threads/Thread/eventLoop eventLoop}
이setData()함수는 스레드 컨텍스트의 변수를 저장하는 데 사용됩니다.
setData (키, 값)
이key매개 변수는 저장된 키-값 쌍의 키 이름을 지정하는 데 사용됩니다.
키
사실
문자열
의value매개 변수는 저장된 키와 값 쌍의 키 값을 지정하는 데 사용됩니다.
가치 사실 문자열, 숫자, bool, 객체, 배열, null 값 등과 같은 시스템에서 지원되는 모든 유형
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Sleep(1000)
Log(`t1.getData("data"):`, t1.getData("data"))
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/Threads/Thread/eventLoop eventLoop}
이id()함수를 반환하는 데 사용됩니다threadId현재 멀티 스레드 객체 인스턴스
이 값의 반환 값은id()함수는threadId.
번호
id()
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/Threads/Thread/name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}
이name()이 함수는 현재 멀티 스레드 객체 인스턴스의 이름을 반환하는 데 사용됩니다.
이name()함수는 동시 스레드 이름을 반환합니다.
문자열
이름 (()
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/Thread/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/thread/eventLoop eventLoop}
이eventLoop()이 함수는 스레드에서 수신되는 이벤트를 듣기 위해 사용됩니다.
이eventLoop()함수는 현재 스레드에 의해 수신된 이벤트 정보를 반환합니다. 참조이벤트 정보 구조.
객체, null 값
이벤트 루프 (eventLoop) 이벤트 루프 (타임아웃)
매개 변수timeout이 매개 변수에서timeout0으로 설정되면, 반환하기 전에 이벤트가 발생하기를 기다립니다. 0보다 크다면, 이벤트 대기 타임 아웃을 설정합니다. 0보다 작다면, 가장 최근의 이벤트를 즉시 반환합니다.
타임아웃 거짓 번호
function main() {
var t1 = threading.Thread(function() {
while (true) {
var eventMsg = threading.currentThread().eventLoop() // Blocking wait
// 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) // Return immediately
Log(_D(), "thread2 eventMsg:", eventMsg)
Sleep(5000)
}
})
var t3 = threading.Thread(function() {
while (true) {
var eventMsg = threading.currentThread().eventLoop(3000) // Set a 3 second timeout
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()
}
동시에 세 개의 스레드를 실행하고 수신된 이벤트 정보를 출력합니다. 타임 아웃이 발생하거나 함수가 즉시 반환되면 출력 값은 null입니다.
그 처리 메커니즘은eventLoop()함수는 전체 함수와 같습니다EventLoop().
{@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 setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name},
스레드 잠금 객체, 멀티 스레드 동기화 처리용
이acquire()함수는 스레드 잠금 (lock) 을 요청하는 데 사용됩니다.
취득 (()
참고:threading.Lock()예제 섹션.
이acquire()스레드 로크를 요청하는 기능입니다. 스레드가 스레드 로크를 호출할 때acquire()스레드 잠금 객체의 함수, 그것은 잠금을 획득하려고합니다. 만약 잠금이 현재 다른 스레드에 의해 유지되지 않는다면, 호출 스레드는 잠금을 성공적으로 획득하고 실행을 계속합니다. 만약 잠금이 이미 다른 스레드에 의해 유지된다면, 스레드 호출acquire()잠금 장치가 풀리기 전까지 잠금됩니다.
{@fun/Threads/threading/Lock Lock}, {@fun/Threads/ThreadLock/release release}
이release()함수는 스레드 잠금 (불 잠금) 을 풀기 위해 사용됩니다.
방출
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() placed after pLock.acquire() will not cause deadlock
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()신호를 제거하는 기능입니다.
맑습니다.
참고:threading.Event()예제 섹션.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}
이wait()함수는 이벤트 (신호) 대기 설정에 사용되며 이벤트 (신호) 설정 전에 차단됩니다. 타임 아웃 매개 변수를 설정하는 것을 지원합니다.
이wait()timeout가 발생했는지 여부를 반환합니다. 만약 그렇다면 true값을 반환합니다.
bool
잠깐만 기다려 (타임오웃)
이timeout이 매개 변수는 대기 시간을 밀리 초로 설정하는 데 사용됩니다.
타임아웃 거짓 번호
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() function.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/isSet isSet}
이isSet()함수는 이벤트 (신호) 가 설정되었는지 여부를 결정하는 데 사용됩니다.
이isSet()함수는 이벤트 (신호) 가 설정되었는지 여부를 반환합니다. 이벤트 (신호) 가 설정되어 있다면 true 값을 반환합니다.
bool
isSet ((()
참고:threading.Event()예제 섹션.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}
조건 객체, 멀티 스레드 동기화를 위해 사용된다.
이notify()이 함수는 대기 스레드를 깨우기 위해 사용 됩니다.wait()이 방법은 깨어나게 될 것입니다.
통지합니다
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()이 함수는 대기열의 스레드를 깨우게 합니다.
그 때notify()이 함수가 스레드를 깨우면 스레드는 스레드 잠금 장치를 다시 얻습니다.
{@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
이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()특정 설계 조건에서 스레드를 기다리게 하는 기능입니다.
잠깐만
참고:ThreadCondition.notify()예제 섹션.
이wait()기능은 스레드 잠금을 풀고 깨어나면 스레드 잠금을 다시 얻습니다.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
이acquire()함수는 스레드 잠금 (lock) 을 요청하는 데 사용됩니다.
취득 (()
참고:ThreadCondition.notify()예제 섹션.
사용 전에wait(), 당신은 현재 상태 객체의 스레드 잠금 (lock) 를 요청해야 합니다.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/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}
데이터 공유에 사용되는 사전 객체
이get()함수는 사전 객체에 기록된 키 값을 얻기 위해 사용됩니다.
이get()함수는 키의 값을 반환key parameter.
문자열, 숫자, bool, 객체, 배열, null 값 및 시스템에서 지원되는 다른 유형
get (키)
이key이 매개 변수는 얻을 수 있는 키에 해당하는 키 이름을 지정하는 데 사용됩니다.
키 사실 문자열
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()이 함수는 키와 값의 쌍을 설정하는 데 사용됩니다.
set (키, 값)
매개 변수key변경해야 하는 키 이름을 설정하는 데 사용됩니다.
키
사실
문자열
매개 변수value변경해야 하는 키 값을 설정하는 데 사용됩니다.
가치 사실 문자열, 숫자, bool, 객체, 배열, null 값 및 시스템에서 지원되는 다른 유형
참고:ThreadDict.get()예제 섹션.
###############################################################################################################################################################################################################################################################
FMZ 퀀트 트레이딩 플랫폼에서는 주로 다양한 기능을 구현합니다.exchange.IO()다음 문서에서는exchange.IO()그 기능에 따라 별도로 작동합니다.exchange.IO("abi", ...)ABI를 등록하는 기능입니다.
exchange.IO(k, 주소, abiContent)
이k매개 변수exchange.IO()함수, 설정"abi"함수가 등록을 위해 사용되는 것을 의미합니다.ABI...
k
사실
문자열
의address이 매개 변수는 스마트 계약의 주소를 지정하는 데 사용됩니다.
주소
사실
문자열
의abiContent매개 변수를 지정하는 데 사용됩니다ABI스마트 컨트랙트.
abi콘텐츠
사실
문자열
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"}]`
// Get the ```ABI``` content of the contract can be obtained with the following URL, taking the ```result``` field only, e.g:
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 메소드를 호출하는 데 사용됩니다.
이exchange.IO("api", "eth", ...)함수는 호출된 RPC 방법의 반환 값을 반환합니다.
문자열, 숫자, bool, object, array, null 및 시스템에서 지원하는 다른 모든 타입
exchange.IO(k, 블록 체인, rpc 메소드)exchange.IO(k, 블록 체인, rpc 메소드,...args)
이k매개 변수exchange.IO()함수, 설정"api"함수가 호출 요청을 확장하는 데 사용되는 것을 나타냅니다.
k
사실
문자열
의blockChain매개 변수exchange.IO()함수, 설정"eth"함수가 Ethereum 네트워크에서 RPC 메소드 호출에 사용된다는 것을 나타냅니다.
블록 체인
사실
문자열
의rpcMethod이 매개 변수는 RPC 메소드를 설정하는 데 사용됩니다.exchange.IO()기능.
rpc 방법
사실
문자열
의arg매개 변수는 호출되는 RPC 메소드의 매개 변수를 지정하는 데 사용됩니다.arg매개 변수arg그 매개 변수들은rpcMethod매개 변수
아그
거짓
문자열, 숫자, bool, 객체, 배열, 함수, null 및 시스템에서 지원하는 다른 모든 유형
function main() {
// "owner" needs to be replaced with the specific wallet address
// Parameter labels for the "latest" string position: 'latest', 'earliest' or 'pending', please refrer to https://eth.wiki/json-rpc/API#the-default-block-parameter
// The return value ethBalance is a hexadecimal string: 0x9b19ce56113070
var ethBalance = exchange.IO("api", "eth", "eth_getBalance", "owner", "latest")
// ETH has a precision unit of 1e18
var ethDecimal = 18
// Because of the JavaScript language precision, it is necessary to use the system underlying package function BigInt, BigDecimal to process
// Convert ethBalance to readable amount, 0x9b19ce56113070 to 0.043656995388076145
Log(Number((BigDecimal(BigInt(ethBalance))/BigDecimal(Math.pow(10, ethDecimal))).toString()))
}
지갑에 있는 ETH 잔액을 확인하세요:
function mian() {
// ETH has a precision unit of 1e18
var ethDecimal = 18
// Number of transfers, readable amount e.g. 0.01 ETH
var sendAmount = 0.01
// Due to the JavaScript language precision, it is necessary to use the system underlying encapsulated functions BigInt, BigDecimal to process, and to convert the readable amount to the data processed on the chain
var toAmount = (BigDecimal(sendAmount)*BigDecimal(Math.pow(10, ethDecimal))).toFixed(0)
// "toAddress" is the address of the recipient's ETH wallet at the time of the transfer, which needs to be filled in specifically, and toAmount is the number of transfers
exchange.IO("api", "eth", "send", "toAddress", toAmount)
}
ETH 송금의 경우{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) {
// The toAmount function can convert hex-encoded values to decimal values
return Number((BigDecimal(BigInt(s))/BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
// Coding approve (authorization) method calls
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:
두 번째 매개 변수는exchange.IO()함수"eth"이더리움 노드 서버에서 사용할 수 있는 RPC 메소드를 직접 호출할 수 있습니다.
###############################################################################################################################################################################################################################################################
이exchange.IO("encode", ...)데이터 인코딩을 위해 함수가 호출됩니다.
이exchange.IO("encode", ...)함수는 암호화된 데이터를 반환합니다.
문자열
exchange.IO(k, dataFormat,...args)exchange.IO(k, 주소, 데이터 포맷)exchange.IO(k, 주소, 데이터 포맷,...args)
이k매개 변수exchange.IO()함수, 설정"encode"함수는 데이터 코딩에 사용됩니다.
k
사실
문자열
의address이 매개 변수는 스마트 계약의 주소를 설정하는 데 사용됩니다.exchange.IO("encode", ...)기능,address매개 변수는 스마트 계약에 메소드 호출을 코딩을 나타냅니다.exchange.IO("encode", ...)기능, 만약address매개 변수가 전달되지 않는 경우, 함수는 지정된 타입 순서를 코딩하는 데 사용되며 기능적으로abi.encode안쪽Solidity...
주소
거짓
문자열
의dataFormat이 매개 변수는 암호화된 데이터의 방법, 유형 및 순서를 지정하는 데 사용됩니다.
데이터 형식
사실
문자열
의arg이 매개 변수는dataFormat한 개 이상 있을 수 있습니다.arg매개 변수와arg매개 변수dataFormat파라미터 설정
아그
거짓
문자열, 숫자, 튜플, 배열, 그리고 시스템에서 지원하는 다른 모든 유형
function main() {
// Main network address of ContractV3SwapRouterV2: 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
// Calling the unwrapWETH9 method requires registering the ABI first, which is omitted here
// "owner" represents the wallet address, which need to fill in the specific, 1 represents the number of unpacking, unpacking a WETH into 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 i.e. uint256 , the type length needs to be specified on FMZ
Log("ret:", ret)
/*
000000000000000000000000000000000000000000000000000000000000000a // x
00000000000000000000000002a5fbb259d20a3ad2fdf9ccadef86f6c1c1ccc9 // address
0000000000000000000000000000000000000000000000000000000000000080 // Offset of str
00000000000000000000000000000000000000000000000000000000000000c0 // Offset of array
000000000000000000000000000000000000000000000000000000000000000b // The length of str
48656c6c6f20576f726c64000000000000000000000000000000000000000000 // str data
0000000000000000000000000000000000000000000000000000000000000003 // The length of the array
0000000000000000000000000000000000000000000000000000000000000001 // array the first data
0000000000000000000000000000000000000000000000000000000000000002 // array the second data
0000000000000000000000000000000000000000000000000000000000000003 // array the third data
*/
}
이 예제와 같습니다abi.encode안쪽Solidity:
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).
bytes:"0011"
function main() {
var path = ["0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", "0xdac17f958d2ee523a2206206994597c13d831ec7"] // ETH address, USDT address
var ret = exchange.IO("encode", "address[]", path)
Log("encode: ", ret)
}
배열 또는 배열을 포함하는 타입의 순차적 인코딩을 지원합니다:
이exchange.IO()함수는encode함수 호출 코드를 반환할 수 있는hex문자열 형식입니다. 특정 사용을 위해 공개된 플랫폼을 참조할 수 있습니다.
이exchange.IO("encodePacked", ...)함수에서 호출되는 방식은encodePacked encoding.
이exchange.IO("encodePacked", ...)함수는encodePacked암호화된 데이터
문자열
exchange.IO(k, dataFormat,...args)
이k매개 변수exchange.IO()함수, 설정"encodePacked"함수가 데이터에 사용되는 것을 의미합니다.encodePacked코딩.
k
사실
문자열
의dataFormat매개 변수는 종류와 순서를 지정하는 데 사용됩니다encodePacked암호화된 데이터
데이터 형식
사실
문자열
의arg이 매개 변수는dataFormat한 개 이상 있을 수 있습니다.arg매개 변수와arg매개 변수dataFormat파라미터 설정
아그
사실
문자열, 숫자, 튜플, 배열, 그리고 시스템에서 지원하는 다른 모든 유형
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", ...)함수는 해독에 사용되는 방식으로 호출됩니다.
이exchange.IO("decode", ...)function는 해독된 데이터를 반환합니다.dataFormat매개 변수. 매개 변수에 의해 지정된 하나 이상의 데이터가 있을 때 배열을 반환dataFormat매개 변수
배열,string
exchange.IO(k, data포맷, 데이터)
이k매개 변수exchange.IO()기능, 그리고 설정"decode"함수가 데이터 디코딩에 사용된다는 뜻입니다.
k
사실
문자열
의dataFormat이 매개 변수는 복호화된 데이터의 종류와 순서를 지정하는 데 사용됩니다.
데이터 형식
사실
문자열
의data이 매개 변수는 암호 해독 데이터를 설정하는 데 사용됩니다.
데이터
사실
문자열
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)
}
역동 작동exchange.IO("encode", ...)기능:
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 only uses the contents of the local exactOutput method, the full abi can be searched on the Internet
// 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)
}
다음 예제에서는 먼저encodePacked에 대한 작업path패러미터 처리,exactOutput나중에 코딩해야 하는 메소드 호출은path매개 변수로encode의exactOutput라우팅 계약의 방법, 타입의 하나의 매개 변수만tuple방법 이름exactOutput코딩:0x09b81346, 그리고exchange.IO("decode", ...)그 결과의 암호를 해독하는 방법decodeRaw, 변수와 일치합니다dataTuple.
데이터 처리를 위해,exchange.IO()이 기능은 암호화뿐만 아니라 해독도 지원합니다.
이exchange.IO("key", ...)이 함수는 개인 키를 전환하는 방식으로 호출됩니다.
exchange.IO(K, 키)
매개 변수k이 기능을 설정하는 데 사용됩니다.exchange.IO()함수, 설정"key"함수는 개인 키를 전환하는 데 사용됩니다.
k
사실
문자열
의key프라이빗 키를 설정하는 매개 변수입니다
키
사실
문자열
function main() {
exchange.IO("key", "Private Key") // "Private Key" represents the private key string, which needs to be filled in specifically
}
이exchange.IO()함수는 개인 키를 전환하는 것을 지원하며 여러 지갑 주소를 조작할 수 있습니다. 여러 지갑 주소를 조작하기 위해 여러 교환 객체를 추가 할 수도 있습니다.
이exchange.IO("api", ...)이 함수는 스마트 계약의 메소드를 호출하는 데 사용되는 방식으로 호출됩니다.
이exchange.IO("api", ...)함수는 소위 스마트 계약 방법의 반환 값을 반환합니다.
문자열, 숫자, bool, object, array, null 및 시스템에서 지원하는 다른 모든 타입
exchange.IO(k, 주소, 방법)exchange.IO(k, 주소, 방법,...args)exchange.IO(k, 주소, 방법, 값,...args)
이k매개 변수exchange.IO()함수, 설정"api"함수가 호출 요청을 확장하는 데 사용되는 것을 나타냅니다.
k
사실
문자열
의address이 매개 변수는 스마트 계약의 주소를 지정하는 데 사용됩니다.
주소
사실
문자열
의method이 매개 변수는 호출될 스마트 계약의 메소드를 지정하는 데 사용됩니다.
방법
사실
문자열
의value이 매개 변수는 전송될 ETH의 양을 설정하는 데 사용됩니다.stateMutability실행해야 하는 스마트 계약 메소드의 속성은payable, 그 다음value매개 변수를 전달해야 합니다."stateMutability": "payable"ABI에서 볼 수 있습니다.exchange.IO()함수는 필요 매개 변수를stateMutability등록 된 ABI에 속성.stateMutability속성은nonpayable, 그 다음value매개 변수는 전달할 필요가 없습니다.
가치
거짓
숫자, 문자열
의arg이 매개 변수는 호출될 스마트 계약의 메소드의 매개 변수를 지정하는 데 사용됩니다.arg매개 변수와arg매개 변수는 호출되는 스마트 계약의 방법에 달려 있습니다.
아그
거짓
문자열, 숫자, bool, 그리고 시스템에서 지원하는 다른 모든 유형
function main(){
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302" // The contract address of the token, the token is 1INCH in the example
Log(exchange.IO("api", tokenAddress, "decimals")) // Query, print 1INCH tokens with precision index of 18
}
이decimals방법은constant이 ERC20의 방법은 가스 소비를 발생하지 않으며 토큰의 정확성 데이터를 검색 할 수 있습니다.decimals메소드에는 매개 변수가 없습니다. 반환 값: 토큰의 정확성 데이터.
function main(){
// The contract address of the token, in the example the token is 1INCH
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
// For example, the query yields 1000000000000000000, divided by the precision unit of the token 1e18, the wallet to which the current exchange object is bound has authorized 1 1INCH to the spender address
Log(exchange.IO("api", tokenAddress, "allowance", "owner", "spender"))
}
이allowance방법은constantERC20의 방법은 가스 소비를 생성하지 않으며 특정 계약 주소에 대한 승인 된 토큰 금액을 검색 할 수 있습니다.allowance이 방법은 2개의 매개 변수를 취하고, 첫 번째는 지갑 주소이고 두 번째는 승인 주소입니다. 반환 값: 토큰의 승인 금액.
owner: 지갑의 주소는, 예제는 문자열 spender: 허가 계약의 주소를, 예를 들어 문자열에 의해 대체됩니다Uniswap V3 router v1 address.
function main(){
// The contract address of the token, the token is 1INCH in the example
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
// The hexadecimal string of the authorization amount: 0xde0b6b3a7640000 , the corresponding decimal string: 1e18 , 1e18 divided by the precision unit of the token, i.e. 1 token amount, so this refers to the authorization of one token
Log(exchange.IO("api", tokenAddress, "approve", "spender", "0xde0b6b3a7640000"))
}```
The ```approve``` method is a non-```constant``` method of ERC20, which generates gas consumption and is used to authorize the operation amount of a token to a contract address. The ```approve``` method takes 2 parameters, the first one is the address to be authorized and the second one is the amount to be authorized. Return value: txid.
```spender```: the address of the authorized contract, the example is replaced by the string "spender", the actual use needs to fill in the specific address, for example, it can be ```Uniswap V3 router v1``` address. ```0xde0b6b3a7640000```: the number of authorizations, here is the hexadecimal string, the corresponding decimal value is 1e18, divided by the token precision unit in the example (i.e. 1e18). The result is that 1 token is authorized. The third parameter of the ```exchange.IO()``` function is passed to the method name ```approve```, which can also be written in the form of methodId, such as "0x571ac8b0". It is also possible to write the full standard method name, for example: "approve(address,uint256)".
```javascript
function main() {
var ContractV3SwapRouterV2 = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var tokenInName = "ETH"
var amountIn = 0.01
var options = {gasPrice: 5000000000, gasLimit: 21000, nonce: 100} // This is an example, depending on the actual scene settings
var data = "" // The encoded data, here is the empty string, depending on the actual scene settings
var tx = exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", (tokenInName == 'ETH' ? amountIn : 0), (new Date().getTime() / 1000) + 3600, data, options || {})
}
이multicall이 방법은constant방법Uniswap V3가스 소비를 발생시키고 여러 가지 방법으로 토큰을 환불하는 데 사용됩니다.
의multicall메소드는 매개 변수를 전달하는 다양한 방법을 가질 수 있습니다. 메소드를 구체적으로 포함하는 ABI를 확인할 수 있습니다. 메소드를 호출하기 전에 ABI를 등록해야 합니다. 반환 값: txid.
구체적인 예제multicall방법 호출, 당신은 공개 가능한 플랫폼을 참조할 수 있습니다
이 부분에서는 위조 코드를 사용하여 몇 가지 세부 사항을 설명합니다.
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data)
ContractV3SwapRouterV2: Uniswap V3의 라우터 v2의 주소value: 교환 거래의 토큰인 토큰이 ETH가 아닌 경우 전송할 ETH의 금액, 0로 설정됩니다.deadline: deadline이 지표의 매개 변수multicall메소드 (new Date().getTime() / 1000) + 3600로 설정할 수 있어 1시간 동안 유효합니다.data: data이 지표의 매개 변수multicall메소드, 수행해야 하는 포장 작업의 데이터
비슷한exchange.IO("api", "eth", "send", "toAddress", toAmount), 그gasLimit/gasPrice/nonce설정 방법 호출을 호출 할 때 지정할 수 있습니다multicall방법.
다시 말하지만, 우리는 표절 코드를 사용하여
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data, {gasPrice: 123456, gasLimit: 21000})
매개 변수{gasPrice: 11, gasLimit: 111, nonce: 111}특정 필요에 따라 설정할 수 있습니다.exchange.IO()기능.
방치 할 수 있습니다.nonce그리고 시스템 기본값을 사용하거나gasLimit/gasPrice/nonce설정 해제하고 모든 시스템 기본값을 사용하세요.
이exchange.IO("address")함수는 {@var/EXCHANGE exchange} 교환 객체에 의해 구성된 지갑의 주소를 얻을 수 있는 방식으로 호출됩니다.
이exchange.IO("address")이 함수는 구성된 지갑 주소를 반환합니다.
문자열
exchange.IO(k)
이k매개 변수exchange.IO()함수, 설정"address"함수가 구성된 지갑 주소를 얻기 위해 사용된다는 것을 의미합니다.
k
사실
문자열
function main() {
Log(exchange.IO("address")) // Print the wallet address of the private key configured on the exchange object
}
이exchange.IO("base", ...)함수는 RPC 노드 주소를 설정하는 방식으로 호출됩니다.
exchange.IO(k, 주소)
이k매개 변수exchange.IO()함수, 설정"base"함수는 RPC 노드를 전환하는 데 사용됩니다.
k
사실
문자열
의address이 매개 변수는 RPC 노드 주소를 설정하는 데 사용됩니다.
주소
사실
문자열
function main() {
var chainRpc = "https://bsc-dataseed.binance.org"
e.IO("base", chainRpc) // Switching to BSC chain
}
이TA.MACD()함수는 계산에 사용됩니다기하급수적으로 평평한 불일치와 유사성 MACD 지표.
이 값의 반환 값은TA.MACD()함수는 구조가 있는 2차원 배열입니다.[DIF, DEA, MACD]...
배열
TA.MACD ((inReal) TA.MACD ((현실, optInFastPeriod, optInSlowPeriod, optInSignalPeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInFastPeriod패러미터는 빠른 기간을 설정하는 데 사용됩니다.
optInFastPeriod
거짓
번호
의optInSlowPeriod이 매개 변수는 느린 기간을 설정하는 데 사용됩니다.
optInSlowPeriod
거짓
번호
의optInSignalPeriod이 매개 변수는 신호 기간을 설정하는 데 사용됩니다.
opt신호 기간
거짓
번호
function main(){
// You can fill in different k-line periods, such as PERIOD_M1,PERIOD_M30,PERIOD_H1...
var records = exchange.GetRecords(PERIOD_M15)
var macd = TA.MACD(records, 12, 26, 9)
// Watching the logs, you can see that three arrays are returned, corresponding to DIF, DEA and 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일반적인 지표 알고리즘에 최적화 된 FMZ Quant의 지표 라이브러리.JavaScript, Python, C++언어 전략 요청오픈 소스 TA 라이브러리 코드...
기본 값은optInFastPeriod, optInSlowPeriod, 그리고optInSignalPeriod변수TA.MACD()기능은12, 26, 그리고9.
[@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()함수는 구조가 있는 2차원 배열입니다.[K, D, J]...
배열
TA.KDJ ((inReal) TA.KDJ ((실제, 기간, k 기간, d 기간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의period매개 변수는 1기를 설정하는 데 사용됩니다.
기간
거짓
번호
의kPeriod파라미터는 기간 2을 설정하는 데 사용됩니다.
k기간
거짓
번호
의dPeriod파라미터는 기간 3을 설정하는 데 사용됩니다.
d기간
거짓
번호
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]);
}
기본 값은period, kPeriod, 그리고dPeriod변수TA.KDJ()기능은9, 3, 그리고3.
[@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()함수는: 1차원 배열입니다.
배열
TA.RSI (인리얼) TA.RSI (실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다.
optInTime 기간
거짓
번호
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);
}
기본 값optInTimePeriod매개 변수TA.RSI()함수는:14.
[@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()함수는: 1차원 배열입니다.
배열
TA.ATR ((인프라이스HLC) TA.ATR ((인프라이스HLC, optInTimePeriod)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다.
optInTime 기간
거짓
번호
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);
}
기본 값optInTimePeriod매개 변수TA.ATR()함수는:14.
[@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.OBV TA.OBV},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()함수는: 1차원 배열입니다.
배열
TA.OBV ((inReal) TA.OBV ((inReal, inPriceV)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의inPriceV매개 변수는 거래 금액 데이터를 지정하는 데 사용됩니다.
inPriceV
거짓
{@struct/Record Record} 구조 배열
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},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.MA()함수는 계산에 사용됩니다MACD 지표.
이 값의 반환 값은TA.MA()함수는: 1차원 배열입니다.
배열
TA.MA(이인리얼)TA.MA(inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다.
optInTime 기간
거짓
번호
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);
}
기본 값optInTimePeriod매개 변수TA.MA()함수는:9.
[@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.CM TAF.CMF}, {@fun/TA/TA.Highest.Hist}, {@fun/TA/TA.Lowest.TA.Lowest},
이TA.EMA()함수는 계산에 사용됩니다지수 평균 지표.
이 값의 반환 값은TA.EMA()함수는: 1차원 배열입니다.
배열
TA.EMA ((inReal) TA.EMA (실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다.
optInTime 기간
거짓
번호
function main(){
var records = exchange.GetRecords()
// Determine if the number of K-line bars meets the calculation period of the indicator
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);
}
}
기본 값optInTimePeriod매개 변수TA.EMA()함수는:9.
[@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR},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()함수는 구조가 있는 2차원 배열입니다.[upLine, midLine, downLine]...
배열
TA.BOLL ((inReal) TA.BOLL (실제, 점, 곱)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의period이 매개 변수는 기간을 설정하는 데 사용됩니다.
기간
거짓
번호
의multiplier이 매개 변수는 곱셈을 설정하는 데 사용됩니다.
곱셈
거짓
번호
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);
}
}
기본 값은period그리고multiplier변수TA.BOLL()기능은20그리고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},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()함수는 구조가 있는 2차원 배열입니다.[jawLine, teethLine, lipsLine]...
배열
TA. 알리거터 (inReal) TA. 알리거터 (진짜, 턱길이, 이빨길이, 입술길이)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의jawLength매개 변수는 턱 기간을 설정하는 데 사용됩니다.
턱길이
거짓
번호
의teethLength이변은 치아 기간을 설정하는 데 사용됩니다.
이빨길이
거짓
번호
의lipsLength이 매개 변수는 윗입술의 주위를 설정하는 데 사용됩니다.
입술길이
거짓
번호
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]);
}
기본 값은jawLength, teethLength, 그리고lipsLength변수TA.Alligator()기능은13, 8, 그리고5.
[@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR},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()함수는: 1차원 배열입니다.
배열
TA.CMF ((inReal) TA.CMF ((inReal, inPriceV)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의inPriceV매개 변수는 부피 데이터를 지정하는 데 사용됩니다.
inPriceV
거짓
{@struct/Record Record} 구조 배열
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},TA.MA{,@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
이TA.Highest()함수는 계산에 사용됩니다기간 최고 가격.
이TA.Highest()함수는 현재 바를 제외한 마지막 특정 기간에 속성의 최대 값을 반환합니다.
번호
TA.최고 (실제) TA.최고 (실제, 기간, attr)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의period이 매개 변수는 기간을 설정하는 데 사용됩니다.
기간
거짓
번호
의attr매개 변수는 속성을 설정하는 데 사용됩니다. 선택적으로:Open, Close, Low, High, Volume, OpenInterest...
어트르
거짓
문자열
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, 그것은 모든 계산을 의미BarsK-라인 데이터의inReal매개 변수, 만약 속성 매개 변수attr정해지지 않은 경우, K-라인 데이터가inReal매개 변수는 일반 배열로 간주됩니다.
[@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR},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.Lowest TA.Lowest}
이TA.Lowest()함수는 계산에 사용됩니다기간 최저 가격.
이TA.Lowest()함수는 현재 바를 제외한 마지막 특정 기간에 속성의 최소 값을 반환합니다.
번호
TA.Lowest (실제) TA.최저 (실제, 기간, attr)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의period이 매개 변수는 기간을 설정하는 데 사용됩니다.
기간
거짓
번호
의attr매개 변수는 속성을 설정하는 데 사용됩니다. 선택적으로:Open, Close, Low, High, Volume, OpenInterest...
어트르
거짓
문자열
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, 그것은 모든 계산을 의미BarsK-라인 데이터의inReal매개 변수, 만약 속성 매개 변수attr정해지지 않은 경우, K-라인 데이터가inReal매개 변수는 일반 배열로 간주됩니다.
사용TA.Highest()그리고TA.Lowest()의 역할C++이 전략은Highest()그리고Lowest()각각의 함수들은 2개의 매개 변수만 가지고 있습니다.
그리고 첫 번째 매개 변수는 K-라인 데이터가 아닙니다.r함수auto r = exchange.GetRecords()전화가 왔습니다.
전화해야 돼r특정 속성 데이터에 전달. 예를 들어,r.Close()종료 가격 데이터.Close, High, Low, Open, Volume같은r.Close()호출 방법
시험 예제C++언어 전략
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);
}
for(int j = 0; j < r.size(); j++){
Log(r[j]);
}
// Note: the first parameter passed is not r, you need to call 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},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()함수는: 1차원 배열입니다.
배열
TA.SMA ((inReal) TA.SMA (실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다.
optInTime 기간
거짓
번호
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);
}
기본 값optInTimePeriod매개 변수TA.SMA()함수는:9.
[@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR},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.CDL2CROWS()함수는 계산에 사용됩니다두 까마귀 (K-line chart - Two Crows).
이 값의 반환 값은talib.CDL2CROWS()함수는 1차원 배열입니다.
배열
talib.CDL2CROWS ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDL2CROWS()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDL2CROWS(Records[Open,High,Low,Close]) = Array(outInteger)전화에 대해Python언어, 통과 매개 변수는 다르며 위의 설명에 근거해야 합니다.Records[Open,High,Low,Close].
변수를 분할하는 예records(즉, 파라미터)inPriceOHLC, {@struct/Record Record} 구조의 배열을 입력:Openlist: 파이썬으로records.Open.
High목록:records.High파이썬에서Lowlist: 파이썬으로records.Low.
Closelist: 파이썬으로records.Close.
파이썬 전략 코드에서 호출:
talib.CDL2CROWS(records.Open, records.High, records.Low, records.Close)
다른talib지표들은 동일하게 설명되고 반복되지 않습니다.
이talib.CDL3BLACKCROWS()함수는 계산에 사용됩니다세 개의 검은 까마귀 (K-line chart - Three Black Crows).
이 값의 반환 값은talib.CDL3BLACKCROWS()함수는: 1차원 배열입니다.
배열
talib.CDL3BLACKCROWS ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDL3BLACKCROWS()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDL3BLACKCROWS(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDL3INSIDE()함수는 계산에 사용됩니다3 내부 위/아래 (K-라인 차트: 3 내부 위/아래).
이 값의 반환 값은talib.CDL3INSIDE()함수는: 1차원 배열입니다.
배열
talib.CDL3INSIDE ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDL3INSIDE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDL3INSIDE(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDL3LINESTRIKE()함수는 계산에 사용됩니다3선 스트라이크 (K선 차트: 3선 스트라이크).
이 값의 반환 값은talib.CDL3LINESTRIKE()함수는: 1차원 배열입니다.
배열
talib.CDL3LINESTRIKE ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDL3LINESTRIKE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDL3LINESTRIKE(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDL3OUTSIDE()함수는 계산에 사용됩니다위/아래로 3개 (K선 차트: 위/아래로 3개).
이 값의 반환 값은talib.CDL3OUTSIDE()함수는: 1차원 배열입니다.
배열
talib.CDL3OUTSIDE ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDL3OUTSIDE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDL3OUTSIDE(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDL3STARSINSOUTH()함수는 계산에 사용됩니다남쪽의 세 별 (K-line chart: Three Stars In The South).
이 값의 반환 값은talib.CDL3STARSINSOUTH()함수는: 1차원 배열입니다.
배열
talib.CDL3STARSINSOUTH ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDL3STARSINSOUTH()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDL3STARSINSOUTH(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDL3WHITESOLDIERS()함수는 계산에 사용됩니다3명 의 백병 들 의 진격 (K-라인 차트: 3명 의 백병 들 의 진격).
이 값의 반환 값은talib.CDL3WHITESOLDIERS()함수는: 1차원 배열입니다.
배열
talib.CDL3WHITESOLDIERS ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDL3WHITESOLDIERS()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDL3WHITESOLDIERS(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLABANDONEDBABY()함수는 계산에 사용됩니다버려진 아기 (K선 차트: 버려진 아기).
이 값의 반환 값은talib.CDLABANDONEDBABY()함수는: 1차원 배열입니다.
배열
talib.CDLABANDONEDBABY ((인프라이스OHLC) talib.CDLABANDONEDBABY ((인프라이스OHLC, optInPenetration)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
의optInPenetration매개 변수를 사용 하 여 침투를 설정 합니다, 기본 값은 0.3입니다.
optInPenetration
거짓
번호
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);
}
이CDLABANDONEDBABY()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLABANDONEDBABY(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
이talib.CDLADVANCEBLOCK()함수는 계산에 사용됩니다선행 블록 (K-라인 차트: 선행).
이 값의 반환 값은talib.CDLADVANCEBLOCK()함수는 1차원 배열입니다.
배열
talib.CDLADVANCEBLOCK ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLADVANCEBLOCK()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLADVANCEBLOCK(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLBELTHOLD()함수는 계산에 사용됩니다벨트 붙잡기 (K선 차트: 벨트 붙잡기).
이 값의 반환 값은talib.CDLBELTHOLD()함수는: 1차원 배열입니다.
배열
talib.CDLBELTHOLD ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLBELTHOLD()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLBELTHOLD(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLBREAKAWAY()함수는 계산에 사용됩니다브레이카웨이 (K-라인 차트: 브레이카웨이).
이 값의 반환 값은talib.CDLBREAKAWAY()함수는: 1차원 배열입니다.
배열
talib.CDLBREAKAWAY ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
CDLBREAKAWAY()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLBREAKAWAY(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLCLOSINGMARUBOZU()함수는 계산에 사용됩니다마루보즈 (K-라인 차트: 맨발로 닫습니다).
이 값의 반환 값은talib.CDLCLOSINGMARUBOZU()함수는: 1차원 배열입니다.
배열
talib.CDLCLOSINGMARUBOZU ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLCLOSINGMARUBOZU()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLCLOSINGMARUBOZU(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLCONCEALBABYSWALL()함수는 계산에 사용됩니다아기 굴을 숨기는 것 (K-line chart: Baby Swallow 패턴을 숨기는 것).
이 값의 반환 값은talib.CDLCONCEALBABYSWALL()함수는: 1차원 배열입니다.
배열
talib.CDLCONCEALBABYSWALL ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLCONCEALBABYSWALL()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLCONCEALBABYSWALL(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLCOUNTERATTACK()함수는 계산에 사용됩니다반격 (K-라인 차트:반격).
이 값의 반환 값은talib.CDLCOUNTERATTACK()함수는 1차원 배열입니다.
배열
talib.CDL대항공 (inPriceOHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLCOUNTERATTACK()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLCOUNTERATTACK(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLDARKCLOUDCOVER()함수는 계산에 사용됩니다어두운 구름 덮개 (K-라인 차트: 어두운 구름 덮개).
이 값의 반환 값은talib.CDLDARKCLOUDCOVER()함수는 1차원 배열입니다.
배열
talib.CDDARKCLOUDCOVER ((인프라이스OHLC) talib.CDDARKCLOUDCOVER ((인프라이스OHLC, optInPenetration)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
의optInPenetration매개 변수를 사용 하 여 침투 설정, 기본 값은 0.5.
optInPenetration
거짓
번호
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);
}
이CDLDARKCLOUDCOVER()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLDARKCLOUDCOVER(Records[Open,High,Low,Close],Penetration = 0.5) = Array(outInteger)
이talib.CDLDOJI()함수는 계산에 사용됩니다도지 (K선 차트: 도지).
이 값의 반환 값은talib.CDLDOJI()함수는: 1차원 배열입니다.
배열
talib.CDLDOJI ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLDOJI()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLDOJISTAR()함수는 계산에 사용됩니다도지 스타 (K-라인 차트: 도지 스타).
이 값의 반환 값은talib.CDLDOJISTAR()함수는: 1차원 배열입니다.
배열
talib.CDLDOJISTAR ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLDOJISTAR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLDOJISTAR(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLDRAGONFLYDOJI()함수는 계산에 사용됩니다드래곤플라이 도지 (K-라인 차트: 드래곤플라이 도지).
이 값의 반환 값은talib.CDLDRAGONFLYDOJI()함수는: 1차원 배열입니다.
배열
타리브.CD 드래곤 플라이도지 (PriceOHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLDRAGONFLYDOJI()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLDRAGONFLYDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLENGULFING()함수는 계산에 사용됩니다삼켜는 패턴 (K-라인 차트: 삼켜는).
이 값의 반환 값은talib.CDLENGULFING()함수는 1차원 배열입니다.
배열
talib.CDLENGULFING ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLENGULFING()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLENGULFING(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLEVENINGDOJISTAR()함수는 계산에 사용됩니다저녁 도지 별 (K-라인 차트: 저녁 도지 별).
이 값의 반환 값은talib.CDLEVENINGDOJISTAR()함수는: 1차원 배열입니다.
배열
타리브.CDLEVENINGDOJISTAR (인프라이스 OHLC) talib.CDLEVENINGDOJISTAR ((인프라이스OHLC,optInPenetration)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
의optInPenetration매개 변수를 사용 하 여 침투를 설정 합니다, 기본 값은 0.3입니다.
optInPenetration
거짓
번호
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);
}
이CDLEVENINGDOJISTAR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLEVENINGDOJISTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
이talib.CDLEVENINGSTAR()함수는 계산에 사용됩니다이브닝 스타 (K-라인 차트: 이브닝 스타).
이 값의 반환 값은talib.CDLEVENINGSTAR()함수는: 1차원 배열입니다.
배열
타리브.CDLEVENINGSTAR (인프라이스) talib.CDLEVENINGSTAR ((인프라이스OHLC, optInPenetration)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
의optInPenetration매개 변수를 사용 하 여 침투를 설정 합니다, 기본 값은 0.3입니다.
optInPenetration
거짓
번호
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);
}
이CDLEVENINGSTAR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLEVENINGSTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
이talib.CDLGAPSIDESIDEWHITE()함수는 계산에 사용됩니다위/아래 간격 옆 하얀 선 (K선 차트: 위/아래 간격 옆 하얀 선).
이 값의 반환 값은talib.CDLGAPSIDESIDEWHITE()함수는: 1차원 배열입니다.
배열
talib.CDLGAPSIDESIDEWHITE ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLGAPSIDESIDEWHITE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLGAPSIDESIDEWHITE(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLGRAVESTONEDOJI()함수는 계산에 사용됩니다그레이브스토인 도지 (K-라인 차트: 그레이브스토인 도지).
이 값의 반환 값은talib.CDLGRAVESTONEDOJI()함수는: 1차원 배열입니다.
배열
타리브.CDL그라브스테론도지 (인프라이스)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLGRAVESTONEDOJI()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLGRAVESTONEDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLHAMMER()함수는 계산에 사용됩니다해머 (K-라인 차트: 해머).
이 값의 반환 값은talib.CDLHAMMER()함수는: 1차원 배열입니다.
배열
talib.CDLHAMMER ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLHAMMER()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLHAMMER(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLHANGINGMAN()함수는 계산에 사용됩니다
이 값의 반환 값은talib.CDLHANGINGMAN()함수는 1차원 배열입니다.
배열
타리브.CDLHANGINGMAN (인프라이스 OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLHANGINGMAN()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLHANGINGMAN(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLHARAMI()함수는 계산에 사용됩니다하라미 패턴 (K선 차트: 음선과 양선).
이 값의 반환 값은talib.CDLHARAMI()함수는 1차원 배열입니다.
배열
talib.CDLHARAMI ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLHARAMI()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLHARAMI(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLHARAMICROSS()함수는 계산에 사용됩니다하라미 십자 패턴 (K선 차트: 음선과 양선을 십자).
이 값의 반환 값은talib.CDLHARAMICROSS()함수는: 1차원 배열입니다.
배열
talib.CDLHARAMICROSS ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLHARAMICROSS()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLHARAMICROSS(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLHIGHWAVE()함수는 계산에 사용됩니다하이 웨이브 촛불 (K-라인 차트: 긴 다리 크로스).
이 값의 반환 값은talib.CDLHIGHWAVE()함수는 1차원 배열입니다.
배열
talib.CDLHIGHWAVE ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLHIGHWAVE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLHIGHWAVE(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLHIKKAKE()함수는 계산에 사용됩니다히카케 패턴 (K선 차트: 함정).
이 값의 반환 값은talib.CDLHIKKAKE()함수는 1차원 배열입니다.
배열
talib.CDLHIKKAKE ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLHIKKAKE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLHIKKAKE(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLHIKKAKEMOD()함수는 계산에 사용됩니다수정된 히카케 패턴 (K선 차트: 수정된 함정).
이 값의 반환 값은talib.CDLHIKKAKEMOD()함수는: 1차원 배열입니다.
배열
talib.CDLHIKKAKEMOD ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLHIKKAKEMOD()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLHIKKAKEMOD(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLHOMINGPIGEON()함수는 계산에 사용됩니다호밍
이 값의 반환 값은talib.CDLHOMINGPIGEON()함수는: 1차원 배열입니다.
배열
talib.CDLHOMINGPIGEON ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLHOMINGPIGEON()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLHOMINGPIGEON(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLIDENTICAL3CROWS()함수는 계산에 사용됩니다동일한 세 까마귀 (K-라인 차트: 같은 세 까마귀).
이 값의 반환 값은talib.CDLIDENTICAL3CROWS()함수는: 1차원 배열입니다.
배열
talib.CDLIDENTICAL3CROWS ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLIDENTICAL3CROWS()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLIDENTICAL3CROWS(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLINNECK()함수는 계산에 사용됩니다목 모양 (K선 차트: 목 모양).
이 값의 반환 값은talib.CDLINNECK()함수는: 1차원 배열입니다.
배열
talib.CDLINNECK ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLINNECK()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLINNECK(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLINVERTEDHAMMER()함수는 계산에 사용됩니다역동 망치 (K-라인 차트: 역동 망치).
이 값의 반환 값은talib.CDLINVERTEDHAMMER()함수는: 1차원 배열입니다.
배열
talib.CDLINVERTEDHAMMER ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLINVERTEDHAMMER()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLINVERTEDHAMMER(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLKICKING()함수는 계산에 사용됩니다
이 값의 반환 값은talib.CDLKICKING()함수는 1차원 배열입니다.
배열
타리브.CDLKICKING ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLKICKING()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLKICKING(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLKICKINGBYLENGTH()함수는 계산에 사용됩니다키크 - 더 긴 마루보즈로 결정된 황소/곰 (K-라인 차트: 키크 황소/키크 곰).
이 값의 반환 값은talib.CDLKICKINGBYLENGTH()함수는: 1차원 배열입니다.
배열
talib.CDLKICKINGBYLENGTH (PriceOHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLKICKINGBYLENGTH()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLKICKINGBYLENGTH(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLLADDERBOTTOM()함수는 계산에 사용됩니다사다리 바닥 (K-라인 차트: 사다리 바닥).
이 값의 반환 값은talib.CDLLADDERBOTTOM()함수는: 1차원 배열입니다.
배열
타리브.CDLLADDERBOTTOM ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLLADDERBOTTOM()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLLADDERBOTTOM(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLLONGLEGGEDDOJI()함수는 계산에 사용됩니다긴 다리 도지 (K선 차트: 긴 다리 도지).
이 값의 반환 값은talib.CDLLONGLEGGEDDOJI()함수는: 1차원 배열입니다.
배열
타리브.CDLLONGLEGGEDDOJI (인프라이스 OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLLONGLEGGEDDOJI()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLLONGLEGGEDDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLLONGLINE()함수는 계산에 사용됩니다롱 라인 촛불 (K 라인 차트: 롱 라인).
이 값의 반환 값은talib.CDLLONGLINE()함수는: 1차원 배열입니다.
배열
talib.CDLLONGLINE (인프라이스)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLLONGLINE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLLONGLINE(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLMARUBOZU()함수는 계산에 사용됩니다마루보즈 (K선 차트: 맨발의 머리와 맨발의 발).
이 값의 반환 값은talib.CDLMARUBOZU()함수는 1차원 배열입니다.
배열
talib.CDLMARUBOZU ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLMARUBOZU()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLMARUBOZU(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLMATCHINGLOW()함수는 계산에 사용됩니다매칭 로우 (K-라인 차트: 매칭 로우).
이 값의 반환 값은talib.CDLMATCHINGLOW()함수는: 1차원 배열입니다.
배열
talib.CDLMMATCHINGLOW ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLMATCHINGLOW()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLMATCHINGLOW(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLMATHOLD()함수는 계산에 사용됩니다매트 홀드 (K 라인 차트: 매트 홀드).
이 값의 반환 값은talib.CDLMATHOLD()함수는: 1차원 배열입니다.
배열
talib.CDLMATHOLD ((인프라이스OHLC) talib.CDLMATHOLD ((inPriceOHLC, optInPenetration)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
의optInPenetration이 매개 변수는 선택적이며 상승/하락 트렌드 라인의 너비의 비율을 지정하는 데 사용됩니다. 기본 값은 0.5입니다.
optInPenetration
거짓
번호
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);
}
이CDLMATHOLD()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLMATHOLD(Records[Open,High,Low,Close],Penetration = 0.5) = Array(outInteger)
이talib.CDLMORNINGDOJISTAR()함수는 계산에 사용됩니다아침 도지 별 (K-라인 차트: 아침 도지 별).
이 값의 반환 값은talib.CDLMORNINGDOJISTAR()함수는: 1차원 배열입니다.
배열
태리브.CDLMORNINGDOJISTAR (인프라이스 OHLC) talib.CDLMORNINGDOJISTAR ((인프라이스OHLC,optInPenetration)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
의optInPenetration이 매개 변수는 검증 시작 가격과 고체 부분 사이의 중복 정도를 지정하는 데 사용됩니다. 기본 값은 0.3입니다.
optInPenetration
거짓
번호
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);
}
이CDLMORNINGDOJISTAR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLMORNINGDOJISTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
이talib.CDLMORNINGSTAR()함수는 계산에 사용됩니다아침 별 (K선 차트: 아침 별).
이 값의 반환 값은talib.CDLMORNINGSTAR()함수는: 1차원 배열입니다.
배열
알리브.CDLMORNINGSTAR ((인프라이스OHLC) talib.CDLMORNINGSTAR ((인프라이스OHLC, optInPenetration)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
의optInPenetration매개 변수는 트렌드 확인에 필요한 가격 변동 비율의 문턱이며 값은 범위 [0,1]에서 기본 값은 0.3입니다.
optInPenetration
거짓
번호
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);
}
이CDLMORNINGSTAR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLMORNINGSTAR(Records[Open,High,Low,Close],Penetration=0.3) = Array(outInteger)
이talib.CDLONNECK()함수는 계산에 사용됩니다목 패턴 (K-라인 차트: 목 패턴).
이 값의 반환 값은talib.CDLONNECK()함수는 1차원 배열입니다.
배열
talib.CDLONNECK ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLONNECK()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLONNECK(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLPIERCING()함수는 계산에 사용됩니다피어싱 패턴 (K-라인 차트: 피어싱 패턴).
이 값의 반환 값은talib.CDLPIERCING()함수는 1차원 배열입니다.
배열
talib.CDLPIERCING ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLPIERCING()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLPIERCING(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLRICKSHAWMAN()함수는 계산에 사용됩니다릭샤맨 (K-라인 차트: 릭샤맨).
이 값의 반환 값은talib.CDLRICKSHAWMAN()함수는: 1차원 배열입니다.
배열
talib.CDLRICKSHAWMAN ((인프라이스OHLC)
이inPriceOHLC이 매개 변수는 K선 데이터를 지정하는 데 사용됩니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLRICKSHAWMAN()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLRICKSHAWMAN(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLRISEFALL3METHODS()함수는 계산에 사용됩니다상승/하락 세 가지 방법 (K-라인 차트: 상승/하락 세 가지 방법).
이 값의 반환 값은talib.CDLRISEFALL3METHODS()함수는: 1차원 배열입니다.
배열
talib.CDLRISEFALL3METHODS ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLRISEFALL3METHODS()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLRISEFALL3METHODS(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLSEPARATINGLINES()함수는 계산에 사용됩니다분리선 (K-선 차트: 분리선).
이 값의 반환 값은talib.CDLSEPARATINGLINES()함수는 1차원 배열입니다.
배열
talib.CDLSEPARATINGLINES ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLSEPARATINGLINES()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLSEPARATINGLINES(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLSHOOTINGSTAR()함수는 계산에 사용됩니다쏘닝 스타 (K-라인 차트: 쏘닝 스타).
이 값의 반환 값은talib.CDLSHOOTINGSTAR()함수는 1차원 배열입니다.
배열
타리브.CDSHOOTINGSTAR ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLSHOOTINGSTAR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLSHOOTINGSTAR(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLSHORTLINE()함수는 계산에 사용됩니다단선 촛불 (K-라인 차트: 단선).
이 값의 반환 값은talib.CDLSHORTLINE()함수는: 1차원 배열입니다.
배열
talib.CDLSSORTLINE ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLSHORTLINE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLSHORTLINE(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLSPINNINGTOP()함수는 계산에 사용됩니다스핀닝 톱 (K-라인 차트: 스핀닝 톱).
이 값의 반환 값은talib.CDLSPINNINGTOP()함수는: 1차원 배열입니다.
배열
talib.CDLSPINNINGTOP ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLSPINNINGTOP()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLSPINNINGTOP(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLSTALLEDPATTERN()함수는 계산에 사용됩니다정지 패턴 (K-라인 차트: 정지 패턴).
이 값의 반환 값은talib.CDLSTALLEDPATTERN()함수는: 1차원 배열입니다.
배열
talib.CDLSTALLEDPATTERN (인프라이스 OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLSTALLEDPATTERN()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLSTALLEDPATTERN(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLSTICKSANDWICH()함수는 계산에 사용됩니다스틱 샌드위치 (K선 차트: 스틱 샌드위치).
이 값의 반환 값은talib.CDLSTICKSANDWICH()함수는 1차원 배열입니다.
배열
talib.CDLSTICKSSANDWICH ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLSTICKSANDWICH()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLSTICKSANDWICH(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLTAKURI()함수는 계산에 사용됩니다타쿠리 (아래 그림자 선이 매우 길고 드래곤플라이 도지) (K선 차트: 타쿠리).
이 값의 반환 값은talib.CDLTAKURI()함수는 1차원 배열입니다.
배열
talib.CDLTAKURI ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLTAKURI()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLTAKURI(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLTASUKIGAP()함수는 계산에 사용됩니다타스키 간격 (K-라인 차트: 타스키 간격).
이 값의 반환 값은talib.CDLTASUKIGAP()함수는 1차원 배열입니다.
배열
talib.CDLTASUKIGAP ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLTASUKIGAP()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLTASUKIGAP(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLTHRUSTING()함수는 계산에 사용됩니다추진 패턴 (K-라인 차트: 추진 패턴).
이 값의 반환 값은talib.CDLTHRUSTING()함수는: 1차원 배열입니다.
배열
talib.CDLTHRUSTING ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLTHRUSTING()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLTHRUSTING(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLTRISTAR()함수는 계산에 사용됩니다트리스타 패턴 (K선 차트: 트리스타 패턴).
이 값의 반환 값은talib.CDLTRISTAR()함수는: 1차원 배열입니다.
배열
talib.CDLTRISTAR ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLTRISTAR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLTRISTAR(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLUNIQUE3RIVER()함수는 계산에 사용됩니다유니크 3 강 (K-라인 차트: 유니크 3 강).
이 값의 반환 값은talib.CDLUNIQUE3RIVER()함수는: 1차원 배열입니다.
배열
talib.CDLUNIQUE3RIVER ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLUNIQUE3RIVER()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLUNIQUE3RIVER(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLUPSIDEGAP2CROWS()함수는 계산에 사용됩니다상향 간격 두 까마귀 (K선 차트: 상향 간격 두 까마귀).
이 값의 반환 값은talib.CDLUPSIDEGAP2CROWS()함수는: 1차원 배열입니다.
배열
talib.CDLUPSIDEGAP2CROWS ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLUPSIDEGAP2CROWS()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLUPSIDEGAP2CROWS(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.CDLXSIDEGAP3METHODS()함수는 계산에 사용됩니다상향/하향 간격 세 가지 방법 (K-라인 차트: 상향/하향 간격 세 가지 방법).
이 값의 반환 값은talib.CDLXSIDEGAP3METHODS()함수는: 1차원 배열입니다.
배열
talib.CDLXSIDEGAP3METHODS (인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이CDLXSIDEGAP3METHODS()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CDLXSIDEGAP3METHODS(Records[Open,High,Low,Close]) = Array(outInteger)
이talib.AD()함수는 계산에 사용됩니다Chaikin A/D 라인 (라인 스토카스틱 표시기).
이 값의 반환 값은talib.AD()함수는: 1차원 배열입니다.
배열
talib.AD(PriceHLCV)
이inPriceHLCVK선 데이터를 지정하는 매개 변수입니다.
inPriceHLCV
사실
{@struct/Record Record} 구조 배열
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);
}
이AD()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.AD(Records[High,Low,Close,Volume]) = Array(outReal)
이talib.ADOSC()함수는 계산에 사용됩니다Chaikin A/D 오시레이터 (Chaikin Oscillator).
이 값의 반환 값은talib.ADOSC()함수는 1차원 배열입니다.
배열
talib.ADOSC ((인프라이스HLCV) talib.ADOSC ((인프라이스HLCV, optInFastPeriod, optInSlowPeriod)
이inPriceHLCVK선 데이터를 지정하는 매개 변수입니다.
inPriceHLCV
사실
{@struct/Record Record} 구조 배열
의optInFastPeriod패러미터는 빠른 기간을 설정하는 데 사용됩니다.
optInFastPeriod
거짓
번호
의optInSlowPeriod이 매개 변수는 느린 기간을 설정하는 데 사용됩니다.
optInSlowPeriod
거짓
번호
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);
}
이ADOSC()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.ADOSC(Records[High,Low,Close,Volume],Fast Period = 3,Slow Period = 10) = Array(outReal)
이talib.OBV()함수는 계산에 사용됩니다밸런스 부피 (에너지 유동).
이 값의 반환 값은talib.OBV()함수는 1차원 배열입니다.
배열
talib.OBV ((inReal) talib.OBV ((inReal, inPriceV)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의inPriceVK선 데이터를 지정하는 매개 변수입니다.
inPriceV
거짓
{@struct/Record Record} 구조 배열
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);
}
이OBV()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.OBV(Records[Close],Records[Volume]) = Array(outReal)
이talib.ACOS()함수는 계산에 사용됩니다벡터 삼각형 ACos (반면 코시노스 함수).
이 값의 반환 값은talib.ACOS()함수는 1차원 배열입니다.
배열
talib.ACOS ((인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이ACOS()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.ACOS(Records[Close]) = Array(outReal)
이talib.ASIN()함수는 계산에 사용됩니다벡터 삼각형 ASin (반면 시누스 함수).
이 값의 반환 값은talib.ASIN()함수는 1차원 배열입니다.
배열
talib.ASIN (인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이ASIN()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.ASIN(Records[Close]) = Array(outReal)
이talib.ATAN()함수는 계산에 사용됩니다벡터 삼각형 ATan (반면 접수함수).
이 값의 반환 값은talib.ATAN()함수는: 1차원 배열입니다.
배열
talib.ATAN (인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이ATAN()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.ATAN(Records[Close]) = Array(outReal)
이talib.CEIL()함수는 계산에 사용됩니다벡터 천장 (둥근 함수).
이 값의 반환 값은talib.CEIL()함수는 1차원 배열입니다.
배열
talib.CEIL (인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이CEIL()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CEIL(Records[Close]) = Array(outReal)
이talib.COS()함수는 계산에 사용됩니다벡터 삼각법 코스 (코시노스 함수).
이 값의 반환 값은talib.COS()함수는: 1차원 배열입니다.
배열
talib.COS ((inReal)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이COS()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.COS(Records[Close]) = Array(outReal)
이talib.COSH()함수는 계산에 사용됩니다벡터 삼각형 Cosh (하이퍼볼리 코시노스 값).
이 값의 반환 값은talib.COSH()함수는 1차원 배열입니다.
배열
talib.COSH (인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이COSH()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.COSH(Records[Close]) = Array(outReal)
이talib.EXP()함수는 계산에 사용됩니다벡터 수학적 Exp (배수 함수).
이 값의 반환 값은talib.EXP()함수는: 1차원 배열입니다.
배열
talib.EXP (인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이EXP()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.EXP(Records[Close]) = Array(outReal)
이talib.FLOOR()함수는 계산에 사용됩니다벡터 바닥 (아래로 둥근).
이 값의 반환 값은talib.FLOOR()함수는 1차원 배열입니다.
배열
talib.FLOOR ((inReal)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이FLOOR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.FLOOR(Records[Close]) = Array(outReal)
이talib.LN()함수는 계산에 사용됩니다벡터 로그 자연 (자연 로그리듬).
이 값의 반환 값은talib.LN()함수는 1차원 배열입니다.
배열
talib.LN (인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이LN()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.LN(Records[Close]) = Array(outReal)
이talib.LOG10()함수는 계산에 사용됩니다벡터 로그10 (로그리듬 함수).
이 값의 반환 값은talib.LOG10()함수는 1차원 배열입니다.
배열
talib.LOG10 ((inReal)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이LOG10()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.LOG10(Records[Close]) = Array(outReal)
이talib.SIN()함수는 계산에 사용됩니다벡터 삼각형 Sin (신수 값).
이 값의 반환 값은talib.SIN()함수는 1차원 배열입니다.
배열
talib.SIN ((인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이SIN()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.SIN(Records[Close]) = Array(outReal)
이talib.SINH()함수는 계산에 사용됩니다벡터 삼각형 시너스 (하이퍼볼리 시너스 함수).
이 값의 반환 값은talib.SINH()함수는: 1차원 배열입니다.
배열
talib.SINH (인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이SINH()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.SINH(Records[Close]) = Array(outReal)
이talib.SQRT()함수는 계산에 사용됩니다벡터 제곱근 (제곱근).
이 값의 반환 값은talib.SQRT()함수는: 1차원 배열입니다.
배열
talib.SQRT ((inReal)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이SQRT()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.SQRT(Records[Close]) = Array(outReal)
이talib.TAN()함수는 계산에 사용됩니다벡터 삼각형 텐 (관점).
이 값의 반환 값은talib.TAN()함수는 1차원 배열입니다.
배열
talib.TAN (인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이TAN()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.TAN(Records[Close]) = Array(outReal)
이talib.TANH()함수는 계산에 사용됩니다벡터 삼각형 Tanh (하이퍼볼릭 접수함수).
이 값의 반환 값은talib.TANH()함수는: 1차원 배열입니다.
배열
talib.TANH (인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이TANH()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.TANH(Records[Close]) = Array(outReal)
이talib.MAX()이 함수는 가장 높은 (최대) 값을 계산하는 데 사용됩니다.특정 기간.
이 값의 반환 값은talib.MAX()함수는: 1차원 배열입니다.
배열
talib.MAX (인리얼) talib.MAX ((inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이MAX()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MAX(Records[Close],Time Period = 30) = Array(outReal)
이talib.MAXINDEX()함수는 계산에 사용됩니다지정 기간 동안 가장 높은 값의 지수 (최대 지수).
이 값의 반환 값은talib.MAXINDEX()함수는: 1차원 배열입니다.
배열
talib.MAXINDEX ((inReal) talib.MAXINDEX ((인리얼, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이MAXINDEX()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MAXINDEX(Records[Close],Time Period = 30) = Array(outInteger)
이talib.MIN()이 함수는 지정된 기간 동안 가장 낮은 값 (최저 값) **를 계산하는 데 사용됩니다.
이 값의 반환 값은talib.MIN()함수는: 1차원 배열입니다.
배열
talib.MIN (인리얼) talib.MIN ((inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이MIN()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MIN(Records[Close],Time Period = 30) = Array(outReal)
이talib.MININDEX()함수는 계산에 사용됩니다가장 낮은 가치 지수 (최저 가치 지수)정해진 기간 동안
이 값의 반환 값은talib.MININDEX()함수는: 1차원 배열입니다.
배열
talib.MININDEX ((inReal) talib.MININDEX ((inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이MININDEX()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MININDEX(Records[Close],Time Period = 30) = Array(outInteger)
이talib.MINMAX()함수는 계산에 사용됩니다정해진 기간에 가장 낮고 가장 높은 값 (최저 및 최대).
이 값의 반환 값은talib.MINMAX()function는 2차원 배열입니다. 이 2차원 배열의 첫 번째 요소는 최소 값의 배열이고 두 번째 요소는 최대 값의 배열입니다.
배열
talib.MINMAX (인리얼) talib.MINMAX ((inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이MINMAX()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MINMAX(Records[Close],Time Period = 30) = [Array(outMin),Array(outMax)]
이talib.MINMAXINDEX()함수는 계산에 사용됩니다지정 기간 동안 가장 낮은 값과 가장 높은 값 (최저 값과 최대 값) 의 지수.
이 값의 반환 값은talib.MINMAXINDEX()함수는: 2차원 배열입니다. 이 2차원 배열의 첫 번째 요소는 최소 인덱스 배열이고 두 번째 요소는 최대 인덱스 배열입니다.
배열
talib.MINMAXINDEX ((인리얼) talib.MINMAXINDEX (실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이MINMAXINDEX()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MINMAXINDEX(Records[Close],Time Period = 30) = [Array(outMinIdx),Array(outMaxIdx)]
이talib.SUM()함수는 계산에 사용됩니다요약.
이 값의 반환 값은talib.SUM()함수는: 1차원 배열입니다.
배열
talib.SUM ((inReal) talib.SUM ((실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이SUM()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.SUM(Records[Close],Time Period = 30) = Array(outReal)
이talib.HT_DCPERIOD()함수는 계산에 사용됩니다힐베르트 변환 - 지배적인 주기 기간 (힐베르트 변환, 지배적인 기간).
이 값의 반환 값은talib.HT_DCPERIOD()함수는: 1차원 배열입니다.
배열
talib.HT_DCPERIOD ((inReal)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이HT_DCPERIOD()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.HT_DCPERIOD(Records[Close]) = Array(outReal)
이talib.HT_DCPHASE()함수는 계산에 사용됩니다힐베르트 변환 - 지배적인 사이클 단계 (Hilbert Transform, Dominant Cycle Phase).
이 값의 반환 값은talib.HT_DCPHASE()함수는: 1차원 배열입니다.
배열
talib.HT_DCPHASE ((inReal)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이HT_DCPHASE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.HT_DCPHASE(Records[Close]) = Array(outReal)
이talib.HT_PHASOR()함수는 계산에 사용됩니다힐베르트 변환 - 파소 구성 요소 (힐베르트 변환, 단계 구성 요소).
이 값의 반환 값은talib.HT_PHASOR()함수는 2차원 배열입니다.
배열
talib.HT_PHASOR (인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이HT_PHASOR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.HT_PHASOR(Records[Close]) = [Array(outInPhase),Array(outQuadrature)]
이talib.HT_SINE()함수는 계산에 사용됩니다힐베르트 변환 - 시노파 (Hilbert Transform, Sine Wave).
이 값의 반환 값은talib.HT_SINE()함수는 2차원 배열입니다.
배열
talib.HT_SINE (인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이HT_SINE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.HT_SINE(Records[Close]) = [Array(outSine),Array(outLeadSine)]
이talib.HT_TRENDMODE()함수는 계산에 사용됩니다힐베르트 변환 - 트렌드 및 사이클 모드.
이 값의 반환 값은talib.HT_TRENDMODE()함수는: 1차원 배열입니다.
배열
talib.HT_TRENDMODE (인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이HT_TRENDMODE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.HT_TRENDMODE(Records[Close]) = Array(outInteger)
이talib.ATR()함수는 계산에 사용됩니다평균 실제 범위.
이 값의 반환 값은talib.ATR()함수는 1차원 배열입니다.
배열
talib.ATR (인프라이스HLC) talib.ATR ((인프라이스HLC, optInTimePeriod)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이ATR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.ATR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
이talib.NATR()함수는 계산에 사용됩니다정규화 된 평균 실제 범위.
이 값의 반환 값은talib.NATR()함수는 1차원 배열입니다.
배열
talib.NATR ((인프라이스HLC) talib.NATR ((인프라이스HLC, optInTimePeriod)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이NATR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.NATR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
이talib.TRANGE()함수는 계산에 사용됩니다실제 범위.
이 값의 반환 값은talib.TRANGE()함수는: 1차원 배열입니다.
배열
talib.TRANGE ((인프라이스HLC)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이TRANGE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.TRANGE(Records[High,Low,Close]) = Array(outReal)
이talib.BBANDS()함수는 계산에 사용됩니다볼링거 밴드.
이 값의 반환 값은talib.BBANDS()함수는: 2차원 배열입니다. 배열은 세 가지 요소를 포함합니다. 상위 라인 배열, 중간 라인 배열, 하위 라인 배열입니다.
배열
talib.BBANDS (인리얼) talib.BBANDS (실제, 선택 시간) talib.BBANDS (inReal, optInTimePeriod, optInNbDevUp) talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn) talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn, optInMAType)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 5입니다.
optInTime 기간
거짓
번호
의optInNbDevUp이 매개 변수는 상향 곱셈을 설정하는 데 사용됩니다. 기본 값은 2입니다.
optInNbDevUp
거짓
번호
의optInNbDevDn이 매개 변수는 하위 선 곱셈을 설정하는데 사용되는데, 기본 값은 2입니다.
선택NbDevDn
거짓
번호
의optInMAType매개 변수는 평균 유형을 설정하는 데 사용됩니다. 기본 값은 0입니다.
optInMAType
거짓
번호
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);
}
이BBANDS()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.BBANDS(Records[Close],Time Period = 5,Deviations up = 2,Deviations down = 2,MA Type = 0) = [Array(outRealUpperBand),Array(outRealMiddleBand),Array(outRealLowerBand)]
이talib.DEMA()함수는 계산에 사용됩니다이중 기하급수적 이동 평균.
이 값의 반환 값은talib.DEMA()함수는 1차원 배열입니다.
배열
talib.DEMA (인리얼) talib.DEMA (실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이DEMA()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.DEMA(Records[Close],Time Period = 30) = Array(outReal)
이talib.EMA()함수는 계산에 사용됩니다기하급수적인 이동 평균.
이 값의 반환 값은talib.EMA()함수는 1차원 배열입니다.
배열
talib.EMA (인리얼) talib.EMA (실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이EMA()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.EMA(Records[Close],Time Period = 30) = Array(outReal)
이talib.HT_TRENDLINE()함수는 계산에 사용됩니다힐베르트 변환 - 즉각적인 트렌드 라인 (힐베르트 변환, 즉각적인 트렌드).
이 값의 반환 값은talib.HT_TRENDLINE()함수는: 1차원 배열입니다.
배열
talib.HT_TRENDLINE (인리얼)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
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);
}
이HT_TRENDLINE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.HT_TRENDLINE(Records[Close]) = Array(outReal)
이talib.KAMA()함수는 계산에 사용됩니다카우프만 적응 이동 평균.
이 값의 반환 값은talib.KAMA()함수는: 1차원 배열입니다.
배열
talib.KAMA (인리얼) talib.KAMA (실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이KAMA()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.KAMA(Records[Close],Time Period = 30) = Array(outReal)
이talib.MA()함수는 계산에 사용됩니다이동평균.
이 값의 반환 값은talib.MA()함수는: 1차원 배열입니다.
배열
talib.MA(이인리얼)talib.MA(inReal, optInTimePeriod)talib.MA(inReal, optInTimePeriod, optInMAType)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
의optInMAType매개 변수는 평균 유형을 설정하는 데 사용됩니다. 기본 값은 0입니다.
optInMAType
거짓
번호
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);
}
이MA()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MA(Records[Close],Time Period = 30,MA Type = 0) = Array(outReal)
이talib.MAMA()함수는 계산에 사용됩니다MESA 적응 이동 평균.
이 값의 반환 값은talib.MAMA()함수는 2차원 배열입니다.
배열
talib.MAMA ((인리얼) talib.MAMA ((inReal, optInFastLimit) talib.MAMA ((inReal, optInFastLimit, optInSlowLimit)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInFastLimit패러미터는 빠른 제한을 설정하는 데 사용됩니다, 기본 값은 0.5.
optInFastLimit
거짓
번호
의optInSlowLimit이 매개 변수는 느린 제한을 설정하는 데 사용됩니다. 기본 값은 0.05입니다.
optInSlowLimit
거짓
번호
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);
}
이MAMA()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MAMA(Records[Close],Fast Limit = 0.5,Slow Limit = 0.05) = [Array(outMAMA),Array(outFAMA)]
이talib.MIDPOINT()함수는 계산에 사용됩니다기간 중점 (중점).
이 값의 반환 값은talib.MIDPOINT()함수는 1차원 배열입니다.
배열
talib.MIDPOINT (이인리얼) talib.MIDPOINT ((실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이MIDPOINT()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MIDPOINT(Records[Close],Time Period = 14) = Array(outReal)
이talib.MIDPRICE()함수는 계산에 사용됩니다기간 중 중간 가격 (중 중간 가격).
이 값의 반환 값은talib.MIDPRICE()함수는 1차원 배열입니다.
배열
talib.MIDPRICE ((인프라이스HL) talib.MIDPRICE (중간 가격)
이inPriceHLK선 데이터를 지정하는 매개 변수입니다.
inPriceHL
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이MIDPRICE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MIDPRICE(Records[High,Low],Time Period = 14) = Array(outReal)
이talib.SAR()함수는 계산에 사용됩니다파라볼 SAR.
이 값의 반환 값은talib.SAR()함수는: 1차원 배열입니다.
배열
talib.SAR ((인프라이스HL) talib.SAR ((inPriceHL, optInAcceleration) talib.SAR ((inPriceHL, optInAcceleration, optInMaximum)
이inPriceHLK선 데이터를 지정하는 매개 변수입니다.
inPriceHL
사실
{@struct/Record Record} 구조 배열
의optInAcceleration패러미터는 가속 인수를 설정하는 데 사용됩니다. 기본 값은 0.02입니다.
가속을 선택
거짓
번호
의optInMaximumAF 최대값을 설정하는 매개 변수, 기본값은 0.2입니다.
optInMaximum
거짓
번호
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);
}
이SAR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.SAR(Records[High,Low],Acceleration Factor = 0.02,AF Maximum = 0.2) = Array(outReal)
이talib.SAREXT()함수는 계산에 사용됩니다파라볼리 SAR - 확장 (강화 된 파라볼리 스티어링).
이 값의 반환 값은talib.SAREXT()함수는 1차원 배열입니다.
배열
talib.SAREXT ((인프라이스HL) 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)
이inPriceHLK선 데이터를 지정하는 매개 변수입니다.
inPriceHL
사실
{@struct/Record Record} 구조 배열
의optInStartValue이 매개 변수는 시작값을 설정하는데 사용되는데, 기본값은 0입니다.
optInStartValue
거짓
번호
의optInOffsetOnReverse이 매개 변수는 오프셋을 역으로 설정하는 데 사용됩니다. 기본 값은 0입니다.
optInOffsetOnReverse
거짓
번호
의optInAccelerationInitLongAF Init Long를 설정하는 매개 변수, 기본 값은 0.02입니다.
가속도 가속도
거짓
번호
의optInAccelerationLongAF를 설정하는 매개 변수입니다. 기본 값은 0.02입니다.
오프인속도 길다
거짓
번호
의optInAccelerationMaxLongAF 최대 길이를 설정하는 매개 변수, 기본 값은 0.2입니다.
optInAccelerationMaxLong
거짓
번호
의optInAccelerationInitShortAF Init Short를 설정하는 매개 변수입니다. 기본 값은 0.02입니다.
오프인 가속인 이트 쇼트
거짓
번호
의optInAccelerationShort이 매개 변수는 AF Short를 설정하는데 사용되며 기본값은 0.02입니다.
선택AccelerationShort
거짓
번호
의optInAccelerationMaxShortAF Max Short를 설정하는 매개 변수입니다. 기본 값은 0.2입니다.
optInAccelerationMaxShort 를 선택하세요
거짓
번호
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);
}
이SAREXT()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.SAREXT(Records[High,Low],Start Value = 0,Offset on Reverse = 0,AF Init Long = 0.02,AF Long = 0.02,AF Max Long = 0.2,AF Init Short = 0.02,AF Short = 0.02,AF Max Short = 0.2) = Array(outReal)
이talib.SMA()함수는 계산에 사용됩니다단순 이동 평균.
이 값의 반환 값은talib.SMA()함수는: 1차원 배열입니다.
배열
talib.SMA ((인리얼) talib.SMA ((inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이SMA()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.SMA(Records[Close],Time Period = 30) = Array(outReal)
이talib.T3()함수는 계산에 사용됩니다삼배 지수 이동 평균 (T3) (삼배 지수 이동 평균).
이 값의 반환 값은talib.T3()함수는 1차원 배열입니다.
배열
talib.T3 ((inReal) talib.T3 ((inReal, optInTimePeriod) talib.T3 ((inReal, optInTimePeriod, optInVFactor)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 5입니다.
optInTime 기간
거짓
번호
의optInVFactor매개 변수는 부피 인수를 설정하는 데 사용됩니다. 기본 값은 0.7입니다.
optInVFactor
거짓
번호
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);
}
이T3()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.T3(Records[Close],Time Period = 5,Volume Factor = 0.7) = Array(outReal)
이talib.TEMA()함수는 계산에 사용됩니다삼배 지수적 이동 평균.
이 값의 반환 값은talib.TEMA()함수는 1차원 배열입니다.
배열
talib.TEMA (인리얼) talib.TEMA ((inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이TEMA()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.TEMA(Records[Close],Time Period = 30) = Array(outReal)
이talib.TRIMA()함수는 계산에 사용됩니다삼각형 이동 평균 (tri-exponential 이동 평균).
이 값의 반환 값은talib.TRIMA()함수는 1차원 배열입니다.
배열
talib.TRIMA (인리얼) talib.TRIMA (실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이TRIMA()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.TRIMA(Records[Close],Time Period = 30) = Array(outReal)
이talib.WMA()함수는 계산에 사용됩니다가중화 이동 평균 (WMA).
이 값의 반환 값은talib.WMA()함수는 1차원 배열입니다.
배열
talib.WMA ((inReal) talib.WMA (inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이WMA()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.WMA(Records[Close],Time Period = 30) = Array(outReal)
이talib.LINEARREG()함수는 계산에 사용됩니다선형 회귀.
이 값의 반환 값은talib.LINEARREG()함수는 1차원 배열입니다.
배열
talib.LINEARREG ((inReal) talib.LINEARREG (실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이LINEARREG()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.LINEARREG(Records[Close],Time Period = 14) = Array(outReal)
이talib.LINEARREG_ANGLE()함수는 계산에 사용됩니다선형 회귀 각.
이 값의 반환 값은talib.LINEARREG_ANGLE()함수는: 1차원 배열입니다.
배열
talib.LINEARREG_ANGLE ((inReal) talib.LINEARREG_ANGLE (실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이LINEARREG_ANGLE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.LINEARREG_ANGLE(Records[Close],Time Period = 14) = Array(outReal)
이talib.LINEARREG_INTERCEPT()함수는 계산에 사용됩니다선형 회귀 차단.
이 값의 반환 값은talib.LINEARREG_INTERCEPT()함수는: 1차원 배열입니다.
배열
talib.LINEARREG_INTERCEPT (실제) talib.LINEARREG_INTERCEPT (실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이LINEARREG_INTERCEPT()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.LINEARREG_INTERCEPT(Records[Close],Time Period = 14) = Array(outReal)
이talib.LINEARREG_SLOPE()함수는 계산에 사용됩니다선형 회귀 기울기.
이 값의 반환 값은talib.LINEARREG_SLOPE()함수는: 1차원 배열입니다.
배열
talib.LINEARREG_SLOPE ((inReal) talib.LINEARREG_SLOPE ((inReal, optInTimePeriod) 는
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이LINEARREG_SLOPE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.LINEARREG_SLOPE(Records[Close],Time Period = 14) = Array(outReal)
이talib.STDDEV()함수는 계산에 사용됩니다표준편차.
이 값의 반환 값은talib.STDDEV()함수는: 1차원 배열입니다.
배열
talib.STDDEV (인리얼) talib.STDDEV ((inReal, optInTimePeriod) talib.STDDEV ((inReal, optInTimePeriod, optInNbDev)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 5입니다.
optInTime 기간
거짓
번호
의optInNbDev이 매개 변수는 오차를 설정하는 데 사용됩니다. 기본 값은 1입니다.
optInNbDev
거짓
번호
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);
}
이STDDEV()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.STDDEV(Records[Close],Time Period = 5,Deviations = 1) = Array(outReal)
이talib.TSF()함수는 계산에 사용됩니다시간 시리즈 예측.
이 값의 반환 값은talib.TSF()함수는 1차원 배열입니다.
배열
talib.TSF (인리얼) talib.TSF (inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이TSF()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.TSF(Records[Close],Time Period = 14) = Array(outReal)
이talib.VAR()함수는 계산에 사용됩니다변동성.
이 값의 반환 값은talib.VAR()함수는: 1차원 배열입니다.
배열
talib.VAR (인리얼) talib.VAR ((inReal, optInTimePeriod) talib.VAR ((inReal, optInTimePeriod, optInNbDev)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 5입니다.
optInTime 기간
거짓
번호
의optInNbDev이 매개 변수는 오차를 설정하는 데 사용됩니다. 기본 값은 1입니다.
optInNbDev
거짓
번호
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);
}
이VAR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.VAR(Records[Close],Time Period = 5,Deviations = 1) = Array(outReal)
이talib.ADX()함수는 계산에 사용됩니다평균 방향 운동 지수.
이 값의 반환 값은talib.ADX()함수는 1차원 배열입니다.
배열
talib.ADX (인프라이스HLC) talib.ADX ((인프라이스HLC, optInTimePeriod)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이ADX()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.ADX(Records[High,Low,Close],Time Period = 14) = Array(outReal)
이talib.ADXR()함수는 계산에 사용됩니다평균 방향 움직임 지수 등급 (평가 지수).
이 값의 반환 값은talib.ADXR()함수는 1차원 배열입니다.
배열
talib.ADXR (인프라이스HLC) talib.ADXR ((인프라이스HLC, optInTimePeriod)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이ADXR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.ADXR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
이talib.APO()함수는 계산에 사용됩니다절대 가격 오시레이터.
이 값의 반환 값은talib.APO()함수는: 1차원 배열입니다.
배열
talib.APO ((인리얼) talib.APO ((inReal, optInFastPeriod) talib.APO ((inReal, optInFastPeriod, optInSlowPeriod) (실제, 빠른 기간, 느린 기간) talib.APO ((inReal, optInFastPeriod, optInSlowPeriod, optInMAType)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInFastPeriod패러미터는 빠른 기간을 설정하는 데 사용됩니다. 기본 값은 12입니다.
optInFastPeriod
거짓
번호
의optInSlowPeriod이 매개 변수는 느린 기간을 설정하는 데 사용됩니다. 기본 값은 26입니다.
optSlowPeriod
거짓
번호
의optInMAType매개 변수는 평균 유형을 설정하는 데 사용됩니다. 기본 값은 0입니다.
optInMAType
거짓
번호
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);
}
이APO()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.APO(Records[Close],Fast Period = 12,Slow Period = 26,MA Type = 0) = Array(outReal)
이talib.AROON()함수는 계산에 사용됩니다아론 (아론 지표).
이 값의 반환 값은talib.AROON()함수는 2차원 배열입니다.
배열
talib.AROON (인프라이스HL) talib.AROON ((PriceHL, optInTimePeriod)
이inPriceHLK선 데이터를 지정하는 매개 변수입니다.
inPriceHL
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이AROON()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.AROON(Records[High,Low],Time Period = 14) = [Array(outAroonDown),Array(outAroonUp)]
이talib.AROONOSC()함수는 계산에 사용됩니다아론 오시레이터.
이 값의 반환 값은talib.AROONOSC()함수는: 1차원 배열입니다.
배열
talib.AROONOSC ((인프라이스HL) talib.AROONOSC ((PriceHL, optInTimePeriod) 가격, 시간 기간)
이inPriceHLK선 데이터를 지정하는 매개 변수입니다.
inPriceHL
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이AROONOSC()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.AROONOSC(Records[High,Low],Time Period = 14) = Array(outReal)
이talib.BOP()함수는 계산에 사용됩니다힘 의 균형.
이 값의 반환 값은talib.BOP()함수는 1차원 배열입니다.
배열
talib.BOP ((인프라이스OHLC)
이inPriceOHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceOHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이BOP()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.BOP(Records[Open,High,Low,Close]) = Array(outReal)
이talib.CCI()함수는 계산에 사용됩니다상품 채널 지수 (호메오패스 지표).
이 값의 반환 값은talib.CCI()함수는 1차원 배열입니다.
배열
talib.CCI ((인프라이스HLC) talib.CCI ((인프라이스HLC, optInTimePeriod)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이CCI()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CCI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
이talib.CMO()함수는 계산에 사용됩니다
이 값의 반환 값은talib.CMO()함수는: 1차원 배열입니다.
배열
talib.CMO ((inReal) talib.CMO ((inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이CMO()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.CMO(Records[Close],Time Period = 14) = Array(outReal)
이talib.DX()함수는 계산에 사용됩니다방향 운동 지수.
이 값의 반환 값은talib.DX()함수는: 1차원 배열입니다.
배열
talib.DX (인프라이스HLC) talib.DX ((inPriceHLC, optInTimePeriod)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이DX()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.DX(Records[High,Low,Close],Time Period = 14) = Array(outReal)
이talib.MACD()함수는 계산에 사용됩니다이동 평균 컨버전스/디버전스 (비례적으로 평평한 이동 평균).
이 값의 반환 값은talib.MACD()함수는 2차원 배열입니다.
배열
talib.MACD (인리얼) talib.MACD ((inReal, optInFastPeriod) talib.MACD ((inReal, optInFastPeriod, optInSlowPeriod) 이 있습니다. talib.MACD ((inReal, optInFastPeriod, optInSlowPeriod, optInSignalPeriod) (현실, 선택, 빠른 기간, 느린 기간, 신호 기간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInFastPeriod패러미터는 빠른 기간을 설정하는 데 사용됩니다. 기본 값은 12입니다.
optInFastPeriod
거짓
번호
의optInSlowPeriod이 매개 변수는 느린 기간을 설정하는 데 사용됩니다. 기본 값은 26입니다.
optSlowPeriod
거짓
번호
의optInSignalPeriod신호 기간을 설정하는 매개 변수, 기본 값은 9입니다.
opt신호 기간
거짓
번호
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);
}
이MACD()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MACD(Records[Close],Fast Period = 12,Slow Period = 26,Signal Period = 9) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
이talib.MACDEXT()함수는 계산에 사용됩니다제어 가능한 MA 타입의 MACD.
이 값의 반환 값은talib.MACDEXT()함수는 2차원 배열입니다.
배열
talib.MACDEXT (인리얼) 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)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInFastPeriod패러미터는 빠른 기간을 설정하는 데 사용됩니다. 기본 값은 12입니다.
optInFastPeriod
거짓
번호
의optInFastMAType패러미터는 빠른 평균 타입을 설정하는 데 사용됩니다. 기본 값은 0입니다.
optInFastMAType
거짓
번호
의optInSlowPeriod이 매개 변수는 느린 기간을 설정하는 데 사용됩니다. 기본 값은 26입니다.
optSlowPeriod
거짓
번호
의optInSlowMAType이 매개 변수는 느린 평균 타입을 설정하는데 사용되는데, 기본 값은 0입니다.
optInSlowMAType
거짓
번호
의optInSignalPeriod신호 기간을 설정하는 매개 변수, 기본 값은 9입니다.
opt신호 기간
거짓
번호
의optInSignalMAType이 매개 변수는 신호 평균 타입을 설정하는 데 사용되며 기본 값은 0입니다.
optInSignalMAType
거짓
번호
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);
}
이MACDEXT()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MACDEXT(Records[Close],Fast Period = 12,Fast MA = 0,Slow Period = 26,Slow MA = 0,Signal Period = 9,Signal MA = 0) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
이talib.MACDFIX()함수는 계산에 사용됩니다이동평균 컨버전스/디버전스 수정 12/26.
이 값의 반환 값은talib.MACDFIX()함수는 2차원 배열입니다.
배열
talib.MACDFIX ((인리얼) talib.MACDFIX ((inReal, optInSignalPeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInSignalPeriod신호 기간을 설정하는 매개 변수, 기본 값은 9입니다.
opt신호 기간
거짓
번호
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);
}
이MACDFIX()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MACDFIX(Records[Close],Signal Period = 9) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
이talib.MFI()함수는 계산에 사용됩니다현금 흐름 지수.
이 값의 반환 값은talib.MFI()함수는 1차원 배열입니다.
배열
talib.MFI ((inPriceHLCV) talib.MFI ((인프라이스HLCV, optInTimePeriod)
이inPriceHLCVK선 데이터를 지정하는 매개 변수입니다.
inPriceHLCV
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이MFI()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MFI(Records[High,Low,Close,Volume],Time Period = 14) = Array(outReal)
이talib.MINUS_DI()함수는 계산에 사용됩니다마이너스 방향 지표 (네거티브 지표).
이 값의 반환 값은talib.MINUS_DI()함수는 1차원 배열입니다.
배열
talib.MINUS_DI (인프라이스HLC) talib.MINUS_DI (PriceHLC, optInTimePeriod)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이MINUS_DI()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MINUS_DI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
이talib.MINUS_DM()함수는 계산에 사용됩니다- 방향 이동 (반면 이동).
이 값의 반환 값은talib.MINUS_DM()함수는 1차원 배열입니다.
배열
talib.MINUS_DM ((인프라이스HL) talib.MINUS_DM ((PriceHl, optInTimePeriod) 값에 따라)
이inPriceHLK선 데이터를 지정하는 매개 변수입니다.
inPriceHL
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이MINUS_DM()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MINUS_DM(Records[High,Low],Time Period = 14) = Array(outReal)
이talib.MOM()함수는 계산에 사용됩니다추진력.
이 값의 반환 값은talib.MOM()함수는 1차원 배열입니다.
배열
talib.MOM ((인리얼) talib.MOM ((inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 10입니다.
optInTime 기간
거짓
번호
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);
}
이MOM()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MOM(Records[Close],Time Period = 10) = Array(outReal)
이talib.PLUS_DI()함수는 계산에 사용됩니다+ 방향 지표.
이 값의 반환 값은talib.PLUS_DI()함수는: 1차원 배열입니다.
배열
talib.PLUS_DI (인프라이스HLC) talib.PLUS_DI ((인프라이스HLC, optInTimePeriod)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이PLUS_DI()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.PLUS_DI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
이talib.PLUS_DM()함수는 계산에 사용됩니다+ 방향 이동.
이 값의 반환 값은talib.PLUS_DM()함수는 1차원 배열입니다.
배열
talib.PLUS_DM ((인프라이스HL) talib.PLUS_DM ((인프라이스HL, optInTimePeriod)
이inPriceHLK선 데이터를 지정하는 매개 변수입니다.
inPriceHL
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이PLUS_DM()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.PLUS_DM(Records[High,Low],Time Period = 14) = Array(outReal)
이talib.PPO()함수는 계산에 사용됩니다% 가격 오시레이터.
이 값의 반환 값은talib.PPO()함수는 1차원 배열입니다.
배열
talib.PPO (인리얼) talib.PPO ((인리얼, optInFastPeriod) talib.PPO ((인리얼, optInFastPeriod, optInSlowPeriod) talib.PPO ((inReal, optInFastPeriod, optInSlowPeriod, optInMAType)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInFastPeriod패러미터는 빠른 기간을 설정하는 데 사용됩니다. 기본 값은 12입니다.
optInFastPeriod
거짓
번호
의optInSlowPeriod이 매개 변수는 느린 기간을 설정하는 데 사용됩니다. 기본 값은 26입니다.
optSlowPeriod
거짓
번호
의optInMAType매개 변수는 평균 유형을 설정하는 데 사용됩니다. 기본 값은 0입니다.
optInMAType
거짓
번호
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);
}
이PPO()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.PPO(Records[Close],Fast Period = 12,Slow Period = 26,MA Type = 0) = Array(outReal)
이talib.ROC()함수는 계산에 사용됩니다변화율: ((가격/전기 가격) -1) * 100 (변화율 지표).
이 값의 반환 값은talib.ROC()함수는 1차원 배열입니다.
배열
talib.ROC ((inReal) talib.ROC (inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 10입니다.
optInTime 기간
거짓
번호
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);
}
이ROC()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.ROC(Records[Close],Time Period = 10) = Array(outReal)
이talib.ROCP()함수는 계산에 사용됩니다변화율 비율: (가격-prevPrice) /prevPrice (가격 변화율).
이 값의 반환 값은talib.ROCP()함수는: 1차원 배열입니다.
배열
talib.ROCP (인리얼) talib.ROCP ((inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 10입니다.
optInTime 기간
거짓
번호
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);
}
이ROCP()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.ROCP(Records[Close],Time Period = 10) = Array(outReal)
이talib.ROCR()함수는 계산에 사용됩니다변화율 비율: (가격/예전 가격) (가격 변화 비율).
이 값의 반환 값은talib.ROCR()함수는 1차원 배열입니다.
배열
talib.ROCR (인리얼) talib.ROCR (inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 10입니다.
optInTime 기간
거짓
번호
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);
}
이ROCR()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.ROCR(Records[Close],Time Period = 10) = Array(outReal)
이talib.ROCR100()함수는 계산에 사용됩니다변화 비율 100 스칼라: (가격/전시 가격) * 100 (가격 변화 비율).
이 값의 반환 값은talib.ROCR100()함수는: 1차원 배열입니다.
배열
talib.ROCR100 ((inReal) talib.ROCR100 ((inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 10입니다.
optInTime 기간
거짓
번호
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);
}
이ROCR100()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.ROCR100(Records[Close],Time Period = 10) = Array(outReal)
이talib.RSI()함수는 계산에 사용됩니다상대적 강도 지수.
이 값의 반환 값은talib.RSI()함수는 1차원 배열입니다.
배열
talib.RSI (인리얼) talib.RSI ((inReal, optInTimePeriod)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}
이RSI()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.RSI(Records[Close],Time Period = 14) = Array(outReal)
이talib.STOCH()함수는 계산에 사용됩니다스토카스틱 (STOCH 지표).
이 값의 반환 값은talib.STOCH()함수는 2차원 배열입니다.
배열
talib.STOCH ((인프라이스HLC) 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)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
의optInFastK_Period패러미터는 패스트-K 기간을 설정하는 데 사용됩니다. 기본 값은 5입니다.
optInFastK_Period
거짓
번호
의optInSlowK_Period이 매개 변수는 Slow-K 기간을 설정하는 데 사용됩니다. 기본 값은 3입니다.
optInSlowK_Period
거짓
번호
의optInSlowK_MAType이 매개 변수는 Slow-K 평균 타입을 설정하는데 사용되는데, 기본 값은 0입니다.
optInSlowK_MAType
거짓
번호
의optInSlowD_Period이 매개 변수는 슬로우-D 기간을 설정하는데 사용되는데, 기본 값은 3입니다.
optInSlowD_Period를 선택하세요
거짓
번호
의optInSlowD_MAType이 매개 변수는 Slow-D 평균 타입을 설정하는데 사용되는데, 기본 값은 0입니다.
optInSlowD_MAType
거짓
번호
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);
}
이STOCH()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.STOCH(Records[High,Low,Close],Fast-K Period = 5,Slow-K Period = 3,Slow-K MA = 0,Slow-D Period = 3,Slow-D MA = 0) = [Array(outSlowK),Array(outSlowD)]
이talib.STOCHF()함수는 계산에 사용됩니다스토카스틱 패스트 (빠른 STOCH 지표).
이 값의 반환 값은talib.STOCHF()함수는 2차원 배열입니다.
배열
talib.STOCHF ((인프라이스HLC) talib.STOCHF ((인프라이스HLC, optInFastK_Period) talib.STOCHF ((inPriceHLC, optInFastK_Period, optInFastD_Period) 는 talib.STOCHF ((inPriceHLC, optInFastK_Period, optInFastD_Period, optInFastD_MAType)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
의optInFastK_Period패러미터는 패스트-K 기간을 설정하는 데 사용됩니다. 기본 값은 5입니다.
optInFastK_Period
거짓
번호
의optInFastD_Period패러미터가 패스트-D 기간을 설정하는 데 사용됩니다. 기본 값은 3입니다.
optInFastD_Period
거짓
번호
의optInFastD_MAType패러미터는 패스트-D 평균 타입을 설정하는데 사용되는데, 기본 값은 0입니다.
optInFastD_MAType
거짓
번호
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);
}
이STOCHF()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.STOCHF(Records[High,Low,Close],Fast-K Period = 5,Fast-D Period = 3,Fast-D MA = 0) = [Array(outFastK),Array(outFastD)]
이talib.STOCHRSI()함수는 계산에 사용됩니다스토카스틱 상대적 강도 지수.
이 값의 반환 값은talib.STOCHRSI()함수는 2차원 배열입니다.
배열
talib.STOCHRSI (인리얼) talib.STOCHRSI (실제, 선택 시간) talib.STOCHRSI ((인리얼, optInTimePeriod, optInFastK_Period) talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period, optInFastD_Period) talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period, optInFastD_Period, optInFastD_MAType)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
의optInFastK_Period패러미터는 패스트-K 기간을 설정하는 데 사용됩니다. 기본 값은 5입니다.
optInFastK_Period
거짓
번호
의optInFastD_Period패러미터가 패스트-D 기간을 설정하는 데 사용됩니다. 기본 값은 3입니다.
optInFastD_Period
거짓
번호
의optInFastD_MAType패러미터는 패스트-D 평균 타입을 설정하는데 사용되는데, 기본 값은 0입니다.
optInFastD_MAType
거짓
번호
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);
}
이STOCHRSI()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.STOCHRSI(Records[Close],Time Period = 14,Fast-K Period = 5,Fast-D Period = 3,Fast-D MA = 0) = [Array(outFastK),Array(outFastD)]
이talib.TRIX()함수는 계산에 사용됩니다트리플 슬림 EMA의 1일 변화율 (ROC).
이 값의 반환 값은talib.TRIX()함수는: 1차원 배열입니다.
배열
talib.TRIX ((인리얼) talib.TRIX (실제, 선택 시간)
이inRealK선 데이터를 지정하는 매개 변수입니다.
inReal
사실
{@struct/Record Record} 구조 배열, 수치 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 30입니다.
optInTime 기간
거짓
번호
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);
}
이TRIX()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.TRIX(Records[Close],Time Period = 30) = Array(outReal)
이talib.ULTOSC()함수는 계산에 사용됩니다최후 오시레이터.
이 값의 반환 값은talib.ULTOSC()함수는 1차원 배열입니다.
배열
talib.ULTOSC (인프라이스HLC) talib.ULTOSC ((인프라이스HLC, optInTimePeriod1) talib.ULTOSC ((인프라이스HLC, optInTimePeriod1, optInTimePeriod2) talib.ULTOSC ((inPriceHLC, optInTimePeriod1, optInTimePeriod2, optInTimePeriod3)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod1첫 번째 항을 설정하는 매개 변수, 기본 값은 7입니다.
optInTimePeriod1
거짓
번호
의optInTimePeriod2이 매개 변수는 두 번째 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTimePeriod2
거짓
번호
의optInTimePeriod3세 번째 기간을 설정하는 매개 변수, 기본 값은 28입니다.
optInTimePeriod3
거짓
번호
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);
}
이ULTOSC()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.ULTOSC(Records[High,Low,Close],First Period = 7,Second Period = 14,Third Period = 28) = Array(outReal)
이talib.WILLR()함수는 계산에 사용됩니다윌리엄스 %R.
이 값의 반환 값은talib.WILLR()함수는: 1차원 배열입니다.
배열
talib.WILLR ((인프라이스HLC) talib.WILLR ((인프라이스HLC, optInTimePeriod)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
의optInTimePeriod이 매개 변수는 기간을 설정하는 데 사용됩니다. 기본 값은 14입니다.
optInTime 기간
거짓
번호
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);
}```
The ```WILLR()``` function is described in the talib library documentation as: ```WILLR(Records[High,Low,Close],Time Period = 14) = Array(outReal)```
### talib.AVGPRICE
The ```talib.AVGPRICE()``` function is used to calculate **Average Price**.
The return value of the ```talib.AVGPRICE()``` function is a one-dimensional array.
array
talib.AVGPRICE(inPriceOHLC)
The ```inPriceOHLC``` parameter is used to specify the K-line data.
inPriceOHLC
true
{@struct/Record Record} structure array
```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);
}
이AVGPRICE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.AVGPRICE(Records[Open,High,Low,Close]) = Array(outReal)
이talib.MEDPRICE()함수는 계산에 사용됩니다중간 가격.
이 값의 반환 값은talib.MEDPRICE()함수는 1차원 배열입니다.
배열
talib.MEDPRICE ((인프라이스HL)
이inPriceHLK선 데이터를 지정하는 매개 변수입니다.
inPriceHL
사실
{@struct/Record Record} 구조 배열
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);
}
이MEDPRICE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.MEDPRICE(Records[High,Low]) = Array(outReal)
이talib.TYPPRICE()함수는 계산에 사용됩니다전형적 가격.
이 값의 반환 값은talib.TYPPRICE()함수는 1차원 배열입니다.
배열
talib.TYPPRICE ((인프라이스HLC)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
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);
}
이TYPPRICE()그 기능은 탈리브 라이브러리 문서에 다음과 같이 설명되어 있습니다.TYPPRICE(Records[High,Low,Close]) = Array(outReal)
이talib.WCLPRICE()함수는 계산에 사용됩니다가중화 된 폐쇄 가격.
이 값의 반환 값은talib.WCLPRICE()함수는 1차원 배열입니다.
배열
talib.WCLPRICE ((인프라이스HLC)
이inPriceHLCK선 데이터를 지정하는 매개 변수입니다.
inPriceHLC
사실
{@struct/Record Record} 구조 배열
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)