Die Ressourcen sind geladen. Beförderung...
  1. Foren
  2. Hilfe!
  3. FMZ-API-Anweisungen

FMZ-API-Anweisungen

Schriftsteller:Null, Erstellt: 2020-04-20 10:19:00, Aktualisiert: 2023-04-12 14:44:56

oparameter is set toZeichenorZeichen, theder Parameter key``` erforderlich ist.

function main(){
    Log(Encode("md5", "raw", "hex", "hello"))
    Log(Encode("sha512", "raw", "base64", "hello"))
    Log(Encode("keccak256", "raw", "hex", "unwrapWETH9(uint256,address)"))

    Log(Encode("raw", "string", "hex", "example"))          // 6578616d706c65
    Log(Encode("raw", "hex", "string", "6578616d706c65"))   // example
}

def main():
    Log(Encode("md5", "raw", "hex", "hello", "", ""))
    Log(Encode("sha512", "raw", "base64", "hello", "", ""))
    Log(Encode("keccak256", "raw", "hex", "unwrapWETH9(uint256,address)", "", ""))

    Log(Encode("raw", "string", "hex", "example", "", ""))
    Log(Encode("raw", "hex", "string", "6578616d706c65", "", ""))

void main(){
    Log(Encode("md5", "raw", "hex", "hello"));
    Log(Encode("sha512", "raw", "base64", "hello"));
    Log(Encode("keccak256", "raw", "hex", "unwrapWETH9(uint256,address)"));
    
    Log(Encode("raw", "string", "hex", "example"));          // 6578616d706c65
    Log(Encode("raw", "hex", "string", "6578616d706c65"));   // example
}

Der Parameteralgounterstützt auch das Kodieren und Entschlüsseln von Zeichenfolgen, wietext.encoder.utf8, text.decoder.utf8, text.encoder.gbkundtext.decoder.gbk.

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);
}

UnixNano (siehe unten)

UnixNano()gibt einen Zeitstempel auf Nanosekundenebene zurück; wenn Sie den Zeitstempel auf Millisekundenebene erhalten müssen, können Sie den folgenden Code verwenden:

function main() {
    var time = UnixNano() / 1000000
    Log(_N(time, 0))
}

def main():
    time = UnixNano()
    Log(time)

void main() {
    auto time = UnixNano();
    Log(time);
}

Unix()

Unix()Gibt einen Zeitstempel in Sekunden zurück.

function main() {
    var t = Unix()
    Log(t)
}

def main():
    t = Unix()
    Log(t)

void main() {
    auto t = Unix();
    Log(t);
}

GetOS()

GetOS()gibt Informationen über das System zurück, in dem sich der Docker befindet.

function main() {
    Log("GetOS:", GetOS())
}

def main():
    Log("GetOS:", GetOS())

void main() {
    Log("GetOS:", GetOS());
}

Die Log-Ausgabe des vonMac OSvon einem Apple-Computer:

GetOS: darwin/amd64

darwinist der Name derMac OS system.

MD5 ((String)

MD5(String); Parameterwert: Zeichenfolgeart.

function main() {
    Log("MD5", MD5("hello world"))
}

def main():
    Log("MD5", MD5("hello world"))

void main() {
    Log("MD5", MD5("hello world"));
}

Ausgabe des Protokolls:

Wir haben eine Reihe von Problemen.

DBExec ((...)

DBExec(), sein Parameterwert könnte String, Zahl oder Boolean, Null und andere Typen sein; Return-Wert: das Objekt mit den Ausführungsresultaten in der SQLite-Sprache.DBExec(), die Schnittstellenfunktion der Datenbank, durch das Übergeben von Parametern, kann die Datenbank des Bots (SQLite-Datenbank) ausführen.SQLiteDas System speichert Tabellen in der Bot-Datenbank, darunter:kvdb, cfg, log, profitundchart- keine der oben erwähnten Tabellen bedienen.DBExec()Unterstützt nur den echten Bot.

  • Unterstützt Speicherdatenbank Für die FunktionsparameterDBExec, wenn dieQuadratkilometerBeginnt mit:, die Operationen in der Speicherdatenbank werden schneller, ohne Dateien zu schreiben.

    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 the 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 the 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 the data
    Log(DBExec(":SELECT * FROM TEST_TABLE;"));
}

  • Erstellen einer Tabelle

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);
}
  • Die in der Tabelle aufgezeichneten Zusatz-, Lösch-, Abfrage- und Änderungen
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 the data
    Log(DBExec("SELECT * FROM TEST_TABLE;"))
    
    // Modify the data
    Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000))    
    
    // Delete the 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 the data
    Log(DBExec("SELECT * FROM TEST_TABLE;"))
    
    # Modify the data
    Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000))
    
    # Delete the 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 the data
    Log(DBExec("SELECT * FROM TEST_TABLE;"));
    
    // Modify the data
    Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000));
    
    // Delete the data
    Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110));
}

UUID (()

UUID(), gibt eine 32-Bit-Unique UUID zurück, diese Funktion ist nur für echte Bots verfügbar.

function main() {
    var uuid1 = UUID()
    var uuid2 = UUID()
    Log(uuid1, uuid2)
}

def main():
    uuid1 = UUID()
    uuid2 = UUID()
    Log(uuid1, uuid2)

void main() {
    auto uuid1 = UUID();
    auto uuid2 = UUID();
    Log(uuid1, uuid2);
}

EventLoop (Zeitrahmen)

EventLoop(timeout), wird nach einerwebsocketLesbar oderexchange.Go, HttpQuery_GoWenn der Parametertimeoutist auf 0 gesetzt, warten Sie, bis ein Ereignis auftritt, bevor Sie zurückkehren. Wenn es größer als 0 ist, setzen Sie das Ereignis auf Wartezeit. Wenn es kleiner als 0 ist, geben Sie das letzte Ereignis sofort zurück. Wenn das zurückgegebene Objekt nichtnull, dieEventDiese Funktion ist nur für den echten Bothandel verfügbar.

Der erste Anruf vonEventLoopWenn der erste Aufruf vonEventLoopDie von dem zugrunde liegenden System eingekapselte Warteschlangeinheit speichert bis zu 500 Ereignisrückrufe.EventLoopwenn die Anrufung nicht rechtzeitig zur Entfernung während der Programmdurchführung aufgenommen wird, werden die späteren Ereignisrückrufe über den 500-Cache hinaus verloren.EventLoopFunktion wird die Cache-Warteschlange vonwebsocketDas ist nicht nur das Problem.exchange.GoFür die Daten, die vor der Auswahl entnommen wurden, müssen die Daten in den Caches gespeichert werden.EventLoopFunktion zurückgibt, wird kein Rückgabeereignis in derEventLoop function.

Der Hauptzweck derEventLoopDie Strategie-Schicht wird von der Netzwerk-Layer informiert, dass das zugrunde liegende System neue Netzwerkdaten erhalten hat.EventLoopWenn die Funktion ein Ereignis zurückgibt, müssen Sie nur alle Datenquellen durchqueren.websocketVerbindungen und Objekte, die vonexchange.GoSie können sich auf ein Open-Source-Klassenbibliotheksdesign beziehen:Klassenbibliotheksverbindung.

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, the subsequent EventLoop function will miss the previous events, because after waiting for 2 seconds, the concurrent function has received the data, and the EventLoop monitoring mechanism will start later, and these events will be missed
     // Unless you start calling EventLoop(-1) on the first line of code, first initialize the listening mechanism of EventLoop, you will not miss these events

     // Log("GetDepth:", routine_getDepth.wait()) If the wait function is called in advance to get the result of the concurrent call of the GetDepth function, the event that the GetDepth function receives the request result 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);
}

Eingebaute Funktionen

_G(K, V)

_G(K, V), mit der Funktion eines globalen Wörterbuchs, das gespeichert werden kann, unterstützt sowohl Backtest als auch Bot. Nach dem Backtest werden die gespeicherten Daten gelöscht. Die Datenstruktur istKVJeder Bot hat eine separate Datenbank. Sie wird immer existieren, wenn der Docker wieder gestartet wird.Kmuss eine Zeichenkette sein, die nicht für Großbuchstaben sensibel ist.Vkann jeder seinJSONDie Funktion "Serialisierbare Inhalte" ist eine Funktion, die_G()wird aufgerufen und keine Parameter im Bot-Betrieb übergeben, die Funktion_G()Gibt dieIDdes aktuellen Bots.

function main(){
    // Set a global variable num with a value of 1
    _G("num", 1)     
    // Change a global variable num with the value "ok"
    _G("num", "ok")    
    // Delete global variable num
    _G("num", null)
    // Return the value of the global variable num
    Log(_G("num"))
    // Delete all global variables
    _G(null)
    // Return bot 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);
    // does not support auto robotId = _G();
}

Anmerkung: Wenn Sie die_GDie Datensicherungsfunktion sollte entsprechend dem Speicher- und Festplattenraum des Hardwaregeräts vernünftig genutzt und nicht missbraucht werden.Speicherüberflutung problem.

Zeitstempel, FMT

_D(Timestamp, Fmt), gibt die entsprechenden Zeitrahmen der angegebenen Zeitstempel zurück.Timestampist ein numerischer Typ, in Millisekunden.Fmtist ein Zeichenkettentyp;FmtStandardeinstellungen auf:yyyy-MM-dd hh:mm:ss; Rückgabewert: Zeichenfolgeart. Es gibt die angegebene Zeitstempel ((ms) String zurück und gibt die aktuelle Zeit zurück, ohne Parameter zu übergeben; zum Beispiel:_D()oder_D(1478570053241), wobei das Standardformatyyyy-MM-dd hh:mm:ss.

function main(){
    var time = _D()
    Log(time)
}

def main():
    strTime = _D()
    Log(strTime)

void main() {
    auto strTime = _D();
    Log(strTime);
}

Anmerkung: Bei Anwendung_D()in derPythonStrategie, müssen wir darauf achten, dass die übermittelten Parameter Zeitstempel in Sekunden (die Millisekunden-Ebene Zeitstempel in derJavaScriptundC ++Strategie, und 1 Sekunde = 1000 Millisekunden). Im Bot, wenn die Funktion verwendet wird_D()um eine Zeitfolge mit einem lesbaren Zeitstempel zu analysieren, müssen Sie auf die Zeitzone im Betriebssystem des Docker-Programms achten._D()analysiert einen Zeitstempel als lesbare Zeitfolge basierend auf der Zeit des Docker-Systems.

Zum Beispiel, ein Zeitstempel von1574993606000mit Code:

function main() {
    Log(_D(1574993606000))
}

def main():
    # Beijing time server runs: 2019-11-29 10:13:26, and the docker on another server in another region runs this code will get the results: 2019-11-29 02:13:26
    Log(_D(1574993606))

void main() {
    Log(_D(1574993606000));
}

_N ((Nummer, Präzision)

_N(Num, Precision), eine formatierte Fließkomma-Nummer.Numist numerischer Art;Precisionist des ganzen Typs. Rückgabewert: numerischer Typ.

Zum Beispiel:_N(3.1415, 2)wird den Wert nach zwei Dezimalstellen von3.1415und zurück3.14.

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);
}

Wenn Sie N Ziffern links vom Dezimalpunkt auf 0 ändern müssen, können Sie schreiben:

function main(){
    var i = 1300
    Log(i)
    var ii = _N(i, -3)
    // Checking the log shows 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);
}

- Ich weiß.

_C(function, args…)ist eine Wiederholungsfunktion, die für die Fehlerverträglichkeit der Schnittstellen zur Erfassung von Marktinformationen und zum Erwerb unvollendeter Aufträge usw. verwendet wird.

Die Schnittstelle wird die angegebene Funktion kontinuierlich aufrufen, bis sie erfolgreich zurückgegeben wird (ParameterfunctionGibt Null-Wert zurück, wenn die referenzierte Funktion aufgerufen wird oderfalseSie werden den Anruf erneut versuchen._ C(exchange. GetTicker), ist das Standard-Wiederversuchsintervall 3 Sekunden, das die Funktion aufrufen kann_CDelay (...)Um das Wiederversuchsintervall festzulegen, z. B._CDelay (1000)bedeutet Veränderungsfunktion_CWiederholung des Versuchsintervalls auf 1 Sekunde.

für folgende Funktionen:

  • exchange.GetTicker()
  • exchange.GetDepth()
  • exchange.GetTrades()
  • exchange.GetRecords()
  • exchange.GetAccount()
  • exchange.GetOrders()
  • exchange.GetOrder()
  • exchange.GetPosition()

Sie können alle aufgerufen werden, Fehlerverträglichkeit nach Funktion zu tun_C(...). Die Funktion_C(function, args...)ist nicht auf die Fehlerverträglichkeit der oben aufgeführten Funktionen beschränkt.functionist nicht genannt zitiert, und achten Sie darauf, dass es ist_C(exchange.GetTicker), nicht_C(exchange.GetTicker()).

function main(){
    var ticker = _C(exchange.GetTicker)
    // Adjust _C() function's 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 Funktionen mit Parametern bei Verwendung_C(...)für die Fehlerverträglichkeit:

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);
}

Es kann auch für die eigene Funktionsfehlertoleranz verwendet werden:

var test = function(a, b){
    var time = new Date().getTime() / 1000
    if(time % b == 3){
        Log("Meet the criteria! ", "#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("Meet the criteria!", "#FF0000")
        return True
    Log("Retry!", "#FF0000")
    return False

def main():
    ret = _C(test, 1, 5)
    Log(ret)

// C++ does not support this method for fault tolerance of custom functions.

_Kreuzung ((Arr1, Arr2)

_Cross(Arr1, Arr2)Gibt die Anzahl der Kreuzungszeiten der Arrays zurückArr1undArr2. Eine positive Zahl ist die Periode des Aufschwungs, und eine negative Zahl ist die Periode des Abschwungs, und 0 bedeutet das gleiche wie der aktuelle Preis. Parameterwert: Array des Zahlentyps.

Sie können eine Reihe von Daten simulieren, um die Funktion zu testen_Cross(Arr1, Arr2):

// Fast line indicator
var arr1 = [1,2,3,4,5,6,8,8,9]
// Slow line indicator
var arr2 = [2,3,4,5,6,7,7,7,7]
function main(){
    Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2))
    Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1))
}

arr1 = [1,2,3,4,5,6,8,8,9]     
arr2 = [2,3,4,5,6,7,7,7,7]
def main():
    Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2))
    Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1))

void main() {
    vector<double> arr1 = {1,2,3,4,5,6,8,8,9};
    vector<double> arr2 = {2,3,4,5,6,7,7,7,7};
    Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2));
    Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1));
}

img

Visualisieren Sie die simulierten Daten zur Beobachtung

img

Spezifische Anweisungen:Eingebaute Funktion _Kreuzanalyse und Anweisungen

JSONParse ((strJson)

JSONParse(strJson), die Funktion wird verwendet, um JSON-Strings zu analysieren. JSON-Strings mit großen Zahlen können korrekt analysiert werden, und große Zahlen werden in Stringtypen analysiert. Das Backtesting-System unterstützt diese Funktion nicht.

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
}

Benutzerdefinierte Farbe

Jede Nachrichtenfolge kann mit einem RGB-Wert wie#ff0000, die die dargestellte Vordergrundfarbe darstellt.#ff0000112233, die letzten sechs Hinterseiten stellen die Hintergrundfarbe dar.

function main() {
    Log("Red", "#FF0000")
}

def main():
    Log("Red", "#FF0000")

void main() {
    Log("Red", "#FF0000");
}

Daten des Protokolls

Wenn der Bot ausgeführt wird, werden die Protokollinformationen in der Datenbank des Bots erfasst, die diesqlite3Die Datenbankdateien befinden sich im Gerät mit dem Dockerprogramm, und der genaue Standort der Dateien ist im Wörterbuch des Dockerprogramms (robotBeispiel: Die Bot-Datenbankdatei mit ID130350ist im Verzeichnis../logs/storage/130350 (..ist das Wörterbuch, in dem der Docker derrobotist), und der Dateinamen der Datenbank ist130350.db3.

Die Protokolle im Backtest-System können heruntergeladen werden, indem Sie auf [Downloadprotokoll] Schaltfläche in der unteren rechten Ecke der Backtestseite nach Beendigung des Backtests. Wenn Sie den Bot auf einen Docker auf einem anderen Server übertragen müssen, können Sie die Datenbankdateien des Bots (Datenbankdateien mit der Erweiterung db3) auf den Transferzielserver verschieben und den Dateinamen auf die entsprechende Bot-ID auf der Plattform setzen. Auf diese Weise werden alle Protokollinformationen des vorherigen Bots nicht durch die Migration auf das neue Gerät verloren gehen.

Das ist der Fall.

Log(message)bedeutet, eine Nachricht in die Protokollliste zu speichern.messagekann jeder Art sein. Wenn Sie das Zeichen hinzufügen@Nach der Zeichenfolge wird die Nachricht in die Push-Warteschlange eingegeben und auf das aktuelle WeChat-Konto der FMZ Quant Trading-Plattform geschoben, und die Email, Telegram und WebHook in der Push-Einstellungen werden gedrückt (die Seiten vonDashboard, AbrechnungundEinstellungen drückenDurch Anordnungen zur Festlegung von Verpflichtungen).

Anmerkung:

  • Push wird im Debug Tool nicht unterstützt.
  • Push wird im Backtest System nicht unterstützt.
function main() {
    Log("Hello FMZ Quant!@")
    Sleep(1000 * 5)
    // Add the string to #ff0000, 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@");
}

WebHookSchieben:

Verwenden Sie das Dienstprogramm DEMO inGolang:

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)
}

AusgestattetWebHook: http://XXX.XX.XXX.XX:9090/data?data=Hello_FMZ

Nachdem das Serviceprogramm ausgeführt wurde, führen Sie die Strategie aus und drücken Sie die Information:

function main() {
    Log("msg", "@")
}

def main():
    Log("msg", "@")

void main() {
    Log("msg", "@");
}

Erhalten Sie die Push-Informationen, und das Serviceprogramm druckt die Informationen:

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}

Drucken Sie diebase64Bild mit CodeDie FunktionLogunterstützt das Drucken der inbase64, beginnt sie mit`, und endet mit`, zum Beispiel:

function main() {
    Log("`data:image/png;base64,AAAA`")
}

def main():
    Log("`data:image/png;base64,AAAA`")

void main() {
    Log("`data:image/png;base64,AAAA`");
}

Logunterstützt den Druck dermatplotlib.pyplotGegenstände vonPythonSie sind direkt, d.h. solange die GegenständesavefigMethode können Sie verwendenLogzum direkten Drucken, z. B.:

import matplotlib.pyplot as plt 
def main(): 
    plt.plot([3,6,2,4,7,1]) 
    Log(plt)

Automatische Sprachaustausch von gedruckten ProtokollenDie FunktionLogunterstützt den Sprachwechsel; wenn die Funktion Text ausgibt, wechselt sie automatisch nach der Spracheinstellung auf der Plattformseite auf die entsprechende Sprache.

function main() {
    Log("[trans]Chinese|abc[/trans]")
}

def main():
    Log("[trans]Chinese|abc[/trans]")

void main() {
    Log("[trans]Chinese|abc[/trans]");
}

LogProfit ((Profit))

LogProfit(Profit)Der Profitwert wird erfasst, gedruckt und eine Gewinnkurve nach dem Gewinnwert gezogen.Gewinnist numerischer Typ.

Wenn die Funktion mit dem Zeichen endet&, kann es nur realisieren, das Gewinndiagramm zu zeichnen, und nicht das Gewinnprotokoll zu drucken, wie:LogProfit(10, '&').

LogProfitReset (siehe unten)

LogProfitReset()Löscht alle Gewinnprotokolle; zur Angabe der Anzahl der reservierten Elemente kann ein ganzzahliger Wert verwendet werden.

function main() {
    // Print 30 points on the income chart, then reset, and only retain 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);
}

LogStatus (Msg)

LogStatus(Msg), werden die Informationen nicht in der Protokollliste gespeichert, nur die aktuellen Statusinformationen des Bots werden aktualisiert; sie werden über dem Protokoll angezeigt und können mehrmals aufgerufen werden, um den Status zu aktualisieren.Msgkann jeder Art sein.

function main() {
    LogStatus('This is a normal status prompt')
    LogStatus('This is a status prompt in red font # ff0000')
    LogStatus('This is a multi-line status message \n I am the second line')
}

def main():
    LogStatus('This is a normal status prompt')
    LogStatus('This is a status prompt in red font # ff0000')
    LogStatus('This is a multi-line status message \nI am the second line')

void main() {
    LogStatus("This is a normal status prompt");
    LogStatus("This is a status prompt in red font # ff0000");
    LogStatus("This is a multi-line status message \nI am the second line");
}

LogStatus(Msg)Unterstützung des Druckensbase64Gecodeerte Bilder, angefangen mit`und endet mit`, wie z. B.:LogStatus("`data:image/png;base64,AAAA`"). LogStatus(Msg)Unterstützung der direkten EinfuhrPythonDas ist...matplotlib.pyplotObjekt, solange das ObjektsavefigMethode, können Sie in der Funktion passierenLogStatus(Msg), wie z. B.:

import matplotlib.pyplot as plt 
def main():
    plt.plot([3,6,2,4,7,1])
    LogStatus(plt)

Das Ausgabebeispiel der Daten in der Statusleiste:

function main() {
    var table = {type: 'table', title: 'Position Information', cols: ['Column1', 'Column2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
    // After the JSON order is serialized, add the character "`" on both sides, which is regarded as a complex message format (currently supporting tables)
    LogStatus('`' + JSON.stringify(table) + '`')                    
    // Table information can also appear in multiple lines
    LogStatus('First line message\n`' + JSON.stringify(table) + '`\nThird line message')
    // That supports multiple tables displayed at the same time, and that will be displayed in a group with TAB
    LogStatus('`' + JSON.stringify([table, table]) + '`')
    
    // You can also construct a button in the table, and the strategy uses "GetCommand" to receive the content of the cmd attribute                                
    var table = { 
        type: 'table', 
        title: 'Position operation', 
        cols: ['Column1', 'Column2', 'Action'], 
        rows: [ 
            ['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': 'close position'}]
        ]
    }
    LogStatus('`' + JSON.stringify(table) + '`') 
    // Or create a separate button 
    LogStatus('`' + JSON.stringify({'type':'button', 'cmd': 'coverAll', 'name': 'close position'}) + '`') 
    // You can customize the button style (button attribute of bootstrap)
    LogStatus('`' + JSON.stringify({'type':'button', 'class': 'btn btn-xs btn-danger', 'cmd': 'coverAll', 'name': 'close position'}) + '`')
}

import json
def main():
    table = {"type": "table", "title": "Position Information", "cols": ["Column1", "Column2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]}
    LogStatus('`' + json.dumps(table) + '`')
    LogStatus('First line message\n`' + json.dumps(table) + '`\nThird line message')
    LogStatus('`' + json.dumps([table, table]) + '`')

    table = {
        "type" : "table", 
        "title" : "Position operation", 
        "cols" : ["Column1", "Column2", "Action"], 
        "rows" : [
            ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "close position"}]
        ] 
    }
    LogStatus('`' + json.dumps(table) + '`')
    LogStatus('`' + json.dumps({"type": "button", "cmd": "coverAll", "name": "close position"}) + '`')
    LogStatus('`' + json.dumps({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "close position"}) + '`')

void main() {
    json table = R"({"type": "table", "title": "Position Information", "cols": ["Column1", "Column2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
    LogStatus("`" + table.dump() + "`");
    LogStatus("First line message\n`" + table.dump() + "`\nThird line message");
    json arr = R"([])"_json;
    arr.push_back(table);
    arr.push_back(table);
    LogStatus("`" + arr.dump() + "`");

    table = R"({
        "type" : "table", 
        "title" : "Position operation", 
        "cols" : ["Column1", "Column2", "Action"], 
        "rows" : [
            ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "close position"}]
        ] 
    })"_json;
    LogStatus("`" + table.dump() + "`");
    LogStatus("`" + R"({"type": "button", "cmd": "coverAll", "name": "close position"})"_json.dump() + "`");
    LogStatus("`" + R"({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "close position"})"_json.dump() + "`");
}

Einstellen der Deaktivierungs- und Beschreibungsfunktionen der Statusleiste-Tasten:

img

function main() {
    var table = {
        type: "table",
        title: "Test the disable and description functions of status bar buttons",
        cols: ["Column1", "Column2", "Column3"], 
        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 enabled", "disabled": false}
    table.rows.push([button1, button2, button3])
    LogStatus("`" + JSON.stringify(table) + "`")
}

import json
def main():
    table = {
        "type": "table",
        "title": "Test the disable and description functions of status bar buttons",
        "cols": ["Column1", "Column2", "Column3"], 
        "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 enabled", "disabled": False}
    table["rows"].append([button1, button2, button3])
    LogStatus("`" + json.dumps(table) + "`")

void main() {
    json table = R"({
        "type": "table",
        "title": "Test the disable and description functions of status bar buttons",
        "cols": ["Column1", "Column2", "Column3"], 
        "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 enabled", "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() + "`");
}

Styling der Statusleiste:

img

function main() {
    var table = {
        type: "table",
        title: "status bar button style",
        cols: ["default", "raw", "success", "information", "warning", "danger"], 
        rows: [
            [
                {"type":"button", "class": "btn btn-xs btn-default", "name": "default"},
                {"type":"button", "class": "btn btn-xs btn-primary", "name": "raw"},
                {"type":"button", "class": "btn btn-xs btn-success", "name": "success"},
                {"type":"button", "class": "btn btn-xs btn-info", "name": "information"},
                {"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", "raw", "success", "information", "warning", "danger"], 
        "rows": [
            [
                {"type":"button", "class": "btn btn-xs btn-default", "name": "default"},
                {"type":"button", "class": "btn btn-xs btn-primary", "name": "raw"},
                {"type":"button", "class": "btn btn-xs btn-success", "name": "success"},
                {"type":"button", "class": "btn btn-xs btn-info", "name": "information"},
                {"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", "raw", "success", "information", "warning", "danger"], 
        "rows": [
            [
                {"type":"button", "class": "btn btn-xs btn-default", "name": "default"},
                {"type":"button", "class": "btn btn-xs btn-primary", "name": "raw"},
                {"type":"button", "class": "btn btn-xs btn-success", "name": "success"},
                {"type":"button", "class": "btn btn-xs btn-info", "name": "information"},
                {"type":"button", "class": "btn btn-xs btn-warning", "name": "warning"},
                {"type":"button", "class": "btn btn-xs btn-danger", "name": "danger"}
            ]
        ]
    })"_json;
    LogStatus("`" + table.dump() + "`");
}

Kombination der FunktionGetCommand()zur Erstellung der interaktiven Funktion der Statusleiste-Tasten:

function test1() {
    Log("Call a custom function")
}

function main() {
    while (true) {
        var table = {
            type: 'table',
            title: 'operation',
            cols: ['Column1', 'Column2', 'Action'],
            rows: [
                ['a', '1', {
                    'type': 'button',                       
                    'cmd': "CoverAll",                      
                    'name': 'close position'                           
                }],
                ['b', '1', {
                    'type': 'button',
                    'cmd': 10,                              
                    'name': 'Send value'
                }],
                ['c', '1', {
                    'type': 'button',
                    'cmd': _D(),                          
                    'name': 'Call a function'
                }],
                ['d', '1', {
                    'type': 'button',
                    'cmd': 'test1',       
                    'name': 'Call a custom function'
                }]
            ]
        }
        LogStatus(_D(), "\n", '`' + JSON.stringify(table) + '`')

        var str_cmd = GetCommand()
        if (str_cmd) {
            Log("Received interactive data str_cmd:", "Types of:", typeof(str_cmd), "Value:", str_cmd)
            if(str_cmd == "test1") {
                test1()
            }
        }

        Sleep(500)
    }
}

import json
def test1():
    Log("Call a custom function")

def main():
    while True:
        table = {
            "type": "table", 
            "title": "Operation", 
            "cols": ["Column1", "Column2", "Action"],
            "rows": [
                ["a", "1", {
                    "type": "button", 
                    "cmd": "CoverAll",
                    "name": "close position"
                }],
                ["b", "1", {
                    "type": "button",
                    "cmd": 10,
                    "name": "Send value" 
                }], 
                ["c", "1", {
                    "type": "button",
                    "cmd": _D(),
                    "name": "Call a function" 
                }],
                ["d", "1", {
                    "type": "button",
                    "cmd": "test1",
                    "name": "Call a custom function" 
                }]
            ]
        }

        LogStatus(_D(), "\n", "`" + json.dumps(table) + "`")
        str_cmd = GetCommand()
        if str_cmd:
            Log("Received interactive data str_cmd", "Types:", type(str_cmd), "Value:", str_cmd)
            if str_cmd == "test1":
                test1()
        Sleep(500)

void test1() {
    Log("Call a custom function");
}

void main() {
    while(true) {
        json table = R"({
            "type": "table", 
            "title": "Operation", 
            "cols": ["Column1", "Column2", "Action"],
            "rows": [
                ["a", "1", {
                    "type": "button", 
                    "cmd": "CoverAll",
                    "name": "close position"
                }],
                ["b", "1", {
                    "type": "button",
                    "cmd": 10,
                    "name": "Send value" 
                }], 
                ["c", "1", {
                    "type": "button",
                    "cmd": "",
                    "name": "Call a function" 
                }],
                ["d", "1", {
                    "type": "button",
                    "cmd": "test1",
                    "name": "Call a custom function" 
                }]
            ]
        })"_json;
        table["rows"][2][2]["cmd"] = _D();
        LogStatus(_D(), "\n", "`" + table.dump() + "`");
        auto str_cmd = GetCommand();
        if(str_cmd != "") {
            Log("Received interactive data str_cmd", "Type:", typeid(str_cmd).name(), "Value:", str_cmd);
            if(str_cmd == "test1") {
                test1();
            }
        }
        Sleep(500);
    }
}

Bei der Konstruktion einer Statusleiste-Taste für die Interaktion werden auch Eingabedaten unterstützt, und der interaktive Befehl wird letztendlich vomGetCommand()Funktion. Um eineinputElement in die Datenstruktur einer Tastensteuerung in der Statusleiste, z. B."input": {"name": "Number of opening orders", "type": "number", "defValue": 1}zu{"type": "button", "cmd": "open", "name": "open position"}, können Sie die Schaltfläche mit einem Eingabefeldsteuerungsknopf zum Klicken eröffnen lassen (Der Standardwert im Eingabefeld ist 1, der durch die defValue-Daten festgelegt wird), und Sie können Daten eingeben, die mit dem Buttonbefehl gesendet werden sollen. Zum Beispiel, wenn Sie den folgenden Testcode ausführen, wird nach dem Klicken auf die Open position-Schaltfläche ein Dialog mit einem Eingabefeld angezeigt.111in das Eingabefeld und klicken Sie auf "OK",GetCommandFunktion wird die Nachricht erfassen:open:111.

function main() {
    var tbl = {
        type: "table",
        title: "operation",
        cols: ["column 1", "column2"],
        rows: [
            ["Open position operation", {"type": "button", "cmd": "open", "name": "open position", "input": {"name": "number of opening 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": ["column 1", "column 2"],
        "rows": [
            ["Open position operation", {"type": "button", "cmd": "open", "name": "open position", "input": {"name": "number of opening 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": ["column 1", "column 2"],
        "rows": [
            ["Open position operation", {"type": "button", "cmd": "open", "name": "open position", "input": {"name": "number of opening 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);
    }
}

Kombination der Zellen in der von derLogStatus(Msg)Funktion:

  • Horizontale Fusion

    function main() {
    var table = { 
        type: 'table', 
        title: 'position operation', 
        cols: ['Column1', 'Column2', 'Action'], 
        rows: [ 
            ['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': 'close position'}]
        ]
    } 
    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 position"}]
        ]
    }
    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" : [
Die nächste Seite Nächste Seite
Mehr

2019 FMZ - Alle Rechte vorbehalten