Gibt die aktuelle Versionnummer des Systems zurück.
Aktuelle Systemversionsnummer, z. B.3.6- Ich weiß.
String
Ausgabe ((()
function main() {
Log("version:", Version())
}
def main():
Log("version:", Version())
void main() {
Log("version:", Version());
}
Die Systemversionsnummer ist die Versionsnummer des Docker
Die Schlaffunktion, wodurch das Programm für eine gewisse Zeit pausiert.
Schlaf (Millisekunde)
DiemillisecondDer Parameter wird verwendet, um die Schlafdauer und die Anzahl der Millisekunden festzulegen.
Millisekunde
- Das stimmt.
Zahl
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");
}
Zum Beispiel bei der Ausführung derSleep(1000)Es unterstützt Operationen mit einer Schlafzeit von weniger als 1 Millisekunde, z. B. Einstellung vonSleep(0.1). Es unterstützt einen Mindestparameter von0.000001, d.h. Nanosekunden-Wachstum, wobei 1 Nanosekunde gleich ist1e-6Millisekunden.
Bei der Erstellung von Strategien inPythonSprache, dieSleep(millisecond)Es wird nicht empfohlen, dietime.sleep(second)Funktion derPythonDas ist...timeDas ist, weil die Verwendung dertime.sleep(second)Funktion in einer Strategie lässt das Strategieprogramm für einen Zeitraum warten, tatsächlich beim Backtesting (nicht überspringen auf die Zeitreihen des Backtesting-Systems), so dass es die Strategie verursacht, um sehr langsam zu backtest.
Bestimmen Sie, ob die laufende Umgebung der Strategie ein Backtesting-System ist.
Die Strategie gibt einen wahren Wert zurück, z. B.:trueDie Strategie gibt einen falschen Wert zurück, z. B.:falsewenn sie in einer Live-Handelsumgebung ausgeführt werden.
Boole
Ist virtuell?
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.");
}
}
Bestimmen Sie, ob die aktuelle laufende Umgebung ein Backtesting-System ist, das mit dem Unterschied zwischen Backtesting und Live-Handel kompatibel ist.
Schicken Sie eine E-Mail.
Eine erfolgreiche E-Mail-Zustellung gibt einen wahren Wert zurück, z. B.true, und eine fehlgeschlagene Lieferung gibt einen falschen Wert zurück, z. B.false- Ich weiß.
Boole
Mail ((smtpServer, smtpBenutzername, smtpPasswort, mailTo, Titel, Körper)
Verwendet zur Angabe derSMTPDienstadresse des E-Mail-Senders.
SmtpServer
wahr
String
Wird verwendet, um die E-Mail-Adresse des E-Mail-Senders anzugeben.
Sms-Benutzername
wahr
String
DieSMTPPasswort für das Postfach des E-Mail-Senders.
Smp Passwort
wahr
String
Verwendet zur Angabe der E-Mail-Adresse des E-Mail-Empfängers.
Nachrichten
wahr
String
E-Mail-Adresse.
Titel
wahr
String
E-Mail Körper.
Körper
wahr
String
function main(){
Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
}
def main():
Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
void main() {
Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body");
}
DiesmtpPasswordParameter setzt das Passwort für dieSMTPService, nicht das Postfach-Passwort.
Bei Einstellung dersmtpServerParameter, wenn Sie den Port ändern müssen, können Sie die Portnummer direkt in Parameter hinzufügensmtpServer. Zum Beispiel: QQ-Mailsmtp.qq.com:587, die zur Prüfung zur Verfügung steht.
Wenn ein Fehler gemeldet wird:unencryped connection, müssen Sie diesmtpServerderMailDas Parameterformat lautet:ssl://xxx.com:xxx, zum Beispiel diesslVerfahren derSMTPfür QQ-Mail:ssl://smtp.qq.com:465odersmtp://xxx.com:xxx- Ich weiß.
Es funktioniert nicht im Backtesting-System.
Ich bin nicht derjenige, der dich anspricht.
Asynchrone Version derMail function.
DieMail_GoFunktion gibt ein gleichzeitiges Objekt sofort zurück, und Sie können diewaitEine erfolgreiche Postlieferung gibt einen wahren Wert zurück, z. B.true, und eine fehlgeschlagene Lieferung gibt einen falschen Wert zurück, z. B.false- Ich weiß.
Gegenstand
Mail_Go ((smtpServer, smtpBenutzername, smtpPasswort, mailTo, Titel, Körper)
Es wird verwendet, um dieSMTPDienstadresse des E-Mail-Senders.
SmtpServer
- Das stimmt.
String
Es wird verwendet, um die E-Mail-Adresse des E-Mail-Senders anzugeben.
Sms-Benutzername
- Das stimmt.
String
DieSMTPPasswort für das Postfach des E-Mail-Senders.
SmtpPasswort
- Das stimmt.
String
Es dient zur Angabe der E-Mail-Adresse des E-Mail-Empfängers.
Nachrichten
- Das stimmt.
String
E-Mail-Adresse.
Titel
- Das stimmt.
String
E-Mail Körper.
Körper
- Das stimmt.
String
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.
Es funktioniert nicht im Backtesting-System.
Ich bin nicht hier.
Filterfehlerprotokolle.
SetErrorFilter (Filter)
Regelmäßige Ausdrucksfolge. Filter wahr String
function main() {
SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused")
}
def main():
SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused")
void main() {
SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused");
}
Filtern von häufigen Fehlern.
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);
}
Filtern Sie eine Schnittstellenfehlermeldung.
Fehlerprotokolle, die mit diesem regulären Ausdruck übereinstimmen, werden nicht in das Protokollsystem hochgeladen. Sie können ihn mehrmals (ohne Begrenzung der Anzahl der Zeiten) aufrufen, um mehrere Filterbedingungen festzulegen. Regelmäßige Ausdrücke, die mehrmals gesetzt wurden, werden angesammelt und wirken gleichzeitig. Sie können eine leere Zeichenfolge festlegen, um den regulären Ausdruck, der zum Filtern von Fehlerprotokollen verwendet wird, zurückzusetzen:SetErrorFilter(""). Die gefilterten Protokolle werden nicht mehr in die Datenbankdatei geschrieben, die der Live-Trading-ID im Docker-Verzeichnis entspricht, um zu verhindern, dass häufige Fehlermeldungen die Datenbankdatei aufblähen.
Holen Sie sich die Live-Handelsprozess-ID.
Rückgabe der Live-Handelsprozess-ID. String
GetPid (siehe unten)
function main(){
var id = GetPid()
Log(id)
}
def main():
id = GetPid()
Log(id)
void main() {
auto id = GetPid();
Log(id);
}
Erhaltet die letzte Fehlermeldung.
Letzte Fehlermeldung. String
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);
}
Es funktioniert nicht im Backtesting-System.
Erhält den Strategie-Interaktionsbefehl.
Das Format des zurückgegebenen Befehls istControlName:Data. ControlNameist der Name der Kontrolle undDataist das in die Steuerung eingegebene Datenformat. Wenn die interaktive Steuerung keine Eingabeboxen, Dropdown-Boxen und andere Komponenten (z. B. eine Tastensteuerung ohne Eingabeboxen) hat, wird das zurückgegebene BefehlformatControlName, die nur den Kontrollnamen zurückgibt.
String
GetCommand (siehe unten)
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);
}
}
Ermittelt den Interaktionsbefehl und verwendet dieLogFunktion zur Ausgabe des Interaktionsbefehls, wenn er erkannt wird.
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);
}
}
Zum Beispiel fügt die Strategie-Interaktionssteuerung eine Steuerung ohne Eingabebox hinzu, die interaktive Steuerung heißt:buy, sind die Angaben zur Kontrollbeschreibung:buy, das eine Tastensteuerung ist. Führen Sie fort, indem Sie eine Steuerung mit einem Eingabefeld hinzufügen. Die interaktive Steuerung heißt:sellund die Beschreibungsmeldung für die Kontrolle lautet:sellDer Interaktionscode ist in der Strategie so konzipiert, dass er auf die verschiedenen Interaktionssteuerungen reagiert:
Es funktioniert nicht im Backtesting-System.
Erhalten Sie den Wert von Meta geschrieben, wenn die Strategie Registrierungscode generiert.
MetaDaten.
String
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);
}
}
Beispiel für die Anwendung: VerwendungMetadie Höhe der von der Strategie betriebenen Vermögenswerte zu begrenzen.
Anwendungsszenario: müssen Kapitallimits für verschiedene Strategie Mieter.Metader bei der Erstellung des Registrierungscodes festgelegte Wert darf 190 Zeichen nicht überschreiten, undGetMeta()Die Funktion unterstützt nur Live-Handel.Meta) wird bei der Erstellung eines Strategie-Registrierungscodes, derGetMeta()Die Funktion gibt null zurück. Sie funktioniert nicht im Backtesting System.
Für primitiveSocketZugang, Unterstützungtcp, udp, tls, unixUnterstützung von 4 gängigen Kommunikationsprotokollen:mqtt, nats, amqp, kafkaUnterstützung für die Verbindung zu Datenbanken:sqlite3, mysql, postgres, clickhouse.
DieDial()Ein normaler Aufruf gibt ein Verbindungsobjekt zurück, das drei Methoden hat:read, writeundclose. DiereadDie Methode wird zur Ablesung der Daten verwendet.writeDaten zu senden und diecloseMethode verwendet wird, um die Verbindung zu schließen.
DiereadDie Methode unterstützt folgende Parameter:
ws.read().ws.read(2000)eine Zeitraffer von zwei Sekunden (2000 Millisekunden) angibt.-1bedeutet, dass die Funktion unabhängig vom Vorhandensein oder Fehlen von Nachrichten sofort zurückgibt, z. B.:ws.read(-1)- Ich weiß.
Übergabe des Parameters-2bedeutet, dass die Funktion sofort mit oder ohne eine Nachricht zurückgibt, aber nur die letzte Nachricht zurückgegeben wird, und die pufferte Nachricht wird entsorgt.ws.read(-2).read()Beschreibung des Funktionspuffers:
Die eingehenden Daten, die durch das WebSocket-Protokoll geschoben werden, können eine Datenauflagerung verursachen, wenn das Zeitintervall zwischenread()Diese Daten werden in dem Puffer gespeichert, der eine Datengestaltung einer Warteschlange mit maximal 2000 hat.
| Szenario | Keine Parameter | Parameter: -1 | Parameter: -2 | Parameter: 2000, in Millisekunden |
|---|---|---|---|---|
| Daten bereits im Puffer | Sofortige Rückgabe der ältesten Daten | Sofortige Rückgabe der ältesten Daten | Sofort die neuesten Daten zurückgeben | Sofortige Rückgabe der ältesten Daten |
| Keine Daten im Puffer | Zurückkehren, wenn Daten blockiert sind | Null sofort zurückgeben | Null sofort zurückgeben | Warten Sie 2000 ms, Null zurückgeben, wenn keine Daten, Null zurückgeben, wenn es Daten gibt |
| Die WebSocket-Verbindung wird vom zugrunde liegenden | read() Funktion gibt die leere Zeichenfolge zurück, d.h.: |
Gegenstand
Wählen Sie (Adresse) Wählen Sie (Adresse, Zeitverzögerung)
Anfrageadresse. Anschrift wahr String Zeitraffer Sekunden, Zeitverzögerung falsche Zahl
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();
}
}
Beispiel für einen Aufruf der Funktion "Dial":
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();
}
Zugriff auf die WebSocket-Ticker-Schnittstelle von Binance:
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");
}
Zugriff auf die 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");
}
Zugriff auf Huobi's WebSocket Tickerschnittstelle:
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");
}
Zugriff auf die WebSocket-Authentifizierungsoberfläche von 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
Das Verbindungsobjekt, das bei der Verbindung zu einer Datenbank durch die Funktion Dial zurückgegeben wird, hat zwei Methodenfunktionen, die einzigartig sind:
exec(sqlString): Wird verwendet, um SQL-Anweisungen ähnlich wie dieDBExec() function.fd()Diefd()Funktion gibt einen Handler zurück (z. B. die Handlervariable ist Handler), der von anderen Threads zur Wiederverbindung verwendet wird (auch wenn das von Dial erstellte Objekt bereits durch die Ausführung desclose()Funktion, um die Verbindung zu schließen) durch dasDial()Funktion, zum Beispiel,Dial(handle)Wiederverwendungsanschluss.
Das folgende ist ein Beispiel für die Dial-Funktion, die eine Verbindung zu einemsqlite3 database.Einzelheiten deraddressParameter, getrennt durch die|Symbol nach der normalen Adresse:wss://ws.okx.com:8443/ws/v5/publicWenn es welche gibt.|Zeichen in der Parameterzeile, dann||Der Teil danach sind einige Funktionsparameter-Einstellungen, und jeder Parameter ist mit&Siehe auch:ss5Proxy- und Kompressionsparameter können wie folgt zusammengestellt werden:Dial("wss://ws.okx.com:8443/ws/v5/public|proxy=socks5://xxx:9999&compress=gzip_raw&mode=recv")
| Funktionen, die durch den Adressparameter der Dial-Funktion unterstützt werden | Beschreibung der Parameter |
|---|---|
| Parameter im Zusammenhang mit der Datenkomprimierung des WebSocket-Protokolls: compress=Parameterwert | compress ist die Komprimierungsmethode, die Komprimierungsparameteroptionen sind: gzip_raw, gzip usw. Wenn die gzip-Methode nicht gzip ist, können Sie die erweiterte Methode verwenden: gzip_raw |
| Parameter im Zusammenhang mit der Datenkomprimierung des WebSocket-Protokolls: Mode=Parameterwert | Modus ist der Komprimierungsmodus, Modusparameter kann dual sein, send, recv. dual ist Zwei-Wege-Komprimierung, send komprimierte Daten, empfangen komprimierte Daten. send send komprimierte Daten. recv empfangen komprimierte Daten, lokale Dekomprimierung. |
| Das WebSocket-Protokoll legt die zugrunde liegenden Parameter für die automatische Wiederverbindung fest: reconnect=Parameterwert | reconnect ist, ob reconnect gesetzt wird, reconnect=true ist, ob reconnect aktiviert wird. |
| Das WebSocket-Protokoll setzt die zugrunde liegenden Parameter für die automatische Wiederverbindung: interval=Parameterwert | Intervall ist das Wiederversuchsintervall, in Millisekunden, interval=10000 ist das Wiederversuchsintervall von 10 Sekunden, der Standardwert ist 1 Sekunde, wenn es nicht eingestellt ist, d. h. interval=1000. |
| Das WebSocket-Protokoll legt die zugrunde liegenden Parameter für die automatische Wiederverbindung fest: Nutzlast=Parameterwert | Payload ist die Abonnementnachricht, die gesendet werden muss, wenn die WebSocket wieder verbunden wird, z. B.: payload=okokok. |
| Parameter im Zusammenhang mit socks5 proxy: proxy=Parameterwert | Proxy ist die Proxy-Einstellung ss5, Parameterwertformat: socks5://name:pwd@192.168.0.1:1080, Name ist SS5-Server-Benutzername, pwd ist SS5-Server-Login-Passwort, 1080 ist SS5-Service-Port. |
DieDial()Die Funktion wird nur für den Live-Handel unterstützt.
Bei der Verbindung mit einer Datenbank mit der Dial-Funktion wird die Verbindungszeile mit Bezug auf das Go-Sprachtreiberprojekt für jede Datenbank geschrieben.
| Unterstützte Datenbanken | Antriebsprojekte | Verbindungsstring | Anmerkungen |
|---|---|---|---|
| Schnitt 3 | github.com/mattn/go-sqlite3 | sqlite3://Datei:test.db?Cache=shared&mode=Speicher | Diesqlite3://Prefix zeigt an, dass eine sqlite3-Datenbank verwendet wird, Beispielruf:Dial("sqlite3://test1.db") |
| MySQL | github.com/go-sql-driver/mysql | Ich bin nicht derjenige, der das Problem hat, aber ich bin derjenige, der das Problem hat.localhost:3306) / Ihre Datenbank? Charset=utf8mb4 | – |
| Nachwuchs | github.com/lib/pq | Postgres://user=postgres dbname=yourdatabase sslmode=disable password=yourpassword host=localhost port=5432 | – |
| Klickhaus | github.com/ClickHouse/clickhouse-go | Sie müssen sich an die Datenbank wenden, die Sie benötigen. | – |
Bitte beachten Sie, daß diepayloadInhalte in deraddressParameter enthält Zeichen=oder andere Sonderzeichen, kann es die Parsierung deraddressParameter derDialFunktion, wie zum Beispiel im folgenden Beispiel.
Beispiel für den Aufruf der privaten Schnittstelle von backPack Exchange websocket:
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}}")
}
Der folgende Anruf im Code funktioniert:
client = Dial("wss://ws.backpack.exchange")
client.write(JSON.stringify(payload))
Wenn Sie es direkt inpayload, wird es nicht richtig funktionieren, zum Beispiel:
client = Dial("wss://ws.backpack.exchange|payload=" + JSON.stringify(payload))
Derzeit unterstützt nur JavaScript die Verwendung dermqtt, nats, amqp, undkafkaDer JavaScript-Strategiekode wird als Beispiel verwendet, um die Verwendung der vier Protokolle zu zeigen:mqtt, nats, amqp, undkafka:
// 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")
}
}
Ausführliche Dokumentation:Erforschung von FMZ: Praxis des Kommunikationsprotokolls zwischen Live-Handelsstrategien
Senden Sie eine Http-Anfrage.
Gibt die Antwortdaten der Anfrage zurück.JSONString, es kann durch dieJSON.parse()Funktion imJavaScriptDie Europäische Kommissionjson::parse()Funktion imC++Wenn Debug in der Optionsstruktur auf true gesetzt ist, ist der zurückgegebene Wert ein Objekt (JSON); wenn Debug auf false gesetzt ist, ist der zurückgegebene Wert eine Zeichenfolge.
String, Objekt
HttpQuery (URL) HttpQuery (URL, Optionen)
Http-Anfrage-URL. Url - Das stimmt. String Http-Anfrage-bezogene Einstellungen können beispielsweise wie folgt strukturiert werden:
{
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
}
tlsFingerabdrücke.
Die unterstützten Einstellungen umfassen folgende Optionen:
- Ich weiß nicht."chrome_103", "chrome_104", "chrome_105", "chrome_106", "chrome_107", "chrome_108", "chrome_109", "chrome_110", "chrome_111", "chrome_112", "chrome_117"- Ich weiß.
Safari_:"safari_15_6_1", "safari_16_0", "safari_ipad_15_6", "safari_ios_15_5", "safari_ios_15_6", "safari_ios_16_0"- Ich weiß.
Firefox_:"firefox_102", "firefox_104", "firefox_105", "firefox_106", "firefox_108", "firefox_110", "firefox_117"- Ich weiß.
- Ich weiß nicht."opera_89", "opera_90", "opera_91"- Ich weiß.
Ich habe ihn nicht gesehen."zalando_android_mobile", "zalando_ios_mobile"- Ich weiß.
- Ich weiß nicht."nike_ios_mobile", "nike_android_mobile"- Ich weiß.
Wolkenkratzer:"cloudscraper"- Ich weiß.
- Ich weiß nicht."mms_ios"- Ich weiß.
Sieh mal an:"mesh_ios", "mesh_ios_1", "mesh_ios_2", "mesh_android", "mesh_android_1", "mesh_android_2"- Ich weiß.
Bestätigt:"confirmed_ios", "confirmed_android"- Ich weiß.
Ok. Das ist alles."okhttp4_android_7", "okhttp4_android_8", "okhttp4_android_9", "okhttp4_android_10", "okhttp4_android_11", "okhttp4_android_12", "okhttp4_android_13",true, dieHttpQueryFunktionsanruf gibt die vollständige Antwort zurück.false, nur die Daten inBodyder Antwortnachricht zurückgegeben wird.profileDas Feld kann ausgeschlossen werden.Optionen falsche Gegenstand
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);
}
Ein Beispiel für den Zugriff auf die öffentliche OKX-Ticker-API-Schnittstelle.
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/");
}
Die HttpQuery-Funktion verwendet Proxy-Einstellungen.
DieHttpQuery()Funktion nur unterstütztJavaScript, C++Sprache,PythonSprache kann dieurllibDie Web-Library ist für den direkten Versand von HTTP-Anfragen geeignet.HttpQuery()Die Anwendungsmöglichkeiten sind in der Regel für den Zugriff auf die Schnittstellen der Börse, die keine Signatur erfordern, wie z. B. öffentliche Schnittstellen wie Tickerinformationen.HttpQuery()kann im Backtesting-System verwendet werden, um Anfragen (nurGETDas Backtesting beschränkt sich auf die Verwendung von 20 Besuchen in verschiedenenURLs, undHttpQuery()Die Daten werden von den Besuchern im Cache gespeichert.URLDer zweite Zugriff erfolgtHttpQuery()Funktion gibt die zwischengespeicherten Daten zurück und es werden keine tatsächlichen Netzwerkanfragen mehr erfolgen.
Ich bin nicht derjenige, der das Problem hat.
Sendet eine HTTP-Anfrage, eine asynchrone Version desHttpQuery function.
DieHttpQuery_Go()Funktion gibt sofort ein gleichzeitiges Objekt zurück, das verwendet werden kann, um das Ergebnis einer HTTP-Anfrage mit demwaitVerfahren derJSON.parse()Funktion kann verwendet werden, um dieJSON.parse()Funktion imJavaScriptSprachenstrategie.
Gegenstand
HttpQuery_Go (URL) HttpQuery_Go (URL, Optionen)
Http-Anfrage-URL. Url - Das stimmt. String Http-Anfrage-bezogene Einstellungen können beispielsweise wie folgt strukturiert werden:
{
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.trueDas ist...HttpQuery_GoFunktionsanruf gibt die vollständige Antwort zurück.false, nur die Daten inBodyder Antwortnachricht zurückgegeben wird.profileDas Feld kann ausgeschlossen werden.Optionen falsche Gegenstand
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
Asynchroner Zugriff auf die öffentliche Schnittstelle der Börse für aggregierte Tickerdaten.
DieHttpQuery_Go()Funktion nur unterstütztJavaScript, diePythonDie Sprache kann mit derurllibDie Web-Library ist für den direkten Versand von HTTP-Anfragen geeignet.HttpQuery_Go()Die Anwendungsmöglichkeiten sind in der Regel in der Form von Anwendungen, die für den Zugang zu Schnittstellen verwendet werden, die keine Unterschrift auf der Börse erfordern, z. B. öffentliche Schnittstellen wie Tickerinformationen.HttpQuery_GoFunktion nicht im Backtesting-System unterstützt.
Ich bin nicht derjenige, der das Problem hat.
Diese Funktion kodiert die Daten nach den eingegebenen Parametern.
DieEncodeFunktion gibt die Daten nach der Verschlüsselung und Verschlüsselung zurück.
String
Code (algo, inputFormat, outputFormat, Daten) Code ((algo, inputFormat, outputFormat, Daten, SchlüsselFormat, Schlüssel)
Der Parameteralgoist der Algorithmus, der bei der Codierung berechnet wird.raw(Kein Algorithmus wird verwendet), das"Zeichen", algoUnterstützt auch: algounterstützt auch: algokann als ed25519.seedBerechnung.
etwas
wahr
String
Verwendet zur Festlegung des Datenformats derdataDieinputFormatDer Parameter kann als einer der folgenden Einstellungen festgelegt werden:raw, hex, base64, string. hexkodiert, base64und outputFormatDer Parameter kann als einer der folgenden Einstellungen festgelegt werden:raw, hex, base64, string. hexkodiert, base64und dataist die zu verarbeitende Daten.
Daten
wahr
String
Verwendet zur Festlegung des Datenformats derkeyDiekeyDer Parameter kann als einer der folgenden Einstellungen festgelegt werden:raw, hex, base64, string. hexkodiert, base64und keyist der geheime Schlüssel, der fürHMACDer Parameterkeyist erforderlich, wenn der Parameteralgoist aufsignodersignTx. DiekeyParameter wird nicht fürHMACVerschlüsselung, wennalgoDer Parameter ist auf
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
}
Beispiel für den Aufruf der Funktion "Encode".
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);
}
Der ParameteralgoUnterstützt auch:
DieEncode()Die Funktion wird nur für den Live-Handel unterstützt.keyundkeyFormatParameter werden nicht übergeben, dannkeyVerschlüsselung wird nicht verwendet.
Holen Sie sich den Nanosekunden-Zeitstempel des aktuellen Moments.
DieUnixNano()Die Funktion gibt den Nanosekundenzeitstempel zurück.
Zahl
UnixNano (siehe unten)
function main() {
var time = UnixNano() / 1000000
Log(_N(time, 0))
}
def main():
time = UnixNano()
Log(time)
void main() {
auto time = UnixNano();
Log(time);
}
Wenn Sie Millisekundenzeitstempel benötigen, können Sie den folgenden Code verwenden:
Ich bin nicht derjenige.
Holen Sie sich den Zeitstempel des aktuellen Moments auf der zweiten Ebene.
Gibt den Zeitstempel der zweiten Ebene zurück. Zahl
Unix()
function main() {
var t = Unix()
Log(t)
}
def main():
t = Unix()
Log(t)
void main() {
auto t = Unix();
Log(t);
}
Ich bin nicht derjenige, der das Problem hat.
Holen Sie sich die Systeminformationen des Geräts, wo sich der Docker befindet.
Systeminformationen. String
GetOS()
function main() {
Log("GetOS:", GetOS())
}
def main():
Log("GetOS:", GetOS())
void main() {
Log("GetOS:", GetOS());
}
Zum Beispiel ein Anruf an dieGetOS()Funktion für einen Docker, der auf derMac-BetriebssystemDas Betriebssystem könnte zurückkehren:darwin/amd64Weil Apple-Computer mehrere Hardware-Architekturen haben.darwinist der Name derMac-Betriebssystem system.
Berechnet den MD5-Hash des Parametersdata.
MD5-Hashwert. String
MD5 (Daten)
Die Daten, die eine MD5-Berechnung erfordern. Daten wahr String
function main() {
Log("MD5", MD5("hello world"))
}
def main():
Log("MD5", MD5("hello world"))
void main() {
Log("MD5", MD5("hello world"));
}
Ich rufe dieMD5("hello world")Funktion, der Rückgabewert beträgt:5eb63bbbe01eeed093cb22bb8f5acdc3.
Ich bin nicht derjenige.
Datenbank-Schnittstellenfunktionen
Ein Objekt, das das Ergebnis der Ausführung einesQuadratkilometerAngabe, zum Beispiel:
{"columns":["TS","HIGH","OPEN","LOW","CLOSE","VOLUME"],"values":[[1518970320000,100,99.1,90,100,12345.6]]}
Gegenstand
DBExec (sql)
QuadratkilometerAnweisungsstring. Quadratkilometer wahr String
function main() {
var strSql = [
":CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
].join("")
var ret = DBExec(strSql)
Log(ret)
// 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;"));
}
Unterstützung der Datenbank im Speicher fürDBExecFunktionsparameter, wennQuadratkilometerBeginnt mit:Es ist für Datenbankoperationen geeignet, die kein ständiges Speichern erfordern, zum Beispiel:
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);
}
Machen Sie einen Tisch.
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));
}
Hinzufügen, Löschen, Überprüfen und Ändern der Datensätze in der Tabelle.
Die FunktionDBExec()kann die Live-Trading-Datenbank (SQLite-Datenbank) bedienen, indem Parameter eingegeben werden.SQLiteDas System reservierte Tabellen in der Live-Handelsdatenbank:kvdb, cfg, log, profit, chartSie dürfen auf diesen Tischen nicht arbeiten.TransaktionenDiese Funktionen werden nicht unterstützt und es wird nicht empfohlen, solche Operationen durchzuführen, da sie Konflikte im System verursachen können.DBExec()Die Funktion wird nur für den Live-Handel unterstützt.
Ich bin nicht derjenige, der das Problem hat.
Erstellen Sie eine UUID.
32-Bit-UID. String
UUID (()
function main() {
var uuid1 = UUID()
var uuid2 = UUID()
Log(uuid1, uuid2)
}
def main():
uuid1 = UUID()
uuid2 = UUID()
Log(uuid1, uuid2)
void main() {
auto uuid1 = UUID();
auto uuid2 = UUID();
Log(uuid1, uuid2);
}
DieUUID()Die Funktion unterstützt nur Live-Handel.
Hören Sie auf die Ereignisse, es kommt zurück, wenn es irgendwelcheWebSocketLesbare Daten oder gleichzeitige Aufgaben wieexchange.Go(), HttpQuery_Go(), etc. sind abgeschlossen.
Wenn das zurückgegebene Objekt kein Nullwert ist, wird dieEventDer in der Rückgabe enthaltenen Inhalt ist der Ereignis-Trigger-Typ. Zum Beispiel die folgende Rückgabewertstruktur:
{"Seq":1,"Event":"Exchange_GetTrades","ThreadId":0,"Index":3,"Nano":1682068771309583400}
Gegenstand
EventLoop (siehe unten) EventLoop (Zeitrahmen)
Der Parametertimeoutist die Einstellung der Ausfallzeit in Millisekunden.timeoutwartet, bis ein Ereignis auftritt, bevor es zurückgegeben wird, wenn es auf 0 gesetzt ist. Wenn es größer als 0 ist, setzt es das Ereignis auf einen Timeout und gibt das jüngste Ereignis sofort zurück, wenn es kleiner als 0 ist.
Zeitverzögerung
falsche
Zahl
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);
}
Der erste Anruf an dieEventLoop()Funktion im Code initialisiert den Mechanismus für das zugehörte Ereignis, und wenn die ersteEventLoop()Wenn ein Call nach dem Ereignis-Callback beginnt, wird es die vorherigen Ereignisse verpassen. Das zugrunde liegende System wickelt eine Warteschlange, die maximal 500 Ereignis-Callbacks speichert.EventLoop()Wenn die Funktion nicht rechtzeitig aufgerufen wird, um sie während der Programmdurchführung zu entfernen, werden spätere Ereignisrückrufe außerhalb des 500-Cache verloren gehen.EventLoop()Funktion beeinflussen nicht die Cache-Warteschlange des zugrunde liegenden Systems WebSocket oder die Caches von gleichzeitigen Funktionen wieexchange.Go(). Für diese Caches ist es immer noch notwendig, die jeweiligen Methoden zu verwenden, um die Daten abzurufen.EventLoop()Funktion für Daten, die vor demEventLoop()Der Hauptzweck derEventLoop()Die Funktion der Strategie-Schicht besteht darin, die Strategie-Schicht darüber zu informieren, dass neue Netzdaten vom zugrunde liegenden System empfangen wurden.EventLoop()Funktion gibt ein Ereignis zurück, durchläuft einfach alle Datenquellen.exchange.Go()Versuchen Sie, Daten zu erhalten.EventLoop()Die Funktion unterstützt nur Live-Handel.
Hören Sie auf Ereignisse im Hauptthread, wenn Sie von der Hauptfunktion aufgerufen werdenmain(). in den in derJavaScriptSprache, diethreading.Thread()Funktion erstellt einen Thread, der auch in der Ausführungsfunktion des Threads aufgerufen werden kann, um auf Ereignisse im aktuellen Thread zu hören.
Das bedeutet, dass wir uns nicht mehr auf die Frage konzentrieren müssen.
Die__ServeFunktion wird verwendet, um Http-Dienst, TCP-Dienst und Websocket-Dienst (basierend auf Http-Protokoll) zu erstellen.
Gibt eine Zeichenfolge zurück, die die IP-Adresse und den Port des erstellten Dienstes aufzeichnet.127.0.0.1:8088, [::]:8089.
String
__Serve (ServeURI, Handler) __Serve ((serveURI, Handler,...args)
DieserveURIParameter wird verwendet, um das Protokoll, die IP-Adresse, den Port und andere Einstellungen der Dienstbindung zu konfigurieren, wiehttp://0.0.0.0:8088?gzip=true, d. h.http://:8088?gzip=true.
serveURIEinstellung von Parametern wietcp://127.0.0.1:6666?tls=trueSie können z. B. Zertifikate und private Schlüssel hinzufügentls=true&cert_pem=xxxx&cert_key_pem=xxxx.serveURIEinstellungen von Parametern wiehttp://127.0.0.1:6666?gzip=true; Sie können Komprimierungseinstellungen einstellen:gzip=true- Ich weiß.
DieserveURIParameter wird für Https verwendet, wiehttps://127.0.0.1:6666?tls=true&gzip=true; Sie können hinzufügencert_pemundcert_key_pemParameter zum Laden des Zertifikats.ServiceURI
wahr
String
DiehandlerDer Parameter wird verwendet, um in der Routing-Verarbeitungsfunktion (Http-Protokoll), der Nachrichtenverarbeitungsfunktion (TCP-Protokoll) und der Stream-Verarbeitungsfunktion (Websocket) zu übergeben.
Die von dem Parameter übermittelte Rückruffunktionhandlerkann mehrere Parameter definieren, der erste Parameter ist das ctx-Objekt (Kontextobjekt).
Handler
wahr
Funktion
Der tatsächliche Parameter der Rückruffunktion wird als Parameter übergebenhandlerEs kann mehrere Parameter geben.arg, zum Beispiel:
__Serve("http://:8088", function(ctx, a, b, c) {
Log(`ctx.host():`, ctx.host(), ", a=", a, ", b=", b, ", c=", c)
}, 1, 2, 3)
Die Parameter1, 2, 3Sie ist bei der Anrufung der__Serve()Funktion entsprechen den Parameterna, b, cin der Rückruffunktion übergeben.
Arg falsche String, Zahl, bool, Objekt, Array, Funktion, Nullwert und andere vom System unterstützte Typen
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
WebsocketSie können einen Routing-Zweig in den Pfad setzen und den Implementierungscode fürWebsocketSie können sich auf den Mustercode in diesem Abschnitt beziehen.Die von dem Parameter übermittelte Rückruffunktionhandlererhält einectxDiectxParameter ist ein Kontextobjekt, das zur Erfassung und Schreibung von Daten mit folgenden Methoden verwendet wird:
HTTP/1.1, tcp.http://127.0.0.1:8088?num=123, und die von dem Parameter übermittelte Funktion für die RückrufverarbeitunghandlerErträge"123"Wann?ctx.query("num")ist genannt.User-Agentin den Überschriften des vorliegenden Antrags:ctx.header("User-Agent").GET, POST, usw.ctxKontextobjekt zum Websocket-Protokoll; Gibt einen Boolean-Wert (true) zurück, wenn der Switch erfolgreich ist, und einen Boolean-Wert (false), wenn er fehlschlägt.readSie können den Timeout-Parameter angeben.timeout_msin Millisekunden.JSON.stringify()Das JSON-Objekt in eine Zeichenkette zu kodieren und dann zu schreiben.WebSocketProtokoll, Sie können diese Methode verwenden, um die verschlüsselte Zeichenfolge an den Client weiterzugeben.Das ist eine sehr schwierige Aufgabe.
Die Datenstruktur ist eine KV-Tabelle, die dauerhaft in der lokalen Datenbankdatei des Dockers gespeichert wird.
Dauerhaft gespeicherte Schlüsselwertdaten ink-vSchlüssel-Wert-Paare.
String, Zahl, bool, Objekt, Array, Nullwert
_G() _G(k) _G(k, v)
Der Parameterkist der Name des Schlüssels im gespeicherten Schlüssel-Wert-Paar und ist nicht groß- oder kleinbuchstabenbezogen.
k
falsche
String, Nullwert
Der Parametervist der Schlüsselwert im gespeicherten Schlüssel-Wert-Paar, das alle Daten sein kann, die gespeichert werden könnenJSONSie ist in Serie.
v
falsche
String, Zahl, bool, Objekt, Array, Nullwert
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();
}
Eine getrennte Datenbank für jeden Live-Handel, die von der_G()Wenn das Backtesting abgeschlossen ist, werden die Daten, die im Backtesting-System gespeichert werden, von der_G()Wenn Sie die Funktion_G()Funktion, um die gespeicherten Daten aufrechtzuerhalten, sollte sie entsprechend dem Speicher- und Festplattenraum der Hardwareinrichtung vernünftig verwendet werden und nicht missbraucht werden.
Bei Anrufen der_G()Funktion in einem Live-Handel und keine Parameter übergeben werden, die_G()Funktion gibt dieIdDer aktuelle Live-Handel._G()Funktion, der Parametervwird als null übergeben, um die Löschung derk-vBei Aufrufen der_G()Funktion, nur der Parameterkwird in der Zeichenfolge übergeben, und die_G()Funktion gibt den Schlüsselwert zurück, der dem gespeicherten Parameter entsprichtk. Wenn Sie die_G()Funktion, nur der Parameterkwird in einem Nullwert übergeben, der anzeigt, dass alle Datensätze derk-vDas Key-Value-Paar wird gelöscht.k-vdie Schlüssel-Wert-Paare wurden dauerhaft gespeichert,_G()Funktion wird erneut aufgerufen, indem der Name des Schlüssels, der als Parameter aufrechterhalten wurde, weitergegeben wirdk. Das neue Schlüsselwert als Parameter gebenvWir werden das aktualisieren.k-vSchlüssel-Wert-Paar.
Ich bin nicht derjenige.
Konvertiert Millisekundenzeitstempel oderDateGegenstände zu Zeitfolgen.
Zeitstring. String
_D() Zeitstempel _BAR_ Zeitstempel, fmt)
Zeitstempel in Millisekunden oderDateGegenstand.
Zeitstempel
falsche
Nummer, Gegenstand
Formatierung der Zeichenkette,JavaScriptSprache Standardformat:yyyy-MM-dd hh:mm:ss; PythonSprache Standardformat:%Y-%m-%d %H:%M:%S; C++Sprache Standardformat:%Y-%m-%d %H:%M:%S- Ich weiß.
fmt
falsche
String
function main(){
var time = _D()
Log(time)
}
def main():
strTime = _D()
Log(strTime)
void main() {
auto strTime = _D();
Log(strTime);
}
Erhalten und drucken Sie die aktuelle Zeitfolge:
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));
}
Der Zeitstempel lautet 1574993606000, wobei der Code umgerechnet wird:
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
}
Formatierung mit dem Parameterfmtist fürJavaScript, Python, undC++Sprachen, wie in den folgenden Beispielen gezeigt:
Gibt die aktuelle Zeitfolge zurück, ohne Parameter zu übergeben._D()Funktion imPythonSie müssen sich bewusst sein, dass die übergebenen Parameter Zeitstempel der zweiten Ebene sind (Zeitstempel auf Millisekundenebene in den JavaScript- und C++-Strategien, bei denen 1 Sekunde 1000 Millisekunden entspricht)._D()Die Funktion, um eine Zeitkette mit einem lesbaren Zeitstempel im Live-Handel zu analysieren, müssen Sie auf die Zeitzone und die Zeiteinstellung des Betriebssystems, in dem sich das Docker-Programm befindet, achten._D()Die Funktion analysiert einen Zeitstempel in eine lesbare Zeitfolge, abhängig von der Zeit des Docker
Das ist nicht nur ein Spiel, sondern auch ein Spiel.
Formatieren Sie eine Fließkomma.
Die nach der Präzisionseinstellung formatierte Zahl mit schwebender Komma. Zahl
_N() _N (Nummer) _N (Nummer, Präzision)
Die zu formatierende Zahl mit schwebender Komma.
Zahl
wahr
Zahl
Die Präzisionseinstellung für die Formatierung, der Parameterprecisionist eine ganze Zahl, und der ParameterprecisionStandardeinstellungen 4.
Präzision
falsche
Zahl
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);
}
Zum Beispiel:_N(3.1415, 2)wird den Wert nach3.1415Zwei Dezimalstellen und die Funktion gibt zurück3.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);
}
Wenn Sie alle N-Zahlen links vom Dezimalpunkt auf 0 ändern müssen, können Sie es so schreiben:
Der Parameterprecisionkann eine positive oder negative ganze Zahl sein.
Ich bin nicht derjenige, der das Problem hat.
Wiederholen Sie die Funktion für die Schnittstellenfehlertoleranz.
Der Rückgabewert der Rückruffunktion bei Ausführung. Alle Typen werden vom System unterstützt, außerlogischer falscher WertundNull-Wert.
_C (((pfn) - Ich bin nicht derjenige.
Der Parameterpfnist eine Funktionsreferenz, die eineRückruffunktion- Ich weiß.
Pfn
wahr
Funktion
Parameter bisRückruffunktionen, kann es mehr als einen Parameter gebenarg. Art und Anzahl der ParameterargDie Ergebnisse der StudieRückruffunktion- Ich weiß.
Arg
falsche
String, Zahl, bool, Objekt, Array, Funktion, alle Typen werden vom System unterstützt, z. B. Nullwerte
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);
}
Für fehlertolerante Funktionen ohne Parameter:
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);
}
Für Funktionen mit fehlertoleranten Parametern:
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
Es kann auch für die Fehlerverträglichkeit von benutzerdefinierten Funktionen verwendet werden:
Die_C()function wird die angegebene Funktion aufrufen, bis sie erfolgreich zurückgegeben wird (die Funktion, auf die der Parameter verweistpfnErträgeNulloderfalscheWenn Sie angerufen werden, versuchen Sie es erneut.pfn) Zum Beispiel_C(exchange.GetTicker). Das Standard-Wiederversuchsintervall beträgt 3 Sekunden, Sie können die_CDelay()Funktion, um das Wiederholungsintervall festzulegen._CDelay(1000)Mittel zur Änderung des Wiederversuchsintervalls der_C()Funktion auf 1 Sekunde.
Die Fehlertoleranz kann für folgende Funktionen durchgeführt werden, jedoch nicht auf diese beschränkt:
exchange.GetTicker()exchange.GetDepth()exchange.GetTrades()exchange.GetRecords()exchange.GetAccount()exchange.GetOrders()exchange.GetOrder()exchange.GetPositions()Alle können von der_C()Die Funktion der Fehlerverträglichkeit_C()Die Funktion ist nicht auf die oben aufgeführte Funktion Fehlertoleranz beschränkt, der Parameterpfnist eine Funktionsreferenz und nicht ein Funktionsanruf.
Beachten Sie, dass es_C(exchange.GetTicker), nicht_C(exchange.GetTicker()).Gibt die Anzahl der Schnittpunkte des Arrays zurückarr1und das Arrayarr2.
Anzahl der Querschnittsperioden des Arraysarr1und das Arrayarr2- Ich weiß.
Zahl
_Kreuzung ((arr1, arr2)
Elemente sind Arrays von Typnumber- Ich weiß.
Arr1
wahr
Reihenfolge
Elemente sind Arrays von Typnumber- Ich weiß.
Arr2
wahr
Reihenfolge
// 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));
}
Eine Datenmenge kann simuliert werden, um die _Cross ((Arr1, Arr2) -Funktion zu testen:
Wenn der Rückgabewert der_Cross()Wenn die Funktion eine positive Zahl ist, gibt sie die Periode des Aufwärtstrends an, wenn sie eine negative Zahl ist, gibt sie die Periode des Abwärtstrends an, 0 entspricht dem aktuellen Preis.Analyse und Gebrauchsanweisung über die eingebaute Funktion.
Die FunktionJSONParse()wird zur Parsierung verwendetJSON strings.
JSONGegenstand.
Gegenstand
JSONParse (s)
JSONSieht aus wie eine Schnur.
s
wahr
String
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-Strings mit großen Werten können korrekt analysiert werden, und es wird große Werte als Stringtypen analysieren.JSONParse()Funktion wird im Backtestsystem nicht unterstützt.
Ausgangsprotokolle.
Log ((...msgs)
Der Parametermsgist der Inhalt der Ausgabe und der Parametermsgkann mehr als eine übergeben werden.
Msg
falsche
String, Zahl, bool, Objekt, Array, jeder vom System unterstützte Typ wie z.B. null.
function main() {
Log("msg1", "msg2", "msg3")
}
def main():
Log("msg1", "msg2", "msg3")
void main() {
Log("msg1", "msg2", "msg3");
}
MehrfachmsgParameter können übergeben werden:
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@");
}
Es unterstützt die Einstellung der Farbe der Ausgabe Nachricht, wenn wir verwenden Einstellung Farbe und schieben zur gleichen Zeit, müssen wir die Farbe zuerst und verwenden@Charakter, der als Letzter drückt.
function main() {
Log("`data:image/png;base64,AAAA`")
}
def main():
Log("`data:image/png;base64,AAAA`")
void main() {
Log("`data:image/png;base64,AAAA`");
}
DieLog()Funktion unterstützt das Druckenbase64kodierte Bilder, beginnend mit`und endet mit`, zum Beispiel:
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
Log(plt)
DieLog()Funktion unterstützt den direkten Druck vonPythonDas ist...matplotlib.pyplotObjekt. Solange das Objekt diesavefigDie Daten werden mit Hilfe derLogFunktion, zum Beispiel:
function main() {
Log("[trans]中文|abc[/trans]")
}
def main():
Log("[trans]中文|abc[/trans]")
void main() {
Log("[trans]中文|abc[/trans]");
}
DieLog()Die Funktion unterstützt den Sprachaustausch.Log()Funktion liefert Text, der automatisch auf der Grundlage der Spracheinstellung auf der Plattformseite auf die entsprechende Sprache umschaltet, z. B.:
DieLog()Die Funktion erzeugt eine Protokollnachricht im Protokollbereich des Live-Handels oder des Backtesting-Systems, und das Protokoll wird in der Live-Handelsdatenbank gespeichert, wenn der Live-Handel ausgeführt wird.Log()Funktion liefert eine Protokollmeldung, die mit der@Schieben Sie auf die E-Mail-Adresse, WebHook-Adresse usw.Einstellungen drückenNachrichtenpushing wird nicht unterstütztDebug-ToolsDie spezifischen Einschränkungsregeln sind wie folgt: Innerhalb eines 20-Sekunden-Zyklus eines Live-Handels wird nur die letzte Push-Nachricht gespeichert und geschoben, und andere Nachrichten werden gefiltert und nicht geschoben (die Push-Log-Ausgabe durch die Log-Funktion wird normalerweise im Log-Bereich gedruckt und angezeigt).
FürWebHookPush, Sie können das Dienstprogramm verwenden, das vonGolang:
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)
}
AusgestattetWebHookinEinstellungen drücken: http://XXX.XX.XXX.XX:9090/data?data=Hello_FMZ- Ich weiß.
Nach der Ausführung des geschriebenenGolangService-Programm, beginnen wir die Strategie laufen Live-Handel, folgt die Strategie in geschriebenJavaScriptDie Strategie basiert auf derLog()Funktion und Druck der Nachricht:
function main() {
Log("msg", "@")
}
Ein Dienstleistungsprogramm, geschrieben in derGolangSprache empfängt den Push und das Serviceprogramm druckt die Nachricht:
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
Das ist ein sehr schwieriger Fall.
Der Gewinn- und Verlustwert wird aufgezeichnet, der Gewinn- und Verlustwert gedruckt und die Rendite-Kurve auf der Grundlage des Gewinn- und Verlustwerts gezeichnet.
LogProfit (Gewinn) LogProfit ((Gewinn,... args)
Der Parameterprofitist die Ertragsdaten, die durch den Konstruktionsalgorithmus und die Berechnung in der Strategie ermittelt werden.
Gewinn
- Das stimmt.
Zahl
Erweiterter Parameter zur Ausgabe von Nebeninformationen im Einnahmenprotokoll,argParameter können mehr als eine übergeben werden.
Arg
falsche
String, Zahl, bool, Objekt, Array, jeder vom System unterstützte Typ wie z.B. 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);
}
}
DieLogProfitFunktion, wenn sie mit dem Zeichen&, erstellt nur die Einnahmentabelle und druckt das Einnahmenprotokoll nicht aus.
- Ich bin nicht derjenige.
Löschen Sie alle Einnahmenprotokolle, Einkommensdiagramme.
LogProfitReset (siehe unten) LogProfitReset (bleiben)
DieremainDer Parameter wird verwendet, um die Anzahl der zu behaltenen Log-Einträge (ganzzahliger Wert) anzugeben.
bleiben
falsche
Zahl
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);
}
Das ist nicht meine Idee.
Ausgabeinformationen in der Statusleiste des Backtesting-Systems oder der Live-Handelsseite.
LogStatus ((...msgs)
Der Parametermsgist der Inhalt der Ausgabe und der Parametermsgkann mehr als eine übergeben werden.
Msg
falsche
String, Zahl, bool, Objekt, Array, jeder vom System unterstützte Typ wie z.B. 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");
}
Es unterstützt die Einstellung der Farbe des Ausgabeinhalts:
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() + "`");
}
Beispiel für die Ausgabe der Daten in der Statusleiste:
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() + "`");
}
Es unterstützt das Entwerfen von Buttons in der Statusleiste (alte Buttonsstruktur):
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() + "`");
}
Setzen Sie die Funktion Beschreibung der Statusleiste (alte Schaltflächenstruktur) deaktiviert:
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);
}
}
In Kombination mit derGetCommand()Funktion, konstruieren Sie die Interaktionsfunktion der Statusleiste (alte Tastenstruktur):
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);
}
}
Die Eingabedaten werden auch bei der Konstruktion von Statusleisten für die Interaktion unterstützt, und die Interaktionsbefehle werden vomGetCommand()Wir haben eine Funktion.inputElemente (alte Schaltflächenstruktur) zur Datenstruktur der Schaltflächensteuerung in der Statusleiste, z. B. Hinzufügen"input": {"name": "number of open positions", "type": "number", "defValue": 1}zu{"type": "button", "cmd": "open", "name": "open position"}wird ein Popup mit einem Eingabefeldsteuerungsknopf angezeigt, wenn auf die Taste geklickt wird (der Standardwert im Eingabefeld ist 1, das ist die vondefValueSie können Daten eingeben, die zusammen mit dem Buttonbefehl gesendet werden sollen. Zum Beispiel, wenn der folgende Testcode ausgeführt wird, erscheint nach dem Klicken auf die "Open positionGetCommand()Funktion wird dann die Nachricht erfassen: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);
}
}
Es unterstützt gruppierte Tastensteuerungen (alte Tastenstruktur).Statusleisten, die die Dateneingabe unterstützen(mit dem Feld GetCommand()Der Unterschied besteht darin, dass die"group"Feld Einstellung, wenn der Knopf geklickt wird, um die Interaktion auszulösen, enthält der Dialog, der auf der Seite erscheint, eine Reihe vonGruppeEinheitliche Eingabesteuerungen, die eine Datengruppe gleichzeitig einführen.
Einige Punkte zu beachten über die"group"Feld in der Struktur der Tastensteuerung der Statusleiste und der Tastensteuerung der Gruppe:
typeEigenschaft in der Gruppe unterstützt nur die folgenden vier Typen, und diedefValueEigenschaft ist der Standardwert.
|Symbol, um jede Option in einem Dropdown-Feld zu trennen, wie sie eingestellt ist.
"name": "tradePrice@orderType==1"DieHandelspreisEintrittssteuerung nur verfügbar, wenn dieAnordnungdie Drop-down-Steuerung alsAusstehende Anordnung.|Symbole zur Trennung des Inhalts der Beschreibung in chinesischer und englischer Sprache.name, descriptionin der Gruppe undname, descriptionin der Knopfstruktur nicht die gleichen Definitionen haben, obwohl sie die gleichen Feldnamen haben.
Die Definition vonnameDie Definition von "In-Group" unterscheidet sich auch von der Definition vonnamein der Eingabe.Log("cmd:", cmd)Angabe in der folgenden Beispieltest:cmd: open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}, d.h. was durch dieGetCommand()Funktion, wenn eine Wechselwirkung eintritt:open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}.typeEigenschaft der Tastensteuerung unterstützt nur:"button"- Ich weiß.
Buttonsteuerungen, die Eingabedaten unterstützen, d. h. Steuerelemente mitinputEigenschaftssammlungen,typeEigenschaft in den Konfigurationsinformationen derinputDas Feld unterstützt mehrere Steuertypen.
Siehe folgende Beispiele: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);
}
}
Wenn der Statusleiste-Knopf Gruppe Steuerung (implementiert durch Einstellung dergroupFeld) und der Statusleiste-Knopfsteuerung (umgesetzt durch Einstellung derinputWenn Sie auf ein Feld klicken, um eine Interaktion auszulösen (alte Schaltflächenstruktur), unterstützt das Dropdown-Box-Steuerelement im Dialogfeld, das auf der Seite erscheint, auch mehrere Auswahlmöglichkeiten.
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...
Wenn Sie auf die Taste klicken, um die Interaktion auszulösen, wird ein Popup-Fenster mit mehreren Steuerungen angezeigt. Weitere Einzelheiten finden Sie unter:Benutzerhandbuch - Interaktive Steuerelemente in der Statusleiste.
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() + "`");
}
Horizontale Verschmelzung von Zellen innerhalb der von derLogStatus()Funktion:
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() + "`");
}
Vertikal verschmelzen die Zellen in der von derLogStatus()Funktion:
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() + "`");
}
Anzeige der Statusleiste:
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() + "`");
}
Neben der Anzeige von Tabellen in Seiten können mehrere Tabellen auch in einer von oben nach unten verlaufenden Reihenfolge angezeigt werden:
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() + "`");
}
Unterstützung für die Einstellung des horizontalen und vertikalen Scroll-Modus der Statusleiste.scrollAttribut für"auto", wenn die Anzahl der vertikalen Zeilen der Statusleiste 20 Zeilen überschreitet, wird der Inhalt gescrollt.scrollDas Attribut kann verwendet werden, um das Problem der Verzögerung beim Schreiben einer großen Menge an Daten in der Statusleiste während des Live-Handels zu lindern.
Die Ausgabe von Informationen aus derLogStatus()Diese Funktion wird nicht in die Live-Trading-Datenbank gespeichert, sondern aktualisiert nur den Inhalt der aktuellen Live-Trading-Statusleiste.
DieLogStatus()Funktion unterstützt das Druckenbase64kodierte Bilder, beginnend mit`und endet mit`Zum Beispiel:LogStatus("`data:image/png;base64,AAAA`")- Ich weiß.
DieLogStatus()Funktion unterstützt das Durchlaufenmatplotlib.pyplotGegenstände direkt inPython, solange das Objekt diesavefigDie Daten werden als Parameter an dieLogStatus()Funktion, zum Beispiel:
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
LogStatus(plt)
Wenn die Strategie läuft Live-Handel, wenn Sie durch die Geschichte auf der Live-Handelseite gehen, wird die Statusleiste schlafen und nicht mehr aktualisiert werden. Nur die Statusleiste Daten aktualisiert werden, wenn das Protokoll auf der ersten Seite ist.base64Es unterstützt auch die Ausgabe vonbase64Da die Stringdaten des codierten Bildes in der Regel sehr lang sind, wird der Beispielcode nicht angezeigt.
Ich bin nicht hier.
Aktivieren oder deaktivieren Sie die Protokollierung von Auftragsinformationen.
AktivierenLog (Aktivieren)
Wenn dieenableDer Parameter ist auf einen falschen Wert gesetzt, z. B.false, das Auftragsprotokoll (d. h. das Protokoll, das durch Funktionen wieexchange.Buy()) wird nicht gedruckt und nicht in die Datenbank des Live-Handels eingetragen.
Aktivieren
- Das stimmt.
Boole
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}
Anpassen der Diagrammzeichnungsfunktion.
Chartobjekt. Gegenstand
Tabelle (Optionen)
DieoptionsDie Parameter sind die Diagrammkonfiguration.Chart()Funktionsparameteroptionsist einJSONSerialisierbarHighStocksParameter fürHighcharts.StockChartEin zusätzliches__isStockAttribut über den nativen Parameter hinzugefügt wird, und wenn__isStock:falseWenn die Angabe des Wertes der Werte angegeben wird, wird sie als normales Diagramm angezeigt.__isStockAttribut ist auf einen falschen Wert gesetzt, z. B.false, d. h. das verwendete Diagramm ist einHighchartsDie__isStockAttribut wird auf einen wahren Wert gesetzt, z. B.true, d. h. das verwendete Diagramm ist einHighstocksDiagramm (standardmäßig)__isStockist wahr, z.B.true) Sie können dieHighStocks-Charts-Bibliothek- Ich weiß.
Optionen
wahr
Objekt, Objekt-Array
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});
}
}
Konfiguration für mehrere Diagramme:
extension.layoutAttribut
Wenn das Attribut mit dem Wert extension.heightAttribut
Das Attribut wird verwendet, um die Höhe des Diagramms, entweder als numerischen Wert oder als extension.colAttribut
Das Attribut wird verwendet, um die Breite des Diagramms festzulegen, die Seitenbreite wird in 12 Zellen unterteilt, Satz 8, das heißt, das Diagramm nimmt 8 Zellen Breite.// 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);
}
}
Beispiel für eine einfache Zeichnung:
// 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);
}
}
Beispiel für die Zeichnung einer trigonometrischen Kurve
/*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;
}
}
Komplexe Beispiele für die Verwendung hybrider Diagramme:
// 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);
TypenkartenpieSie müssen die Diagrammkonfiguration direkt beim Aktualisieren der Daten aktualisieren.c.update(chartCfg)nach Aktualisierung der Daten wie folgt:
DieChart()Funktion gibt ein Diagrammobjekt zurück, das 4 Methoden hat:add(), reset(), update(), del().
update()Methode:
Dieupdate()Der Parameter dieser Methode ist das Chart Configuration Object (JSON).del()Methode:
Diedel()Methode kann die Datenreihe des angegebenen Indizes auf der Grundlage des übermittelten Serienparameters löschen.add()Methode:
Dieadd()Diese Methode kann Daten mit folgenden Parametern in der Reihenfolge auf das Diagramm schreiben:series: verwendet, um den Datenreihenindex zu setzen, der eine ganze Zahl ist.data: verwendet, um die spezifischen zu schreibenden Daten festzulegen, es ist ein Array.index(optional): verwendet, um den Datenindex einzustellen, es ist eine ganze Zahl.-1bezieht sich auf die letzten Daten des Datensatzes.
Zum Beispiel, wenn Sie eine Linie zeichnen, ändern Sie die Daten am letzten Punkt der Linie:chart.add(0, [1574993606000, 13.5], -1), d. h. die Daten am vorletzten ersten Punkt des Diagramms ändernseries[0].data- Ich weiß.
DieindexParameter nicht eingestellt ist, was bedeutet, dass die Daten zum letzten Punkt der aktuellen Datenreihe hinzugefügt werden.reset()Methode:
Diereset()Die Methode wird verwendet, um die Diagrammdaten zu entleeren.reset()Methode kann einen Parameter annehmenremainUm die Anzahl der Einträge anzugeben. Keine Parameterremainwird übergeben, um alle Daten zu löschen.Ich bin nicht derjenige, der das Problem hat.
Die Funktion wird für die benutzerdefinierte Zeichnung in der Strategielaufzeit mit einer Zeichnungsmethode verwendet, die derPine language.
Das Chartobjekt.KLineChart()Funktion gibt ein Chartobjekt mit mehreren Methoden zurück, unter denen Sie aufpassen müssenbegin()undclose(). Die Zeichnung muss mit einembegin()Funktionsaufruf und Ende mit aclose()Funktionsaufruf beim Durchqueren der KLine-Daten zur Durchführung des Zeichnungsvorgangs.
Gegenstand
KLineChart (Optionen)
DieoptionsParameter ist die Diagrammkonfiguration.
Optionen
wahr
Objekt, Objekt-Array
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
Wenn ein Diagrammsteuerobjekt benötigt wird, um in der Strategie benutzerdefinierten Zeichnungsbereich zu zeichnen, verwenden Sie dieKLineChart()Die Parameter für dieKLineChart()Funktion ist eine Diagrammkonfigurationsstruktur, die im Referenzcode verwendet wird, ist einfach:{overlay: true}. Diese Diagrammkonfigurationsstruktur legt nur den auf dem Hauptdiagramm auszuführenden Zeichnungsinhalt fest.overlayist auf einen falschen Wert gesetzt, z. B.falseWenn Sie eine Zeichnungsfunktion angeben müssen, um auf dem Hauptdiagramm zu zeichnen, können Sie auch den Parameter angebenoverlayals wahren Wert im spezifischen Funktionsanruf, z. B.: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
Die Funktionen der Zeichnungsoberfläche derPinebei der Zeichnung unterstützte Sprachen sind:barcolor, die die K-Linienfarbe festlegt.
Barcolor (Farbe, Offset, bearbeitbar, show_last, Titel, Anzeige) Anzeigeparameter sind optional:
keines , alle
c.bgcolor('rgba(0, 255, 0, 0.5)')
c.bgcolor('rgba(0, 255, 0, 0.5)')
// Not supported for now
bgcolor, füllt den Hintergrund der K-Linie mit der angegebenen Farbe.
bgcolor ((Farbe, Offset, bearbeitbar, show_last, Titel, Anzeige, Überlagerung) Anzeigeparameter sind optional:
keines , alle
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, eine Reihe von Daten auf einem Diagramm darstellen.
plot ((Serie, Titel, Farbe, Zeilenbreite, Stil, Trackprice, Histbase, Offset, Join, bearbeitbar, show_last, angezeigt) Die Stilparameter sind optional:
stepline_diamond , stepline , cross , areabr , area , circles , columns , histogram , linebr , line Anzeigeparameter sind optional:
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, den Hintergrund zwischen zwei Plätzen ausfüllen oderhlinemit den angegebenen Farben.
Ausfüllen (Line1, Linie2, Farbe, Titel, bearbeitbar, Ausfüllen, Anzeigen) Anzeigeparameter sind optional:
keines , alle
Seit demJavaScriptSprache kann keine eingehenden Parameter basierend auf den Namen der Funktion formalen Parameter angeben, um dieses Problem zu lösen, können Sie eine{key: value}Struktur zur Angabe der Parameter, die an einen bestimmten formalen Parameternamen übergeben werden sollen.
Der Referenzcode verwendet beispielsweise{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0, 0.2)'}Sie legt diecolorParameter derfillFunktion.
Wenn Sie mehrere Parameter mit aufeinanderfolgenden Formparameternamen angeben müssen, können Sie{key1: value1, key2: value2, key3: value3}- Ich weiß.
Zum Beispiel in diesem Beispiel, eine zusätzlichetitleDer Parameter ist angegeben:{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0, 0.2)', title: 'fill'}- Ich weiß.
Für den Farbwert können Sie es mit'rgba(255, 0, 0, 0, 0.2)'oder mit'#FF0000'.
c.hline(bar.High)
c.hline(bar.High)
// Not supported for now
hline, wird die horizontale Linie auf einem bestimmten Festpreisniveau dargestellt.
Linie ((Preis, Titel, Farbe, Zeilenart, Zeilenbreite, bearbeitbar, Anzeige) Linestyle-Parameter sind optional:
dashed , dotted , solid Anzeigeparameter sind optional: keines , alle
c.plotarrow(bar.Close - bar.Open)
c.plotarrow(bar.Close - bar.Open)
// Not supported for now
plotarrow, Zeichnen Sie auf der Karte Pfeile nach oben und unten.
Plotarrow ((Serie, Titel, Farbgebung, Farbgestaltung, Offset, Minheight, Maxheight, bearbeitbar, show_last, Anzeige) Anzeigeparameter sind optional:
keines , alle
c.plotshape(bar.Low, {style: 'diamond'})
c.plotshape(bar.Low, style = 'diamond')
// Not supported for now
plotshape, visuelle Formen auf dem Diagramm zeichnen.
Plotshape (Serie, Titel, Stil, Standort, Farbe, Offset, Text, Textfarbe, bearbeitbar, Größe, show_last, Anzeige) Die Stilparameter sind optional:
diamond size.autoEs ist klein. Anzeigeparameter sind optional:, square , label_down , label_up , arrow_down , arrow_up , circle , flag , triangle_down , triangle_up , cross , xcross Standortparameter sind optional: abovebar , belowbar , top , bottom , absolute Größenparameter sind optional: 10px , 14px , 20px , 40px , 80px , Vergleich von size.tiny, size.small, size.normal, size.large, size.huge in der Pine-Sprache. keines , alle
c.plotchar(bar.Close, {char: 'X'})
c.plotchar(bar.Close, char = 'X')
// Not supported for now
plotchar, Zeichnen Sie visuelle Formen auf dem Diagramm mit einem bestimmten Unicode-Zeichen.
plotchar ((Serie, Titel, Chart, Ort, Farbe, Offset, Text, Textfarbe, bearbeitbar, Größe, show_last, Anzeige) Die Standortparameter sind optional:
abovebar size.autoEs ist klein. Anzeigeparameter sind optional:, belowbar , top , bottom , absolute Die Größenparameter sind optional: 10px , 14px , 20px , 40px , 80px , vergleichend size.tiny, size.small, size.normal, size.large, size.huge in der Pine-Sprache. keines , alle
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, ein K-Liniendiagramm auf einem Diagramm zu zeichnen.
Plotcandle ((offene, hohe, niedrige, schließende, Titel, Farbe, wickcolor, bearbeitbar, show_last, bordercolor, display) Anzeigeparameter sind optional:
keines , alle
c.signal("long", bar.High, 1.5)
c.signal("long", bar.High, 1.5)
// Not supported for now
signal, eine Funktion, die in der Pine-Sprache nicht verfügbar ist, wird hier für Kauf- und Verkaufssignale verwendet.
Signal ((Richtung, Preis, Qty, ID) Der Parameter
long wird eingegeben, um die Richtung der Transaktion anzuzeigen, Sie können wählen long , closelong , short , closeshort . bar.Highist die Y-Achsenposition des Markersignals. Der übertragene Parameter 1.5 gibt die Anzahl der Transaktionen des Signals an. Der vierte Parameter kann übertragen werden, um den ausgezeichneten Standardtextinhalt zu ersetzen, und der Standardtext des ausgezeichneten Signalmarkers ist die Richtung der Transaktion, z. B.closelong .
c.reset()
c.reset()
// Not supported for now
reset, eine Funktion, die in der Pine-Sprache nicht verfügbar ist, wird verwendet, um die Diagrammdaten zu leeren.
Zurücksetzen (Remain) Die
reset()die Methode kann einen Parameter annehmen,remain, um die Anzahl der zu speichernden Daten anzugeben.remainbedeutet, alle Daten zu löschen.
Strategie benutzerdefinierte Zeichnung kann nur eine der Möglichkeiten derKLineChart()Funktion oderChart()Für einige Farbe und Stil Einstellungen verwendet in derKLineChart()Funktionsaufruf, sieheVerwenden Sie die KLineChart-Funktion, um die Strategie-Zeichnung einfacher zu gestalten.
Ich habe dich nicht gesehen.
Räumen Sie das Protokoll.
LogReset (bleiben)
DieremainDer Parameter wird verwendet, um die Anzahl der zu speichernden aktuellen Protokolleinträge festzulegen.
bleiben
falsche
Zahl
function main() {
// Keep the last 10 logs and clear the rest
LogReset(10)
}
def main():
LogReset(10)
void main() {
LogReset(10);
}
Das Startprotokoll für jeden Start der Strategie Live Trading zählt als eins, so dass, wenn keine Parameter in übergeben werden und es keine Log-Ausgabe zu Beginn der Strategie gibt, werden keine Logs überhaupt angezeigt, warten auf das Docker-Log zurückgegeben werden (keine Ausnahme).
Das ist ein sehr schwieriger Fall.
Verwendet zur Rückgewinnung des Lagerraums, der vonSQLitebei Löschung von Daten nach Aufruf derLogReset()Funktion, um das Protokoll zu löschen.
LogVacuum (siehe unten)
function main() {
LogReset()
LogVacuum()
}
def main():
LogReset()
LogVacuum()
void main() {
LogReset()
LogVacuum()
}
Der Grund dafür ist, dassSQLitewird nicht zurückgefordert, wenn Daten gelöscht werden, und es muss ausgeführt werdenVACUUMDie Dateibewegung erfolgt, wenn diese Funktion aufgerufen wird, und die Verzögerung ist groß, so dass es empfohlen wird, in einem geeigneten Zeitintervall zu rufen.
- Ich bin nicht hier. - Ich bin hier.
Es wird verwendet, um Debug-Informationen in der Spalte 123456, dieconsole.logFunktion Ausgänge Debugging-Informationen auf der Live-Handelsseite, und gleichzeitig erstellen Sie eine Protokolldatei mit der Erweiterung.logund schreiben Sie Debug-Informationen in die/logs/storage/123456/in dem Verzeichnis des Dockers, zu dem der Live-Handel gehört, mit dem Vorwort "Dateiname"stdout_.
- Das ist nicht wahr.
Der Parametermsgist der Inhalt der Ausgabe und der Parametermsgkann mehr als eine übergeben werden.
Msg
falsche
String, number, bool, object, array, null und andere vom System unterstützte Typen.
function main() {
console.log("test console.log")
}
# Not supported
// Not supported
JavaScriptSprache unterstützt diese Funktion.[object Object], also versuchen Sie, so viele lesbare Informationen wie möglich auszugeben.Ich habe einen Fehler gemacht.
Verwendet für die Fehlerdaten im Feld 123456, dieconsole.errorFunktion erstellt eine Protokolldatei mit der Erweiterung.login der/logs/storage/123456/Verzeichnis des Docker, wo der Live-Handel gehört, und schreibt die Fehlerleistung mit dem Präfixstderr_.
Ich habe einen Fehler bei der Konsole.
Der Parametermsgist der Inhalt der Ausgabe und der Parametermsgkann mehr als eine übergeben werden.
Msg
falsche
String, number, bool, object, array, null und andere vom System unterstützte Typen.
function main() {
console.error("test console.error")
}
# Not supported
// Not supported
JavaScriptSprache unterstützt diese Funktion.[object Object], also versuchen Sie, so viele lesbare Informationen wie möglich auszugeben.- Ich bin nicht hier. - Ich bin hier.
Erhalten Sie die {@struct/Ticker Ticker} -Struktur des Spot- oder Vertrags, die dem derzeit eingestellten Handelspar, dem Vertragscode, d. h. den Ticker-Daten entspricht.GetTicker ()Funktion ist eine Mitgliederfunktion des Austauschobjekts {@var/EXCHANGE exchange}, die Verwendung vonexchangeObjektmitgliederfunktionen (Methoden), die nur mitexchange, und es wird nicht im Dokument wiederholt werden.
Dieexchange.GetTicker()Funktion gibt die Struktur {@struct/Ticker Ticker} zurück, wenn die Datenanfrage erfolgreich ist, und gibt null zurück, wenn die Datenanfrage fehlschlägt.
{@struct/Ticker Ticker}, Nullwert
- Ich bin nicht derjenige, der das sagt. - Das ist ein Symbol.
Der Parametersymbolwird verwendet, um das spezifische Handelspaar und den Vertragscode anzugeben, die den angeforderten {@struct/Ticker Ticker}-Daten entsprechen. Wird dieser Parameter nicht übergeben, werden standardmäßig die Marktdaten des aktuell eingestellten Handelspaares und des Vertragscodes angefordert.
Bei Anrufen derexchange.GetTicker(symbol)Funktion,exchangeWenn Sie Marktdaten mit der Währung als USDT und der Handelswährung als BTC anfordern müssen, wird der Parametersymbolist:"BTC_USDT", und das Format ist das von der FMZ-Plattform definierte Handelspaarformat.
Bei Anrufen derexchange.GetTicker(symbol)Funktion,exchangeWenn Sie die Marktdaten von BTCsymbolist:"BTC_USDT.swap", und das Format ist eine Kombination derHandelspaarundVertragskodedurch die FMZ-Plattform definiert, getrennt durch das Zeichen exchange.GetTicker(symbol)Funktion,exchangeWenn Sie die Marktdaten von BTCsymbolist:"BTC_USDT.BTC-240108-40000-C"(beispielsweise Binance Option BTC-240108-40000-C), ist das Format die Kombination derHandelspaarvon der FMZ-Plattform und dem von der Börse definierten spezifischen Optionsvertragskode definiert, getrennt durch den Zeichen
Symbol falsche String
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);
}
Für Futures-Börsenobjekte (d. h.exchangeoderexchanges[0]), müssen Sie den Vertragscode mit demexchange.SetContractType()Funktion vor dem Aufruf der Tickelfunktion, die nicht wiederholt wird.
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);
}
VerwendensymbolParameter zur Anforderung von Marktdaten für ein bestimmtes Symbol (Spot-Symbol).
DieTickerDaten, die von derexchange.GetTicker()Die Ergebnisse des Backtesting-SystemsHighundLowIm übrigen sind die Wertvorstellungen von der Verkaufs- und der Kaufwährung des Marktes zu diesem Zeitpunkt simuliert.TickerDaten, die von derexchange.GetTicker()In der Praxis sind dieHighundLowWerte basieren auf den von dem eingekapselten Austausch zurückgegebenen DatenTickInterface, die die höchsten und niedrigsten Preise innerhalb eines bestimmten Zeitraums (in der Regel einen Zeitraum von 24 Stunden) enthält.
Die Ausgabe vonexchange.GetTicker()Funktion:
| Funktionsname | Nicht unterstützte Spotbörsen | Nicht abgesicherte Futures-Börsen |
|---|---|---|
| GetTicker | – | Futures_Aevo |
Der Markt wird von der Kommission und den Mitgliedstaaten geprüft, ob sie in der Lage sind, die erforderlichen Maßnahmen zu treffen.
Erhalten Sie die {@struct/Depth Depth}-Struktur des Spot- oder Vertrags, der dem derzeit eingestellten Handelspar, dem Vertragskode, d. h. den Auftragsbuchdaten entspricht.
Dieexchange.GetDepth()Funktion gibt die Struktur {@struct/Depth Depth} zurück, wenn die Anfrage erfolgreich ist, und null, wenn die Anfrage fehlschlägt.
{@struct/Depth Depth}, Nullwert
Erhalten Sie die Tiefe. Wechseln.Symbol GetDepth
Der Parametersymbolwird verwendet, um das spezifische Handelspaar und den entsprechenden Vertragscode für die angeforderten {@struct/Depth Depth} Daten anzugeben. Wird dieser Parameter nicht übergeben, werden standardmäßig die Auftragsbuchdaten des aktuell eingestellten Handelspaares und der Vertragscode angefordert.exchange.GetDepth(symbol)Funktion,exchangeist das Spot-Austauschobjekt. Wenn Sie die Auftragsbuchdaten mit der Währung USDT und der Transaktionswährung BTC anfordern müssen, wird der Parametersymbolist:"BTC_USDT", und das Format ist das von der FMZ-Plattform definierte Handelspaarformat.exchange.GetDepth(symbol)Funktion,exchangeist das Futures-Austauschobjekt. Wenn Sie die Auftragsbuchdaten von BTCsymbolist:"BTC_USDT.swap", und das Format ist eine Kombination derHandelspaarundVertragskodedie durch die FMZ-Plattform definiert sind, getrennt durch den Zeichen exchange.GetDepth(symbol)Funktion,exchangeist das Futures Exchange Objekt. Wenn Sie die Auftragsbuchdaten des BTCsymbolist:"BTC_USDT.BTC-240108-40000-C"(beispielsweise Binance Option BTC-240108-40000-C), ist das Format die Kombination derHandelspaarvon der FMZ-Plattform und dem von der Börse definierten spezifischen Optionsvertragskode definiert, getrennt durch den Zeichen
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);
}
Prüfungexchange.GetDepth()Funktion:
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);
}
Wenn die konfigurierteexchangeObjekt ist ein Futures-Börse Objekt, verwenden Sie diesymbolParameter zur Anforderung der Auftragsbuchdaten eines bestimmten Symbols (Futures-Symbol).
Im Backtesting-System werden die Daten für jede Klasse von derexchange.GetDepth()Funktion bei der Verwendung derSimulieren von TicksDie Daten, die von der Datenbank zurückgegeben werden, werden in einem System für Backtesting mit einemexchange.GetDepth()Funktion bei der Verwendung derEchte ZeckeBacktesting ist eine zweite Ebene tiefe Momentaufnahme.
Der Markt wird von der Kommission überwacht, um die Ergebnisse der Prüfung zu ermitteln.
Erhalten Sie das Strukturmatrix {@struct/Trade Trade} des Spot- oder Vertrags, das dem aktuell eingestellten Handelspar, dem Vertragskode, d. h. den Markttransaktionsdaten entspricht.
Dieexchange.GetTrades()Funktion gibt ein Array von {@struct/Trade Trade}-Strukturen zurück, wenn die Anfrage erfolgreich ist, und nullwerte, wenn die Anfrage fehlschlägt.
{@struct/Trade Trade} Arrays, Nullwerte
- Ich bin nicht derjenige, der das Problem hat. - (Symbol für GetTrades)
Der Parametersymbolwird verwendet, um das spezifische Handelspaar und den entsprechenden Vertragscode für die angeforderten Arraydaten von {@struct/Trade Trade} anzugeben. Wenn dieser Parameter nicht übergeben wird, werden standardmäßig die neuesten Transaktionsdatensätze des aktuell eingestellten Handelspaares und der Vertragscode angefordert.exchange.GetTrades(symbol)Funktion,exchangeWenn Sie die Daten des Auftragsbuchs mit der Währung USDT und der Handelswährung BTC anfordern müssen, ist der Parametersymbolist:"BTC_USDT", und das Format ist das von der FMZ-Plattform definierte Handelspaarformat.exchange.GetTrades(symbol)Funktion,exchangeist das Futures-Austauschobjekt. Wenn Sie die Auftragsbuchdaten von BTCsymbolist:"BTC_USDT.swap", und das Format ist eine Kombination derHandelspaarundVertragskodedie durch die FMZ-Plattform definiert sind, getrennt durch den Zeichen exchange.GetTrades(symbol)Funktion,exchangeist das Futures-Austauschobjekt. Wenn Sie die Auftragsbuchdaten von BTCsymbolist:"BTC_USDT.BTC-240108-40000-C"(beispielsweise Binance Option BTC-240108-40000-C), ist das Format die Kombination derHandelspaarvon der FMZ-Plattform und dem von der Börse definierten spezifischen Optionsvertragskode definiert, getrennt durch den Zeichen
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);
}
Test derexchange.GetTrades()Funktion:
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);
}
Wenn die konfigurierteexchangeObjekt ist ein Futures-Börse Objekt, verwenden Sie diesymbolParameter zur Anforderung von Marktgeschäftsdatensätzen für ein bestimmtes Symbol (Futures-Symbol).
exchange.GetTrades()Einige Börsen unterstützen diese Funktion nicht, und die spezifischen Daten, die zurückgegeben werden, sind, wie viel der Bandbreite der Transaktionsdatensätze von der Börse abhängt und entsprechend der spezifischen Situation behandelt werden muss.exchange.GetRecords ()Die Funktion gibt die gleiche Reihenfolge an Daten zurück, d. h. das letzte Element des Arrays ist die Daten, die der aktuellen Zeit am nächsten liegen.
Dieexchange.GetTrades()Funktion gibt ein leeres Array zurückSimulieren von TicksDie Daten, die von derexchange.GetTrades()Funktion bei der VerwendungEchte ZeckeBacktesting im Backtesting-System sind die Order-Flow-Snapshot-Daten, d. h. das {@struct/Trade Trade} Strukturarray.
Die Ausgabe vonexchange.GetTrades()Funktion:
| Funktionsname | Nicht unterstützte Spotbörsen | Nicht abgesicherte Futures-Börsen |
|---|---|---|
| GetTrades | – | Futures_BitMart / Futures_Bibox |
Das bedeutet, dass wir uns in der Lage fühlen müssen, die Daten zu verarbeiten, die wir brauchen.
Erhalten Sie das {@struct/Record Record} Strukturarray des Spot- oder Vertrags, das dem aktuell eingestellten Handelspar, dem Vertragskode, d. h. den K-Liniendaten entspricht.
Dieexchange.GetRecords()Funktion gibt ein Array von {@struct/Record Record}-Strukturen zurück, wenn die Datenanfrage erfolgreich ist, und nullwerte, wenn die Datenanfrage fehlschlägt.
{@struct/Record Record} Arrays, Nullwerte
- Ich bin nicht derjenige, der das Problem hat. - Das ist ein Symbol. Sie werden von der E-Mail-Adresse des E-Mail-Nachrichtendienstes erhalten. exchange.GetRecords (Symbol, Punkt, Grenze) - Ich bin nicht hier. (Veröffentlichung der Veröffentlichung)
Der Parametersymbolwird verwendet, um das spezifische Handelspaar und den entsprechenden Vertragscode für die angeforderten Arraydaten von {@struct/Record Record} anzugeben. Wenn dieser Parameter nicht übergeben wird, werden standardmäßig die K-Zeilendaten des aktuell eingestellten Handelspaares und des Vertragscodes angefordert.exchange.GetRecords(symbol)Funktion,exchangeWenn Sie die Daten mit der in USDT lautenden Währung und der Transaktionswährung als BTC anfordern müssen, wird der Parametersymbolist:"BTC_USDT", und das Format ist das von der FMZ-Plattform definierte Handelspaarformat.exchange.GetRecords(symbol)Funktion,exchangeist das Futures-Austauschobjekt. Wenn Sie die Auftragsbuchdaten von BTCsymbolist:"BTC_USDT.swap", und das Format ist eine Kombination derHandelspaarundVertragskodedie durch die FMZ-Plattform definiert sind, getrennt durch den Zeichen exchange.GetRecords(symbol)Funktion,exchangeist das Futures-Austauschobjekt. Wenn Sie die Auftragsbuchdaten von BTCsymbolist:"BTC_USDT.BTC-240108-40000-C"(beispielsweise Binance Option BTC-240108-40000-C), ist das Format die Kombination derHandelspaarvon der FMZ-Plattform und dem von der Börse definierten spezifischen Optionsvertragskode definiert, getrennt durch den Zeichen periodDer Wert des Parameters ist der Wert der in der Tabelle 1 angegebenen Periode.periodkann nicht nur die definierte Standardperiode, sondern auch ganze Werte in Sekunden überschritten werden. Wird dieser Parameter nicht überschritten, ist die Standardperiode der standardmäßig angeforderten K-Liniendaten die Standardperiode der aktuellen Strategie Echtzeit-/Backtest-Konfiguration.
Periode
falsche
Zahl
Der Parameterlimitwird verwendet, um die Länge der angeforderten K-Line-Daten anzugeben. Wenn dieser Parameter nicht übergeben wird, ist die Standardanforderung Länge die maximale Anzahl von K-Line-Bars, die zu einem Zeitpunkt der Austausch-K-Line-Schnittstelle angefordert werden. Dieser Parameter kann dazu führen, dass die Paging-Abfrage die Austausch-K-Line-Daten abfragt, und der Zeitverbrauch des Funktionsanrufs wird während der Paging-Abfrage zunehmen.
Grenzwerte
falsche
Zahl
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]);
}
Holen Sie K-Liniendaten für eine individuelle Periode.
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]);
}
Ausgangsdaten der K-Linienbalken:
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);
}
Wenn die konfigurierteexchangeObjekt ist ein Futures-Börse Objekt, verwenden Sie diesymbol, period, undlimitParameter zur Anforderung der K-Linie-Daten eines bestimmten Produkts (zukünftiges Produkt).
Die Standard-K-Line-Periode kann in den Backtest- und Real-Trading-Seiten festgelegt werden.exchange.GetRecords()Wenn beim Aufruf der Funktion kein Parameter angegeben wird, werden die entsprechenden K-Liniendaten gemäß der im Backtest und in den realen Marktparametern festgelegten K-Linienperiode zurückgegeben.
Der zurückgegebene Wert ist ein Array vonRecordDie Daten werden im Laufe der Zeit akkumuliert, die Obergrenze der akkumulierten K-Linienbalken wird durch dieexchange.SetMaxBarLen()Die Standardgrenze beträgt 5000 Bars, wenn sie nicht eingestellt ist. Wenn die K-Liniendaten die K-Linienbar-Akkumulationsgrenze erreichen, wird sie aktualisiert, indem eine K-Linienbar hinzugefügt und die früheste K-Linienbar gelöscht wird (z. B. Warteschlange in/aus). Einige Börsen bieten keine K-Linienschnittstelle, so dass der Docker Markttransaktionsdatensätze sammelt (TradeStruktur-Array) in Echtzeit generiert werden.
Wenn die K-Line-Schnittstelle des Austauschs Paging-Abfragen unterstützt, werden mehrere API-Anfragen gestellt, wenn dieexchange.SetMaxBarLen()Funktion zur Einstellung einer größeren K-Linienlänge.
Wenn dieexchange.GetRecords()Die Anzahl der erhaltenen K-Line-Bars unterscheidet sich zwischen dem Backtesting und dem realen Handel: - Das Backtesting-System erhält eine bestimmte Anzahl von K-Line-Bars vor Beginn des Backtesting-Zeitraums im Voraus (Standard ist 5000, die Einstellungen des Backtesting-Systems und die Datenmenge beeinflussen die endgültige Anzahl der zurückgegebenen Daten). - Die Anzahl der während des tatsächlichen Handels erhaltenen K-Line-Bars basiert auf der maximalen Datenmenge, die aus der K-Line-Schnittstelle der Börse gewonnen werden kann.
DieperiodDer Parameter ist auf 5 gesetzt, was eine Anforderung ist, K-Liniendaten mit einer Periode von 5 Sekunden zu erhalten.periodDas zugrunde liegende System verwendet die entsprechende Schnittstelle vonexchange.GetTrades()Um die Daten der Transaktionsprotokolle zu erhalten und die erforderlichen K-Liniendaten zu synthetisieren.periodWenn der Parameter durch 60 teilbar ist, werden die erforderlichen K-Liniendaten mit mindestens 1-minütigen K-Liniendaten synthetisiert (wenn möglich, werden die erforderlichen K-Liniendaten mit einer größeren Periode synthetisiert).
Das simulierte Level-Backtesting im Backtesting-System erfordert die Einstellung der zugrunde liegenden K-Linienperiode (wenn das Backtesting-System das Level-Backtesting simuliert, werden die entsprechenden K-Liniendaten verwendet, um Tick-Daten gemäß der gesetzten zugrunde liegenden K-Linienperiode zu generieren). Es sollte beachtet werden, dass die Periode der in der Strategie erhaltenen K-Liniendaten nicht kleiner sein sollte als die zugrunde liegende K-Linienperiode.
DieC++Die Sprache hat das folgende Codebeispiel, wenn Sie Ihre eigenen K-Liniendaten erstellen müssen:
#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);
}
Dieexchange.GetRecords()Funktion:
| Funktionsname | Nicht unterstützte Spotbörsen | Nicht abgesicherte Futures-Börsen |
|---|---|---|
| GetRecords | Zaif / Coincheck / BitFlyer | Futures_Aevo |
Die Kommission hat die Kommission aufgefordert, die von ihr vorgenommenen Maßnahmen zu prüfen.
Erhalten Sie die K-Linienperiode auf der Website der FMZ Quant Trading Plattform, wenn Sie die Strategie im Live-Handel backtesten und ausführen, d. h. die Standard-K-Linienperiode, die beim Anrufen derexchange.GetRecords()Funktion ohne Übergabe von Parametern.
K-Linienperiode in Sekunden, ganzzahliger Wert in Sekunden. Zahl
Auswechselung.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");
}
Ich bin nicht derjenige, der dich anspricht.
Setzen Sie die maximale Länge der K-Linie.
Auswechselung.SetMaxBarLen (n)
Der Parameternwird verwendet, um die maximale K-Länge anzugeben.
n
wahr
Zahl
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]);
}
Dieexchange.SetMaxBarLen()Funktion wirkt sich auf zwei Aspekte für die Laufzeit der Kryptowährungsstrategie aus:
Ich bin nicht derjenige, der dich anspricht.
Erhalten Sie den ursprünglichen Inhalt bis zum letztenrestAnforderung für das aktuelle Austauschobjekt ({@var/EXCHANGE exchange}, {@var/EXCHANGE/exchanges exchanges}).
Die Daten für dierestAnforderung.
String
- Das ist nicht wahr.
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);
}
Dieexchange.GetRawJSON()Diese Funktion wird nur für den realen Handel unterstützt.C++ language.
{@var/EXCHANGE-Austausch}
Erhalten Sie den aktuell für das Tauschobjekt festgelegten Wechselkurs.
Der aktuelle Wert des Wechselkurses des Austauschobjekts. Zahl
Auswechselung.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());
}
Wennexchange.SetRate()Der Umrechnungskurs wird nicht festgelegt.exchange.GetRate()Die Funktion gibt einen Standardwert von 1 zurück, d. h. die Daten zur aktuell angezeigten Währung (quoteCurrency) wurden nicht konvertiert.
Wenn ein Wechselkurswert unter Verwendungexchange.SetRate(), zum Beispiel,exchange.SetRate(7). Dann werden alle Preisinformationen, wie Angebot, Tiefe und Auftragspreise, die über dieexchangeder Wechselkurs wird durch Multiplikation mit dem festgelegten Wechselkurs umgerechnet7- Ich weiß.
Wennexchangeentspricht einem Umtausch mit USD als Stückelwährung, nachdemexchange.SetRate(7), werden alle Preise auf dem Live-Markt in einen Preis nahe dem CNY umgerechnet, indem7An dieser Stelle wird der Wechselkurswert, der unter Verwendung derexchange.GetRate()ist7.
{@fun/Trade/exchange.SetRate exchange.SetRate}
Dieexchange.SetData()Die Funktion wird verwendet, um die geladenen Daten zu setzen, wenn die Strategie ausgeführt wird.
Die Länge der Zeichenfolge nach dem ParametervalueJSON-Codierung.
Zahl
exchange.SetData (Schlüssel, Wert)
Name der Datenerhebung.
Schlüssel
wahr
String
Die Daten, die von derexchange.SetData()Die Datenstruktur ist die gleiche wie das von derexchange.GetData()Funktion bei der Anforderung externer Daten, d. h.:"schema": ["time", "data"]- Ich weiß.
Wert
wahr
Reihenfolge
/*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);
}
}
Es ist erforderlich, dass die Daten für den Parametervaluein demselben Format wie diedataSie können sehen, dass der Zeitstempel1579622400000entspricht der Zeit2020-01-22 00:00:00, und dass, wenn das Strategieprogramm nach dieser Zeit ausgeführt wird, dieexchange.GetData()Funktion, um die Daten vor dem nächsten Zeitstempel zu erhalten1579708800000, d. h. Zeit2020-01-23 00:00:00Was du bekommst, ist[1579622400000, 123]In dem folgenden Beispiel erreicht oder überschreitet der aktuelle Moment in der Laufzeit (Backtesting oder Live Trading) den Zeitstempel1579795200000, dieexchange.GetData()Funktion aufgerufen wird und der zurückgegebene Wert lautet:{"Time":1579795200000,"Data":["abc", 123,{"price":123}]}. "Time":1579795200000entspricht1579795200000in Daten[1579795200000, ["abc", 123, {"price": 123}]]. "Data":["abc", 123, {"price": 123}]entspricht den Daten["abc", 123, {"price": 123}]]in[1579795200000, ["abc", 123, {"price": 123}]].
Die geladenen Daten können alle wirtschaftlichen Indikatoren, Branchendaten, relevanten Indikatoren usw. sein, die für die strategische quantitative Bewertung aller quantifizierbaren Informationen verwendet werden.
Ich bin nicht derjenige, der das Problem hat, aber ich bin derjenige, der es hat.
Dieexchange.GetData()Die Funktion wird verwendet, um die von derexchange.SetData()Funktion oder durch eine externe Verbindung bereitgestellt.
Aufzeichnungen in der Datensammlung. Gegenstand
- Das ist nicht wahr. Erhalten Sie die Daten (Schlüssel, Timeout)
Name der Datenerhebung. Schlüssel - Das stimmt. String Der Cache-Timeout wird in Millisekunden eingestellt, bei Live-Tradings ist der Cache-Timeout eine Minute. Zeitverzögerung falsche Zahl
/*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);
}
}
Der Anruf, um die Daten direkt zu schreiben.
/*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);
}
}
Es unterstützt die Anforderung von Daten über externe Links, das Format der angeforderten Daten:
{
"schema":["time","data"],
"data":[
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
}
Wo ist er?schemaist das Datenformat für jeden Datensatz im Inhalt der geladenen Daten, das auf["time", "data"]die dem Format der Eintrag-für-Eintrag-Daten in derdataEigenschaft.
Was ist in derdataAttribut ist der Datenkörper, wobei jeder Eintrag aus einem Zeitstempel auf Millisekundenebene und dem Dateninhalt (der beliebige JSON-kodierbare Daten sein kann) besteht.
Das Serviceprogramm für Tests, geschrieben in 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)
}
Die Antwortdaten des Programms bei Erhalt der Anfrage:
{
"schema":["time","data"],
"data":[
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
}
Teststrategiecode:
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"));
}
Die Anrufmethode, um die Daten einer externen Verbindung zu erhalten.
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"));
}
Anforderung von Daten für eine auf der Plattform erstellte AbfrageDatendaten, in dem das Datenformat der Antwort (Zeit, in dem Schema beschriebene Datenfelder enthalten müssen) angegeben wird:
{
"data": [],
"schema": ["time", "data"]
}
Das Feld exchange.GetData()Funktion aufgerufen wird, wird ein JSON-Objekt zurückgegeben, z. B.:{"Time":1579795200000, "Data":"..."}.
In einem Backtesting-System, wenn Daten über die Zugangsschnittstelle angefordert werden, fügt das Backtesting-System automatischfrom(Zeitstempel in Sekunden),to(Zeitstempel in Sekunden) auf die Anfrage, Parameter wieperiod(unterliegende K-Zeile, in Millisekunden zeitgestempelt) werden verwendet, um den Zeitrahmen zu bestimmen, über den die Daten erhoben werden sollen.
{@fun/Market/exchange.SetData-Austausch.SetData}
Dieexchange.GetMarkets()Funktion wird verwendet, um Informationen über den Devisenmarkt zu erhalten.
Wörterbuch, das die Struktur {@struct/Market Market} enthält. Gegenstand
- Ich bin nicht derjenige, der das Problem hat.
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]);
}
Beispiel für einen Aufruf an ein Futures-Börseobjekt:
/*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() + "`");
}
Verwenden Sie das Futures Exchange Objekt, um dieexchange.GetMarkets()Funktion im Backtesting-System. Bevor eine Marktfunktion aufgerufen wird, gibt GetMarkets nur die Marktdaten des aktuellen Standard-Handelspaares zurück. Nach dem Aufruf der Marktfunktion gibt es die Marktdaten aller angeforderten Sorten zurück. Sie können sich auf das folgende Testbeispiel beziehen:
Dieexchange.GetMarkets()Funktion gibt ein Wörterbuch mit einem Schlüssel zurück, der den Namen der Handelssorte benennt, und für als Handelspaar formatierte Spot-Fixes:
{
"BTC_USDT" : {...}, // The key value is the Market structure
"LTC_USDT" : {...},
...
}
Für Futures-Kontrakte, da es mehrere Verträge für eine einzelne Sorte geben kann, z. B.BTC_USDTEs gibt also auch eine Vielzahl von Handelspaaren.exchange.GetMarkets()Funktion gibt ein Wörterbuch mit dem Schlüsselnamen des Paares in Kombination mit dem Vertragskode zurück, z. B.:
{
"BTC_USDT.swap" : {...}, // The key value is the Market structure
"BTC_USDT.quarter" : {...},
"LTC_USDT.swap" : {...},
...
}
exchange.GetMarkets()Funktion unterstützt Live-Handel, Backtesting-System.exchange.GetMarkets()Funktion gibt nur Marktinformationen für die Sorten zurück, die an der Börse online gehandelt werden.exchange.GetMarkets()Funktion unterstützt keine Optionskontrakte.Dieexchange.GetMarkets()Funktion:
| Funktionsname | Nicht unterstützte Spotbörsen | Nicht abgesicherte Futures-Börsen |
|---|---|---|
| GetMarkets | Coincheck / Bithumb / BitFlyer | – |
{@struct/Marktmarkt}
Dieexchange.GetTickers()Die Funktion wird verwendet, um aggregierte Tickerdaten auszutauschen (das Array der Struktur {@struct/Ticker Ticker}).exchangegibt Tickerdaten für alle Handelspare zurück, wenn es sich um ein Spot-Börseobjekt handelt;exchangegibt Tickerdaten für alle Verträge zurück, wenn es sich um ein Futures-Austauschobjekt handelt.
Dieexchange.GetTickers()Funktion gibt ein Array von {@struct/Ticker Ticker} Strukturen zurück, wenn sie erfolgreich Daten anfordert, und null, wenn sie fehlschlägt.
{@struct/Ticker Ticker} Arrays, Nullwerte
- Ich bin nicht derjenige, der das sagt.
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());
}
}
Rufen Sie dieexchange.GetTickers()Funktion zur Erfassung aggregierter Marktdaten.
/*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() + "`");
}
Verwenden Sie das Spot-Austauschobjekt und rufen Sie dieexchange.GetTickers()Vor dem Aufruf einer Marktfunktion gibt GetTickers nur die Tickerdaten des aktuellen Standardhandelspaares zurück. Nach dem Aufruf der Marktfunktion gibt es die Tickerdaten aller angeforderten Varianten zurück. Sie können sich auf das folgende Testbeispiel beziehen:
Dieexchange.GetTickers()Funktion:
| Funktionsname | Nicht unterstützte Spotbörsen | Nicht abgesicherte Futures-Börsen |
|---|---|---|
| GetTickers | Zaif / WOO / Gemini / Coincheck / BitFlyer / Bibox | Futures_WOO / Futures_dYdX / Futures_Deribit / Futures_Bibox / Futures_Aevo |
Ich habe eine Frage an Sie.
Dieexchange.Buy()Diese Funktion wird verwendet, um Bestellungen zu platzieren.Buy()Die Funktion ist eine Mitgliederfunktion des Austauschobjekts {@var/EXCHANGE exchange}.Buy()Funktion arbeitet auf dem mit dem Tauschobjekt verbundenen Tauschkontoexchange. Zweck der Funktionen der Mitglieder (Methoden) derexchangeObjekt ist nur mitexchange, und wird nach der Dokumentation nicht wiederholt.
Eine erfolgreiche Bestellung gibt die Order-Id zurück, eine fehlgeschlagene Bestellung gibt einen Nullwert zurück.
Das AttributIdDie Struktur der Bestellstruktur {@struct/Order Order} der FMZ-Plattform besteht aus dem Austauschproduktcode und der Austausch-Originalorder-ID, die durch englische Kommas getrennt sind.IdFormat des SpothandelspaaresETH_USDTdie Reihenfolge der OKX-Börse lautet:ETH-USDT,1547130415509278720- Ich weiß.
Bei Anrufen derexchange.Buy()Funktion, um eine Bestellung zu platzieren, die Wertbestellung zurückzugebenIdist mit demIdAttribut der Struktur der Reihenfolge {@struct/Order Order}.
String, Nullwert
Umtausch.Kauf ((Preis, Betrag) Austausch.Kauf ((Preis, Betrag,... args)
DiepriceDer Parameter wird verwendet, um den Auftragspreis festzulegen.
Preis
wahr
Zahl
DieamountDer Parameter wird verwendet, um den Auftragsbetrag festzulegen.
Betrag
- Das stimmt.
Zahl
Erweiterte Parameter, die die Begleitinformationen in dieses Auftragsprotokoll einfügen können,argParameter können mehr als eine übergeben werden.
Arg
falsche
String, number, bool, object, array, null und jeder andere vom System unterstützte Typ
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);
}
Die vonexchange.Buy()kann verwendet werden, um die Bestellinformationen abzufragen und die Bestellung zu stornieren.
// 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);
}
Bei der Bestellung eines Futures-Kontrakts für Kryptowährungen muss darauf geachtet werden, dass die Handelsrichtung korrekt eingestellt ist, da ein Missverhältnis zwischen der Handelsrichtung und der Handelsfunktion zu einem Fehler führt:
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);
}
Spotmarktbestellung.
Wenn Sie einen Auftrag für einen Futures-Kontrakt aufgeben, müssen Sie darauf achten, ob die Handelsrichtung korrekt eingestellt ist, da ein Fehler gemeldet wird, wenn die Handelsrichtung und die Handelsfunktion nicht übereinstimmen.
Der Parameterpriceist auf-1Bei der Platzierung von Marktordern für Kryptowährungs-Spotkontrakte wird der Parameteramountist der Geldbetrag in der Währung des Auftrags.amountist die Anzahl der Verträge. Es gibt ein paar Kryptowährungsbörsen, die während des Live-Handels keine Marktorder-Schnittstelle unterstützen. Die Bestellmenge für Marktkaufbestellungen an einigen Spotbörsen ist die Anzahl der Handelsmünzen. Bitte beachten Sie dieSondervorschriften für den AustauschSiehe Idderexchange.Buy()Funktion kann sich von dem Rückgabewert des Auftrags unterscheidenIdin diesem Dokument beschrieben.
{@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
Dieexchange.Sell()Funktion wird verwendet, um Verkaufsbestellungen zu platzieren.
Ein erfolgreicher Auftrag gibt die Order-Id zurück, ein fehlgeschlagener Auftrag gibt einen Nullwert zurück.IdDie Struktur der Bestellstruktur {@struct/Order Order} der FMZ-Plattform besteht aus dem Austauschproduktcode und der Austausch-Originalorder-ID, die durch englische Kommas getrennt sind.IdFormat des SpothandelspaaresETH_USDTdie Reihenfolge der OKX-Börse lautet:ETH-USDT,1547130415509278720. Wenn Sie dieexchange.Sell()Funktion, um eine Bestellung zu platzieren, die Wertbestellung zurückzugebenIdist mit demIdAttribut der Struktur der Reihenfolge {@struct/Order Order}.
String, Nullwert
Umtausch.Verkauf ((Preis, Betrag) Umtausch.Verkauf ((Preis, Betrag,... args)
DiepriceDer Parameter wird verwendet, um den Auftragspreis festzulegen.
Preis
wahr
Zahl
DieamountDer Parameter wird verwendet, um den Auftragsbetrag festzulegen.
Betrag
- Das stimmt.
Zahl
Erweiterte Parameter, die die Begleitinformationen in dieses Auftragsprotokoll einfügen können,argParameter können mehr als eine übergeben werden.
Arg
falsche
String, number, bool, object, array, null und jeder andere vom System unterstützte Typ
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);
}
Die vonexchange.Sell()kann verwendet werden, um Bestellinformationen abzufragen und Bestellungen zu stornieren.
// 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);
}
Bei der Bestellung eines Futures-Kontrakts für Kryptowährungen muss darauf geachtet werden, dass die Handelsrichtung korrekt eingestellt ist, da ein Missverhältnis zwischen der Handelsrichtung und der Handelsfunktion zu einem Fehler führt:
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);
}
Spotmarktbestellung.
Wenn Sie einen Auftrag für einen Futures-Kontrakt aufgeben, müssen Sie darauf achten, ob die Handelsrichtung korrekt eingestellt ist, da ein Fehler gemeldet wird, wenn die Handelsrichtung und die Handelsfunktion nicht übereinstimmen.
Der Parameterpriceist auf-1Bei der Platzierung von Marktordern für Kryptowährungs-Spot-Kontrakte wird der Betrag-Parameteramountist der Betrag in der Handelswährung.amountEs gibt einige Kryptowährungsbörsen, die während des Live-Handels keine Marktorder-Schnittstelle unterstützen.
Wenn Sie eine ältere Version des Dockers verwenden, wird der Wert der Bestellung zurückgegebenIdderexchange.Sell()Funktion kann sich von dem Rückgabewert des Auftrags unterscheidenIdin diesem Dokument beschrieben.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
Dieexchange.CreateOrder()Funktion wird verwendet, um eine Bestellung zu platzieren.
Wenn die Bestellung erfolgreich platziert wird, wird die Order-ID zurückgegeben; wenn die Bestellung fehlschlägt, wird ein Nullwert zurückgegeben.IdDie Struktur der Bestellstruktur {@struct/Order Order} der FMZ-Plattform besteht aus dem Austauschproduktcode und der Austausch-Originalorder-ID, die durch englische Kommas getrennt sind.IdFormat der Bestellung des Spot-HandelspaaresETH_USDTder OKX-Börse ist:ETH-USDT,1547130415509278720. Wenn Sie dieexchange.CreateOrder(symbol, side, price, amount)Funktion zur Auftragserteilung, der Wert der AuftragserteilungIdist mit demIdEigenschaft der Struktur der Reihenfolge {@struct/Order Order}.
String, Nullwert
exchange.CreateOrder (Symbol, Seite, Preis, Betrag) exchange.CreateOrder ((Symbol, Seite, Preis, Betrag,... args)
Der ParametersymbolBei der Anforderung der Angabe des Handelspaares und des Auftragscodes der Bestellung wird die Angabe des Handelspaares und des Auftragscodes verwendet.exchange.CreateOrder(symbol, side, price, amount)Funktion zur Bestellung,exchangeist das Spot-Austauschobjekt. Ist die auf USDT lautende Währung der Auftrag und ist BTC die Handelswährung, wird der Parametersymbolist:"BTC_USDT", im Format des von der FMZ-Plattform definierten Handelspaares.exchange.CreateOrder(symbol, side, price, amount)Funktion zur Bestellung,exchangeist das Objekt des Futures-Austauschs. Wenn es sich bei der Bestellung um eine BTCsymbolist:"BTC_USDT.swap", und das Format ist eine Kombination derHandelspaarundVertragskodedie durch die FMZ-Plattform definiert sind, getrennt durch den Zeichen exchange.CreateOrder(symbol, side, price, amount)Funktion zur Bestellung,exchangeist das Futures-Austauschobjekt. Wenn es sich bei der Bestellung um eine BTCsymbolist:"BTC_USDT.BTC-240108-40000-C"(beim Beispiel Binance Option BTC-240108-40000-C), und das Format ist eine Kombination derHandelspaarvon der FMZ-Plattform und dem von der Börse definierten spezifischen Optionsvertragskode definiert, getrennt durch den Zeichen sideDer Parameter wird verwendet, um die Handelsrichtung des Auftrags anzugeben.
Für Spot-Austauschobjekte gelten die optionalen Werte dersideParameter sind:buy, sell. buybedeutet Kauf, undsellbedeutet zu verkaufen.
Für Futures-Börsen werden die optionalen Werte dersideParameter sind:buy, closebuy, sell, closesell. buybedeutet, eine Long-Position zu eröffnen,closebuybedeutet, eine Long-Position zu schließen,sellbedeutet, eine Leerposition zu eröffnen, undclosesellbedeutet, eine Leerposition zu schließen.
Seite
wahr
String
Der ParameterpriceBei einem Preis von -1 wird angegeben, dass es sich bei der Bestellung um eine Marktorder handelt.
Preis
- Das stimmt.
Zahl
Der ParameteramountBei einer Bestellung mit Marktkaufbestellung ist der Kaufbetrag der Bestellbetrag; bei einigen Spotbörsen ist die Bestellmenge der Marktkaufbestellung die Anzahl der Handelsmünzen.Sondervorschriften für den Austauschin der argParameter können übergeben werden.
Arg
falsche
Jeder vom System unterstützte Typ, z. B. Zeichenfolge, Zahl, bool, Objekt, Array, Nullwert usw.
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);
}
Die Gegenstände des Spot- und Futures-Austauschs werden alsexchange.CreateOrder()Funktion, um eine Bestellung zu erteilen.
(Durchschnittliche Anzahl von Personen, die in einem Unternehmen tätig sind)
Dieexchange.CancelOrder()Funktion wird verwendet, um die Bestellung zu stornieren.
Das AttributIdDie Struktur der Bestellstruktur {@struct/Order Order} der FMZ-Plattform besteht aus dem Austauschproduktcode und der Austausch-Originalorder-ID, die durch englische Kommas getrennt sind.IdFormat der Bestellung des Spot-HandelspaaresETH_USDTder OKX-Börse ist:ETH-USDT,1547130415509278720- Ich weiß.
Der ParameterorderIdSie ist bei der Anrufung derexchange.CancelOrder()Funktion, um eine Bestellung zu stornieren, ist mit derIdEigenschaft der Struktur der Reihenfolge {@struct/Order Order}.
Dieexchange.CancelOrder()Funktion gibt einen wahren Wert zurück, zum Beispieltruebedeutet, dass die Stornierungsanfrage erfolgreich gesendet wurde.false, bedeutet, dass die Stornierungsanfrage nicht gesendet wurde. Der zurückgegebene Wert stellt nur den Erfolg oder Misserfolg der gesendeten Anfrage dar, um festzustellen, ob die Börse die Bestellung storniert.exchange.GetOrders()um festzustellen, ob die Bestellung storniert wird.
Boole
Auswechselung.Rückgängig machenBestellung (Bestellnummer) Auswechselung.Auftrag stornieren
DieorderIdDer Parameter wird verwendet, um den zu stornierenden Auftrag anzugeben.
Auftraggeber
- Das stimmt.
Zahl, Zeichenfolge
Erweiterte Parameter, Sie können die angehängten Informationen in dieses Rücktrittsprotokoll einfügen,argParameter können mehr als eine übergeben werden.
Arg
falsche
String, number, bool, object, array, null und jeder andere vom System unterstützte Typ
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);
}
Stornieren Sie die Bestellung.
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-Funktionen, die Log-Output-Funktionen erzeugen können, wie z. B.:Log(), exchange.Buy(), exchange.CancelOrder()Nach den erforderlichen Parametern können einige begleitende Ausgangsparameter folgen.exchange.CancelOrder(orders[i].Id, orders[i]), so dass bei der Stornierung der Bestellung, deren IDorders[i].Id, wird die Auftragsinformation mit ihm ausgegeben. Das heißt, die {@struct/Order Order} Struktur vonorders[i].
Wenn Sie eine ältere Version des Dockers verwenden, kann sich der Parameter orderId der Exchange.CancelOrder() -Funktion von der im aktuellen Dokument beschriebenen orderId unterscheiden.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}
Dieexchange.GetOrder()Die Funktion wird verwendet, um die Bestellinformationen zu erhalten.
Abfragen Sie die Bestelldetails nach der Bestellnummer und geben Sie die Struktur {@struct/Order Order} zurück, wenn die Abfrage erfolgreich ist, oder Null zurück, wenn die Abfrage fehlschlägt. {@struct/Order Order}, Nullwert
Auswechselung.GetOrder (OrderId)
DieorderIdParameter wird verwendet, um die zu abfragende Reihenfolge anzugeben.
Das AttributIdDie Struktur der Bestellstruktur {@struct/Order Order} der FMZ-Plattform besteht aus dem Austauschproduktcode und der Austausch-Originalorder-ID, die durch englische Kommas getrennt sind.IdFormat der Bestellung des Spot-HandelspaaresETH_USDTder OKX-Börse ist:ETH-USDT,1547130415509278720- Ich weiß.
Der ParameterorderIdSie ist bei der Anrufung derexchange.GetOrder()Funktion, um eine Bestellung abzufragen, ist mit derIdEigenschaft der Struktur der Reihenfolge {@struct/Order Order}.
Auftrag wahr String
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);
}
Dieexchange.GetOrder()Die Funktion wird von einigen Börsen nicht unterstützt.AvgPriceEinige Börsen unterstützen dieses Feld nicht, und wenn nicht, wird es auf 0 festgelegt.
Wenn Sie eine ältere Version des Dockers verwenden,orderIdParameter derexchange.GetOrder()Funktion kann von derorderIdin der aktuellen Dokumentation beschrieben.
Dieexchange.GetOrder()Funktion:
| Funktionsname | Nicht unterstützte Spotbörsen | Nicht abgesicherte Futures-Börsen |
|---|---|---|
| GetOrder | Zaif / Coincheck / Bitstamp | – |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}
Dieexchange.GetOrders()Die Funktion wird verwendet, um ausstehende Aufträge zu erhalten.
Dieexchange.GetOrders()Funktion gibt ein Array von {@struct/Order Order}-Strukturen zurück, wenn die Datenanfrage erfolgreich ist, und nullwerte, wenn die Datenanfrage fehlschlägt.
{@struct/Order Order}-Array, Nullwert
- Ich bin nicht hier. - Das ist nicht wahr.
Der Parametersymbolwird verwendet, um dieTransaktionssymboloderTransaktionssymbolbereichSie werden befragt.
Für Spot-Austauschobjekte, wenn diesymbolWenn der Parameter nicht übergeben wird, werden die unvollendeten Bestelldaten aller Spotprodukte angefordert.
Für Futures-BörsensymbolWenn der Parameter nicht übergeben wird, werden standardmäßig die unvollendeten Auftragsdaten aller Sorten im Dimensionsbereich des aktuellen Handelspaares und des Vertragscodes angefordert.
Symbol falsche String
/*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;
}
Verwenden Sie das Spot-Exchange-Objekt, um Kaufoptionen für mehrere verschiedene Handelspare zu der Hälfte des aktuellen Preises zu platzieren und dann die ausstehenden Auftragsinformationen abzufragen.
/*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;
}
Verwenden Sie Futures-Börsenobjekte, um Aufträge für mehrere verschiedene Handelspare und Vertragscodes zu platzieren. Platzieren Sie Aufträge zu Preisen, die weit vom Gegenparteipreis entfernt sind, halten Sie Aufträge in einem unerfüllten Zustand und abfragen Sie Aufträge auf mehrere Arten.
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);
}
Bei Anrufen derexchange.GetOrders()Funktion, in dieSymbolParameter zur Anforderung von Auftragsdaten für ein bestimmtes Handelspaar und einen Vertragskode.
In derGetOrdersFunktion, werden die Anwendungsszenarien des Symbolparameters wie folgt zusammengefasst:
| Klassifizierung von Exchange-Objekten | Symbol Parameter | Umfang der Abfrage | Anmerkung |
|---|---|---|---|
| Stellfläche | Symbolparameter nicht übergeben | Abfrage aller Spot-Handelspaare | Für alle Anrufszenarien wird, wenn die Austauschoberfläche sie nicht unterstützt, ein Fehler gemeldet und ein Nullwert zurückgegeben. |
| Stellfläche | Angabe des Handelstyps, der Symbolparameter lautet: |
Abfrage des angegebenen BTC_USDT-Handelspaares | Für Spot-Börsenobjekte ist das Symbolparameterformat: |
| Futures | Symbolparameter nicht übergeben | Abfrage aller Handelsprodukte innerhalb des aktuellen Handelspaares und des Dimensionsabstands des Vertragscodes | Wenn das aktuelle Handelspaar BTC_USDT ist und der Vertragscode Swap ist, werden alle USDT-margierten Perpetual Contracts abgefragt.GetOrders("USDT.swap") |
| Futures | Angabe des Handelstyps, der Symbolparameter lautet: |
Abfrage des USDT-basierten Dauerkontrakts für einen bestimmten BTC | Für Futures-Börsenobjekte ist das Format des Parameter-Symbols: eine Kombination vonHandelspaarundVertragskodedurch die FMZ-Plattform definiert, getrennt durch die Zeichen".. |
| Futures | Angabe des Handelssortiments, der Symbolparameter lautet: |
Abfrage aller USDT-basierten Daueraufträge | - |
| Futures-Börsen, die Optionen unterstützen | Symbolparameter nicht übergeben | Abfrage aller Optionskontrakte innerhalb des aktuellen Dimensionsbereichs des Handelspares | Wenn das aktuelle Handelspaar BTC_USDT ist, wird der Vertrag auf einen Optionsvertrag festgelegt, z. B. Binance-Optionvertrag: BTC-240108-40000-C |
| Futures-Börsen, die Optionen unterstützen | Spezifische Handelsprodukte angeben | Abfrage des angegebenen Optionskontrakts | Für die Binance Futures Exchange beispielsweise ist der Symbolparameter: BTC_USDT.BTC-240108-40000-C |
| Futures-Börsen, die Optionen unterstützen | Angabe des Handelssortiments, der Symbolparameter lautet: |
Abfrage aller USDT-basierten Optionskontrakte | - |
In derGetOrdersFunktion, die Futures Exchange-Objektanfrage
Der Abmessungsbereich ist wie folgt zusammengefasst:
| Symbol Parameter | Definition des Anforderungsbereichs | Anmerkung |
|---|---|---|
| USDT.swap | USDT-basierte Dauervertragsspanne. | Für |
Abmessungen, die von der Exchange-API-Schnittstelle nicht unterstützt werden, Ein Fehler wird gemeldet und ein Nullwert wird zurückgegeben, wenn Sie ruft. ♫ USDT.Futures ♫ ♫ USDT-basierte Liefervertragsspanne ♫ ♫ USDT-basierte Liefervertragsspanne ♫ USD.Swap. Eine Reihe von Währungsbasierten Verträge. ♫ USD.Futures ♫ Verträge. USDT.Option. USDT-basierte Optionskontrakt-Bereich. USD.Option. Währungsbasierte Optionskontrakt-Range. USDT.Futures_Combo. Eine Reihe von CFD-Kombinationen. Futures_Deribit-Börse USD.Futures_ff Eine Reihe von Margin-Lieferverträgen. Die Futures_Kraken Exchange. USD.Swap_pf. Eine Reihe von perpetual Margin-Verträgen. Ich habe eine Idee. Ich habe eine Idee.
Wenn das durch den Austauschgegenstand dargestellte Kontoexchangehat keine ausstehenden Aufträge innerhalb derAbfragebereichoderbestimmte Handelsinstrumente(aktive Aufträge in einem unerfüllten Zustand), wenn diese Funktion aufgerufen wird, wird ein leeres Array zurückgegeben, d. h.:[]- Ich weiß.
Bei der Aufforderung der GetOrders-Funktion bei diesen Börsen werden, wenn der Instrumentparameter nicht eingegeben wird, nur die unvollendeten Aufträge des aktuellen Instruments angefordert, nicht die unvollendeten Aufträge aller Instrumente (weil die Exchange-Schnittstelle dies nicht unterstützt).
Zaif, MEXC, LBank, Korbit, Coinw, BitMart, Bithumb, BitFlyer, BigONE. Das ist nicht nur ein Spiel.
Dieexchange.GetOrders()Funktion:
| Funktionsname | Nicht unterstützte Spotbörsen | Nicht abgesicherte Futures-Börsen |
|---|---|---|
| GetOrders | – | Futures_Bibox |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}
Dieexchange.GetHistoryOrders()Die Funktion wird verwendet, um das aktuelle Handelspaar, die historischen Aufträge für Verträge zu erhalten; sie unterstützt die Spezifikation spezifischer Handelsvarianten.
Dieexchange.GetHistoryOrders()Funktion gibt ein Array von {@struct/Order Order}-Strukturen zurück, wenn die Anfrage erfolgreich ist, und null, wenn die Anfrage fehlschlägt.
{@struct/Order Order} Arrays, Nullwerte
- Ich bin nicht hier. Erhalten Sie die Geschichte der Bestellungen (Symbol) (Symbol, seit) exchange.GetHistoryOrders (Symbol, seit, Grenze) - Ich bin nicht derjenige, der das sagt. exchange.GetHistoryOrders (seit, Grenze)
DiesymbolBei der Angabe des Handelssymbols wird ein Parameter verwendet.BTC_USDTDas Handelspaar wird beispielsweiseexchangeist ein Spot-Austauschobjekt, das Parameterformat fürsymbolistBTC_USDTWenn es sich um ein Futures-Börseobjekt handelt, beispielsweise um einen Dauervertrag, ist das Parameterformat fürsymbolist:BTC_USDT.swap- Ich weiß.
Wenn Sie die Auftragsdaten von Optionsverträgen abfragen, setzen Sie den Parametersymbolzu"BTC_USDT.BTC-240108-40000-C"Das Format ist eine Kombination aus denHandelspaarvon der FMZ-Plattform und dem von der Börse definierten spezifischen Optionsvertragskode definiert, getrennt durch den Zeichen
Symbol
falsche
String
DiesinceParameter wird verwendet, um den Startzeitstempel der Abfrage in Millisekunden anzugeben.
Seit
falsche
Zahl
DielimitParameter wird verwendet, um die Anzahl der zu abfragenden Aufträge anzugeben.
Grenzwerte
falsche
Zahl
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, limitWenn keine Parameter angegeben sind, ist die Standardabfrage das aktuelle Handelspaar, die historischen Auftragsverträge. Abfragt die historischen Aufträge innerhalb eines bestimmten Bereichs, der der aktuellen Zeit am nächsten ist, hängt der Abfragebereich vom einzelnen Abfragebereich der Austauschoberfläche ab.symbolDer Anforderungsprozess wird durch die Angabe des Parameters durchgeführt.sinceParameter angegeben ist, Abfrage in Richtung der aktuellen Zeit mit dersinceZeitstempel als Startzeit.limitWenn ein Parameter angegeben wird, wird die Abfrage nach einer ausreichenden Anzahl von Einträgen zurückgegeben.Dieexchange.GetHistoryOrders()Funktion:
| Funktionsname | Nicht unterstützte Spotbörsen | Nicht abgesicherte Futures-Börsen |
|---|---|---|
| GetHistory-Orders | Zaif / Upbit / Coincheck / Bitstamp / Bithumb / BitFlyer / BigONE | Futures_dYdX / Futures_Bibox / Futures_ApolloX |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}
exchange.SetPrecision()Funktion wird verwendet, um die Präzision derexchangeAustauschobjektPreisundAuftragsbetrag, wird das System die überschüssigen Daten automatisch ignorieren.
Ausgleich.SetPrecision ((PreisPrecision, BetragPrecision)
DiepricePrecisionDer Parameter wird zur Kontrolle der Präzision der Preisdaten verwendet.
PreisGenauigkeit
wahr
Zahl
DieamountPrecisionDie Parameter werden verwendet, um die Genauigkeit der zu bestellenden Datenmenge zu kontrollieren.
BetragGenauigkeit
- Das stimmt.
Zahl
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);
}
Das Backtesting-System unterstützt diese Funktion nicht, und die numerische Genauigkeit des Backtesting-Systems wird automatisch verarbeitet.
(Durchschnittliche Anzahl von Personen, die in einem Unternehmen tätig sind)
Der aktuelle Wechselkurs des Austauschobjekts wird festgelegt.
Wechselkurs.SetRate ((Rate))
DierateDer Parameter wird zur Angabe des Umrechnungskurses verwendet.
Zinssatz
wahr
Zahl
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);
}
Wenn ein Wechselkurswert unter Verwendung derexchange.SetRate()Sie werden dann alle Preisinformationen wie Tickers, Tiefen, Auftragspreise usw. für den Austausch darstellen.exchangeDer Umrechnungskurs wird durch Multiplikation durch den festgelegten Wechselkurs von 7 umgerechnet.exchangeist ein Austausch mit dem US-Dollar als Stückelwährung.exchange.SetRate(7), werden alle Preise auf dem Live-Markt in Preise umgerechnet, die naheCNYDer Nennwert wird mit 7 multipliziert.
Ich bin nicht derjenige, der das Problem hat, aber ich bin derjenige, der das Problem hat.
Dieexchange.IO()Funktion wird für andere Schnittstellenanrufe im Zusammenhang mit dem Austauschobjekt verwendet.
Dieexchange.IO()Funktion ruft andere Schnittstellen auf, die mit dem Exchange-Objekt verbunden sind, und gibt bei einem erfolgreichen Anruf die angeforderten Antwortdaten zurück und bei einem fehlgeschlagenen Anruf null zurück.
String, number, bool, object, array, null und jeder andere vom System unterstützte Typ
exchange.IO(k,... args)
DiekParameter wird verwendet, um den Anruftyp mit optionalen Werten festzulegen"api", "currency", "base", "trade_margin", "trade_normal", "public_base", "mbase", selfTradePreventionMode, simulate, cross, dual, unifiedund so weiter.
k
wahr
String
Erweiterte Parameter gemäß dem spezifischen Anrufszenario,argDurch den polymorphen Mechanismus derexchange.IO()Die Anzahl und Art der Parameter, die für dieexchange.IO()Funktion sind unbestimmt.
Arg
- Das stimmt.
String, number, bool, object, array, null und alle anderen vom System unterstützten Typen
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);
}
Mit Hilfe derexchange.IO("api", httpMethod, resource, params, raw)Aufrufformular derexchange.IO()Die Funktionalität der FMZ-Plattform kann durch die Einreichung eines Antrags auf die Übermittlung von Informationen über die Funktionalität der FMZ-Plattform erweitert werden.POSTAnforderung erfordert nicht, dass Sie sich Sorgen um die Verschlüsselung, Signierung oder Überprüfung der Parameter machen, die bereits von FMZ unten behandelt werden, solange Sie die entsprechenden Parameter ausfüllen.OKX ExchangeFutures-Kontrakte und verwenden Sie den Parameterrawzur Übergabe der Auftragsparameter:
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);
}
Wenn der Schlüsselwert in derparamsParameter (d.h. HTTP-Anfrageparameter) ist eine Zeichenfolge, sie muss in einzelnen Anführungszeichen (d.h. das Symbol ') um den Parameterwert geschrieben werden, um den Parameterwert zu umschließen.
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);
}
Es unterstützt die Übergabe vollständiger URL-Parameter, die den Betrieb des Umschaltens der Basisadresse (Aufrufen der URL-Adresse) weglassen können.exchange.SetBase()Funktion).
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);
}
Beispiel für einen Aufruf ohne Parameterraw:
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());
}
Wechseln Sie das Handelspaar des aktuellen Austauschs, so dass es das Handelspaar durch Code konfiguriert wechselnbei der Schaffung von Live-Handelsgeschäftenoderbei Backtest.
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");
}
Für Börsen mit unterschiedlichen Basisadressen für die Tickerschnittstelle und die Handelsschnittstelle haben Bitfinex Futures beispielsweise zwei Adressen, eine für die Tickerschnittstelle und die andere für die Handelsschnittstelle.exchange.SetBase("xxx"). Bitfinex Futures wechseln öffentliche Schnittstelle Basisadresse mitexchange.IO("mbase", "xxx").
I. Für kryptogeldzentrierte Börsen andere API-Schnittstellenanrufe, die nicht einheitlich verkapselt sind, mit Parameterkauf"api":
exchange.IO("api", httpMethod, resource, params, raw)
POST, GET, usw.URL.Dieexchange.IO("api", httpMethod, resource, params, raw)Funktionsanruf wird auf die Exchange-Schnittstelle zugreifen und null zurückgeben, wenn der Anruf fehlschlägt und ein Fehler auftritt.
Nur der echte Handel unterstützt die Anrufung derexchange.IO("api", httpMethod, resource, params, raw) function.
II. Bei Wechseln von Handelsparen wird der Parameterkist auf"currency":
exchange.IO("currency", currency)
Währung: Der Parameter ist ein Zeichenkettentyp mit einem einheitlichen Großbuchstabenformat, bei dem ein Unterstrich verwendet wird, um zu trennenbaseCurrencyvonquoteCurrency, wie zum BeispielBTC_USDT.
ETH_BTCkann nur aufLTC_BTC, nicht zuLTC_USDT.exchange.IO("currency", currency)um Handelspare zu wechseln.III. Wird verwendet, um den Leveraged-Konto-Modus des Kryptowährungs-Spot-Austauschobjekts zu wechseln:
kist auf"trade_margin"Die Angabe von Aufträgen und der Erwerb von Kontovermögen erfolgt über die Spot-Leveraged-Schnittstelle der Börse.
Wenn die Börse bei Spot-Leverage zwischen voller Marge und isolierter Marge unterscheidet, wird folgendes verwendet:exchange.IO("trade_super_margin")die Umstellung auf die volle Marge für das Hebelkonto undexchange.IO("trade_margin")Umstellung auf eine isolierte Marge für das Hebelkonto.kist auf"trade_normal"Zurück zum normalen Spotkonto-Modus.Spotbörsen, die den Wechsel zwischen Leveraged-Konto-Modellen unterstützen:
| Auswechslungen | Besondere Bemerkungen |
|---|---|
| OKX | Handelspaare im Hebelkonto-Modus unterscheiden sich von normalen, einige Handelspaare haben sie möglicherweise nicht.exchange.IO("trade_super_margin")zur Umstellung auf die volle Position für Hebelkonten und zur Verwendungexchange.IO("trade_margin")Sie können auch eine andere Anlage verwenden.trade_normalSie können die Tabelle in einem anderen Modus verwenden, um in den normalen Spotmodus zu wechseln.exchange.IO("tdMode", "cross")um die Hebelwirkung direkt anzugeben. |
| Weiß nicht. | Bei Huobi gibt es eine Reihe von Handelspaaren, bei denen es sich um die vollständigen Positionen und die Positionen nach Positionen handelt.trade_marginzur Umstellung auf Hebelkontoposition nach Position, Verwendungtrade_super_marginUm auf Hebelwirkung zu wechseln.trade_normalzum normalen Währungs-Währungs-Modus wechseln. |
| Binance | Der Leveraged-Konto-Modus wird in Position nach Position und Vollposition, Verwendungtrade_marginUm von Position zu Position zu wechseln, verwendentrade_super_marginUm in die volle Position zu wechseln, verwenden Sietrade_normalzum normalen Währungs-Währungs-Modus wechseln. |
| Schnittstelle | Der Leveraged-Konto-Modus wird in Position nach Position und Vollposition, Verwendungtrade_marginUm von Position zu Position zu wechseln, verwendentrade_super_marginUm in die volle Position zu wechseln, verwenden Sietrade_normalzum normalen Währungs-Währungs-Modus wechseln. |
| AscendEx | Verwendungexchange.IO("trade_margin")zur Umstellung auf einen Hebelkonto undexchange.IO("trade_normal")Zurück zum normalen Konto-Modus. |
| Wo ist er? | Verwendungexchange.IO("trade_margin")zur Umstellung auf einen Hebelkonto undexchange.IO("trade_normal")Zurück zum normalen Konto-Modus. |
| CoinEx | Verwendungexchange.IO("trade_margin")zur Umstellung auf den Leveraged-Konto-Modus undexchange.IO("trade_normal")Zurück zum normalen Konto-Modus. |
IV. Sonstige Schaltfunktionen:Schauen Sie sich das an.exchange.IO()Funktion fürAndere Schaltfunktionenin der Benutzeranleitung.
{@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@var EXCHANGE_OP_IO_CONTROL}
Dieexchange.Log()Funktion wird verwendet, um das Protokoll der Auftragserteilung und -abnahme im Bereich der Log-Spalte auszugeben.
Austausch.Log ((Bestellungsdatentyp, Preis, Betrag) Austausch.Log ((Bestellung) Art, Preis, Betrag,... args)
DieorderTypeDer Parameter wird verwendet, um den Ausgabeprototyp festzulegen, die optionalen Werte sind {@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}.
Anordnung
- Das stimmt.
Zahl
DiepriceParameter wird verwendet, um den im Ausgangsprotokoll angezeigten Preis festzulegen.
Preis
- Das stimmt.
Zahl
DieamountDer Parameter wird verwendet, um die Menge der in dem Ausgabeprotokoll angezeigten Bestellungen festzulegen.
Betrag
- Das stimmt.
Zahl
Erweiterte Parameter, mit denen die Begleitinformationen in dieses Protokoll ausgeführt werden können,argParameter können mehr als eine übergeben werden.
Arg
falsche
String, number, bool, object, array, null und jeder andere vom System unterstützte Typ
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);
}
Verwendungexchange.Log(orderType, price, amount)Einer der häufigsten Szenarien ist die Verwendung des {@fun/Trade/exchange.IOexchange.IO} Funktion, um auf die Schnittstelle der Börse für die Erstellung bedingter Aufträge zuzugreifen, aber mit derexchange.IO()Funktion nicht die Transaktionsprotokollinformationen in der Live-Handelsprotokollaufzeichnung ausgibt.exchange.Log()Diese Funktion kann zur Ergänzung des Ausgabeprotokolls verwendet werden, um Informationen über Auftragserteilung und Auftragsausschluss aufzuzeichnen.
Wenn dieorderTypeParameter istLOG_TYPE_CANCEL, diepriceParameter ist die Reihenfolge Id der zurückgezogenen Bestellung, die verwendet wird, um das Rücktrittsprotokoll zu drucken, wenn die Bestellung direkt mit demexchange.IO()Dieexchange.Log()Funktion ist eine Mitgliederfunktion des Austauschobjekts {@var/EXCHANGE exchange} im Gegensatz zur globalen Funktion {@fun/Log Log}.
Die Kommission hat die Kommission aufgefordert, die in Artikel 4 Absatz 1 Buchstabe a der Verordnung (EG) Nr. 45/2001 festgelegten Bedingungen für die Erteilung von Zuschüssen für die Durchführung der Verordnung (EG) Nr. 659/1999 und der Verordnung (EG) Nr. 659/1999 anzuwenden.
Dieexchange.Encode()Die Funktion wird für Signaturverschlüsselungsberechnungen verwendet.
Dieexchange.Encode()Funktion gibt die berechnete Hash-Codierung zurück.
String
exchange.Encode ((algo, inputFormat, outputFormat, Daten) exchange.Encode ((algo, inputFormat, outputFormat, Daten, SchlüsselFormat, Schlüssel)
Der Parameteralgoist der Algorithmus, der für die Kodierung berechnet wird. Unterstützte Einstellungen sind: algounterstützt auch: algounterstützt auch: algokann als ed25519.seedBerechnung.
etwas
wahr
String
Verwendet zur Festlegung des Datenformats derdataDieinputFormatDer Parameter kann auf einen der folgenden Werte gesetzt werden: hexkodiert, base64und outputFormatDer Parameter unterstützt folgende Einstellungen: hexkodiert, base64und dataist die zu verarbeitende Daten.
Daten
wahr
String
Verwendet zur Festlegung des Datenformats derkeyDiekeyDer Parameter kann auf einen der folgenden Werte gesetzt werden: hexkodiert, base64und keyParameter wird verwendet, um den Schlüssel für die Signaturberechnung anzugeben, und es kann als Plaintext-String verwendet werden."{{accesskey}}", "{{secretkey}}"dieaccessKeyundsecretKeyin dem Exchange-Objekt {@var/EXCHANGE exchange} konfiguriert.
Schlüssel
falsche
String
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"];
}
}
}
Beispiel für BitMEX-Positionswechsel (wss-Protokoll):
Nur der echte Handel unterstützt dieexchange.Encode()Die"{{accesskey}}", "{{secretkey}}"Die Referenzen gelten nur, wenn dieexchange.Encode()Funktion verwendet wird.
{@var/EXCHANGE exchange}, {@fun/Global/Encode Encode}
Mehrthreaded asynchrone Support-Funktionen können die Operationen aller unterstützten Funktionen in eine asynchrone gleichzeitige Ausführung umwandeln.
Dieexchange.Go()Funktion gibt ein gleichzeitiges Objekt sofort zurück, und Sie können diewait()Methode dieses gleichzeitigen Objekts, um das Ergebnis der gleichzeitigen Anfrage zu erhalten.
Gegenstand
Wechsel.Gehen (Methode) Auswechselung.Go (Methode,... args)
DiemethodParameter wird verwendet, um den Namen der gleichzeitigen Funktion anzugeben. Beachten Sie, dass der Parameter eine Funktionsnamenfolge ist, keine Funktionsreferenz.
Methode
- Das stimmt.
String
Parameter bisgleichzeitig Funktionen ausführen, kann es mehr als einen Parameter gebenarg. Typ und Anzahl des ParametersargDie Ergebnisse der Studiegleichzeitige Ausführung- Ich weiß.
Arg
falsche
String, number, bool, object, array, function, null und alle anderen vom System unterstützten Typen
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()Funktionsanwendungsbeispiel, um zu bestimmenundefinedzu verwendentypeof(xx) === "undefined", weilnull == undefinedist in JavaScript gültig.
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);
}
Ich rufe diewait()Methode auf einem gleichzeitigen Objekt, das freigegeben wurde, wird einen Fehler melden:
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);
}
}
Gleichzeitiger Zugriff auf mehrere Exchange-Tickers:
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");
}
Gleichzeitige Aufrufeexchange.IO("api", ...)Funktion:
Diese Funktion erstellt nur mehrthreaded Ausführungsaufgaben, wenn sie im realen Handel ausgeführt wird, Backtesting unterstützt nicht mehrthreaded gleichzeitige Ausführung von Aufgaben (Backtesting ist verfügbar, aber immer noch sequenziell ausgeführt).
Nach derexchange.Go()Funktion gibt ein Objekt zurück, seinwait()Funktion wird durch dieses Objekt aufgerufen, um die Daten des Threads zurückzugeben.wait()Die Funktion muss aufgerufen werden, um die Daten zu erhalten, bevor der Thread automatisch freigegeben wird.wait()Wenn die Funktion nicht angegeben ist, wird der Thread nicht automatisch freigegeben, selbst wenn ein Timeout eintritt. Das Ergebnis des Threads muss erhalten werden, bevor er automatisch freigegeben wird (unabhängig vom Erfolg oder Scheitern des Schnittstellenanrufs für gleichzeitigen Zugriff).wait()Funktion, unabhängig davon, ob die Ausführung erfolgreich oder fehlschlägt, und die Ressource des vom Thread angefordertenexchange.Go()Funktion muss automatisch vom Docker freigegeben werden.
Diewait()Methode unterstützt einen Timeout-Parameter:
Ohne einen Timeout-Parameter, alsowait(), oder mit einem Timeout-Parameter von 0, d. h.wait(0). Diewait()Funktionsblöcke und wartet, bis der gleichzeitige Thread ausgeführt ist, und gibt das Ergebnis der gleichzeitigen Threadwait(-1). Diewait()Funktion gibt sofort mit unterschiedlichen Rückgabewerten für verschiedene Programmiersprachen zurück, siehe diesen Unterabschnitt für einen Beispielruf.
Setzen Sie den spezifischen Timeout-Parameter,wait(300), und diewait()Die Funktion wird maximal 300 Millisekunden warten, bevor sie zurückkehrt.
Wenn das Ergebnis der letztenwait()Funktion nicht erreicht wird, werden die Thread-Ressourcen nicht automatisch freigegeben, was zur Anhäufung der angeforderten Threads führt, und mehr als 2000 werden einen Fehler melden:"too many routine wait, max is 2000"- Ich weiß.
Unterstützte Funktionen:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO. Alle diese Funktionen werden basierend auf dem aktuellen Exchange-Objekt {@var/EXCHANGE exchange} ausgeführt, wenn sie gleichzeitig aufgerufen werden.
Der Unterschied zwischen Python und JavaScript besteht darin, dasswait()Die Funktion der gleichzeitigen Objekte in der Python-Sprache gibt zwei Parameter zurück. Der erste Parameter ist das Ergebnis eines asynchronen API-Aufrufs und der zweite Parameter gibt an, ob der asynchrone Aufruf abgeschlossen ist.
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)
Wir haben eine Reihe von Programmen entwickelt.
Dieexchange.GetAccount()Die Funktion wird verwendet, um Informationen über den Wechselkonto anzufordern.GetAccount()Funktion ist eine Mitgliederfunktion des Austauschobjekts {@var/EXCHANGE exchange}.exchangeObjekt ist nur mitexchange, und wird nach der Dokumentation nicht wiederholt.
Abfrage der Konto-Asset-Informationen und Rückgabe der Struktur {@struct/Account-Account}, wenn die Abfrage erfolgreich ist oder null, wenn sie fehlschlägt. {@struct/Account Account}, Nullwert
- Ich bin nicht bereit.
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"])
}
Setzen Sie Handelspaare ein, bekommen Sie die Codes und die Kontoinformationen.
Wenn das Austauschobjekt auf einen Austausch von Kryptowährungs-Futures-Kontrakten gesetzt und auf einen Vertrag mitUSDTals Margin (siehe {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType} Funktionen für die Umstellung).USDTDie Marge wird in derBalance, FrozenBalanceAttribute der Struktur {@struct/Account Account}.
Wenn das Austauschobjekt auf einen Austausch von Kryptowährungs-Futures-Kontrakten gesetzt und auf einen währungsbasierten Vertrag umgestellt wird, ist der Vermögenswert in Währung als Marge und wird in derStocks, FrozenStocksAttribute der Struktur {@struct/Account Account}.
Bei der Nutzung des Binance Futures-Gemeinsamen Kontosexchange.GetAccount()Funktion zur Anforderung von Kontoinformationen, die eingekapselten Daten sind der Betrag aller in Konten umgewandelten VermögenswerteUS-Dollar. Es wird in derBalanceWenn Sie den Umrechnungsbetrag für andere Vermögenswerte berechnen müssen, können Sie den USD-Umrechnungsbetrag durch den Indexpreis (des zu konvertierenden Vermögenswerts) und dann durch den Pfandsatz (des zu konvertierenden Vermögenswerts) dividieren.
{@struct/Account-Account}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}
Dieexchange.GetAssetsDie Funktion wird verwendet, um Informationen zu den Vermögenswerten eines Börsenkontos anzufordern.
Dieexchange.GetAssets()Funktion gibt ein Array von {@struct/Asset Asset} Strukturen zurück, wenn die Anfrage erfolgreich ist, oder null, wenn die Anfrage fehlschlägt.
{@struct/Asset Asset} Array, Nullwert
Auswechselung.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);
}
Informationen über die Vermögenswerte eines Umtauschkontos erhalten,exchange.GetAssets()Gibt ein Array mit Elementen der Asset-Struktur zurück.
DieGetAssets()Die Funktion des Futures Exchange-Objekts gibt die Margin-Vermögenswerte des aktuellen Handelspaares (währungsbasiert, USDT-basiert, USDC-basiert usw.) zurück.
{@struct/Asset Asset}
Dieexchange.GetName()Die Funktion wird verwendet, um den Namen des Austauschs zu erhalten, an den das aktuelle Austauschobjekt gebunden ist.
Dieexchange.GetName()Funktion gibt den Namen der von der FMZ Quant Trading Plattform definierten Börse zurück.
String
Erstmals.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");
}
Dieexchange.GetName()Die Funktion wird in der Regel verwendet, um die Austauschobjekte zu identifizieren, z. B.exchangeoderexchanges[1], exchanges[2]Die Namen der Kryptowährungs-Futures-Kontraktbörsen haben das feste PräfixFutures_.
Ich bin nicht derjenige, der das Problem hat, aber ich bin derjenige, der das Problem hat.
Dieexchange.GetLabel()Funktion wird verwendet, um das benutzerdefinierte Label zu erhalten, das beim Konfiguration des Austauschobjekts eingestellt wurde.
Dieexchange.GetLabel()Funktion gibt das benutzerdefinierte Etikett zurück, das bei der Konfiguration des Austauschobjekts festgelegt wurde.
String
Auswechselung.GetLabel
function main() {
Log("exchange label:", exchange.GetLabel())
}
def main():
Log("exchange label:", exchange.GetLabel())
void main() {
Log("exchange label:", exchange.GetLabel());
}
Austauschobjekte wieexchangeoderexchanges[1], exchanges[2]in dem Strategiecode mit dem Set-Tag identifiziert werden.
{@var/EXCHANGE-Austausch}
Dieexchange.GetCurrency()Funktion wird verwendet, um das derzeit festgelegte Handelspaar zu erhalten.
Dieexchange.GetCurrency()Funktion gibt das Handelspaar zurück, das vom aktuellen Exchange-Objekt {@var/EXCHANGE exchange} gesetzt wurde.
String
Wechsel.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());
}
Das Handelspaarformat ist einheitlich mit Großbuchstaben und unterstrichenbaseCurrencyundquoteCurrency, wie zum BeispielBTC_USDT.
{@fun/Account/exchange.SetCurrency exchange.SetCurrency} Das ist der Name des Kontos.
Dieexchange.SetCurrency()Die Funktion wird verwendet, um das aktuelle Handelspaar des Austauschobjekts {@var/EXCHANGE exchange} zu wechseln.
Wechsel.SetWährung (Währung)
DiecurrencyDas Format des Handelspaares ist mit Großbuchstaben einheitlich, wobei ein Unterstrich verwendet wird, um das zu wechselnde Handelspaar zu trennen.baseCurrencyvonquoteCurrency, wie zum BeispielBTC_USDT- Ich weiß.
Währung
wahr
String
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")Umschaltmethode, siehe {@fun)excahnge.IO}.BTC_USDTkann aufLTC_USDT, nicht zuLTC_BTC.BTC_USDT, die Anzahl derBTCist 3, die Anzahl derUSDTist 10.000. Zu dieser Zeit wechseln Sie zuLTC_USDTNach dem Wechsel ist die Anzahl der Handelswährungen sofort 0, d. h. die Anzahl derLTC_USDTin der Rechnung ist 0, das heißt, die Anzahl derLTCauf dem Konto ist 0, und das wechselte Handelspaar teilt die Anzahl derUSDTDas sind 10.000.Ich bin nicht derjenige, der das Problem hat, aber ich bin derjenige, der das Problem hat.
Dieexchange.GetQuoteCurrency()Die Funktion wird verwendet, um den Namen der Währung des aktuellen Handelspaares zu erhalten, d. h.quoteCurrency.
Dieexchange.GetQuoteCurrency()Funktion gibt den Namen der Währung des aktuellen Handelspaares zurück.
String
Wechsel.GetQuoteWährung
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())
}
Zum Beispiel: {@var/EXCHANGE exchange} exchange objectBTC_USDT, dieexchange.GetQuoteCurrency()Funktion gibt zurückUSDT. Wenn das aktuelle HandelspaarETH_BTC, dieexchange.GetQuoteCurrency()Funktion gibt zurückBTC.
{@fun/Account/exchange.GetCurrency exchange.GetCurrency}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}
Dieexchange.GetPositions()Die Funktion wird verwendet, um die Positionsinformationen zu erhalten.GetPositions()Die Funktion ist eine Mitgliederfunktion des Austauschobjekts {@var/EXCHANGE exchange}.GetPositions()Funktion erhält die Positionsinformationen des mit dem Austauschobjekt verbundenen Austauschkontosexchange. Zweck der Funktionen der Mitglieder (Methoden) derexchangeObjekt ist nur mitexchangeund wird sich hier nicht wiederholen.
Dieexchange.GetPositions()Funktion gibt ein Array von {@struct/Position Position}-Strukturen zurück, wenn die Datenanfrage erfolgreich ist, und nullwert, wenn die Datenanfrage fehlschlägt.
{@struct/Position Position} Arrays, Nullwerte
Erhalten Sie Positionen. Wechsel.GetPositions (Symbol)
Der Parametersymbolwird verwendet, um dieHandelszeichenoderHandelssymbolbereichSie werden befragt.
Wenn diesymbolWenn der Parameter nicht übergeben wird, werden standardmäßig die Positionsdaten aller Symbole im Dimensionsbereich des aktuellen Handelspaares und des Vertragscodes angefordert.
Symbol falsche String
/*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;
}
Verwenden Sie Futures-Börsenobjekte, um Marktaufträge für mehrere verschiedene Handelspare und Vertragscodes zu platzieren.
Kryptowährungs-Futures-Kontrakte unterscheiden sich von Kryptowährungs-Spot-Kontrakten, die nur das logische Konzept einer Position haben.Handelspaare, VertragskodeBitte beachten Sie die Funktionen {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}.
In derGetPositionsFunktion, werden die Anwendungsszenarien des Symbolparameters wie folgt zusammengefasst:
| Klassifizierung von Exchange-Objekten | Symbol Parameter | Umfang der Abfrage | Anmerkung |
|---|---|---|---|
| Futures | Symbolparameter nicht übergeben | Abfrage aller Handelsprodukte innerhalb des aktuellen Handelspaares und des Dimensionsabstands des Vertragscodes | Wenn das aktuelle Handelspaar BTC_USDT ist und der Vertragscode Swap ist, werden alle USDT-basierten Perpetual Contracts abgefragt.GetPositions("USDT.swap") |
| Futures | Angabe des Handelsprodukts, der Symbolparameter lautet: |
Abfrage des USDT-basierten Dauerkontrakts eines bestimmten BTC | Für Futures-Börsenobjekte ist das Format des Parameter-Symbols:HandelspaarundVertragskodedurch die FMZ-Plattform definiert, getrennt durch die Zeichen".. |
| Futures | Angabe des Handelssortiments, der Symbolparameter lautet: |
Abfrage aller USDT-basierten Daueraufträge | - |
| Futures-Börsen, die Optionen unterstützen | Symbolparameter nicht übergeben | Abfrage aller Optionskontrakte innerhalb des aktuellen Dimensionsbereichs des Handelspares | Wenn das aktuelle Handelspaar BTC_USDT ist, wird der Vertrag auf einen Optionsvertrag festgelegt, z. B. Binance-Optionvertrag: BTC-240108-40000-C |
| Futures-Börsen, die Optionen unterstützen | Spezifische Handelsprodukte angeben | Abfrage des angegebenen Optionskontrakts | Für die Binance Futures Exchange beispielsweise ist der Symbolparameter: BTC_USDT.BTC-240108-40000-C |
| Futures-Börsen, die Optionen unterstützen | Angabe des Handelssortiments, der Symbolparameter lautet: |
Abfrage aller USDT-basierten Optionskontrakte | - |
In derGetPositionsFunktion, Objekt des Futures-Austauschs
Der Abfrage-Dimensionsbereich wird wie folgt zusammengefasst:
| Symbol Parameter | Definition des Antragsumfangs | Anmerkung |
|---|---|---|
| USDT.swap | USDT-basierte Dauervertragsspanne. | Für |
Abmessungen, die von der Exchange-API-Schnittstelle nicht unterstützt werden, Ein Fehler wird gemeldet und ein Nullwert wird zurückgegeben, wenn Sie ruft.
♫ USDT.Futures ♫ ♫ USDT-basierte Liefervertragsspanne ♫ ♫ USDT-basierte Liefervertragsspanne ♫
USD.Swap. Umfang der währungsbasierten Verträge.
♫ USD.Futures ♫ ♫ Umfang der auf Währung basierenden Lieferung ♫ Verträge.
USDT.Option. USDT-basierte Optionskontrakt-Bereich.
USD.Option. Währungsbasierte Optionskontrakt-Range.
USDT.Futures_Combo. Eine Reihe von CFD-Kombinationen. Futures_Deribit-Börse
USD.Futures_ff. Umfang von Margin-Lieferverträgen. Die Futures_Kraken Exchange.
USD.Swap_pf. Gemischte Margin-Perpetual-Kontrakt-Bereich. Die Futures_Kraken Exchange.
Kompatibelexchange.GetPosition()Anrufen,GetPositionist genau das gleiche wieGetPositions.
Wenn das durch den Austauschgegenstand dargestellte Kontoexchangehat keine Positionen in derAbfragebereichoderbestimmte Handelsinstrumente, dieexchange.GetPositions()Funktion gibt ein leeres Array zurück, zum Beispiel:[].
{@struct/Position Position}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}
Dieexchange.SetMarginLevel()Die Funktion wird verwendet, um den Hebelwert des von dersymbolKompatibel mit nur dem Übergeben des ParametersmarginLevelum den Hebelwert des aktuellen Handelspares oder des aktuellen Handelsvertrags des Austauschobjekts {@var/EXCHANGE exchange} festzulegen.
Die Angabe des MarginLevel (Symbol, MarginLevel) wird durch die Angabe des MarginLevel (MarginLevel) erfolgen. Wechselkurs.MarginLevel (MarginLevel) festlegen
DiesymbolDer Parameter wird verwendet, um das Handelspaar oder den Vertrag anzugeben, für den der Hebelwert angepasst werden muss.symbolParameter derSetMarginLevel()Die Funktion ist mit dem Format dersymbolParameter derGetTicker()Funktion.
Symbol
falsche
String
DiemarginLevelDer Parameter wird verwendet, um den Hebelwert festzulegen, der normalerweise eine ganze Zahl für Börsen ist, und unterstützt auch die Einstellung von Schwellenwertwerten für einige Börsen.
MarginEbene
- Das stimmt.
Zahl
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);
}
Dieexchange.SetMarginLevel()Das Backtesting-System unterstützt die Anrufung der Kryptowährungs-Futures-Kontrakt-Austauschobjekte.exchange.SetMarginLevel()Funktion zur Festlegung des Hebelwerts.
Für Kryptowährungs-Futures-Kontrakte ist der Hebelmechanismus aufgrund der Kryptowährungs-Futures-Kontraktbörsen nicht einheitlich.exchange.SetMarginLevel()Die Funktion erzeugt keine Netzwerkanfrage, sondern setzt lediglich die Hebelwirkung in das zugrunde liegende FMZ-System (verwendet zur Übermittlung von Parametern in der Auftragsplatzierungsoberfläche). Der Hebelwert von einigen Börsen-Futures-Kontrakten ist eine Einstellung der Börse, die auf der Webseite der Börse oder über die API-Oberfläche festgelegt werden muss.exchange.SetMarginLevel()Die Funktion wird eine Netzwerkanfrage generieren und kann den Hebel nicht setzen. Dafür können viele Gründe bestehen, zum Beispiel: Es gibt eine aktuelle Position oder eine ausstehende Order, die es unmöglich macht, einen neuen Hebelwert für dieses Handelspaar oder -kontrakt festzulegen.
Die Ausgabe vonexchange.SetMarginLevel()Funktion:
| Funktionsname | Nicht unterstützte Spotbörsen | Nicht abgesicherte Futures-Börsen |
|---|---|---|
| Margin-Level festlegen | – | Futures_dYdX / Futures_Deribit |
{@var/EXCHANGE-Austausch}
Dieexchange.SetDirection()Diese Funktion wird verwendet, um die Auftragsrichtung der Funktion {@fun/Trade/exchange.Buy exchange.Buy}, der Funktion {@fun/Trade/exchange.Sell exchange.Sell} beim Auftragen von Futures-Kontrakten festzulegen.
Wechsel.SetDirection (Richtung)
DiedirectionDer Parameter wird verwendet, um die Richtung des Futures-Kontrakts bei der Auftragserteilung festzulegen."buy", "closesell", "sell", "closebuy"- Ich weiß.
Richtung
wahr
String
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);
}
Dieexchange.SetDirection()Die Funktion stellt die Korrespondenz zwischen der Richtung des Futures-Kontraktgeschäfts und der Auftragsvergabefunktion fest:
| Auftragsvergabefunktionen | Die von den Parametern der Funktion SetDirection festgelegte Richtung | Anmerkungen |
|---|---|---|
| exchange.Buy | Kauf und Eröffnung von Long-Positionen | |
| exchange.Buy | Kauf und Schließung von Leerpositionen | |
| exchange.Sell | Verkauf und Eröffnung von Leerpositionen | |
| exchange.Sell | Verkauf und Schließung von Longpositionen |
(Durchschnittliche Anzahl von Personen, die in einem Unternehmen tätig sind)
Dieexchange.SetContractType()Die Funktion wird verwendet, um den aktuellen Vertragscode des Exchange-Objekts {@var/EXCHANGE exchange} festzulegen.
Dieexchange.SetContractType()Funktion gibt eine Struktur zurück, die den gegenwärtigen Vertragskode entspricht.quarter, und die Rendite-Wertstruktur dieser Funktion ist:{"InstrumentID": "BTCUSD_230630", "instrument": "BTCUSD_230630"}- Ich weiß.
Gegenstand
Die Angabe der Angabe der Angabe der Angabe der Angabe des Antrags
DiesymbolDer Parameter wird verwendet, um den Auftragscode festzulegen, die optionalen Werte sind:"this_week", "next_week", "quarter", "next_quarter", "swap", usw.
Futures-Kontrakte für KryptowährungenLiefervertragdie Codes, sofern nicht spezifiziert, haben im Allgemeinen folgende Merkmale:
this_week: der Vertrag der laufenden Woche.next_weekDer Vertrag für die nächste Woche.quarter: vierteljährlicher Vertrag.next_quarter: der nächste vierteljährliche Vertrag.DauerverträgeCodes in Kryptowährungs-Futures-Kontrakten, sofern nicht angegeben, haben in der Regel:swap: Vertrag auf Dauer.Symbol wahr String
function main() {
// Set to this week contract
exchange.SetContractType("this_week")
}
def main():
exchange.SetContractType("this_week")
void main() {
exchange.SetContractType("this_week");
}
Setzen Sie den aktuellen Vertrag als den aktuellen Wochenvertrag:
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());
}
Bei Vertragsabschluss mitUSDTals Margin müssen Sie das Handelspaar im Code wechseln (Sie können das Handelspaar auch direkt beim Hinzufügen des Tauschobjekts festlegen):
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);
}
Drucken Sie den zurückgegebenen Wert derexchange.SetContractType()Funktion:
In der Kryptowährungs-Futures-Kontrakt-Strategie, nehmen Sie ein Beispiel der Umstellung auf dieBTC_USDTHandelspaar: Bei Wechseln von Handelspaaren unter Verwendung derexchange.SetCurrency("BTC_USDT")oderexchange.IO("currency", "BTC_USDT")Funktionen, nach dem Wechseln, müssen Sie dieexchange.SetContractType()Das System bestimmt, ob es sich um einenWährungsstandardvertragoder aUSDT-StandardvertragWenn ein Handelspaar beispielsweise aufBTC_USDT, verwendenexchange.SetContractType("swap")Funktion, um den Vertragskode aufswap. An dieser Stelle ist es aufBTCfür dieUSDT-StandardWenn das HandelspaarBTC_USD, verwendenexchange.SetContractType("swap")Funktion, um den Vertragskode aufswap. An dieser Stelle ist es aufBTCDas ist...Währungsstandard- Ein Vertrag auf Dauer.
Einzelheiten der unterstützten Kryptowährungs-Futures-Kontraktbörsen mit den folgenden Vertragsnamen:
Futures_OKCoin (OKX)
Auf dauerhafte Verträge:exchange.SetContractType("swap")Der Vertrag dieser Woche lautet:exchange.SetContractType("this_week")Auf den Vertrag für nächste Woche:exchange.SetContractType("next_week")Auf monatlichen Vertrag festgelegt:exchange.SetContractType("month")Auf den nächsten Monat:exchange.SetContractType("next_month")Auf vierteljährliche Verträge:exchange.SetContractType("quarter")Für das nächste Quartal:exchange.SetContractType("next_quarter")
OKX verfügt über Pre-Market-Handelskontrakte: Das Lieferdatum des Vertrags ist festgesetzt.HMSTR-USDT-250207. Das Handelspaar aufHMSTR_USDTauf der FMZ-Plattform und dannexchange.SetContractType("HMSTR-USDT-250207")um den Vertrag zu verfassen.
Für Funktionen, die diesymbolParameter wie:exchange.GetTicker(), exchange.CreateOrder()Sie können diesymbolParameter wie:HMSTR_USDT.HMSTR-USDT-250207die Marktdaten dieses Auftrags zu erhalten oder einen Auftrag zu erteilen.
Futures_HuobiDM (Futures für Huobi)
Der Vertrag dieser Woche lautet:exchange.SetContractType("this_week")- Ich weiß.
Auf den Vertrag für nächste Woche:exchange.SetContractType("next_week")- Ich weiß.
Auf vierteljährliche Verträge:exchange.SetContractType("quarter")- Ich weiß.
Für das nächste Quartal:exchange.SetContractType("next_quarter")- Ich weiß.
Auf dauerhafte Verträge:exchange.SetContractType("swap")- Ich weiß.
Es unterstützt Verträge mitUSDTals Marge, nehmenBTCVertrag als Beispiel:exchange.IO("currency", "BTC_USDT")Um zu einem Vertrag zu wechseln, derUSDTals Marge.
Oder das aktuelle Handelspaar aufBTC_USDTNach dem Wechseln von Handelsparen müssen Sie die Anrufe vonexchange.SetContractType()Funktion wieder, um den Vertrag festzulegen.
Futures_BitMEX (BitMEX)
Auf dauerhafte Verträge:exchange.SetContractType("swap")- Ich weiß.
Futures_BitMEX-Börsenlieferverträge sind monatliche Verträge mit folgenden Vertragscodes (von Januar bis Dezember):
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
Erstellung von Lieferverträgen:exchange.SetContractType("December"). Zum Beispiel, wenn das Handelspar aufXBT_USDT, dieexchange.SetContractType("December")Die Funktion wird aufgerufen, den Vertrag für die Lieferung im Dezember in USDT auf Basis von BTC festzulegen (entsprechend dem tatsächlichen Vertragskode vonXBTUSDTZ23).
Futures_BitMEX-Kontraktinformationszusammenfassung
| Der von Futures_BitMEX definierte Vertragscode | Das entsprechende Handelspaar in FMZ | Entsprechender Vertragskode in FMZ | Anmerkung |
|---|---|---|---|
| Hunde | Der Wert des Zinses ist zu messen. | Swap | USD lautet, XBT abgewickelt. |
| Hundefleisch | Der Name des Herstellers | Swap | In USDT lautet, in USDT abgewickelt. |
| XBTETH | XBT_ETH | Swap | ETH lautet, XBT abgewickelt. |
| XBTEUR | XBT_EUR | Swap | In EUR lautet und in XBT abgewickelt. |
| USDTUSDC | USDT_USDC | Swap | USDC lautet, XBT abgewickelt. |
| ETHUSD_ETH | ETH_USD_ETH | Swap | USD lautet, ETH abgewickelt. |
| XBTH24 | XBT_USD | März | Verfallsdatum: 24. März, Monatscode: H; in USD lautet, XBT abgewickelt. |
| ETHUSDZ23 | ETH_USD | Dezember | Verfallsdatum: 23. Dezember Monatscode: Z; in USD lautet, XBT abgewickelt. |
| XBTUSDTZ23 | XBT_USDT | Dezember | Ablaufdatum: 23. Dezember Monatscode: Z ; in USDT lautet, in USDT abgewickelt. |
| ADAZ23 | ADA_XBT | Dezember | Ablaufdatum: 23. Dezember, Monatscode ist: Z ; Abrechnung in XBT, Abrechnung in XBT. |
| P_XBTETFX23 | USDT_XXX | P_XBTETFX23 | Verjährung: 23.11.23; ausgedrückt in Prozent und in USDT abgewickelt. |
Futures_GateIO
Der Vertrag dieser Woche lautet:exchange.SetContractType("this_week")- Ich weiß.
Auf den Vertrag für nächste Woche:exchange.SetContractType("next_week")- Ich weiß.
Auf vierteljährliche Verträge:exchange.SetContractType("quarter")- Ich weiß.
Für das nächste Quartal:exchange.SetContractType("next_quarter")- Ich weiß.
Auf dauerhafte Verträge:exchange.SetContractType("swap")- Ich weiß.
Es unterstützt Verträge mitUSDTals Marge, nehmenBTCVertrag als Beispiel:exchange.IO("currency", "BTC_USDT")Um zu einem Vertrag zu wechseln, derUSDTals Marge.
Oder das aktuelle Handelspaar aufBTC_USDTNach dem Wechseln von Handelsparen müssen Sie die Anrufe vonexchange.SetContractType()Funktion wieder, um den Vertrag festzulegen.
Futures_Deribit
Auf dauerhafte Verträge:exchange.SetContractType("swap")- Ich weiß.
Es unterstützt DeribitUSDCVertrag.
Die Lieferverträge sind:"this_week", "next_week", "month", "quarter", "next_quarter", "third_quarter", "fourth_quarter"- Ich weiß.
Die Risikopositionen werden in der folgenden Tabelle aufgeführt:"this_week,swap", "next_week,swap", "next_quarter,this_week", "third_quarter,this_week", "month,next_week", gibt es viele Kombinationen.
Für Optionsverträge müssen Sie den von der Börse definierten spezifischen Optionsvertragscode eingeben. Weitere Informationen finden Sie auf der Website von Deribit.
Futures_KuCoin
Wenn beispielsweise das Handelspar aufBTC_USDund der Vertragscode festgelegt ist, handelt es sich um einen Währungsvertrag:
Auf dauerhafte Verträge:exchange.SetContractType("swap")- Ich weiß.
Auf vierteljährliche Verträge:exchange.SetContractType("quarter")- Ich weiß.
Für das nächste Quartal:exchange.SetContractType("next_quarter").
USDT als Margin-Vertrag:
Wenn beispielsweise das Handelspar aufBTC_USDTEs handelt sich um einen Vertrag mit USDT als Margin.
Auf dauerhafte Verträge:exchange.SetContractType("swap").
Futures_Binance
Binance Futures Exchange Standardbedingungen für den Dauervertrag des aktuellen Handelspares, Vertragskode:swap- Ich weiß.
Auf dauerhafte Verträge:exchange.SetContractType("swap"), die dauerhaften Verträge von Binance haben Verträge, die verwendenUSDTZum Beispiel:USDTStandard-Perpetuum-Vertrag vonBTCkann als Margin-Kontrakt verwendet werden, und das Handelspaar ist aufBTC_USDTBinance unterstützt z.B. auch dauerhafte Verträge, bei denen Münzen als Marge verwendet werden.BTCBinance's Standard-Perpetual-Kontrakt, mit dem Handelspaar aufBTC_USD- Ich weiß.
Auf vierteljährliche Verträge:exchange.SetContractType("quarter"), der Liefervertrag hat einen Währungsstandardvertrag (d. h. mit Währungen als Marge), z. B.BTCDer Quartalsvertrag des Handelspaares ist auf:BTC_USDund dann den Vertrag festlegenexchange.SetContractType("quarter"), ist aufBTCvierteljährlicher Vertrag mit einem Währungsstandardvertrag.
Für das nächste Quartal:exchange.SetContractType("next_quarter"), zum Beispiel,BTCdes vierteljährlichen Währungsstandardkontrakts wird das Handelspaar auf:BTC_USD, und dann den Vertrag festlegenexchange.SetContractType("next_quarter")- Ich weiß.
Binance unterstützt teilweiseUSDTals Margin-Liefervertrag, nehmenBTCzum Beispiel ein Handelspaar aufBTC_USDT, dann setzen Sie den Vertragskode.
Unterstützung für Binance-Optionskontrakte:
Das Format des Optionsvertragscodes basiert auf dem von der Börse definierten Optionsvertragscode:BTC-241227-15000-C, XRP-240112-0.5-C, BTC-241227-15000-PNehmen Sie den Binance-Option-Kontraktcode.BTC-241227-15000-Pzum Beispiel: BTC ist die Optionswährungskode, 241227 ist das Ausübungsdatum, 15000 ist der Ausübungspreis, P eine Put-Option und C eine Call-Option.
Für Einzelheiten über die Optionsart, ob es sich um eine europäische Option oder eine amerikanische Option handelt, lesen Sie bitte die einschlägigen Informationen des Optionsvertrags der Börse.
Die Börse kann Optionsverkäufer einschränken und verlangen, dass sie sich separat für Qualifikationen bewerben.
Futures_Bibox
Vertragskode für Bibox-Perpetualverträge:swap- Ich weiß.
Auf dauerhafte Verträge:exchange.SetContractType("swap").
Futures_Bybit
Der Standard ist der dauerhafte Vertrag für das aktuelle Handelspaar, Vertragskode:swap- Ich weiß.
Der Vertragskode für diese Woche:this_week- Ich weiß.
Der Vertragskode der nächsten Woche:next_week- Ich weiß.
Vertragskode für die dritte Woche:third_week- Ich weiß.
Monatlicher Vertragskode:month- Ich weiß.
Vertragskode für den nächsten Monat:next_month- Ich weiß.
Quartalsvertragskode:quarter- Ich weiß.
Vertragskode für das nächste Quartal:next_quarter- Ich weiß.
Vertragskode für das dritte Quartal:third_quarter.
Futures_Kraken
Der Standard ist der Dauervertrag des aktuellen Handelspaares, Vertragskode:swap.
swap: Vertrag auf Dauer.month: Vertrag für den laufenden Monat.quarter: vierteljährlicher Vertrag.next_quarterDer nächste Quartalsvertrag.swap_pf: Mixt Margin-Perpetual-Vertrag.quarter_ff: Vierteljährlicher Vertrag mit gemischter Marge.month_ff: Vertrag mit gemischter Marge für den laufenden Monat.next_quarter_ff: Gemischte Marge nächstes Quartal Vertrag.
Futures_Bitfinex
Der Standardwert ist der für das aktuelle Handelspaar festgelegte Dauervertrag, Vertragskode:swap.
Futures_Bitget
Der Standardwert ist der für das aktuelle Handelspaar festgelegte Dauervertrag, Vertragskode:swap- Ich weiß.
Das Handelspaar ist aufBTC_USDfür Währungsstandardverträge und das Handelspar ist aufBTC_USDTfür Verträge, die vonUSDT. Demo-Kontrakte können mit Handelsparen wieSBTC_USD, BTC_SUSDT.
Futures_dYdX
Vertragskode für dYdX-Perpetual Contracts:swap- Ich weiß.
Auf dauerhafte Verträge:exchange.SetContractType("swap"), dYdX verfügt nur über USDT-Standardverträge.
Futures_MEXC
Vertragskode für MEXC-Perpetuity-Verträge:swap- Ich weiß.
Auf dauerhafte Verträge:exchange.SetContractType("swap"). Das Handelspaar aufBTC_USD, der ein Währungsstandardvertrag ist, und das Handelspaar aufBTC_USDT, wasUSDT- Vertrag vereinbart.
Futures_Crypto
Token auf einem Konto auf dercrypto.comDer Wert der Margin kann in USD-Derivate umgerechnet werden, die als Margin für den Handel mit Verträgen verwendet werden.
Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("swap"). Beispiel für die Anrufung derexchange.SetContractType("swap")Funktion zur Festlegung eines Dauerkontrakts für BTC, wenn das Handelspaar aufBTC_USD- Ich weiß.
Diecrypto.comWechsellieferverträge sind monatliche Verträge mit folgenden Vertragscodes (von Januar bis Dezember):
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
Festlegen des Liefervertrags:exchange.SetContractType("October"). Zum Beispiel, wenn das Handelspar aufBTC_USD, rufen Sie die Funktionexchange.SetContractType("October")Der Vertrag über die Lieferung von BTC im Oktober.
Der entsprechende Auftragscode lautet derzeit:BTCUSD-231027.
Futures_WOO
Futures_WOO-BörsenunterstützungUSDTdie in den Verträgen mit einem dauerhaften Vertragskodexswap. Zum Beispiel, wenn das Handelspar aufBTC_USDT, die Funktionexchange.SetContractType("swap")Der derzeitige Vertrag soll ein USDT-basierter Dauervertrag für BTC sein.
{@fun/Futures/exchange.GetContractType exchange.GetContractType}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}
Dieexchange.GetContractType()Die Funktion wird verwendet, um den Vertragskode für die aktuelle Einstellung des Exchange-Objekts {@var/EXCHANGE exchange} zu erhalten.
Dieexchange.GetContractType()Funktion gibt den vom FMZ-Plattform definierten Vertragskode zurück, z. B.:this_week, swap, usw.
String
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}
Dieexchange.GetFundings()Diese Funktion wird verwendet, um die Finanzierungsraten für den laufenden Zeitraum zu ermitteln.
Dieexchange.GetFundings()Funktion gibt ein Array von {@struct/Funding Funding} Strukturen zurück, wenn die Datenanfrage erfolgreich ist, und gibt einen Nullwert zurück, wenn die Datenanfrage fehlschlägt.
{@struct/Funding Funding}-Array, Nullwert
Auswechselung.GetFundings Ausgleichszahlungen (Symbol)
Der Parametersymbolwird verwendet, um dieTransaktionssymboloderTransaktionssymbolbereichDie Kommission ist der Auffassung, daß diesymbolWenn der Parameter nicht übergeben wird, werden standardmäßig die aktuellen Finanzierungsquoten aller Instrumente im Dimensionsbereich des aktuellen Handelspaares und des Kontraktcodes angefordert.
Symbol falsche String
/*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() + "`");
}
Verwenden Sie das Futures Exchange Objekt, um dieexchange.GetFundings()Vor dem Aufruf einer Marktfunktion gibt GetFundings nur die Finanzierungsdaten des aktuellen Standard-Handelspaares zurück. Nach dem Aufruf der Marktfunktion gibt es die Finanzierungsdaten aller angeforderten Varianten zurück. Sie können sich auf das folgende Testbeispiel beziehen:
Für Futures-Börsen, die keine Chargenanfragen von Finanzierungsraten unterstützen, wenn diesymbolParameter wird als Abfragebereich angegeben, z. B.:USDT.swapoder dersymbolWenn der Parameter nicht übergeben wird, wird die Schnittstelle einen Fehler melden.GetFundings()Funktion mit dieser Art von Futures Exchange Objekt, müssen Sie diesymbolParameter als spezifische Dauervertragsart, um die aktuellen Finanzierungsquoten des Typs abzufragen.
Dieexchange.GetFundings()Die Funktion unterstützt echte Handels- und Backtesting-Systeme.
Börsen, die keine Chargenakquisition von Finanzierungsraten unterstützen: Futures_Bitget, Futures_OKX, Futures_MEXC, Futures_Deribit, Futures_Crypto.symbolParameter mit dem spezifischen Symbolcode, beispielsweise:ETH_USDT.swap.
Dieexchange.GetFundings()Funktion:
| Funktionsname | Nicht unterstützte Spotbörsen | Nicht abgesicherte Futures-Börsen |
|---|---|---|
| GetFundings | – | Futures_DigiFinex |
- Das ist nicht wahr.
Dieexchange.SetBase()Die Funktion wird verwendet, um die Basisadresse der in dem Exchange-Objekt {@var/EXCHANGE exchange} konfigurierten Exchange-API-Schnittstelle festzulegen.
Auswechselung.SetBase (s)
DiesDer Parameter wird verwendet, um die Basisadresse der Exchange-API-Schnittstelle anzugeben.
s
wahr
String
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());
}
Das Umschalten der Exchange-API-Basisadresse wird im Backtesting-System nicht unterstützt, da das Backtesting-System eine Sandbox-Simulationsumgebung ist und nicht wirklich auf die Exchange-API-Schnittstelle zugreift.
{@fun/Trade/exchange.IO exchange.IO}
Dieexchange.GetBase()Funktion wird verwendet, um die aktuelle Exchange API-Interface-Basisadresse zu erhalten.
Die aktuelle Basisadresse der Exchange-API-Schnittstelle. String
- Ich bin nicht sicher.
function main() {
Log(exchange.GetBase())
}
def main():
Log(exchange.GetBase())
void main() {
Log(exchange.GetBase());
}
- Ich bin nicht derjenige.
Dieexchange.SetProxy()Die Funktion wird verwendet, um die Proxy-Konfiguration des Austauschobjekts {@var/EXCHANGE exchange} festzulegen.
- Das ist nicht der Fall.
DieproxyParameter wird verwendet, um die Proxy-Konfiguration anzugeben.
Stellvertreter
wahr
String
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());
}
Konfigurieren Sie das Exchange-Objekt {@var/EXCHANGE exchange}socks5Stellvertreter
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();
}
Zusätzlich zuallgemeine SpezifikationDie IP-Adresse des Antrags des Exchange-Objekts {@var/EXCHANGE exchange} wird auch unterstützt, wenn eine IP-Adresse basierend auf {@var/EXCHANGE exchange} angegeben wird:
Wenn die Proxy-Einstellung fehlschlägt,exchange.SetProxy()Funktion wird null zurückgeben, wenn sie aufgerufen wird.exchange.SetProxy()Funktion setzt den Proxy für dierestEin Proxy kann für jedes {@var/EXCHANGE exchange} Exchange-Objekt eingestellt werden, und der Zugriff auf die Exchange-Schnittstelle, die an das {@var/EXCHANGE exchange} Exchange-Objekt gebunden ist, wird nach Einstellung des Proxys über den Proxy erreicht.
Unterstützung der Einstellungsocks5Proxy, wobei das erste Exchange-Objekt {@var/EXCHANGE exchange} hinzugefügt wird, d. h.:exchanges[0]Zum Beispiel:
exchange.SetProxy("socks5://127.0.0.1:8889").exchange.SetProxy("socks5://username:password@127.0.0.1:8889"). usernameist der Benutzername undpasswordist das Passwort.exchange.SetProxy("").Unterstützt die Festlegung der IP-Adresse der Anfrage vom Exchange-Objekt {@var/EXCHANGE exchange},allgemein spezifiziert.
{@var/EXCHANGE-Austausch}
Dieexchange.SetTimeout()Funktion wird verwendet, um den Timeout derrestAnforderung für das Exchange-Objekt {@var/EXCHANGE exchange}.
Wechsel.SetTimeout (Zeitrahmen)
DietimeoutDer Parameter wird verwendet, um die Anzahl der Millisekunden für die Timeout-Einstellung anzugeben.
Zeitverzögerung
- Das stimmt.
Zahl
function main() {
exchange.SetTimeout(3000)
Log(exchange.GetTicker())
}
def main():
exchange.SetTimeout(3000)
Log(exchange.GetTicker())
void main() {
exchange.SetTimeout(3000);
Log(exchange.GetTicker());
}
Der Parametertimeoutist ein Millisekundenwert, 1000 Millisekunden sind gleich 1 Sekunde.restNur Protokoll, verwendet, um die Zeit aufrestSie wird nur einmal eingestellt, um wirksam zu werden.exchange.SetTimeout(3000), setzt dierestAnfordern Sie eine Auszeit für dieexchangeFunktionen mit Netzwerkanfragen wieexchange.GetTicker()Funktionsanrufe, die nicht mehr als 3 Sekunden lang eine Antwort erhalten, werden auslaufen, und Funktionsanrufe, die auslaufen, geben Nullwerte zurück.SetTimeout()ist keine globale Funktion, sondern eine Methode des Austauschobjekts {@var/EXCHANGE exchange}.
{@var/EXCHANGE-Austausch}
Die FMZ Quant Trading Plattform unterstützt wirklich die Mehrthread-Funktion derJavaScriptDas System setzt eine Sprachstrategie von Grund auf ein und verfolgt folgende Ziele:
| Gegenstände | Anweisungen | Anmerkungen |
|---|---|---|
| Schleiffaden | Mehrthreadedes globales Objekt | Funktionen der Mitglieder:Thread, getThread, mainThread, usw. |
| Faden | Thread-Objekt | Funktionen der Mitglieder:peekMessage, postMessage, join, usw. |
| ThreadLock | Thread-Sperrobjekt | Funktionen der Mitglieder:acquire, release. Sie können als Parameter der Thread-Ausführungsfunktion in die Thread-Umgebung übergeben werden. |
| ThreadEvent | Ereignisobjekt | Funktionen der Mitglieder:set, clear, wait, isSet. Sie können als Parameter der Thread-Ausführungsfunktion in die Thread-Umgebung übergeben werden. |
| ThreadBedingung | Objekt der Bedingung | Funktionen der Mitglieder:notify, notifyAll, wait, acquire, release. Sie können als Parameter der Thread-Ausführungsfunktion in die Thread-Umgebung übergeben werden. |
| ThreadDict | Wörterbuchobjekt | Funktionen der Mitglieder:get, set. Sie können als Parameter der Thread-Ausführungsfunktion in die Thread-Umgebung übergeben werden. |
DiethreadingObject ist ein globales Multithreading-Management-Tool, das Funktionen wie das Erstellen von gleichzeitigen Threads, Thread-Locks und Condition-Objekten bietet.threadingObjekt. Dieses Objekt wird nur von derJavaScriptSprachstrategie.
DieThread()Funktion wird verwendet, um gleichzeitige Threads zu erstellen.
DieThread()Funktion gibt a zurückThreadObjekt, mit dem gleichzeitige Threads verwaltet werden, Threads kommunizieren usw.
ThreadGegenstand
Thread ((func,...args) Der Begriff "Thread" (Artikel)
Der Parameterfuncist eine Funktion zur gleichzeitigen Ausführung (übergeben durch Referenz) und unterstützt die Übergabe anonymer Funktionen.funckann mehrere Parameter akzeptieren, die durch...argsDaher wird die Parameterliste vonfuncdie in der Richtlinie...args.
Funktion
wahr
Funktion
Der Parameterargist der tatsächliche Parameter, der anfunc(d. h. die Funktion zur gleichzeitigen Ausführung von Threads), wenn der Rückruf ausgeführt wird; es kann mehrere Parameter gebenarg, und die Parameterliste derfuncdie in der Richtlinie...args.
Arg
falsche
String, Zahl, bool, Objekt, Array, Funktion, Nullwert und andere vom System unterstützte Typen
Der Parameteritemist ein Array, das die gleichzeitig auszuführenden Funktionsreferenzen und deren Parameter enthält.itemParameter können bei Aufruf derThread function.
Artikel wahr Reihenfolge
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()
}
Erstellen Sie gleichzeitige Threads für eine benutzerdefinierte Funktion und eine anonyme Funktion.
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()
}
VerwendenThread(...items)Form, um gleichzeitige Threads zu erstellen und mehrere Funktionen sequenziell auszuführen.
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)
}
Es unterstützt die Übergabe von Funktionsfolgen und kann dynamisch externe Bibliotheken für gleichzeitiges Rechnen importieren.
Die Fädenfunktionfuncin dieThread()Die Funktion für die gleichzeitige Ausführung läuft in einer isolierten Umgebung, so dass Variablen außerhalb des Threads nicht direkt referenziert werden können, und die Kompilierung wird beim Referenzieren fehlschlagen. Gleichzeitig werden Referenzen zu anderen Closure-Funktionen nicht innerhalb des Threads unterstützt. Alle von der Plattform bereitgestellten APIs können innerhalb des Threads aufgerufen werden, aber andere benutzerdefinierte Funktionen können nicht aufgerufen werden.
Es unterstützt Backtesting-System und Live-Trading-Umgebung. Alle gleichzeitigen Thread-bezogenen Funktionen werden nur als Code-Kompatibilität im Backtesting-System unterstützt und werden nicht tatsächlich von gleichzeitigen Threads ausgeführt, so dass sie in diesem Kapitel nicht wiederholt werden.
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/threads/threading/condition Condition}, {@fun/threads/threading/event Event}, {@fun/threads/threading/Dict Dict}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/eventLoop event}
DiegetThread()Die Funktion wird verwendet, um das Thread-Objekt basierend auf der angegebenen Thread-ID zu erhalten.
DiegetThread()Funktion gibt dieThreadObjekt mit der durch den Parameter angegebenen ThreadId
ThreadGegenstand
getThread (ThreadId)
Der ParameterthreadIdist die Thread-Objekt-ID. Erhalten Sie das entsprechende Thread-Objekt, indem Sie den Parameter angeben.
Schleifen wahr Zahl
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())
}
Das angegebene Thread-Objekt durchlaufenthreadId.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
Wenn der Thread, den Sie erhalten möchten, ausgeführt und freigegeben wurde, können Sie nicht verwendenthreading.getThread(threadId)um das Gewindeobjekt des Gewindes zu erhalten.
{@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/event Loop}, {@fun/threads/threads/threads/dict Dict}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/eventLoop}
DiemainThread()Die Funktion wird verwendet, um das Gewindeobjekt des Hauptgewindes zu erhalten, d. h. das Gewinde, bei dem diemain()die Funktion in der Strategie liegt.
DiemainThread()Funktion gibt das Thread-Objekt des Hauptthreads zurück.
ThreadGegenstand
Hauptthread (()
function main() {
Log("The threadId of the main thread:", threading.mainThread().id())
}
Holen Sie dieThreadObjekt des Hauptgurtes und Ausgang derthreadIdvon der Hauptschnur.
function test() {
Log("Output the main thread ID in the test function:", threading.mainThread().id())
}
function main() {
var t1 = threading.Thread(test)
t1.join()
}
Das Gewindeobjekt des Hauptgewindes kann auch in gleichzeitigen Gewinden gewonnen werden.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
{@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/pending pending}, {@fun/threads/threading/eventLoop eventLoop}
DiecurrentThread()Funktion wird verwendet, um das Thread-Objekt des aktuellen Threads zu erhalten.
DiecurrentThread()Funktion gibt das Thread-Objekt des aktuellen Threads zurück.
ThreadGegenstand
Der aktuelle Thread (((
function test() {
Log("Id of the current thread:", threading.currentThread().id())
}
function main() {
var t1 = threading.Thread(test)
t1.join()
}
Holen Sie dieThreadGegenstand des Stromdrehs und Ausgang derthreadIdDer aktuelle Faden.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
{@fun/Threads/Threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/condition condition}, {@fun/threads/threading/event event}, {@fun/threads/threading/event dictt}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/event Loop event Loop}, {@fun/threads/threading/event Loop}
DieLock()Die Funktion wird verwendet, um ein Thread-Lock-Objekt zu erstellen.
DieLock()Funktion gibt ein Threadlock-Objekt zurück.
ThreadLockGegenstand
Schließung
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()
}
Zwei gleichzeitige Threads greifen auf eine gemeinsame Ressource zu.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/threading/threadThread}, {@fun/threads/threading/condition Condition}, {@fun/threads/threading/event Event}, {@fun/threads/threading/threading/Dict Dict}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/eventLoop event}
DieCondition()Die Funktion wird verwendet, um ein Objekt der Bedingungsvariablen zu erstellen, das zur Synchronisierung und Kommunikation zwischen Threads in einer mehrthreadigen gleichzeitigen Umgebung verwendet wird.Condition(), kann ein Thread warten, wenn bestimmte Bedingungen nicht erfüllt sind, bis ein anderer Thread ihm mitteilt, dass die Bedingung erfüllt ist.
DieCondition()Funktion gibt a zurückThreadCondition object.
ThreadConditionGegenstand
Zustand
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()
}
Zwei gleichzeitige Threads greifen auf eine gemeinsame Ressource zu.
Das Backtesting-System implementiert diese Funktionalität nicht, es definiert sie nur.
{@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/threading/event Event}, {@fun/threads/threading/Dict Dict}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/eventLoop Loop}
DieEvent()Funktion wird verwendet, um eineThread-EreignisObjekt, das für die Synchronisierung zwischen Threads verwendet wird, sodass ein Thread auf eine Benachrichtigung oder ein Signal von einem anderen Thread warten kann.
DieEvent()Funktion gibt a zurückThreadEvent object.
ThreadEventGegenstand
Ereignis
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()
}
Zwei gleichzeitige Threads greifen auf eine gemeinsame Ressource zu.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
{@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/eventLoop eventop}
DieDict()Die Funktion wird verwendet, um ein Wörterbuchobjekt zu erstellen, das an gleichzeitige Threads übergeben wird.
DieDict()Funktion gibt a zurückThreadDict object.
ThreadDictGegenstand
Das ist ein Diktat.
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()
}
Übertragen eines normalen Objekts an die gleichzeitige Thread-Ausführungsfunktion, um zu testen, ob die Änderung des Schlüsselwerts des Objekts Änderungen des Schlüsselwerts des Objekts in anderen Threads bewirkt.
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()
}
Geben Sie mir dieThreadDictEin Objekt, das von derDict()Funktion an die gleichzeitige Thread-Ausführungsfunktion und prüfen, ob die Änderung des Schlüsselwerts des Objekts dazu führt, dass sich der Schlüsselwert des Objekts in anderen Threads ändert.
Wenn ein gemeinsames Objekt an eine gleichzeitige Thread-Funktion weitergegeben wird, wird es als Deep Copy weitergegeben.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/threads/threading/condition Condition}, {@fun/threads/threading/event Event}, {@fun/threads/threading/threading/thread Thread}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/eventLoop}
DiependingFunktion wird verwendet, um die Anzahl der gleichzeitigen Threads zu erhalten, die im aktuellen Strategieprogramm ausgeführt werden.
Diepending()Funktion gibt die Anzahl der gleichzeitigen Threads zurück, die das aktuelle Strategieprogramm ausführt.
Zahl
Ausstehend
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())
}
Erstellen Sie zwei gleichzeitig laufende Threads und rufen Sie diepending()Funktion in verschiedenen Zeitknoten.
Wenn die Strategiemain()Funktion beginnt zu laufen, ruft die Funktionpending()direkt 1 zurückgeben wird, weil der Haupt-Thread, wo die Strategiemain()Funktion ist auch ein ausstehender Thread.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/threads/threading/condition Condition}, {@fun/threads/threading/event Event}, {@fun/threads/threading/threading/Dict Dict}, {@fun/threads/threading/thread Thread}, {@fun/threads/threading/eventLoop}
ThreadObjekte können erstellt oder zurückgegeben werdenthreading.Thread(), threading.getThread(), threading.mainThread(), undthreading.currentThread().
DiepeekMessage()Funktion wird verwendet, um eine Nachricht von einem Thread zu erhalten.
DiepeekMessage()Funktion gibt die Nachricht zurück, die vom Thread empfangen wurde, der mit dem aktuellen Thread-Objekt verknüpft ist.
Zeichenfolge, Zahl, bool, Objekt, Array, Nullwert und andere vom System unterstützte Typen
Ein BlickMessage() Sieh nach Nachricht (Timeout)
Der Parametertimeoutist die Timeout-Einstellung. Sie blockiert und wartet auf die Anzahl der Millisekunden, die vom Parameter festgelegt werden, und gibt Daten zurück. Wenn keine Daten vorliegen und die Timeout-Einstellung das Limit überschreitet, wird ein Nullwert zurückgegeben.timeoutist auf 0 oder dietimeoutWenn die Daten des Kanals nicht übergeben werden, wird der Prozess blockiert und wartet, bis Daten aus dem Kanal empfangen werden.timeoutist auf -1 gesetzt, bedeutet dies, dass der Prozess Daten nicht sofort blockiert und zurückgibt.
Zeitverzögerung falsche Zahl
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()
}
Senden Sie Nachrichten an den Hauptthread von einem gleichzeitigen Thread.
Beim Schreiben von Programmen müssen wir auf Thread-Standstillstandsprobleme achten.
{@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/threads/Thread/name}, {@Threads/threads/eventLoop EventLoop}
DiepostMessage()Funktion wird verwendet, um eine Nachricht an einen Thread zu senden.
PostNachricht ((msg)
Der Parametermsgist die Botschaft, die gesendet wird.
Msg - Das stimmt. Jeder vom System unterstützte Typ, z. B. Zeichenfolge, Zahl, bool, Objekt, Array, Nullwert usw.
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()
}
Senden von Nachrichten in gleichzeitigen Threads und VerwendungeventLoop()um Benachrichtigungen über Nachrichten zu erhalten.
Wenn die Ausführungsfunktion eines Threads diepostMessage()Wir können die Funktion verwenden, um ein Signal oder Daten zu senden, ein Nachrichtenereignis wird auch generiert.eventLoop()Funktion zum Empfangen von Nachrichtenbenachrichtigungen.
{@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/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}
Diejoin()Funktion wird verwendet, um zu warten, bis der Thread aussteigt und die Systemressourcen zurückfordert.
DieThreadRetGegenstandenthält Daten über das Ausführungsergebnis. Zu den Eigenschaften gehören:
ThreadRetGegenstand
Ich bin ein Teil von dir. Teilnahme (Timeout)
DietimeoutDie Zeitdauer in Millisekunden für das Warten auf das Ende des Threads wird verwendet.timeoutParameter auf 0 oder dietimeoutParameter nicht eingestellt ist,join()Funktion wird blockieren und warten, bis der Thread ausführt.timeoutDer Parameter ist auf -1,join()Die Funktion wird sofort wiederhergestellt.
Zeitverzögerung falsche Zahl
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}
}
Test derjoin()Funktion für Timeout und Ausgabe des Rückgabewerts.
Diejoin()Funktionszeiten aus und zurückundefined.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}
Dieterminate()Funktion wird verwendet, um einen Thread zwangsweise zu beenden und die Hardware-Ressourcen freizugeben, die vom erstellten Thread verwendet werden.
beenden
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)
}
}
Die Ausführung eines Threads wird gewaltsam beendet. Nach dem gewaltsamen Beenden eines Threads gibt es keinen Ausgang aus diesem Thread im Protokoll.
Für Fäden, die gewaltsam durch dieterminate()Wir können nicht mehr diejoin()Funktion, um zu warten, bis sie beendet werden.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}
DiegetData()Diese Funktion wird verwendet, um auf Variablen zuzugreifen, die in der Thread-Umgebung aufgezeichnet sind.join()Funktion (Wartend auf erfolgreichen Ausgang) und hat dieterminate()Funktion (Zwangsschließung des Gurtes).
DiegetData()Funktion gibt den Schlüsselwert zurückkeyParameter im Schlüssel-Wert-Paar, das im aktuellen Thread-Kontext gespeichert ist.
Zeichenfolge, Zahl, bool, Objekt, Array, Nullwert und andere vom System unterstützte Typen
GetDaten (siehe unten) GetData (Schlüssel)
DiekeyParameter ist der Schlüsselname des gespeicherten Schlüssel-Wert-Paares.
Schlüssel wahr String
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()
}
Wert des Schlüssels erfassencountin der gleichzeitigen Thread-Umgebung, und dann lesen Sie den Schlüsselwert voncountin den Hauptgedanken.
{@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}
DiesetData()Funktion wird verwendet, um Variablen im Thread-Kontext zu speichern.
SetDaten (Schlüssel, Wert)
DiekeyParameter wird verwendet, um den Schlüsselnamen des gespeicherten Schlüssel-Wert-Paares anzugeben.
Schlüssel
wahr
String
DievalueParameter wird verwendet, um den Schlüsselwert des gespeicherten Schlüssel-Wert-Paares anzugeben.
Wert - Das stimmt. Jeder vom System unterstützte Typ, z. B. Zeichenfolge, Zahl, bool, Objekt, Array, Nullwert usw.
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Sleep(1000)
Log(`t1.getData("data"):`, t1.getData("data"))
t1.join()
}
Setzen Sie das Schlüssel-Wert-Paar im gleichzeitigen Thread und lesen Sie das Schlüssel-Wert-Paar im Hauptthread.
Die Daten sind gültig, wenn der Thread diejoin()Funktion (Wartend auf erfolgreichen Ausgang) und hat dieterminate()Funktion (Zwangsbeenden des Threads).valuemuss eine serialisierbare Variable sein.
{@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}, {@fun/Threads/Thread/eventLoop eventLoop}
Dieid()Funktion wird verwendet, um diethreadIdder aktuellen multithreaded Objektinstanz.
Der Rücklaufwert derid()Funktion istthreadId.
Zahl
Die Daten sind hier:
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Log(`t1.id():`, t1.id())
t1.join()
}
Erstellen Sie einen gleichzeitig laufenden Thread und geben Sie diethreadIdvon diesem gleichlaufenden Faden im Hauptfaden.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}
Diename()Funktion wird verwendet, um den Namen der aktuellen Multithreaded-Objektinstanz zurückzugeben.
Diename()Funktion gibt den gleichzeitigen Threadnamen zurück.
String
Name (n)
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Log(`t1.name():`, t1.name()) // t1.name(): Thread-1
t1.join()
}
Erstellen Sie einen gleichzeitigen Thread und geben Sie den Namen des gleichzeitigen Threads im Hauptthread aus.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/eventLoop eventLoop}
DieeventLoop()Die Funktion wird verwendet, um die vom Thread empfangenen Ereignisse anzuhören.
DieeventLoop()Funktion gibt die vom aktuellen Thread empfangenen Ereignisinformationen zurück. SieheVeranstaltungsinformationsstruktur.
Objekt, Nullwert
EventLoop ((() EventLoop (Zeitrahmen)
Der Parametertimeoutist die Timeout-Einstellung in Millisekunden.timeoutist auf 0 gesetzt, wartet es, bis ein Ereignis stattfindet, bevor es zurückkehrt. Wenn es größer als 0 ist, setzt es das Ereignis auf Wartezeit. Wenn es kleiner als 0 ist, gibt es sofort das letzte Ereignis zurück.
Zeitverzögerung falsche Zahl
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()
}
Führen Sie drei Threads gleichzeitig aus und geben Sie die empfangenen Ereignisinformationen aus.
Der Verarbeitungsmechanismus dereventLoop()Funktion ist die gleiche wie die globale FunktionEventLoop().
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}
Thread-Lock-Objekt, für die Synchronisierung von mehreren Threads verwendet.
Dieacquire()Die Funktion wird verwendet, um ein Threadlock (Schließen) anzufordern.
Erwerben
Siehethreading.Lock()Abschnitt für Beispiele.
Dieacquire()Wenn ein Thread die Funktion "Thread Lock" anruft, wird die Funktion "Thread Lock" verwendet.acquire()Wenn der Schloss nicht von einem anderen Thread gehalten wird, erhält der aufrufende Thread den Schloss erfolgreich und setzt die Ausführung fort. Wenn der Schloss bereits von einem anderen Thread gehalten wird, wird der aufrufende Threadacquire()wird blockiert, bis das Schloss freigegeben ist.
Ich habe eine Frage. Ich habe eine Frage.
Dierelease()Die Funktion wird verwendet, um ein Gewindeverriegelung (Entriegelung) zu lösen.
Freisetzung
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()
}
Prüfung von Stillstandsszenarien
Es ist zu beachten, dass eine unsachgemäße Verwendung von Fadenverschlüssen zu einer Sackgasse führen kann.
Ich bin nicht derjenige, der das Problem hat, aber ich bin derjenige, der es hat.
Ereignisobjekt, das für mehrstufige Ereignisbenachrichtigungen und -signale verwendet wird.
Dieset()Funktion wird verwendet, um Ereignisse zu benachrichtigen (Satzsignale).
Einheitlich
Siehethreading.Event()Abschnitt für Beispiele.
Wenn das Signal mitset()Wir müssen das Signal löschen und wieder einstellen.
{@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}
Dieclear()Die Funktion wird verwendet, um das Signal zu löschen.
Klar, klar.
Siehethreading.Event()Abschnitt für Beispiele.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}
Diewait()Die Funktion wird verwendet, um ein Ereignis (Signal) warten zu lassen, und wird blockiert, bevor das Ereignis (Signal) gesetzt wird. Sie unterstützt das Setzen eines Timeouts.
Diewait()Wenn dies der Fall ist, gibt es einen wahren Wert.
Boole
Warten Sie. Warten Sie.
DietimeoutDer Parameter wird verwendet, um die Wartezeit in Millisekunden festzulegen.
Zeitverzögerung falsche Zahl
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()
}
Testen Sie den Rückgabewert derwait() function.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/isSet isSet}
DieisSet()Funktion wird verwendet, um festzustellen, ob ein Ereignis (Signal) eingestellt wurde.
DieisSet()Funktion gibt zurück, ob das Ereignis (Signal) eingestellt wurde; wenn das Ereignis (Signal) eingestellt wurde, gibt sie einen wahren Wert zurück.
Boole
istSet()
Siehethreading.Event()Abschnitt für Beispiele.
Das ist eine sehr schwierige Sache.
Bedingungsgegenstand, für die Synchronisierung von mehreren Threads verwendet.
Dienotify()Funktion wird verwendet, um einen wartenden Thread (falls vorhanden) aufzuwecken.wait()Die Methode wird aufgewacht.
Anmeldung
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)
}
}
Verwendennotify()Funktion, um den wartenden Faden zu wecken.
Dienotify()Funktion weckt einen Thread in der Warteschlange.
Wenn dienotify()Wenn eine Funktion einen Thread weckt, erhält der Thread das Thread-Lock zurück.
{@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
DienotifyAll()Funktion weckt alle wartenden Threads auf.
Benachrichtigen Sie alle.
SieheThreadCondition.notify()Abschnitt für Beispiele.
DienotifyAll()Die Funktion weckt alle wartenden Threads einzeln auf, und die erwachten Threads erwerben das Threadlock wieder.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
Diewait()Die Funktion wird verwendet, um einen Faden unter bestimmten Bedingungen warten zu lassen.
Warten Sie.
SieheThreadCondition.notify()Abschnitt für Beispiele.
Diewait()Die Funktion entlässt die Schraube und erhält die Schraube wieder, wenn man aufwacht.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
Dieacquire()Die Funktion wird verwendet, um ein Threadlock (Schließen) anzufordern.
Erwerben
SieheThreadCondition.notify()Abschnitt für Beispiele.
Vor Gebrauchwait(), müssen Sie das Thread-Lock (Lock) des aktuellen Condition-Objekts anfordern.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/release release}
Dierelease()Die Funktion wird verwendet, um ein Gewindeverriegelung (Entriegelung) zu lösen.
Freisetzung
SieheThreadCondition.notify()Abschnitt für Beispiele.
Nach Gebrauchwait(), müssen wir das Thread-Lock (Unlock) des aktuellen Condition-Objekts freigeben.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}
Wörterbuchobjekt, zum Teilen von Daten verwendet.
Dieget()Die Funktion wird verwendet, um den im Wörterbuchobjekt aufgezeichneten Schlüsselwert zu erhalten.
Dieget()Funktion gibt den Wert des Schlüssels zurück, der von derkey parameter.
Zeichenfolge, Zahl, bool, Objekt, Array, Nullwert und andere vom System unterstützte Typen
Get (Schlüssel)
DiekeyParameter wird verwendet, um den Schlüsselnamen anzugeben, der dem zu erhaltenden Schlüssel entspricht.
Schlüssel wahr String
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"))
}
Verwenden Sie Ereignisobjekte, um Threads zu benachrichtigen, um Daten zu lesen und zu ändern.
Ich bin nicht derjenige, der das Problem hat.
Dieset()Die Funktion wird verwendet, um ein Schlüssel-Wert-Paar festzulegen.
Set (Schlüssel, Wert)
Der Parameterkeywird verwendet, um den zu ändernden Schlüsselnamen festzulegen.
Schlüssel
wahr
String
Der Parametervaluewird verwendet, um den zu ändernden Schlüsselwert festzulegen.
Wert - Das stimmt. Zeichenfolge, Zahl, bool, Objekt, Array, Nullwert und andere vom System unterstützte Typen
SieheThreadDict.get()Abschnitt für Beispiele.
Ich bin ein guter Freund.
In der FMZ Quant Trading Plattform implementiert es hauptsächlich verschiedene Funktionen, Anrufe im Zusammenhang mit Blockchain überexchange.IO()Das folgende Dokument beschreibt dieexchange.IO()Die Anrufmethode derexchange.IO("abi", ...)Die Funktion wird zur Registrierung eines ABI verwendet.
exchange.IO(k, Adresse, abiInhalt)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"abi"bedeutet, dass die Funktion zur Registrierung verwendet wirdABI- Ich weiß.
k
wahr
String
DieaddressDer Parameter wird verwendet, um die Adresse des Smart Contracts anzugeben.
Anschrift
wahr
String
DieabiContentParameter wird verwendet, um dieABIder Smart Contract.
abiInhalt
wahr
String
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)
}
Die Methoden zum Aufrufen von Smart Contracts müssen nicht registriert werden, wenn es sich um Standardmethoden von ERC20 handelt.
Holen Sie dieABIDer Inhalt des Auftrags kann unter folgender URL abgerufen werden:resultnur Feld, z. B.:
https://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
Die Anrufmethode vonexchange.IO("api", "eth", ...)Die Funktion wird verwendet, um die Methode Ethereum RPC aufzurufen.
Dieexchange.IO("api", "eth", ...)Funktion gibt den Rückgabewert der genannten RPC-Methode zurück.
String, number, bool, object, array, null und alle anderen vom System unterstützten Typen
exchange.IO(k, BlockChain, rpcMethode)exchange.IO(k, BlockChain, rpcMethode,...args)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"api"zeigt an, dass die Funktion zur Erweiterung der Anrufanfrage verwendet wird.
k
wahr
String
DieblockChainParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"eth"zeigt an, dass die Funktion für Anrufe der RPC-Methode im Ethereum-Netzwerk verwendet wird.
BlockChain
- Das stimmt.
String
DierpcMethodParameter wird verwendet, um die von derexchange.IO()Funktion.
rpcMethode
wahr
String
DieargParameter wird verwendet, um die Parameter der zu aufrufenden RPC-Methode anzugeben.argDie Art und Anzahl derargDie Parameter hängen von der von derrpcMethodParameter.
Arg
falsche
String, number, bool, object, array, function, null und alle anderen vom System unterstützten Typen
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()))
}
Überprüfen Sie den ETH-Guthaben in Ihrer Brieftasche:
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)
}
Für ETH-Überweisungen können Sie die{gasPrice: 11, gasLimit: 111, nonce: 111}Parameter, der auf den letzten Parameter desexchange.IO()Sie können dienonceund verwenden Sie die System-Standard, oder lassengasLimit/gasPrice/nonceDeaktivieren und verwenden Sie den Systemstandardwert für alle.
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)
}
AbfragegasPrice:
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)
}
Abfrageeth_estimateGas:
Der zweite Parameter derexchange.IO()Funktion mit"eth"kann direkt die RPC-Methoden aufrufen, die dem Ethereum-Node-Server zur Verfügung stehen.
Ich habe dich nicht gesehen.
Dieexchange.IO("encode", ...)Die Funktion wird für die Datenkodierung aufgerufen.
Dieexchange.IO("encode", ...)Funktion gibt die codierten Daten zurück.
String
exchange.IO(k, Datenformat,...args)exchange.IO(k, Adresse, Datenformat)exchange.IO(k, Adresse, Datenformat,...args)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"encode"bedeutet, dass die Funktion für die Datenkodierung verwendet wird.
k
wahr
String
DieaddressDie Parameter werden verwendet, um die Adresse des Smart Contracts festzulegen.exchange.IO("encode", ...)Funktion, die in deraddressDer Parameter zeigt die Codierung der Methode auf dem Smart Contract an.exchange.IO("encode", ...)Funktion, wennaddresswenn der Parameter nicht übergeben wird, wird die Funktion verwendet, um die angegebene Typfolge zu kodieren, und ist funktionell gleichwertig mitabi.encodeinSolidity- Ich weiß.
Anschrift
falsche
String
DiedataFormatDer Parameter wird verwendet, um die Methode, den Typ und die Reihenfolge der codierten Daten anzugeben.
DatenFormat
- Das stimmt.
String
DieargParameter wird verwendet, um den spezifischen Datenwert anzugeben, der demdataFormatEs kann mehr als eineargParameter und die Art und Anzahl derargParameter hängen von derdataFormatEinstellung der Parameter.
Arg
falsche
String, number, tuple, array und alle anderen vom System unterstützten Typen
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)
}
Zum Beispiel, rufen Sie die CodierungsmethodeunwrapWETH9:
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
*/
}
Es ist gleichbedeutend mit dem Codierungsbeispiel vonabi.encodeinSolidity:
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)
}
Es unterstützt die Codierung eines Tupels oder einer Typreihenfolge, die ein Tupel enthält.
Diese Typordnung besteht austuple, bytesAlso, wenn Sie anrufenexchange.IO()Für die Kodierung müssen Sie zwei Parameter weitergeben:
{
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}
Die eingegebenen Parameter müssen auch mit der Struktur und dem Typ dertuple, wie sie in dertypesParameter des Formulars: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)
}
Es unterstützt die sequentielle Codierung von Arrays oder Arraytypen, die Arrays enthalten:
Dieexchange.IO()Funktion umfasst dieencodeMethode, die den Funktionsanrufcode zurückgeben kannhexFür spezifische Anwendungen können Sie sich auf die öffentlich zugänglichen Plattformen beziehen
Dieexchange.IO("encodePacked", ...)Funktion wird auf eine Weise aufgerufen, die für verwendet wirdencodePacked encoding.
Dieexchange.IO("encodePacked", ...)Funktion gibt dieencodePackedverschlüsselte Daten.
String
exchange.IO(k, Datenformat,...args)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"encodePacked"bedeutet, dass die Funktion für Daten verwendet wirdencodePackedVerschlüsselung.
k
wahr
String
DiedataFormatDer Parameter wird verwendet, um den Typ und die Reihenfolge derencodePackedverschlüsselte Daten.
DatenFormat
wahr
String
DieargParameter wird verwendet, um den spezifischen Datenwert anzugeben, der demdataFormatEs kann mehr als eineargParameter und die Art und Anzahl derargParameter hängen von derdataFormatEinstellung der Parameter.
Arg
- Das stimmt.
String, number, tuple, array und alle anderen vom System unterstützten Typen
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)
}
Bei AnwendungUniswap V3, müssen Sie in den Parametern wie den Austausch Pfad passieren, müssen Sie dieencodePackedCodierung:
Dieexchange.IO("decode", ...)Funktion wird auf eine Art und Weise aufgerufen, die für die Entschlüsselung verwendet wird.
Dieexchange.IO("decode", ...)Funktion gibt die entschlüsselten Daten zurück. Gibt eine Zeichenkette zurück, wenn nur ein von derdataFormatParameter. Gibt ein Array zurück, wenn mehr als ein von derdataFormatParameter.
- Das ist nicht wahr.
exchange.IO(k, Daten)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion und Einstellung auf"decode"bedeutet, dass die Funktion zur Datenentzifferung verwendet wird.
k
wahr
String
DiedataFormatDer Parameter wird verwendet, um den Typ und die Reihenfolge der entschlüsselten Daten anzugeben.
DatenFormat
- Das stimmt.
String
DiedataDer Parameter wird verwendet, um die zu entschlüsselnden Daten festzulegen.
Daten
wahr
String
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)
}
Umgekehrter Betrieb derexchange.IO("encode", ...)Funktion:
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)
}
Das folgende Beispiel führt zunächst eineencodePackedBetrieb auf derpathParameterverarbeitung, weil dieexactOutputMethodenanruf, der später codiert werden muss, erfordertpathals Parameter. DannencodeDieexactOutputMethode des Routingvertrags, die nur einen Parameter des Typs enthälttuple. Die MethodenbezeichnungexactOutputwird als0x09b81346, und mit Hilfe derexchange.IO("decode", ...)Methode zur Entschlüsselung der resultierendendecodeRaw, entsprechend der VariablendataTuple.
Für die Datenverarbeitung werden dieexchange.IO()Funktion unterstützt nicht nur die Kodierung, sondern auch die Entschlüsselung.
Dieexchange.IO("key", ...)Die Funktion wird so aufgerufen, dass private Schlüssel gewechselt werden können.
exchange.IO(K, Taste)
Der Parameterkwird verwendet, um die Funktion derexchange.IO()Funktion, auf"key"bedeutet, dass die Funktion zum Umschalten des privaten Schlüssels verwendet wird.
k
wahr
String
DiekeyParameter wird verwendet, um den privaten Schlüssel festzulegen.
Schlüssel
wahr
String
function main() {
exchange.IO("key", "Private Key") // "Private Key" represents the private key string, which needs to be filled in specifically
}
Dieexchange.IO()Die Funktion unterstützt das Wechseln privater Schlüssel und kann mehrere Wallet-Adressen manipulieren.
Dieexchange.IO("api", ...)Funktion wird auf eine Weise aufgerufen, die verwendet wird, um die Methoden des Smart Contracts aufzurufen.
Dieexchange.IO("api", ...)Funktion gibt den Rückgabewert der sogenannten Smart-Contract-Methode zurück.
String, number, bool, object, array, null und alle anderen vom System unterstützten Typen
exchange.IO(k, Anschrift, Methode)exchange.IO(k, Anschrift, Methode,... args)exchange.IO(k, Anschrift, Methode, Wert,... args)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"api"zeigt an, dass die Funktion zur Erweiterung der Anrufanfrage verwendet wird.
k
wahr
String
DieaddressDer Parameter wird verwendet, um die Adresse des Smart Contracts anzugeben.
Anschrift
wahr
String
DiemethodDer Parameter wird verwendet, um die Methode des zu aufrufenden Smart Contracts anzugeben.
Methode
- Das stimmt.
String
DievalueDer ETH-Parameter wird verwendet, um den zu versendenden ETH-Betrag festzulegen.stateMutabilityAttribut der auszuführenden Smart Contract-Methode istpayable, dann dievalueDer Parameter muss übergeben werden."stateMutability": "payable"Das Attribut kann im ABI angezeigt werden.exchange.IO()Funktion wird den erforderlichen Parameter auf der Grundlage derstateMutabilityDas ist ein Attribut in der ABI, das registriert wurde.stateMutabilityAttribut istnonpayable, dann dievalueParameter muss nicht übergeben werden.
Wert
falsche
Zahl, Zeichenfolge
DieargParameter wird verwendet, um die Parameter der Methode des zu aufrufenden Smart Contracts anzugeben.argParameter und die Art und Anzahl derargParameter hängen von der Methode des zu aufrufenden Smart Contracts ab.
Arg
falsche
String, number, bool und alle anderen vom System unterstützten Typen
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
}
DiedecimalsMethode ist eineconstantDie ERC20-Technologie ist eine Methode, die keinen Gasverbrauch verursacht und die Präzisionsdaten eines Tokens abfragen kann.decimalsRückgabewert: die Präzisionsdaten des Tokens.
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"))
}
DieallowanceMethode ist eineconstantDie ERC20-Methode, die keinen Gasverbrauch erzeugt und den zugelassenen Betrag eines Tokens für eine bestimmte Vertragsadresse abfragen kann.allowanceDie Methode nimmt 2 Parameter an, der erste ist die Wallet-Adresse und der zweite die autorisierte Adresse.
owner: die Adresse der Brieftasche, das Beispiel wird durch die Zeichenfolge spender: die Adresse des genehmigten Auftrags, das Beispiel wird durch die Zeichenfolge 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 || {})
}
DiemulticallDie Methode ist nichtconstantVerfahren derUniswap V3die Gasverbrauch erzeugt und zur Einlösung von Token auf verschiedene Arten verwendet wird.
DiemulticallMethode kann verschiedene Möglichkeiten haben, Parameter zu übergeben, Sie können die ABI überprüfen, die die Methode speziell enthält, Sie müssen die ABI registrieren, bevor Sie die Methode aufrufen.
Für konkrete BeispielemulticallSie können sich auf die öffentlich zugänglichen Plattformen beziehen.
Einige Details werden hier mit Pseudo-Code beschrieben:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data)
ContractV3SwapRouterV2: Adresse des Routers v2 von Uniswap V3.value: der zu übertragende Betrag an ETH, der auf 0 festgelegt ist, wenn das TokenIn-Token der Börsengeschäft nicht ETH ist.deadline: deadlineist der Parameter dermulticallMethode, die auf (neues Datum (().getTime (()) / 1000) + 3600 eingestellt werden kann, was anzeigt, dass sie für eine Stunde gültig ist.data: dataist der Parameter dermulticallMethode, die Daten des zu durchführenden Verpackungsverfahrens.
Ähnlich wieexchange.IO("api", "eth", "send", "toAddress", toAmount), diegasLimit/gasPrice/nonceDie Einstellung des Methodenanrufs kann beim Aufrufen dermulticallMethode.
Wir verwenden Pseudo-Code, um zu beschreiben:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data, {gasPrice: 123456, gasLimit: 21000})
Der Parameter{gasPrice: 11, gasLimit: 111, nonce: 111}Die Anpassung an die spezifischen Bedürfnisse kann auf den letzten Parameter desexchange.IO()Funktion.
Sie können dienonceund verwenden Sie den System-Standardwert, oder lassen SiegasLimit/gasPrice/nonceDeaktivieren und verwenden Sie den Systemstandardwert für alle.
Dieexchange.IO("address")Die Funktion wird so aufgerufen, dass sie die Adresse der von dem Exchange-Objekt {@var/EXCHANGE exchange} konfigurierten Brieftasche erhält.
Dieexchange.IO("address")Funktion gibt die konfigurierte Wallet-Adresse zurück.
String
exchange.IO(k)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"address"bedeutet, dass die Funktion verwendet wird, um die konfigurierte Wallet-Adresse zu erhalten.
k
- Das stimmt.
String
function main() {
Log(exchange.IO("address")) // Print the wallet address of the private key configured on the exchange object
}
Dieexchange.IO("base", ...)Die Funktion wird so aufgerufen, dass die RPC-Knotenadresse festgelegt wird.
exchange.IO(k, Anschrift)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"base"bedeutet, dass die Funktion zum Wechseln von RPC-Knoten verwendet wird.
k
wahr
String
DieaddressParameter wird verwendet, um die RPC-Knotenadresse festzulegen.
Anschrift
wahr
String
function main() {
var chainRpc = "https://bsc-dataseed.binance.org"
e.IO("base", chainRpc) // Switching to BSC chain
}
DieTA.MACD()Die Funktion wird zur Berechnung derMACD-Indikator für exponentiell glättete Unterschiede und Ähnlichkeiten.
Der Rücklaufwert derTA.MACD()Funktion ist ein zweidimensionaler Array mit der Struktur:[DIF, DEA, MACD]- Ich weiß.
Reihenfolge
TA.MACD ((inReal) TA.MACD ((inReal, optInFastPeriod, optInSlowPeriod, optInSignalPeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInFastPeriodDer Parameter wird verwendet, um die schnelle Periode festzulegen.
OptionInFastPeriod
falsche
Zahl
DieoptInSlowPeriodDer Parameter wird zur Einstellung der langsamen Periode verwendet.
OptInSlowPeriod
falsche
Zahl
DieoptInSignalPeriodDer Parameter wird verwendet, um den Signalzeitraum festzulegen.
OptInSignalPeriode
falsche
Zahl
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]);
}
DieTADas Programm unterstützt die Anwendungen von FMZ Quant, die für gemeinsame Indikator-Algorithmen optimiert sind.JavaScript, Python, C++Sprachstrategieanrufe,Open-Source-TA-Bibliothekscode- Ich weiß.
Die Standardwerte deroptInFastPeriod, optInSlowPeriod, undoptInSignalPeriodParameter derTA.MACD()Funktion sind:12, 26, und9.
Ich bin nicht derjenige, der das Wort "Freiheit" benutzt.TA.MAWir haben eine Reihe von Programmen entwickelt, die uns dabei helfen, die Probleme zu lösen.
DieTA.KDJ()Funktion wird zur Berechnung verwendetStochastische Indikatoren.
Der Rücklaufwert derTA.KDJ()Funktion ist ein zweidimensionaler Array mit der Struktur:[K, D, J]- Ich weiß.
Reihenfolge
TA.KDJ ((inReal)) TA.KDJ ((inReal, Periode, kPeriode, dPeriode)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieperiodDer Parameter wird verwendet, um Periode 1 festzulegen.
Periode
falsche
Zahl
DiekPeriodDer Parameter wird verwendet, um die Periode 2 festzulegen.
kZeitraum
falsche
Zahl
DiedPeriodDer Parameter wird verwendet, um die Periode 3 festzulegen.
dZeitraum
falsche
Zahl
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]);
}
Die Standardwerte für dieperiod, kPeriod, unddPeriodParameter derTA.KDJ()Funktion sind:9, 3, und3.
Ich bin nicht derjenige, der das Problem mit der Verzögerung anspricht, sondern ich bin derjenige, der das Problem anspricht.TA.MAWir haben eine Reihe von Programmen entwickelt, die uns dabei helfen, die Probleme zu lösen.
DieTA.RSI()Die Funktion wird zur Berechnung derStärkenindikator.
Der Rücklaufwert derTA.RSI()Funktion ist: ein einmaliges Array.
Reihenfolge
TA.RSI ((inReal) TA.RSI ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen.
OptionInZeitzeitraum
falsche
Zahl
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);
}
Der Standardwert deroptInTimePeriodParameter derTA.RSI()Funktion ist:14.
Ich bin nicht derjenige, der das Problem hat. Ich bin derjenige, der das Problem hat.TA.MAWir haben eine Reihe von Programmen entwickelt, die uns dabei helfen, die Probleme zu lösen.
DieTA.ATR()Die Funktion wird zur Berechnung derDurchschnittlicher Indikator für die tatsächliche Volatilität.
Der Rücklaufwert derTA.ATR()Funktion ist: ein einmaliges Array.
Reihenfolge
TA.ATR ((inPriceHLC) TA.ATR ((inPriceHLC, optInTimePeriod)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen.
OptionInZeitzeitraum
falsche
Zahl
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);
}
Der Standardwert deroptInTimePeriodParameter derTA.ATR()Funktion ist:14.
Ich bin nicht derjenige, der das Problem mit der Verzögerung anspricht, sondern ich bin derjenige, der es anspricht.TA.MAWir haben eine Reihe von Programmen entwickelt, die uns dabei helfen, die Probleme zu lösen.
DieTA.OBV()Die Funktion wird zur Berechnung derEnergieflutindikator.
Der Rücklaufwert derTA.OBV()Funktion ist: ein einmaliges Array.
Reihenfolge
TA.OBV ((inReal) TA.OBV ((inReal, inPriceV)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieinPriceVDer Parameter wird verwendet, um die Daten zum Transaktionsbetrag anzugeben.
inPriceV
falsche
{@struct/Record Record} Struktur-Array
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);
}
Das ist ein sehr gutes Beispiel für die Art und Weise, in der wir uns auf die Welt begeben.TA.MAWir haben eine Reihe von Programmen entwickelt, die uns dabei helfen, die Probleme zu lösen.
DieTA.MA()Die Funktion wird zur Berechnung derMACD-Indikator.
Der Rücklaufwert derTA.MA()Funktion ist: ein einmaliges Array.
Reihenfolge
TA.MA(inReal)TA.MA(inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen.
OptionInZeitzeitraum
falsche
Zahl
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);
}
Der Standardwert deroptInTimePeriodParameter derTA.MA()Funktion ist:9.
Ein weiterer wichtiger Punkt, der in diesem Zusammenhang berücksichtigt werden muss, ist die Tatsache, dass die Kommission in der Vergangenheit in den letzten Jahren eine Reihe von Maßnahmen ergriffen hat, um die Auswirkungen der Verzögerungen auf die Gesundheit und die Gesundheit der Bevölkerung zu verringern.
DieTA.EMA()Die Funktion wird zur Berechnung derexponentieller Durchschnittsindikator.
Der Rücklaufwert derTA.EMA()Funktion ist: ein einmaliges Array.
Reihenfolge
TA.EMA ((inReal) TA.EMA ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen.
OptionInZeitzeitraum
falsche
Zahl
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);
}
}
Der Standardwert deroptInTimePeriodParameter derTA.EMA()Funktion ist:9.
Ich bin nicht derjenige, der das Wort "Freiheit" benutzt.TA.MAWir haben eine große Anzahl von Anwendungen, die wir in diesem Jahr entwickelt haben.
DieTA.BOLL()Die Funktion wird zur Berechnung derBollinger-Band-Indikator.
Der Rücklaufwert derTA.BOLL()Funktion ist ein zweidimensionaler Array mit der Struktur:[upLine, midLine, downLine]- Ich weiß.
Reihenfolge
Ich bin nicht derjenige, der das Problem hat. TA.BOLL ((inReal, Punkt, Multiplikator)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieperiodDer Parameter wird verwendet, um den Zeitraum festzulegen.
Periode
falsche
Zahl
DiemultiplierParameter wird verwendet, um den Multiplikator festzulegen.
Multiplikator
falsche
Zahl
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);
}
}
Die Standardwerte für dieperiodundmultiplierParameter derTA.BOLL()Funktion sind:20und2.
Ich bin nicht derjenige, der das Wort "Freiheit" benutzt.TA.MAWir haben eine Reihe von Programmen entwickelt, die uns dabei helfen, die Probleme zu lösen.
DieTA.Alligator()Die Funktion wird zur Berechnung derAlligator-Indikator.
Der Rücklaufwert derTA.Alligator()Funktion ist ein zweidimensionaler Array mit der Struktur:[jawLine, teethLine, lipsLine]- Ich weiß.
Reihenfolge
TA.Alligator ((inReal) TA.Alligator ((inReal, KieferLänge, ZähneLänge, LippenLänge)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DiejawLengthDer Parameter wird verwendet, um die Kieferperiode festzulegen.
Kieferlänge
falsche
Zahl
DieteethLengthDer Parameter wird verwendet, um die Zahnperiode festzulegen.
ZähneLängen
falsche
Zahl
DielipsLengthDer Parameter wird verwendet, um die Periode der Oberlippe festzulegen.
Lippenlänge
falsche
Zahl
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]);
}
Die Standardwerte derjawLength, teethLength, undlipsLengthParameter derTA.Alligator()Funktion sind:13, 8, und5.
Ich bin nicht derjenige, der das Wort "Freiheit" benutzt.TA.MAWir haben eine Reihe von Programmen entwickelt, die uns helfen können, unsere Kunden zu unterstützen.
DieTA.CMF()Die Funktion wird zur Berechnung derChaikin-Geldflussindikator.
Der Rücklaufwert derTA.CMF()Funktion ist: ein einmaliges Array.
Reihenfolge
TA.CMF ((inReal) TA.CMF ((inReal, inPriceV)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieinPriceVDer Parameter wird zur Angabe der Volumendaten verwendet.
inPriceV
falsche
{@struct/Record Record} Struktur-Array
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);
}
Ich bin nicht derjenige, der das Wort "Freiheit" benutzt.TA.MAWir haben eine Reihe von Programmen entwickelt, die uns helfen können, unsere Kunden zu unterstützen.
DieTA.Highest()Die Funktion wird zur Berechnung derhöchster Preis der Periode.
DieTA.Highest()Funktion gibt den maximalen Wert eines Attributs in der letzten bestimmten Periode zurück, ohne den aktuellen Bar.
Zahl
TA.Höchste ((inReal) TA.Höchste ((inReal, Periode, attr)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieperiodDer Parameter wird verwendet, um den Zeitraum festzulegen.
Periode
falsche
Zahl
DieattrParameter wird verwendet, um die Attribute festzulegen, optional:Open, Close, Low, High, Volume, OpenInterest- Ich weiß.
Abweichend
falsche
String
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);
}
Zum Beispiel:TA.Highest(records, 30, "High")Funktion wird aufgerufen, wenn der Periodenparameterperiodist auf0, bedeutet es, alle zu berechnenBarsder K-Liniendaten, die von derinRealParameter; wenn der AttributparameterattrDie Daten der K-Linie, die vominRealParameter gilt als gewöhnliches Array.
Ich bin nicht derjenige, der das Wort "Freiheit" benutzt.TA.MAIch habe eine Frage an Sie. Ich habe eine Frage.
DieTA.Lowest()Die Funktion wird zur Berechnung derMindestpreis der Periode.
DieTA.Lowest()Funktion gibt den Mindestwert eines Attributs in der letzten bestimmten Periode zurück, ohne den aktuellen Bar.
Zahl
TA.Niedrigste (inReal) TA.Niedrigste ((inReal, Periode, attr)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieperiodDer Parameter wird verwendet, um den Zeitraum festzulegen.
Periode
falsche
Zahl
DieattrParameter wird verwendet, um die Attribute festzulegen, optional:Open, Close, Low, High, Volume, OpenInterest- Ich weiß.
Abweichend
falsche
String
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);
}
Zum Beispiel:TA.Lowest(records, 30, "Low")Funktion wird aufgerufen, wenn der Periodenparameterperiodist auf0, bedeutet es, alle zu berechnenBarsder K-Liniendaten, die von derinRealParameter; wenn der AttributparameterattrDie Daten der K-Linie, die vominRealParameter gilt als gewöhnliches Array.
Die Anwendung derTA.Highest()undTA.Lowest()Funktionen imC++Strategie ist zu beachten, dass dieHighest()undLowest()Funktionen haben jeweils nur 2 Parameter.
Und der erste Parameter, der übergeben wird, sind nicht die K-Liniendaten.rErlangt, wenn die Funktionauto r = exchange.GetRecords()wurde gerufen.
Sie müssen dierDie Methode wird in den spezifischen Attributdaten übertragen.r.Close()Daten zum Schlusskurs.Close, High, Low, Open, VolumeWie in derr.Close()Anrufmethode.
Beispielprüfung vonC++Sprachstrategie:
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);
}
Ich bin nicht derjenige, der das Wort "Freiheit" benutzt.TA.MAIch habe eine Frage an Sie. Ich habe eine Frage.
DieTA.SMA()Die Funktion wird zur Berechnung dereinfacher gleitender Durchschnittsindikator.
Der Rücklaufwert derTA.SMA()Funktion ist: ein einmaliges Array.
Reihenfolge
TA.SMA ((inReal) TA.SMA ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen.
OptionInZeitzeitraum
falsche
Zahl
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);
}
Der Standardwert deroptInTimePeriodParameter derTA.SMA()Funktion ist:9.
Ich bin nicht derjenige, der das Wort "Freiheit" benutzt.TA.MAWir haben eine Reihe von Programmen entwickelt, die uns dabei helfen, die Probleme zu lösen.
Dietalib.CDL2CROWS()Funktion wird zur Berechnung verwendetZwei Krähen (K-Liniendiagramm - Zwei Krähen).
Der Rücklaufwert dertalib.CDL2CROWS()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDL2CROWS ((inPriceOHLC) ist ein sehr guter Anbieter.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDL2CROWS()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDL2CROWS(Records[Open,High,Low,Close]) = Array(outInteger)Für Anrufe imPythonSprache, Passparameter sind unterschiedlich und müssen auf der obigen Beschreibung beruhen:Records[Open,High,Low,Close].
Beispiel für die Spaltung einer Variablenrecords(d. h. ParameterinPriceOHLC, geben Sie {@struct/Record Record} Array von Strukturen ein) in:OpenListe: in Python alsrecords.Open.
HighListe: geschrieben alsrecords.Highin Python.LowListe: in Python alsrecords.Low.
CloseListe: in Python alsrecords.Close.
In Python Strategie-Code aufgerufen:
talib.CDL2CROWS(records.Open, records.High, records.Low, records.Close)
Der andere.talibDie Indikatoren werden auf die gleiche Weise beschrieben und werden nicht wiederholt.
Dietalib.CDL3BLACKCROWS()Funktion wird zur Berechnung verwendetDrei schwarze Krähen (K-Liniendiagramm - Drei schwarze Krähen).
Der Rücklaufwert dertalib.CDL3BLACKCROWS()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDL3BLACKCROWS (in Preis)
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDL3BLACKCROWS()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDL3BLACKCROWS(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDL3INSIDE()Funktion wird zur Berechnung verwendetDrei nach innen nach oben/nach unten (K-Liniendiagramm: Drei nach innen nach oben/nach unten).
Der Rücklaufwert dertalib.CDL3INSIDE()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDL3INSIDE ((inPriceOHLC)
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDL3INSIDE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDL3INSIDE(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDL3LINESTRIKE()Die Funktion wird zur Berechnung derDrei-Linien-Streik (K-Liniendiagramm: Drei-Linien-Streik).
Der Rücklaufwert dertalib.CDL3LINESTRIKE()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDL3LINESTRIKE ((inPriceOHLC) ist ein sehr guter Anbieter.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDL3LINESTRIKE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDL3LINESTRIKE(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDL3OUTSIDE()Funktion wird zur Berechnung verwendetDrei Außenseite nach oben/nieder (K-Liniendiagramm: Drei Außenseite nach oben/nieder).
Der Rücklaufwert dertalib.CDL3OUTSIDE()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDL3OUTSIDE ((inPriceOHLC) ist eine neue Version von Talib.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDL3OUTSIDE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDL3OUTSIDE(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDL3STARSINSOUTH()Funktion wird zur Berechnung verwendetDrei Sterne im Süden.
Der Rücklaufwert dertalib.CDL3STARSINSOUTH()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDL3STARSINSOUTH ((inPriceOHLC) ist eine neue Version von
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDL3STARSINSOUTH()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDL3STARSINSOUTH(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDL3WHITESOLDIERS()Funktion wird zur Berechnung verwendetDrei Weiße Soldaten im Vormarsch (K-Liniendiagramm: Drei Weiße Soldaten im Vormarsch).
Der Rücklaufwert dertalib.CDL3WHITESOLDIERS()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDL3WHITESOLDIERS ((inPriceOHLC) ist eine der größten
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDL3WHITESOLDIERS()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDL3WHITESOLDIERS(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLABANDONEDBABY()Funktion wird zur Berechnung verwendetVerlassenes Baby (K-Linien-Diagramm: Verlassenes Baby).
Der Rücklaufwert dertalib.CDLABANDONEDBABY()Funktion ist: ein einmaliges Array.
Reihenfolge
Ich bin nicht derjenige, der das Problem hat. Talib.CDLABANDONEDBABY ((inPriceOHLC, optInPenetration) ist eine neue Version von
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInPenetrationDer Parameter wird verwendet, um den Durchdringungswert festzulegen, der Standardwert ist 0,3.
OptionInPenetration
falsche
Zahl
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);
}
DieCDLABANDONEDBABY()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLABANDONEDBABY(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Dietalib.CDLADVANCEBLOCK()Die Funktion wird zur Berechnung derVorlaufblock (K-Liniendiagramm: Vorlauf).
Der Rücklaufwert dertalib.CDLADVANCEBLOCK()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLADVANCEBLOCK ((inPriceOHLC) ist ein sehr gutes Buch.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLADVANCEBLOCK()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLADVANCEBLOCK(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLBELTHOLD()Die Funktion wird zur Berechnung derGürtelhalt (K-Liniendiagramm: Gürtelhalt).
Der Rücklaufwert dertalib.CDLBELTHOLD()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLBELTHOLD (in Preis)
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLBELTHOLD()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLBELTHOLD(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLBREAKAWAY()Die Funktion wird zur Berechnung derBreakaway (K-Liniendiagramm: Breakaway).
Der Rücklaufwert dertalib.CDLBREAKAWAY()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLBRAKAWAY ((inPriceOHLC) ist ein sehr guter Freund.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLBREAKAWAY(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLCLOSINGMARUBOZU()Funktion wird zur Berechnung verwendetAbschluss von Marubozu (K-Liniendiagramm: Abschluss barkopf und barfuß).
Der Rücklaufwert dertalib.CDLCLOSINGMARUBOZU()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLCLOSINGMARUBOZU ((inPriceOHLC) ist ein sehr guter Freund von mir.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLCLOSINGMARUBOZU()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLCLOSINGMARUBOZU(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLCONCEALBABYSWALL()Die Funktion wird zur Berechnung derVerbergen von Babyschwalben (K-Liniendiagramm: Verbergen von Baby Schwalben Muster).
Der Rücklaufwert dertalib.CDLCONCEALBABYSWALL()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLCONCEALBABYSWALL ((inPreisOHLC) ist ein sehr gutes Buch.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLCONCEALBABYSWALL()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLCONCEALBABYSWALL(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLCOUNTERATTACK()Funktion wird zur Berechnung verwendetGegenangriff (K-Liniendiagramm: Gegenangriff).
Der Rücklaufwert dertalib.CDLCOUNTERATTACK()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLKONTRAATTACK ((inPriceOHLC) ist eine der wichtigsten
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLCOUNTERATTACK()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLCOUNTERATTACK(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLDARKCLOUDCOVER()Funktion wird zur Berechnung verwendetDunkle Wolkendecke (K-Liniendiagramm: dunkle Wolkendecke).
Der Rücklaufwert dertalib.CDLDARKCLOUDCOVER()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDDARKCLOUDCOVER (in Preis) Talib.CDLDARKCLOUDCOVER ((inPriceOHLC, optInPenetration) ist eine neue Version von
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInPenetrationDer Parameter wird verwendet, um den Durchdringungswert festzulegen, der Standardwert ist 0,5.
OptionInPenetration
falsche
Zahl
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);
}
DieCDLDARKCLOUDCOVER()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLDARKCLOUDCOVER(Records[Open,High,Low,Close],Penetration = 0.5) = Array(outInteger)
Dietalib.CDLDOJI()Funktion wird zur Berechnung verwendetDoji (K-Liniendiagramm: Doji).
Der Rücklaufwert dertalib.CDLDOJI()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLDOJI ((inPriceOHLC)
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLDOJI()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLDOJISTAR()Die Funktion wird zur Berechnung derDoji-Stern (K-Liniendiagramm: Doji-Stern).
Der Rücklaufwert dertalib.CDLDOJISTAR()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLDOJISTAR ((inPriceOHLC) ist ein sehr gutes Buch.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLDOJISTAR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLDOJISTAR(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLDRAGONFLYDOJI()Funktion wird zur Berechnung verwendetDrachenfliege Doji (K-Liniendiagramm: Drachenfliege Doji).
Der Rücklaufwert dertalib.CDLDRAGONFLYDOJI()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLDRAGONFLYDOJI ((inPreisOHLC) ist ein sehr gutes Buch.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLDRAGONFLYDOJI()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLDRAGONFLYDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLENGULFING()Die Funktion wird zur Berechnung derSchluckmuster (K-Liniendiagramm: Schluckmuster).
Der Rücklaufwert dertalib.CDLENGULFING()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLENGULFING ((inPriceOHLC) ist ein sehr gutes Buch.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLENGULFING()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLENGULFING(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLEVENINGDOJISTAR()Die Funktion wird zur Berechnung derNachmittags-Doji-Stern (K-Liniendiagramm: Nachmittags-Doji-Stern).
Der Rücklaufwert dertalib.CDLEVENINGDOJISTAR()Funktion ist: ein einmaliges Array.
Reihenfolge
Ich bin nicht derjenige, der dich anspricht. Talib.CDLEVENINGDOJISTAR ((inPriceOHLC, optInPenetration) ist ein sehr gutes Beispiel.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInPenetrationDer Parameter wird verwendet, um den Durchdringungswert festzulegen, der Standardwert ist 0,3.
OptionInPenetration
falsche
Zahl
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);
}
DieCDLEVENINGDOJISTAR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLEVENINGDOJISTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Dietalib.CDLEVENINGSTAR()Die Funktion wird zur Berechnung derAbendstern (K-Linienkaart: Abendstern).
Der Rücklaufwert dertalib.CDLEVENINGSTAR()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLEVENINGSTAR ((inPriceOHLC) ist eine neue Version von Talib.CDLEVENINGSTAR ((inPriceOHLC, optInPenetration) ist eine neue Version von
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInPenetrationDer Parameter wird verwendet, um den Durchdringungswert festzulegen, der Standardwert ist 0,3.
OptionInPenetration
falsche
Zahl
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);
}
DieCDLEVENINGSTAR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLEVENINGSTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Dietalib.CDLGAPSIDESIDEWHITE()Funktion wird zur Berechnung verwendetAufwärts-/Abwärts-Grenze (K-Liniendiagramm: Aufwärts-/Abwärts-Grenze).
Der Rücklaufwert dertalib.CDLGAPSIDESIDEWHITE()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLGAPSIDESIDEWHITE ((inPriceOHLC) ist eine neue Version von Talib.CDL
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLGAPSIDESIDEWHITE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLGAPSIDESIDEWHITE(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLGRAVESTONEDOJI()Die Funktion wird zur Berechnung derGravestone Doji (K-Liniendiagramm: Gravestone Doji).
Der Rücklaufwert dertalib.CDLGRAVESTONEDOJI()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLGRAVESTONEDOJI ((inPreisOHLC) ist ein sehr guter Anbieter.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLGRAVESTONEDOJI()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLGRAVESTONEDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLHAMMER()Funktion wird zur Berechnung verwendetHammer (K-Liniendiagramm: Hammer).
Der Rücklaufwert dertalib.CDLHAMMER()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLHAMMER ((inPriceOHLC)
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLHAMMER()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLHAMMER(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLHANGINGMAN()Funktion wird zur Berechnung verwendetHängender Mann (K-Liniendiagramm: Hängender Mann).
Der Rücklaufwert dertalib.CDLHANGINGMAN()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLHANGINGMAN ((inPriceOHLC) ist ein sehr guter Freund von mir.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLHANGINGMAN()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLHANGINGMAN(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLHARAMI()Die Funktion wird zur Berechnung derHarami-Muster (K-Liniendiagramm: negative und positive Linien).
Der Rücklaufwert dertalib.CDLHARAMI()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLHARAMI ((inPriceOHLC)
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLHARAMI()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLHARAMI(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLHARAMICROSS()Die Funktion wird zur Berechnung derHarami-Kreuzmuster (K-Liniendiagramm: Kreuzung von negativen und positiven Linien).
Der Rücklaufwert dertalib.CDLHARAMICROSS()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLHARAMICROSS ((inPriceOHLC) ist eine Firma, die sich für die Entwicklung von Mikroorganismen einsetzt.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLHARAMICROSS()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLHARAMICROSS(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLHIGHWAVE()Die Funktion wird zur Berechnung derHochwellenkerze (K-Liniendiagramm: Langbeinkreuz).
Der Rücklaufwert dertalib.CDLHIGHWAVE()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLHIGHWAVE ((inPriceOHLC) ist ein sehr guter Anbieter.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLHIGHWAVE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLHIGHWAVE(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLHIKKAKE()Die Funktion wird zur Berechnung derHikkake-Muster (K-Liniendiagramm: Fallen).
Der Rücklaufwert dertalib.CDLHIKKAKE()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLHIKKAKE ((inPriceOHLC)
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLHIKKAKE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLHIKKAKE(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLHIKKAKEMOD()Die Funktion wird zur Berechnung derModifiziertes Hikkake-Muster (K-Liniendiagramm: Modifizierte Falle).
Der Rücklaufwert dertalib.CDLHIKKAKEMOD()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLHIKKAKEMOD ((inPriceOHLC) ist ein sehr guter Anbieter.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLHIKKAKEMOD()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLHIKKAKEMOD(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLHOMINGPIGEON()Die Funktion wird zur Berechnung derPigeon (K-Liniendiagramm: Pigeon).
Der Rücklaufwert dertalib.CDLHOMINGPIGEON()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLHOMINGPIGEON ((inPriceOHLC))
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLHOMINGPIGEON()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLHOMINGPIGEON(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLIDENTICAL3CROWS()Funktion wird zur Berechnung verwendetDrei identische Krähen (K-Liniendiagramm: dieselben drei Krähen).
Der Rücklaufwert dertalib.CDLIDENTICAL3CROWS()Funktion ist: ein einmaliges Array.
Reihenfolge
Ich bin nicht derjenige, der dich anspricht.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLIDENTICAL3CROWS()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLIDENTICAL3CROWS(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLINNECK()Die Funktion wird zur Berechnung derIn-Neck-Muster (K-Liniendiagramm: Ausschnitt).
Der Rücklaufwert dertalib.CDLINNECK()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLINNECK ((inPriceOHLC) ist eine Website, die sich mit dem Internet beschäftigt.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLINNECK()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLINNECK(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLINVERTEDHAMMER()Die Funktion wird zur Berechnung derUmgekehrter Hammer (K-Liniendiagramm: Umgekehrter Hammer).
Der Rücklaufwert dertalib.CDLINVERTEDHAMMER()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLINVERTEDHAMMER ((inPriceOHLC) ist ein sehr guter Anbieter.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLINVERTEDHAMMER()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLINVERTEDHAMMER(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLKICKING()Funktion wird zur Berechnung verwendetTreten (K-Liniendiagramm: Treten).
Der Rücklaufwert dertalib.CDLKICKING()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLKICKING ((inPriceOHLC) ist ein sehr gutes Buch.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLKICKING()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLKICKING(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLKICKINGBYLENGTH()Die Funktion wird zur Berechnung derKick - Stier/Bär bestimmt durch den längeren Marubozu (K-Liniendiagramm: Kick Bull/Kick Bear).
Der Rücklaufwert dertalib.CDLKICKINGBYLENGTH()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLKICKKINGBYLENGTH ((inPriceOHLC) ist ein sehr guter Ort, um zu arbeiten.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLKICKINGBYLENGTH()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLKICKINGBYLENGTH(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLLADDERBOTTOM()Die Funktion wird zur Berechnung derDer Schritt nach unten (K-Liniendiagramm: Schritt nach unten).
Der Rücklaufwert dertalib.CDLLADDERBOTTOM()Funktion ist: ein einmaliges Array.
Reihenfolge
Ich bin nicht derjenige, der das Problem hat. Ich bin nicht derjenige, der es hat.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLLADDERBOTTOM()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLLADDERBOTTOM(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLLONGLEGGEDDOJI()Die Funktion wird zur Berechnung derLangbein Doji (K-Liniendiagramm: Langbein Doji).
Der Rücklaufwert dertalib.CDLLONGLEGGEDDOJI()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLLONGLEGGEDDOJI ((inPreisOHLC) ist ein sehr gutes Buch.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLLONGLEGGEDDOJI()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLLONGLEGGEDDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLLONGLINE()Die Funktion wird zur Berechnung derLange Linie Kerze (K-Liniendiagramm: Lange Linie).
Der Rücklaufwert dertalib.CDLLONGLINE()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLLONGLINE ((inPriceOHLC) ist eine neue Version von
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLLONGLINE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLLONGLINE(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLMARUBOZU()Die Funktion wird zur Berechnung derMarubozu (K-Liniendiagramm: Kopf und Fuß nackt).
Der Rücklaufwert dertalib.CDLMARUBOZU()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLMARUBOZU ((inPriceOHLC)
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLMARUBOZU()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLMARUBOZU(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLMATCHINGLOW()Funktion wird zur Berechnung verwendetAbgleichstief (K-Liniendiagramm: Abgleichstief).
Der Rücklaufwert dertalib.CDLMATCHINGLOW()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLMATCHINGLOW ((inPriceOHLC) ist eine neue Version von
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLMATCHINGLOW()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLMATCHINGLOW(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLMATHOLD()Funktion wird zur Berechnung verwendetMattenhalt (K-Liniendiagramm: Mattenhalt).
Der Rücklaufwert dertalib.CDLMATHOLD()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLMATHOLD ((inPriceOHLC)) Talib.CDLMATHOLD ((inPriceOHLC, optInPenetration)
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInPenetrationDer Parameter ist optional und dient zur Angabe des Prozentsatzes der Breite der aufsteigenden/absteigenden Trendlinie, der Standardwert beträgt 0,5.
OptionInPenetration
falsche
Zahl
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);
}
DieCDLMATHOLD()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLMATHOLD(Records[Open,High,Low,Close],Penetration = 0.5) = Array(outInteger)
Dietalib.CDLMORNINGDOJISTAR()Die Funktion wird zur Berechnung derMorgen-Doji-Stern (K-Liniendiagramm: Morgen-Doji-Stern).
Der Rücklaufwert dertalib.CDLMORNINGDOJISTAR()Funktion ist: ein einmaliges Array.
Reihenfolge
Ich bin nicht derjenige, der das Problem hat. Talib.CDLMORNINGDOJISTAR ((inPriceOHLC, optInPenetration) ist eine neue Version von
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInPenetrationDer Parameter wird verwendet, um den Grad der Überschneidung zwischen dem Validierungs-Eröffnungspreis und dem festen Teil anzugeben, der Standardwert beträgt 0,3.
OptionInPenetration
falsche
Zahl
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);
}
DieCDLMORNINGDOJISTAR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLMORNINGDOJISTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Dietalib.CDLMORNINGSTAR()Funktion wird zur Berechnung verwendetMorgenstern (K-Liniendiagramm: Morgenstern).
Der Rücklaufwert dertalib.CDLMORNINGSTAR()Funktion ist: ein einmaliges Array.
Reihenfolge
Ich bin ein toller Mann. Ich bin nicht derjenige, der das Problem hat.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInPenetrationParameter ist die für die Trendbestätigung erforderliche Schwelle für den Kursschwankungsanteil und erhält einen Wert im Bereich [0,1] mit einem Standardwert von 0,3.
OptionInPenetration
falsche
Zahl
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);
}
DieCDLMORNINGSTAR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLMORNINGSTAR(Records[Open,High,Low,Close],Penetration=0.3) = Array(outInteger)
Dietalib.CDLONNECK()Die Funktion wird zur Berechnung derHalsmuster (K-Liniendiagramm: Halsmuster).
Der Rücklaufwert dertalib.CDLONNECK()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLONNECK ((inPriceOHLC) ist ein sehr gutes Buch.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLONNECK()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLONNECK(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLPIERCING()Die Funktion wird zur Berechnung derDurchbohrungsmuster (K-Liniendiagramm: Durchbohrungsmuster).
Der Rücklaufwert dertalib.CDLPIERCING()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLPIERCING ((inPriceOHLC) ist eine der wichtigsten
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLPIERCING()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLPIERCING(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLRICKSHAWMAN()Funktion wird zur Berechnung verwendetRickshaw-Mann (K-Liniendiagramm: Rickshaw-Mann).
Der Rücklaufwert dertalib.CDLRICKSHAWMAN()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLRICKSHAWMAN (in Preis)
DieinPriceOHLCDer Parameter wird zur Angabe von K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLRICKSHAWMAN()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLRICKSHAWMAN(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLRISEFALL3METHODS()Funktion wird zur Berechnung verwendetAufstieg/Abstieg drei Methoden (K-Liniendiagramm: Aufstieg/Abstieg drei Methoden).
Der Rücklaufwert dertalib.CDLRISEFALL3METHODS()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLRISEFALL3METHODS ((inPriceOHLC) ist eine Methode, mit der die
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLRISEFALL3METHODS()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLRISEFALL3METHODS(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLSEPARATINGLINES()Funktion wird zur Berechnung verwendetTrennlinien (K-Liniendiagramm: Trennlinien).
Der Rücklaufwert dertalib.CDLSEPARATINGLINES()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLSEPARATINGLINES ((inPriceOHLC) ist eine Liste von
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLSEPARATINGLINES()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLSEPARATINGLINES(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLSHOOTINGSTAR()Die Funktion wird zur Berechnung derSchießender Stern (K-Liniendiagramm: Schießender Stern).
Der Rücklaufwert dertalib.CDLSHOOTINGSTAR()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLSHOOTINGSTAR ((inPriceOHLC) ist ein Spiel, in dem wir uns mit dem Spiel beschäftigen.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLSHOOTINGSTAR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLSHOOTINGSTAR(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLSHORTLINE()Die Funktion wird zur Berechnung derKurze Linie Kerze (K-Liniendiagramm: Kurze Linie).
Der Rücklaufwert dertalib.CDLSHORTLINE()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLSKURZLINE ((inPriceOHLC)
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLSHORTLINE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLSHORTLINE(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLSPINNINGTOP()Funktion wird zur Berechnung verwendetSpinning Top (K-Liniendiagramm: Spinning Top).
Der Rücklaufwert dertalib.CDLSPINNINGTOP()Funktion ist: ein einmaliges Array.
Reihenfolge
Ich bin nicht derjenige, der das Problem hat. Ich bin nicht derjenige, der es hat.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLSPINNINGTOP()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLSPINNINGTOP(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLSTALLEDPATTERN()Funktion wird zur Berechnung verwendetStall Pattern (K-Liniendiagramm: Stall Pattern).
Der Rücklaufwert dertalib.CDLSTALLEDPATTERN()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLSTALLEDPATTERN ((inPriceOHLC) ist ein Modell, das für die Verwendung von
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLSTALLEDPATTERN()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLSTALLEDPATTERN(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLSTICKSANDWICH()Die Funktion wird zur Berechnung derStick Sandwich (K-Liniendiagramm: Stick Sandwich).
Der Rücklaufwert dertalib.CDLSTICKSANDWICH()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLSTICKSANDWICH ((inPriceOHLC) ist eine neue Version von Talib.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLSTICKSANDWICH()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLSTICKSANDWICH(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLTAKURI()Funktion wird zur Berechnung verwendetTakuri (Drachenfliege-Doji mit einer sehr langen unteren Schattenlinie) (K-Liniendiagramm: Takuri).
Der Rücklaufwert dertalib.CDLTAKURI()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLTAKURI ((inPriceOHLC)
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLTAKURI()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLTAKURI(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLTASUKIGAP()Die Funktion wird zur Berechnung derTasuki Gap (K-Liniendiagramm: Tasuki Gap).
Der Rücklaufwert dertalib.CDLTASUKIGAP()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CDLTASUKIGAP ((inPriceOHLC) ist ein Unternehmen, das sich für die Entwicklung von Technologien einsetzt.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLTASUKIGAP()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLTASUKIGAP(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLTHRUSTING()Die Funktion wird zur Berechnung derSchubmuster (K-Liniendiagramm: Schubmuster).
Der Rücklaufwert dertalib.CDLTHRUSTING()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLTHRUSTING ((inPriceOHLC) ist ein sehr guter Anbieter.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLTHRUSTING()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLTHRUSTING(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLTRISTAR()Die Funktion wird zur Berechnung derTristar-Muster (K-Liniendiagramm: Tristar-Muster).
Der Rücklaufwert dertalib.CDLTRISTAR()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLTRISTAR ((inPriceOHLC) ist ein sehr guter Anbieter.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLTRISTAR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLTRISTAR(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLUNIQUE3RIVER()Die Funktion wird zur Berechnung derUnique 3 River (K-Liniendiagramm: Unique 3 River).
Der Rücklaufwert dertalib.CDLUNIQUE3RIVER()Funktion ist: ein einmaliges Array.
Reihenfolge
Ich bin nicht derjenige, der das Problem hat. Ich bin nicht derjenige, der das Problem hat.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLUNIQUE3RIVER()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLUNIQUE3RIVER(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLUPSIDEGAP2CROWS()Funktion wird zur Berechnung verwendetAufwärtstrend zwei Krähen (K-Liniendiagramm: Aufwärtstrend zwei Krähen).
Der Rücklaufwert dertalib.CDLUPSIDEGAP2CROWS()Funktion ist: ein einmaliges Array.
Reihenfolge
Ich bin nicht derjenige, der das Problem hat. Ich bin derjenige, der das Problem hat.
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLUPSIDEGAP2CROWS()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLUPSIDEGAP2CROWS(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.CDLXSIDEGAP3METHODS()Funktion wird zur Berechnung verwendetAufwärts-/Abwärtslücke drei Methoden (K-Liniendiagramm: Aufwärts-/Abwärtslücke drei Methoden).
Der Rücklaufwert dertalib.CDLXSIDEGAP3METHODS()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CDLXSIDEGAP3METHODS ((inPriceOHLC) ist eine Methode, mit der die
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieCDLXSIDEGAP3METHODS()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CDLXSIDEGAP3METHODS(Records[Open,High,Low,Close]) = Array(outInteger)
Dietalib.AD()Die Funktion wird zur Berechnung derChaikin A/D-Linie (Linien-Stochastische Indikator).
Der Rücklaufwert dertalib.AD()Funktion ist: ein einmaliges Array.
Reihenfolge
talib.AD(inPriceHLCV)
DieinPriceHLCVDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLCV
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieAD()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:AD(Records[High,Low,Close,Volume]) = Array(outReal)
Dietalib.ADOSC()Die Funktion wird zur Berechnung derDer Auslöser ist der Auslöser des Auslöser-A/D-Systems..
Der Rücklaufwert dertalib.ADOSC()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.ADOSC ((inPriceHLCV) Talib.ADOSC ((inPriceHLCV, optInFastPeriod, optInSlowPeriod) ist eine Liste von Produkten, die für die Vermarktung von Produkten verwendet werden.
DieinPriceHLCVDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLCV
wahr
{@struct/Record Record} Struktur-Array
DieoptInFastPeriodDer Parameter wird verwendet, um die schnelle Periode festzulegen.
OptionInFastPeriod
falsche
Zahl
DieoptInSlowPeriodDer Parameter wird zur Einstellung der langsamen Periode verwendet.
OptInSlowPeriod
falsche
Zahl
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);
}
DieADOSC()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:ADOSC(Records[High,Low,Close,Volume],Fast Period = 3,Slow Period = 10) = Array(outReal)
Dietalib.OBV()Funktion wird zur Berechnung verwendetÜber das Bilanzvolumen (Energieflut).
Der Rücklaufwert dertalib.OBV()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.OBV ((inReal)) Talib.OBV ((inReal, inPriceV)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieinPriceVDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceV
falsche
{@struct/Record Record} Struktur-Array
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);
}
DieOBV()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:OBV(Records[Close],Records[Volume]) = Array(outReal)
Dietalib.ACOS()Funktion wird zur Berechnung verwendetVektorrigonometrische ACos (umgekehrte Kosinusfunktion).
Der Rücklaufwert dertalib.ACOS()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.ACOS ((inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieACOS()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:ACOS(Records[Close]) = Array(outReal)
Dietalib.ASIN()Die Funktion wird zur Berechnung derVektor-Trigonometrische ASin (umgekehrte Sinusfunktion).
Der Rücklaufwert dertalib.ASIN()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.ASIN ((inReal))
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieASIN()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:ASIN(Records[Close]) = Array(outReal)
Dietalib.ATAN()Die Funktion wird zur Berechnung derVektor-Trigonometrische ATan (umgekehrte Tangenzfunktion).
Der Rücklaufwert dertalib.ATAN()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.ATAN (inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieATAN()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:ATAN(Records[Close]) = Array(outReal)
Dietalib.CEIL()Funktion wird zur Berechnung verwendetVektordeckel (Abrundungsfunktion).
Der Rücklaufwert dertalib.CEIL()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CEIL ((inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieCEIL()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CEIL(Records[Close]) = Array(outReal)
Dietalib.COS()Die Funktion wird zur Berechnung derVektor-Trigonometrische Cos (Kosin-Funktion).
Der Rücklaufwert dertalib.COS()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.COS ((inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieCOS()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:COS(Records[Close]) = Array(outReal)
Dietalib.COSH()Funktion wird zur Berechnung verwendetVektor Trigonometrischer Cosh (hyperbolischer Kosinuswert).
Der Rücklaufwert dertalib.COSH()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.COSH ((inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieCOSH()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:COSH(Records[Close]) = Array(outReal)
Dietalib.EXP()Die Funktion wird zur Berechnung derVektorarithmetik Exp (Exponentialfunktion).
Der Rücklaufwert dertalib.EXP()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.EXP ((inReal))
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieEXP()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:EXP(Records[Close]) = Array(outReal)
Dietalib.FLOOR()Die Funktion wird zur Berechnung derVektorboden (nach unten gerundet).
Der Rücklaufwert dertalib.FLOOR()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.FLOOR ((inReal))
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieFLOOR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:FLOOR(Records[Close]) = Array(outReal)
Dietalib.LN()Die Funktion wird zur Berechnung derVektor Log Natural (natürlicher Logarithmus).
Der Rücklaufwert dertalib.LN()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.LN (inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieLN()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:LN(Records[Close]) = Array(outReal)
Dietalib.LOG10()Funktion wird zur Berechnung verwendetVektor Log10 (logarithmische Funktion).
Der Rücklaufwert dertalib.LOG10()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.LOG10 (inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieLOG10()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:LOG10(Records[Close]) = Array(outReal)
Dietalib.SIN()Funktion wird zur Berechnung verwendetVektor Trigonometrische Sin (Sinuswert).
Der Rücklaufwert dertalib.SIN()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.SIN ((inReal))
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieSIN()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:SIN(Records[Close]) = Array(outReal)
Dietalib.SINH()Die Funktion wird zur Berechnung derVektor Trigonometrische Synch (hyperbolische Sinusfunktion).
Der Rücklaufwert dertalib.SINH()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.SINH ((inReal))
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieSINH()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:SINH(Records[Close]) = Array(outReal)
Dietalib.SQRT()Die Funktion wird zur Berechnung derQuadratwurzel des Vektors.
Der Rücklaufwert dertalib.SQRT()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.SQRT (inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieSQRT()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:SQRT(Records[Close]) = Array(outReal)
Dietalib.TAN()Die Funktion wird zur Berechnung derVektor Trigonometrischer Tan (Tangente).
Der Rücklaufwert dertalib.TAN()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.TAN ((inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieTAN()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:TAN(Records[Close]) = Array(outReal)
Dietalib.TANH()Die Funktion wird zur Berechnung derVektor Trigonometrische Tanh (hyperbolische Tangenzfunktion).
Der Rücklaufwert dertalib.TANH()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.TANH (inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieTANH()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:TANH(Records[Close]) = Array(outReal)
Dietalib.MAX()Die Funktion wird verwendet, um den höchsten (maximalen) Wert für einespezifischer Zeitraum.
Der Rücklaufwert dertalib.MAX()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.MAX (inReal) Talib.MAX ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieMAX()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MAX(Records[Close],Time Period = 30) = Array(outReal)
Dietalib.MAXINDEX()Funktion wird zur Berechnung verwendetder Index des höchsten Wertes im angegebenen Zeitraum (maximaler Index).
Der Rücklaufwert dertalib.MAXINDEX()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.MAXINDEX ((inReal) Talib.MAXINDEX ((inReal, optInTimePeriod) ist eine Angabe, die sich auf die Anzahl der Daten bezieht.
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieMAXINDEX()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MAXINDEX(Records[Close],Time Period = 30) = Array(outInteger)
Dietalib.MIN()Die Funktion wird zur Berechnung des niedrigsten Wertes (Mindestwert)** für den angegebenen Zeitraum verwendet.
Der Rücklaufwert dertalib.MIN()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.MIN ((inReal) Talib.MIN ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieMIN()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MIN(Records[Close],Time Period = 30) = Array(outReal)
Dietalib.MININDEX()Funktion wird zur Berechnung verwendetder niedrigste Wertindex (Mindestwertindex)für den angegebenen Zeitraum.
Der Rücklaufwert dertalib.MININDEX()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.MININDEX ((inReal) Talib.MININDEX ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieMININDEX()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MININDEX(Records[Close],Time Period = 30) = Array(outInteger)
Dietalib.MINMAX()Funktion wird zur Berechnung verwendetdie niedrigsten und höchsten (Mindest- und Höchstwerte) für den angegebenen Zeitraum.
Der Rücklaufwert dertalib.MINMAX()Das erste Element dieses zweidimensionalen Arrays ist das Array der Mindestwerte, und das zweite Element ist das Array der Maximalwerte.
Reihenfolge
Talib.MINMAX ((inReal) Talib.MINMAX ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieMINMAX()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MINMAX(Records[Close],Time Period = 30) = [Array(outMin),Array(outMax)]
Dietalib.MINMAXINDEX()Funktion wird zur Berechnung verwendetder Index der niedrigsten und höchsten Werte (Mindest- und Höchstindex) im angegebenen Zeitraum.
Der Rücklaufwert dertalib.MINMAXINDEX()Das erste Element dieses zweidimensionalen Arrays ist das minimale indexierte Array und das zweite Element ist das maximale indexierte Array.
Reihenfolge
Talib.MINMAXINDEX ((inReal) Talib.MINMAXINDEX ((inReal, optInTimePeriod) ist die Anzahl der Zeitpunkte, in denen ein Teil der Daten übermittelt wird.
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieMINMAXINDEX()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MINMAXINDEX(Records[Close],Time Period = 30) = [Array(outMinIdx),Array(outMaxIdx)]
Dietalib.SUM()Funktion wird zur Berechnung verwendetZusammenfassung.
Der Rücklaufwert dertalib.SUM()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.SUM ((inReal) Talib.SUM ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieSUM()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:SUM(Records[Close],Time Period = 30) = Array(outReal)
Dietalib.HT_DCPERIOD()Die Funktion wird zur Berechnung derHilbertsche Transformation - Dominanzperiode des Zyklus.
Der Rücklaufwert dertalib.HT_DCPERIOD()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.HT_DCPERIOD ((inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieHT_DCPERIOD()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:HT_DCPERIOD(Records[Close]) = Array(outReal)
Dietalib.HT_DCPHASE()Die Funktion wird zur Berechnung derHilbertsche Transform - Dominanzzyklusphase.
Der Rücklaufwert dertalib.HT_DCPHASE()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.HT_DCPHASE ((inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieHT_DCPHASE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:HT_DCPHASE(Records[Close]) = Array(outReal)
Dietalib.HT_PHASOR()Die Funktion wird zur Berechnung derHilbertsche Transform - Phasorkomponenten (Hilbertsche Transform, Phasekomponenten).
Der Rücklaufwert dertalib.HT_PHASOR()Die Funktion ist ein zweidimensionales Array.
Reihenfolge
Talib.HT_PHASOR ((inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieHT_PHASOR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:HT_PHASOR(Records[Close]) = [Array(outInPhase),Array(outQuadrature)]
Dietalib.HT_SINE()Die Funktion wird zur Berechnung derHilbertsche Transform - Sinuswelle.
Der Rücklaufwert dertalib.HT_SINE()Funktion ist: eine zweidimensionale Matrix.
Reihenfolge
Talib.HT_SINE ((inReal))
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieHT_SINE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:HT_SINE(Records[Close]) = [Array(outSine),Array(outLeadSine)]
Dietalib.HT_TRENDMODE()Die Funktion wird zur Berechnung derHilbert-Transform - Trend und Zyklusmodus.
Der Rücklaufwert dertalib.HT_TRENDMODE()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.HT_TRENDMODE ((inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieHT_TRENDMODE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:HT_TRENDMODE(Records[Close]) = Array(outInteger)
Dietalib.ATR()Die Funktion wird zur Berechnung derDurchschnittlicher tatsächlicher Bereich.
Der Rücklaufwert dertalib.ATR()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.ATR ((inPriceHLC) Talib.ATR ((inPriceHLC, optInTimePeriod)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieATR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:ATR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Dietalib.NATR()Die Funktion wird zur Berechnung derNormalisierter durchschnittlicher tatsächlicher Bereich.
Der Rücklaufwert dertalib.NATR()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.NATR ((inPriceHLC) Talib.NATR ((inPriceHLC, optInTimePeriod)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieNATR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:NATR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Dietalib.TRANGE()Die Funktion wird zur Berechnung derWirkliche Reichweite.
Der Rücklaufwert dertalib.TRANGE()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.TRANGE ((inPriceHLC)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieTRANGE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:TRANGE(Records[High,Low,Close]) = Array(outReal)
Dietalib.BBANDS()Funktion wird zur Berechnung verwendetBollinger-Bänder.
Der Rücklaufwert dertalib.BBANDS()Funktion ist: ein zweidimensionales Array. Das Array enthält drei Elemente, die sind: die obere Linie Array, die mittlere Linie Array, und die untere Linie Array.
Reihenfolge
Talib.BBANDS ((inReal) Talib.BBANDS ((inReal, optInTimePeriod) ist eine Liste von Talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp) Talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn) Talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn, optInMAType)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 5.
OptionInZeitzeitraum
falsche
Zahl
DieoptInNbDevUpParameter wird verwendet, um den Upline-Multiplikator zu setzen, der Standardwert ist 2.
Option InNbDevUp
falsche
Zahl
DieoptInNbDevDnDer Parameter wird verwendet, um den Multiplikator der unteren Zeile festzulegen, der Standardwert ist 2.
- Ich habe keine Ahnung.
falsche
Zahl
DieoptInMATypeDer Parameter wird verwendet, um den mittleren Typ festzulegen, der Standardwert ist 0.
OptionInMAType
falsche
Zahl
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);
}
DieBBANDS()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:BBANDS(Records[Close],Time Period = 5,Deviations up = 2,Deviations down = 2,MA Type = 0) = [Array(outRealUpperBand),Array(outRealMiddleBand),Array(outRealLowerBand)]
Dietalib.DEMA()Die Funktion wird zur Berechnung derDoppel exponentieller gleitender Durchschnitt.
Der Rücklaufwert dertalib.DEMA()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.DEMA ((inReal) Talib.DEMA ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieDEMA()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:DEMA(Records[Close],Time Period = 30) = Array(outReal)
Dietalib.EMA()Die Funktion wird zur Berechnung derExponentieller gleitender Durchschnitt.
Der Rücklaufwert dertalib.EMA()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.EMA (inReal) Talib.EMA ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieEMA()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:EMA(Records[Close],Time Period = 30) = Array(outReal)
Dietalib.HT_TRENDLINE()Die Funktion wird zur Berechnung derHilbertsche Transform - Sofortige Trendlinie (Hilbertsche Transform, sofortige Trendlinie).
Der Rücklaufwert dertalib.HT_TRENDLINE()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.HT_TRENDLINE ((inReal)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
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);
}
DieHT_TRENDLINE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:HT_TRENDLINE(Records[Close]) = Array(outReal)
Dietalib.KAMA()Die Funktion wird zur Berechnung derKaufman Adaptiver gleitender Durchschnitt.
Der Rücklaufwert dertalib.KAMA()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.KAMA (inReal) Talib.KAMA ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieKAMA()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:KAMA(Records[Close],Time Period = 30) = Array(outReal)
Dietalib.MA()Die Funktion wird zur Berechnung derGleitender Durchschnitt.
Der Rücklaufwert dertalib.MA()Funktion ist: ein einmaliges Array.
Reihenfolge
talib.MA(inReal)talib.MA(inReal, optInTimePeriod)talib.MA(inReal, optInTimePeriod, optInMAType)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
DieoptInMATypeDer Parameter wird verwendet, um den mittleren Typ festzulegen, der Standardwert ist 0.
OptionInMAType
falsche
Zahl
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);
}
DieMA()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MA(Records[Close],Time Period = 30,MA Type = 0) = Array(outReal)
Dietalib.MAMA()Die Funktion wird zur Berechnung derMESA Adaptiver gleitender Durchschnitt.
Der Rücklaufwert dertalib.MAMA()Funktion ist: eine zweidimensionale Matrix.
Reihenfolge
Talib.MAMA ((inReal) Talib.MAMA ((inReal, optInFastLimit) Talib.MAMA ((inReal, optInFastLimit, optInSlowLimit) Ich bin nicht derjenige, der das Problem hat.
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInFastLimitDer Parameter wird verwendet, um das Schnelllimit festzulegen, der Standardwert beträgt 0,5.
Optimieren in FastLimit
falsche
Zahl
DieoptInSlowLimitDer Parameter wird verwendet, um die langsame Grenze festzulegen, der Standardwert ist 0,05.
Optimieren
falsche
Zahl
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);
}
DieMAMA()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MAMA(Records[Close],Fast Limit = 0.5,Slow Limit = 0.05) = [Array(outMAMA),Array(outFAMA)]
Dietalib.MIDPOINT()Die Funktion wird zur Berechnung derMittelpunkt über einen Zeitraum (Mittelpunkt).
Der Rücklaufwert dertalib.MIDPOINT()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.MIDPOINT ((inReal) Talib.MIDPOINT ((inReal, optInTimePeriod) ist eine Liste von Daten, die in einem System verwendet werden.
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieMIDPOINT()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MIDPOINT(Records[Close],Time Period = 14) = Array(outReal)
Dietalib.MIDPRICE()Die Funktion wird zur Berechnung derMittelpunktpreis über einen Zeitraum (Mittelpunktpreis).
Der Rücklaufwert dertalib.MIDPRICE()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.MIDPRICE ((inPriceHL)) Talib.MIDPRICE ((inPriceHL, optInTimePeriod) ist eine Liste von Produkten, die in einem bestimmten Zeitraum erhältlich sind.
DieinPriceHLDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHL
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieMIDPRICE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MIDPRICE(Records[High,Low],Time Period = 14) = Array(outReal)
Dietalib.SAR()Die Funktion wird zur Berechnung derParabolische SAR.
Der Rücklaufwert dertalib.SAR()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.SAR ((inPriceHL) Talib.SAR ((inPriceHL, optInAcceleration) Talib.SAR ((inPriceHL, optInAcceleration, optInMaximum)
DieinPriceHLDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHL
wahr
{@struct/Record Record} Struktur-Array
DieoptInAccelerationDer Parameter wird verwendet, um den Beschleunigungsfaktor festzulegen, der Standardwert beträgt 0,02.
OptionIn Beschleunigung
falsche
Zahl
DieoptInMaximumDer Parameter wird verwendet, um das AF-Maxim zu setzen, der Standardwert beträgt 0,2.
Option maximal
falsche
Zahl
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);
}
DieSAR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:SAR(Records[High,Low],Acceleration Factor = 0.02,AF Maximum = 0.2) = Array(outReal)
Dietalib.SAREXT()Die Funktion wird zur Berechnung derParabolische SAR - Erweiterte (verstärkte parabolische Lenkung).
Der Rücklaufwert dertalib.SAREXT()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.SAREXT ((inPriceHL) Talib.SAREXT ((inPriceHL, optInStartValue) Talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse) Talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong) Talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong) Talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong) Talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort) Talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort, optInAccelerationShort) Talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort, optInAccelerationShort, optInAccelerationMaxShort)
DieinPriceHLDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHL
wahr
{@struct/Record Record} Struktur-Array
DieoptInStartValueDer Parameter wird verwendet, um den Startwert festzulegen, der Standardwert ist 0.
OptionInStartWert
falsche
Zahl
DieoptInOffsetOnReverseDer Parameter wird verwendet, um Offset auf Reverse zu setzen, der Standardwert ist 0.
Option InOffsetOnReverse
falsche
Zahl
DieoptInAccelerationInitLongDer Parameter wird verwendet, um den AF Init Long einzustellen, der Standardwert beträgt 0,02.
OptionIn BeschleunigungIn EsLang
falsche
Zahl
DieoptInAccelerationLongDer Parameter wird verwendet, um den AF Long einzustellen, der Standardwert beträgt 0,02.
OptionIn BeschleunigungLang
falsche
Zahl
DieoptInAccelerationMaxLongDer Parameter wird verwendet, um die AF Max Long einzustellen, der Standardwert beträgt 0,2.
OptionInVerschleunigungMaxLong
falsche
Zahl
DieoptInAccelerationInitShortDer Parameter wird verwendet, um AF Init Short einzustellen, der Standardwert beträgt 0,02.
OptionIn BeschleunigungIn Kurz
falsche
Zahl
DieoptInAccelerationShortDer Parameter wird verwendet, um AF Short einzustellen, der Standardwert beträgt 0,02.
OptionInAcceleration Kurz
falsche
Zahl
DieoptInAccelerationMaxShortDer Parameter wird verwendet, um AF Max Short einzustellen, der Standardwert beträgt 0,2.
Option InAccelerationMaxShort
falsche
Zahl
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);
}
DieSAREXT()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben: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)
Dietalib.SMA()Funktion wird zur Berechnung verwendetEinfacher gleitender Durchschnitt.
Der Rücklaufwert dertalib.SMA()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.SMA ((inReal) Talib.SMA ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieSMA()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:SMA(Records[Close],Time Period = 30) = Array(outReal)
Dietalib.T3()Die Funktion wird zur Berechnung derDreifacher exponentieller gleitender Durchschnitt (T3) (dreifacher exponentieller gleitender Durchschnitt).
Der Rücklaufwert dertalib.T3()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.T3 ((inReal) Talib.T3 ((inReal, optInTimePeriod) Talib.T3 ((inReal, optInTimePeriod, optInVFactor)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 5.
OptionInZeitzeitraum
falsche
Zahl
DieoptInVFactorDer Parameter wird verwendet, um den Volumenfaktor einzusetzen, der Standardwert beträgt 0,7.
OptionInVFaktor
falsche
Zahl
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);
}
DieT3()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:T3(Records[Close],Time Period = 5,Volume Factor = 0.7) = Array(outReal)
Dietalib.TEMA()Funktion wird zur Berechnung verwendetDreifacher exponentieller gleitender Durchschnitt.
Der Rücklaufwert dertalib.TEMA()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.TEMA ((inReal) Talib.TEMA ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieTEMA()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:TEMA(Records[Close],Time Period = 30) = Array(outReal)
Dietalib.TRIMA()Die Funktion wird zur Berechnung derDreiecks gleitender Durchschnitt (dreiexponential gleitender Durchschnitt).
Der Rücklaufwert dertalib.TRIMA()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.TRIMA ((inReal) Talib.TRIMA ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieTRIMA()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:TRIMA(Records[Close],Time Period = 30) = Array(outReal)
Dietalib.WMA()Die Funktion wird zur Berechnung derGewichteter gleitender Durchschnitt (WMA).
Der Rücklaufwert dertalib.WMA()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.WMA ((inReal) Talib.WMA ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieWMA()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:WMA(Records[Close],Time Period = 30) = Array(outReal)
Dietalib.LINEARREG()Funktion wird zur Berechnung verwendetLineare Regression.
Der Rücklaufwert dertalib.LINEARREG()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.LINEARREG ((inReal)) Talib.LINEARREG ((inReal, optInTimePeriod) ist die Anzahl der Zeiträume, in denen ein Teil der Zeiträume in einem anderen Teil der Zeiträume verbleibt.
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieLINEARREG()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:LINEARREG(Records[Close],Time Period = 14) = Array(outReal)
Dietalib.LINEARREG_ANGLE()Die Funktion wird zur Berechnung derLineare Regressionswinkel.
Der Rücklaufwert dertalib.LINEARREG_ANGLE()Funktion ist: ein einmaliges Array.
Reihenfolge
Das ist nicht wahr. Talib.LINEARREG_ANGLE ((inReal, optInTimePeriod) ist die Anzahl der Zeiten, in denen ein Teil der Zeit in einem anderen Teil der Zeit verbleibt.
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieLINEARREG_ANGLE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:LINEARREG_ANGLE(Records[Close],Time Period = 14) = Array(outReal)
Dietalib.LINEARREG_INTERCEPT()Die Funktion wird zur Berechnung derLineare Regressionsunterbrechung.
Der Rücklaufwert dertalib.LINEARREG_INTERCEPT()Funktion ist: ein einmaliges Array.
Reihenfolge
Das ist nicht wahr. Talib.LINEARREG_INTERCEPT ((inReal, optInTimePeriod) ist die Anzahl der Zeiten, in denen ein Teil der Zeit in einem bestimmten Zeitraum verbleibt.
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieLINEARREG_INTERCEPT()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:LINEARREG_INTERCEPT(Records[Close],Time Period = 14) = Array(outReal)
Dietalib.LINEARREG_SLOPE()Die Funktion wird zur Berechnung derLineare Regressionsneigung.
Der Rücklaufwert dertalib.LINEARREG_SLOPE()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.LINEARREG_SLOPE ((inReal) Talib.LINEARREG_SLOPE ((inReal, optInTimePeriod) ist die Anzahl der Zeiträume, in denen die Daten gespeichert werden.
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieLINEARREG_SLOPE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:LINEARREG_SLOPE(Records[Close],Time Period = 14) = Array(outReal)
Dietalib.STDDEV()Funktion wird zur Berechnung verwendetStandardabweichung.
Der Rücklaufwert dertalib.STDDEV()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.STDDEV ((inReal)) Talib.STDDEV ((inReal, optInTimePeriod) Talib.STDDEV ((inReal, optInTimePeriod, optInNbDev)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 5.
OptionInZeitzeitraum
falsche
Zahl
DieoptInNbDevDer Parameter wird verwendet, um die Abweichungen festzulegen, der Standardwert ist 1.
OptiInNbDev
falsche
Zahl
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);
}
DieSTDDEV()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:STDDEV(Records[Close],Time Period = 5,Deviations = 1) = Array(outReal)
Dietalib.TSF()Funktion wird zur Berechnung verwendetZeitreihenprognose.
Der Rücklaufwert dertalib.TSF()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.TSF ((inReal) Talib.TSF ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieTSF()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:TSF(Records[Close],Time Period = 14) = Array(outReal)
Dietalib.VAR()Funktion wird zur Berechnung verwendetAbweichung.
Der Rücklaufwert dertalib.VAR()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.VAR ((inReal) Talib.VAR ((inReal, optInTimePeriod) Talib.VAR ((inReal, optInTimePeriod, optInNbDev)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 5.
OptionInZeitzeitraum
falsche
Zahl
DieoptInNbDevDer Parameter wird verwendet, um die Abweichungen festzulegen, der Standardwert ist 1.
OptiInNbDev
falsche
Zahl
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);
}
DieVAR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:VAR(Records[Close],Time Period = 5,Deviations = 1) = Array(outReal)
Dietalib.ADX()Die Funktion wird zur Berechnung derDurchschnittlicher Richtungsbewegungsindex.
Der Rücklaufwert dertalib.ADX()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.ADX ((inPriceHLC) Talib.ADX ((inPriceHLC, optInTimePeriod)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieADX()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:ADX(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Dietalib.ADXR()Die Funktion wird zur Berechnung derDurchschnittliche Bewegungsindexbewertung (Bewertungsindex).
Der Rücklaufwert dertalib.ADXR()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.ADXR ((inPriceHLC) Talib.ADXR ((inPriceHLC, optInTimePeriod)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieADXR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:ADXR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Dietalib.APO()Die Funktion wird zur Berechnung derAbsolute Preis-Oszillator.
Der Rücklaufwert dertalib.APO()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.APO ((inReal) Talib.APO ((inReal, optInFastPeriod) Talib.APO ((inReal, optInFastPeriod, optInSlowPeriod) ist eine der wichtigsten Funktionen des Programms. Talib.APO ((inReal, optInFastPeriod, optInSlowPeriod, optInMAType)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInFastPeriodDer Parameter wird verwendet, um die schnelle Periode festzulegen, der Standardwert ist 12.
OptInFastPeriod
falsche
Zahl
DieoptInSlowPeriodDer Parameter wird verwendet, um die langsame Periode festzulegen, der Standardwert ist 26.
OptionInSlowPeriod
falsche
Zahl
DieoptInMATypeDer Parameter wird verwendet, um den mittleren Typ festzulegen, der Standardwert ist 0.
OptionInMAType
falsche
Zahl
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);
}
DieAPO()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:APO(Records[Close],Fast Period = 12,Slow Period = 26,MA Type = 0) = Array(outReal)
Dietalib.AROON()Die Funktion wird zur Berechnung derAroon (Aroon-Indikator).
Der Rücklaufwert dertalib.AROON()Die Funktion ist ein zweidimensionales Array.
Reihenfolge
Talib.AROON ((inPriceHL) Talib.AROON ((inPreisHL, optInTimePeriod)
DieinPriceHLDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHL
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieAROON()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:AROON(Records[High,Low],Time Period = 14) = [Array(outAroonDown),Array(outAroonUp)]
Dietalib.AROONOSC()Die Funktion wird zur Berechnung derAroon-Oszillator.
Der Rücklaufwert dertalib.AROONOSC()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.AROONOSC (in Preis) Talib.AROONOSC ((inPriceHL, optInTimePeriod) ist eine Liste von Produkten, die für die Vermarktung von Produkten verwendet werden.
DieinPriceHLDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHL
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieAROONOSC()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:AROONOSC(Records[High,Low],Time Period = 14) = Array(outReal)
Dietalib.BOP()Die Funktion wird zur Berechnung derMachtgleichgewicht.
Der Rücklaufwert dertalib.BOP()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.BOP ((inPriceOHLC)
DieinPriceOHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceOHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieBOP()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:BOP(Records[Open,High,Low,Close]) = Array(outReal)
Dietalib.CCI()Die Funktion wird zur Berechnung derIndex der Warenkanäle (homöopathischer Indikator).
Der Rücklaufwert dertalib.CCI()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.CCI ((inPriceHLC) Talib.CCI ((inPriceHLC, optInTimePeriod)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieCCI()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CCI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Dietalib.CMO()Die Funktion wird zur Berechnung derChande Momentum Oscillator (CMO).
Der Rücklaufwert dertalib.CMO()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.CMO ((inReal) Talib.CMO ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieCMO()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:CMO(Records[Close],Time Period = 14) = Array(outReal)
Dietalib.DX()Die Funktion wird zur Berechnung derRichtungsbewegungsindex.
Der Rücklaufwert dertalib.DX()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.DX ((inPriceHLC) Talib.DX ((inPriceHLC, optInTimePeriod)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieDX()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:DX(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Dietalib.MACD()Funktion wird zur Berechnung verwendetSchwankende Durchschnittskonvergenz/Divergenz (exponentiell glätteter gleitender Durchschnitt).
Der Rücklaufwert dertalib.MACD()Funktion ist: eine zweidimensionale Matrix.
Reihenfolge
Talib.MACD (inReal) Talib.MACD ((inReal, optInFastPeriod) Talib.MACD ((inReal, optInFastPeriod, optInSlowPeriod) Talib.MACD ((inReal, optInFastPeriod, optInSlowPeriod, optInSignalPeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInFastPeriodDer Parameter wird verwendet, um die schnelle Periode festzulegen, der Standardwert ist 12.
OptInFastPeriod
falsche
Zahl
DieoptInSlowPeriodDer Parameter wird verwendet, um die langsame Periode festzulegen, der Standardwert ist 26.
OptionInSlowPeriod
falsche
Zahl
DieoptInSignalPeriodDer Parameter wird verwendet, um den Signalzeitraum festzulegen, der Standardwert ist 9.
OptInSignalPeriode
falsche
Zahl
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);
}
DieMACD()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MACD(Records[Close],Fast Period = 12,Slow Period = 26,Signal Period = 9) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
Dietalib.MACDEXT()Funktion wird zur Berechnung verwendetMACD mit kontrollierbarem MA-Typ.
Der Rücklaufwert dertalib.MACDEXT()Die Funktion ist ein zweidimensionales Array.
Reihenfolge
Talib.MACDEXT ((inReal) Talib.MACDEXT ((inReal, optInFastPeriod) ist eine neue Version von Talib. Talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType) Talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod) ist eine Liste von Programmen, die für die Anwendung von MACDEXT verwendet werden. talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType) Die Daten werden in einem anderen Format gespeichert. Talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType, optInSignalPeriod) Talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType, optInSignalPeriod, optInSignalMAType)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInFastPeriodDer Parameter wird verwendet, um die schnelle Periode festzulegen, der Standardwert ist 12.
OptInFastPeriod
falsche
Zahl
DieoptInFastMATypeDer Parameter wird verwendet, um den Typ des schnellen Durchschnitts festzulegen, der Standardwert ist 0.
Optimieren von
falsche
Zahl
DieoptInSlowPeriodDer Parameter wird verwendet, um die langsame Periode festzulegen, der Standardwert ist 26.
OptionInSlowPeriod
falsche
Zahl
DieoptInSlowMATypeDer Parameter wird verwendet, um den Typ des langsamen Mittelwerts festzulegen, der Standardwert ist 0.
Optimieren des Moduls
falsche
Zahl
DieoptInSignalPeriodDer Parameter wird verwendet, um den Signalzeitraum festzulegen, der Standardwert ist 9.
OptInSignalPeriode
falsche
Zahl
DieoptInSignalMATypeDer Parameter wird verwendet, um den Typ des Signaldurchschnitts festzulegen, der Standardwert ist 0.
Option InSignalMAType
falsche
Zahl
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);
}
DieMACDEXT()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben: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)]
Dietalib.MACDFIX()Funktion wird zur Berechnung verwendetBeweglicher Durchschnittskonvergenz/Divergenzfix 12/26.
Der Rücklaufwert dertalib.MACDFIX()Die Funktion ist ein zweidimensionales Array.
Reihenfolge
Talib.MACDFIX ((inReal) Talib.MACDFIX ((inReal, optInSignalPeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInSignalPeriodDer Parameter wird verwendet, um den Signalzeitraum festzulegen, der Standardwert ist 9.
OptInSignalPeriode
falsche
Zahl
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);
}
DieMACDFIX()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MACDFIX(Records[Close],Signal Period = 9) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
Dietalib.MFI()Die Funktion wird zur Berechnung derGeldflussindex.
Der Rücklaufwert dertalib.MFI()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.MFI ((inPriceHLCV) Talib.MFI ((inPriceHLCV, optInTimePeriod)
DieinPriceHLCVDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLCV
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieMFI()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MFI(Records[High,Low,Close,Volume],Time Period = 14) = Array(outReal)
Dietalib.MINUS_DI()Die Funktion wird zur Berechnung derMinus-Richtungsindikator (negativer Indikator).
Der Rücklaufwert dertalib.MINUS_DI()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.MINUS_DI ((inPriceHLC) Talib.MINUS_DI ((inPriceHLC, optInTimePeriod)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieMINUS_DI()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MINUS_DI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Dietalib.MINUS_DM()Die Funktion wird zur Berechnung derMinus Richtungsbewegung (negative Bewegung).
Der Rücklaufwert dertalib.MINUS_DM()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.MINUS_DM ((inPriceHL) Talib.MINUS_DM ((inPriceHL, optInTimePeriod)
DieinPriceHLDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHL
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieMINUS_DM()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MINUS_DM(Records[High,Low],Time Period = 14) = Array(outReal)
Dietalib.MOM()Funktion wird zur Berechnung verwendetMomentum.
Der Rücklaufwert dertalib.MOM()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.MOM ((inReal) Talib.MOM ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 10.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieMOM()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MOM(Records[Close],Time Period = 10) = Array(outReal)
Dietalib.PLUS_DI()Die Funktion wird zur Berechnung derPlus-Richtungsanzeiger.
Der Rücklaufwert dertalib.PLUS_DI()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.PLUS_DI (inPriceHLC) Talib.PLUS_DI ((inPriceHLC, optInTimePeriod)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DiePLUS_DI()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:PLUS_DI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Dietalib.PLUS_DM()Funktion wird zur Berechnung verwendetZusätzliche Richtungsbewegung.
Der Rücklaufwert dertalib.PLUS_DM()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.PLUS_DM ((inPriceHL) Talib.PLUS_DM ((inPriceHL, optInTimePeriod)
DieinPriceHLDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHL
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DiePLUS_DM()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:PLUS_DM(Records[High,Low],Time Period = 14) = Array(outReal)
Dietalib.PPO()Die Funktion wird zur Berechnung derProzentualer Preis-Oszillator.
Der Rücklaufwert dertalib.PPO()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.PPO ((inReal) Talib.PPO ((inReal, optInFastPeriod) Talib.PPO ((inReal, optInFastPeriod, optInSlowPeriod) Talib.PPO ((inReal, optInFastPeriod, optInSlowPeriod, optInMAType)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInFastPeriodDer Parameter wird verwendet, um die schnelle Periode festzulegen, der Standardwert ist 12.
OptInFastPeriod
falsche
Zahl
DieoptInSlowPeriodDer Parameter wird verwendet, um die langsame Periode festzulegen, der Standardwert ist 26.
OptionInSlowPeriod
falsche
Zahl
DieoptInMATypeDer Parameter wird verwendet, um den mittleren Typ festzulegen, der Standardwert ist 0.
OptionInMAType
falsche
Zahl
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);
}
DiePPO()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:PPO(Records[Close],Fast Period = 12,Slow Period = 26,MA Type = 0) = Array(outReal)
Dietalib.ROC()Funktion wird zur Berechnung verwendetVeränderungsrate: ((Preis/PrevPrice) -1) * 100 (Wandelungsrate).
Der Rücklaufwert dertalib.ROC()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.ROC ((inReal) Talib.ROC ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 10.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieROC()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:ROC(Records[Close],Time Period = 10) = Array(outReal)
Dietalib.ROCP()Funktion wird zur Berechnung verwendetVeränderungsrate Prozentsatz: (Preis-vorpreis) /prevPrice (Preisänderungsrate).
Der Rücklaufwert dertalib.ROCP()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.ROCP ((inReal) Talib.ROCP ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 10.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieROCP()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:ROCP(Records[Close],Time Period = 10) = Array(outReal)
Dietalib.ROCR()Die Funktion wird zur Berechnung derWechselkursverhältnis: (Preis/Vorpreis) (Verhältnis der Preisänderung).
Der Rücklaufwert dertalib.ROCR()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.ROCR ((inReal) Talib.ROCR ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 10.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieROCR()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:ROCR(Records[Close],Time Period = 10) = Array(outReal)
Dietalib.ROCR100()Funktion wird zur Berechnung verwendetVeränderungsquote 100 Skala: (Preis/PrevPrice) *100 (Preisveränderungsquote).
Der Rücklaufwert dertalib.ROCR100()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.ROCR100 ((inReal) Talib.ROCR100 ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 10.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieROCR100()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:ROCR100(Records[Close],Time Period = 10) = Array(outReal)
Dietalib.RSI()Die Funktion wird zur Berechnung derRelativer Stärkeindex.
Der Rücklaufwert dertalib.RSI()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.RSI (inReal) Talib.RSI ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieRSI()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:RSI(Records[Close],Time Period = 14) = Array(outReal)
Dietalib.STOCH()Die Funktion wird zur Berechnung derStochastik (STOCH-Indikator).
Der Rücklaufwert dertalib.STOCH()Die Funktion ist ein zweidimensionales Array.
Reihenfolge
Talib.STOCH ((inPriceHLC) Talib.STOCH ((inPriceHLC, optInFastK_Period) Talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period) Talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType) Talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType, optInSlowD_Period) Talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType, optInSlowD_Period, optInSlowD_MAType)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInFastK_PeriodDer Parameter wird verwendet, um die Fast-K-Periode festzulegen, der Standardwert ist 5.
Optimierung der Datenbank
falsche
Zahl
DieoptInSlowK_PeriodDer Parameter wird verwendet, um die Slow-K-Periode festzulegen, der Standardwert ist 3.
Optimierung der Datenbank
falsche
Zahl
DieoptInSlowK_MATypeDer Parameter wird verwendet, um den Slow-K-Durchschnittstyp festzulegen, der Standardwert ist 0.
Optimieren des Moduls
falsche
Zahl
DieoptInSlowD_PeriodDer Parameter wird verwendet, um die Slow-D-Periode festzulegen, der Standardwert beträgt 3.
Optimierung der Datenübertragung
falsche
Zahl
DieoptInSlowD_MATypeDer Parameter wird verwendet, um den Slow-D-Durchschnittstyp festzulegen, wobei der Standardwert 0 ist.
Optimieren des Moduls
falsche
Zahl
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);
}
DieSTOCH()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben: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)]
Dietalib.STOCHF()Die Funktion wird zur Berechnung derStochastic Fast (schneller STOCH-Indikator).
Der Rücklaufwert dertalib.STOCHF()Die Funktion ist ein zweidimensionales Array.
Reihenfolge
Talib.STOCHF ((inPriceHLC) Talib.STOCHF ((inPriceHLC, optInFastK_Period) Talib.STOCHF ((inPriceHLC, optInFastK_Period, optInFastD_Period) Talib.STOCHF ((inPriceHLC, optInFastK_Period, optInFastD_Period, optInFastD_MAType)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInFastK_PeriodDer Parameter wird verwendet, um die Fast-K-Periode festzulegen, der Standardwert ist 5.
Optimierung der Datenbank
falsche
Zahl
DieoptInFastD_PeriodDer Parameter wird verwendet, um die Fast-D-Periode festzulegen, der Standardwert ist 3.
Option InFastD_Periode
falsche
Zahl
DieoptInFastD_MATypeDer Parameter wird verwendet, um den Fast-D-Durchschnittstyp festzulegen, der Standardwert ist 0.
Optimierung der Datenbank
falsche
Zahl
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);
}
DieSTOCHF()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:STOCHF(Records[High,Low,Close],Fast-K Period = 5,Fast-D Period = 3,Fast-D MA = 0) = [Array(outFastK),Array(outFastD)]
Dietalib.STOCHRSI()Die Funktion wird zur Berechnung derStochastic Relative Strength Index.
Der Rücklaufwert dertalib.STOCHRSI()Funktion ist: eine zweidimensionale Matrix.
Reihenfolge
Talib.STOCHRSI ((inReal) Talib.STOCHRSI ((inReal, optInTimePeriod) ist eine Liste von Daten, die in einem bestimmten Zeitraum gespeichert wurden. Talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period) ist die Anzahl der Daten, die für die Anmeldung verwendet werden. Talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period, optInFastD_Period) Talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period, optInFastD_Period, optInFastD_MAType)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
DieoptInFastK_PeriodDer Parameter wird verwendet, um die Fast-K-Periode festzulegen, der Standardwert ist 5.
Optimierung der Datenbank
falsche
Zahl
DieoptInFastD_PeriodDer Parameter wird verwendet, um die Fast-D-Periode festzulegen, der Standardwert ist 3.
Option InFastD_Periode
falsche
Zahl
DieoptInFastD_MATypeDer Parameter wird verwendet, um den Fast-D-Durchschnittstyp festzulegen, der Standardwert ist 0.
Optimierung der Datenbank
falsche
Zahl
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);
}
DieSTOCHRSI()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:STOCHRSI(Records[Close],Time Period = 14,Fast-K Period = 5,Fast-D Period = 3,Fast-D MA = 0) = [Array(outFastK),Array(outFastD)]
Dietalib.TRIX()Die Funktion wird zur Berechnung derEin-Tage-Rate-Of-Change (ROC) einer dreifachen glatten EMA.
Der Rücklaufwert dertalib.TRIX()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.TRIX ((inReal) Talib.TRIX ((inReal, optInTimePeriod)
DieinRealDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inReal
- Das stimmt.
{@struct/Record Record} Struktur- und Zahlenarrays
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 30.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieTRIX()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:TRIX(Records[Close],Time Period = 30) = Array(outReal)
Dietalib.ULTOSC()Die Funktion wird zur Berechnung derEndgültiger Oszillator.
Der Rücklaufwert dertalib.ULTOSC()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.ULTOSC ((inPriceHLC) Talib.ULTOSC ((inPriceHLC, optInTimePeriod1)) ist eine Liste von Produkten, die für die Verwendung in der Industrie verwendet werden. Talib.ULTOSC ((inPriceHLC, optInTimePeriod1, optInTimePeriod2) Talib.ULTOSC ((inPriceHLC, optInTimePeriod1, optInTimePeriod2, optInTimePeriod3)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriod1Der Parameter wird verwendet, um die erste Periode festzulegen, der Standardwert ist 7.
OptInTimePeriod1
falsche
Zahl
DieoptInTimePeriod2Der Parameter wird verwendet, um die zweite Periode festzulegen, der Standardwert ist 14.
OptionInZeitPeriode2
falsche
Zahl
DieoptInTimePeriod3Der Parameter wird verwendet, um die dritte Periode festzulegen, der Standardwert ist 28.
optInTimePeriod3
falsche
Zahl
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);
}
DieULTOSC()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:ULTOSC(Records[High,Low,Close],First Period = 7,Second Period = 14,Third Period = 28) = Array(outReal)
Dietalib.WILLR()Funktion wird zur Berechnung verwendetWilliams
Der Rücklaufwert dertalib.WILLR()Funktion ist: ein einmaliges Array.
Reihenfolge
Talib.WILLR ((inPriceHLC) Talib.WILLR ((inPriceHLC, optInTimePeriod)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
DieoptInTimePeriodDer Parameter wird verwendet, um den Zeitraum festzulegen, der Standardwert ist 14.
OptionInZeitzeitraum
falsche
Zahl
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);
}
DieAVGPRICE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:AVGPRICE(Records[Open,High,Low,Close]) = Array(outReal)
Dietalib.MEDPRICE()Die Funktion wird zur Berechnung derDurchschnittlicher Preis.
Der Rücklaufwert dertalib.MEDPRICE()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.MEDPRICE (in Preis)
DieinPriceHLDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHL
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieMEDPRICE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:MEDPRICE(Records[High,Low]) = Array(outReal)
Dietalib.TYPPRICE()Funktion wird zur Berechnung verwendetTypischer Preis.
Der Rücklaufwert dertalib.TYPPRICE()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.TYPPRICE ((inPriceHLC) ist eine
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieTYPPRICE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:TYPPRICE(Records[High,Low,Close]) = Array(outReal)
Dietalib.WCLPRICE()Die Funktion wird zur Berechnung derGewichteter Schlusskurs.
Der Rücklaufwert dertalib.WCLPRICE()Funktion ist ein einmaliges Array.
Reihenfolge
Talib.WCLPRICE ((inPriceHLC)
DieinPriceHLCDer Parameter wird zur Angabe der K-Liniendaten verwendet.
inPriceHLC
wahr
{@struct/Record Record} Struktur-Array
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);
}
DieWCLPRICE()Die Funktion wird in der Dokumentation der Talib-Bibliothek wie folgt beschrieben:WCLPRICE(Records[High,Low,Close]) = Array(outReal)