Erfinder quantifizieren die API-Dokumentation

Die Daten sind bereits eingegangen, und die EventLoop-Aufhörmechanismen wurden erst eingerichtet, um die Ereignisse zu übersehen. // Diese Ereignisse werden nicht übersehen, es sei denn, man ruft in der ersten Codezeile den EventLoop ((-1) an und initialiert zuerst den Abhörmechanismus für den EventLoop

// Log("GetDepth:", routine_getDepth.wait()) 如果这里提前调用wait函数取出GetDepth函数并发调用的结果，此次GetDepth函数收到请求结果的事件便不会在EventLoop函数返回
var ts1 = new Date().getTime()
var ret1 = EventLoop(0)

var ts2 = new Date().getTime()
var ret2 = EventLoop(0)

var ts3 = new Date().getTime()
var ret3 = EventLoop(0)

Log("第1个并发任务完成的为：", _D(ts1), ret1)
Log("第2个并发任务完成的为：", _D(ts2), ret2)
Log("第3个并发任务完成的为：", _D(ts3), ret3)

Log("GetTicker:", routine_getTicker.wait())
Log("GetDepth:", routine_getDepth.wait())
Log("GetTrades:", routine_getTrades.wait())

}

```python
import time
def main():
    routine_getTicker = exchange.Go("GetTicker")
    routine_getDepth = exchange.Go("GetDepth")
    routine_getTrades = exchange.Go("GetTrades")
    
    ts1 = time.time()
    ret1 = EventLoop(0)
    
    ts2 = time.time()
    ret2 = EventLoop(0)
    
    ts3 = time.time()
    ret3 = EventLoop(0)
    
    Log("第1个并发任务完成的为：", _D(ts1), ret1)
    Log("第2个并发任务完成的为：", _D(ts2), ret2)
    Log("第3个并发任务完成的为：", _D(ts3), ret3)
    
    Log("GetTicker:", routine_getTicker.wait())
    Log("GetDepth:", routine_getDepth.wait())
    Log("GetTrades:", routine_getTrades.wait())

void main() {
    auto routine_getTicker = exchange.Go("GetTicker");
    auto routine_getDepth = exchange.Go("GetDepth");
    auto routine_getTrades = exchange.Go("GetTrades");
    
    auto ts1 = Unix() * 1000;
    auto ret1 = EventLoop(0);
    
    auto ts2 = Unix() * 1000;
    auto ret2 = EventLoop(0);
    
    auto ts3 = Unix() * 1000;
    auto ret3 = EventLoop(0);
    
    Log("第1个并发任务完成的为：", _D(ts1), ret1);
    Log("第2个并发任务完成的为：", _D(ts2), ret2);
    Log("第3个并发任务完成的为：", _D(ts3), ret3);
    
    Ticker ticker;
    Depth depth;
    Trades trades;
    routine_getTicker.wait(ticker);
    routine_getDepth.wait(depth);
    routine_getTrades.wait(trades);
    
    Log("GetTicker:", ticker);
    Log("GetDepth:", depth);
    Log("GetTrades:", trades);
}

Eingebaute Funktionen

_G(K, V)

_G(K, V)Die Funktion ermöglicht eine speicherbare, globalisierte Wörterbuchfunktion, die sowohl Retargeting als auch Festplattenunterstützung bietet. Nach dem Retargeting werden die gespeicherten Daten gelöscht. Die Datenstruktur istKVTabelle, die dauerhaft als lokale Dateien aufbewahrt werden, die auf jeder Festplatte eine separate Datenbank haben und nach dem Neustart oder dem Aussteigen des Administrators bestehen.KSie müssen in Stringform geschrieben werden, ohne Unterschied zwischen Groß und Klein.VSie können für allesJSONSerialisierte Inhalte._G()Wenn eine Funktion keine Parameter übermittelt, wird die Funktion nicht mehr benutzt._G()Die Funktion gibt die aktuelle Festplatte zurück.ID。

function main(){
    // 设置一个全局变量num，值为1
    _G("num", 1)     
    // 更改一个全局变量num，值为字符串ok
    _G("num", "ok")    
    // 删除全局变量num
    _G("num", null)
    // 返回全局变量num的值
    Log(_G("num"))
    // 删除所有全局变量
    _G(null)
    // 返回实盘ID
    var robotId = _G()
}

def main():
    _G("num", 1)     
    _G("num", "ok")    
    _G("num", None)
    Log(_G("num"))
    _G(None)
    robotId = _G()

void main() {
    _G("num", 1);
    _G("num", "ok");
    _G("num", NULL);
    Log(_G("num"));
    _G(NULL);
    // 不支持 auto robotId = _G();
}

Bitte beachten: Nutzung_GBei der Funktionspermanenten Speicherung von Daten sollte die Verwendung der Speicher- und Festplattenfläche der Hardware angemessen sein und nicht missbraucht werden; andernfalls kann dies zu Problemen führen.GedächtnisüberflutungDie Frage ist:

Zeitstempel, FMT

_D(Timestamp, Fmt), gibt die Zeitstring zurück, die dem angegebenen Zeitfenster entspricht.TimestampFür den Zahlentyp ist der Wert Millisekunden.FmtSie können auch eine andere Form verwenden, um die Stringart zu ermitteln.FmtDas ist eine schlechte Idee.yyyy-MM-dd hh:mm:ss, gibt einen String-Typ an. Die String, die dem angegebenen Zeitfenster ((millisekunden)) entspricht, wird ohne die Übermittlung von Parametern zurückgegeben._D()Oder_D(1478570053241)Das Standardformat lautet:yyyy-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);
}

Bitte beachten Sie:PythonStrategische Nutzung_D()Die Parameter, auf die man achten muss, sind Sekundenebene-Zeitzeichen.JavaScript、C++In der Strategie wird die Zeitspanne auf der Ebene der Millisekunden angegeben. Eine Sekunde entspricht 1000 Millisekunden.) Für den Einsatz auf dem Spielfeld_D()Die Funktion analysiert einen Zeitfenster als lesbare Zeitstring und berücksichtigt die Zeitzone des Betriebssystems, in dem sich der Administrator befindet._D()Die Funktion analysiert einen Zeitfenster als lesbare Zeitstring, die auf die Zeit des Administratorsystems basiert.

Ein Zeitfenster ist1574993606000Die Analyse mit Hilfe von Code:

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

def main():
    # 北京时间的服务器上运行：2019-11-29 10:13:26 ，另一台其它地区的服务器上的托管者运行此代码结果则为：2019-11-29 02:13:26
    Log(_D(1574993606))

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

_N ((Nummer, Präzision)

_N(Num, Precision), Formatieren einer Schwellpunktzahl.NumSie können die Anzahl der Werte anzeigen.PrecisionFür den ganzen Typ. Retourwert: Zahlentyp.

Zum Beispiel:_N(3.1415, 2)Sie werden gelöscht.3.1415Die Funktion gibt den Wert nach der Komma zwei Stellen 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 man alle N-Zahlen auf der linken Seite des Komma-Punktes zu 0 machen will, kann man es so schreiben:

function main(){
    var i = 1300
    Log(i)
    var ii = _N(i, -3)
    // 查看日志得知为1000
    Log(ii)
}

def main():
    i = 1300
    Log(i)
    ii = _N(i, -3)
    Log(ii)

void main() {
    auto i = 1300;
    Log(i);
    auto ii = _N(i, -3);
    Log(ii);
}

- Ich weiß.

_C(function, args...)Die Funktion ist eine Wiederholungsfunktion, die für die Erfassung von Interfaces wie Markt, Erfassung von nicht abgeschlossenen Bestellungen verwendet wird.

Die Benutzeroberfläche ruft die angegebene Funktion immer wieder an, bis sie erfolgreich die ((Parameter) zurückgibt.functionDie Funktion, auf die sich der Referenz bezieht, gibt beim Aufruf einen null oderfalseSie werden dann erneut aufgerufen.)_C(exchange.GetTicker)Sie können den Standard-Rücklauf von 3 Sekunden anrufen._CDelay(...)Funktionen, um Wiederholungsintervalle zu setzen, z. B._CDelay(1000)Das bedeutet:_CDie Funktion wird mit 1 Sekunde Intervall wiederholt.

Für folgende Funktionen:

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

Sie können alle durch_C(...)Die Funktion kann Fehler erlauben._C(function, args...)Funktionen sind nicht beschränkt auf die oben aufgeführten Funktionen, die Fehler erlauben, ParameterfunctionEs ist eine Funktionsreferenz, nicht ein Funktionsanruf._C(exchange.GetTicker)Es ist nicht_C(exchange.GetTicker())。

function main(){
    var ticker = _C(exchange.GetTicker)
    // 调整_C()函数重试时间间隔为2秒
    _CDelay(2000)
    var depth = _C(exchange.GetDepth)
    Log(ticker)
    Log(depth)
}

def main():
    ticker = _C(exchange.GetTicker)
    _CDelay(2000)
    depth = _C(exchange.GetDepth)
    Log(ticker)
    Log(depth)

void main() {
    auto ticker = _C(exchange.GetTicker);
    _CDelay(2000);
    auto depth = _C(exchange.GetDepth);
    Log(ticker);
    Log(depth);
}

Verwendung für Funktionen mit Parametern_C(...)Wenn man einen Fehler macht:

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

Sie können auch Fehlerbehebungen für benutzerdefinierte Funktionen verwenden:

var test = function(a, b){
    var time = new Date().getTime() / 1000
    if(time % b == 3){
        Log("符合条件！", "#FF0000")
        return true
    }
    Log("重试！", "#FF0000")
    return false
}

function main(){
    var ret = _C(test, 1, 5)
    Log(ret)
}

import time
def test(a, b):
    ts = time.time()
    if ts % b == 3:
        Log("符合条件！", "#FF0000")
        return True
    Log("重试！", "#FF0000")
    return False

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

// C++ 不支持这种方式对于自定义函数容错

_Kreuzung ((Arr1, Arr2)

_Cross(Arr1, Arr2)Die Array wird zurückgegeben.Arr1undArr2Die Zahl der Kreuzzyklen der Array. Eine positive Zahl ist für die Auf- und Abfahrt, eine negative für die Abfahrt und 0 für den aktuellen Preis.

Sie können eine Reihe von Tests simulieren_Cross(Arr1, Arr2)Die Funktion:

// 快线指标
var arr1 = [1,2,3,4,5,6,8,8,9]
// 慢线指标
var arr2 = [2,3,4,5,6,7,7,7,7]
function main(){
    Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2))
    Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1))
}

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

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

Die simulierten Daten visualisieren und beobachten

Ein paar Beispiele für die Verwendung:Eingebaute Funktion_Cross Analyse und Anleitung

JSONParse ((strJson)

JSONParse(strJson)Die Funktion wird verwendet, um JSON-Streuchen zu parsen. JSON-Streuchen mit größeren Zahlenwerten können korrekt parodiert werden.

function main() {
    let s1 = '{"num": 8754613216564987646512354656874651651358}'
    Log("JSON.parse:", JSON.parse(s1))    // JSON.parse: {"num":8.754613216564988e+39}
    Log("JSONParse:", JSONParse(s1))      // JSONParse:  {"num":"8754613216564987646512354656874651651358"}
    
    let s2 = '{"num": 123}'
    Log("JSON.parse:", JSON.parse(s2))    // JSON.parse: {"num":123}
    Log("JSONParse:", JSONParse(s2))      // JSONParse:  {"num":123}
}

import json

def main():
    s1 = '{"num": 8754613216564987646512354656874651651358}'
    Log("json.loads:", json.loads(s1))    # json.loads: map[num:8.754613216564987e+39]
    Log("JSONParse:", JSONParse(s1))      # JSONParse:  map[num:8754613216564987646512354656874651651358]
    
    s2 = '{"num": 123}'
    Log("json.loads:", json.loads(s2))    # json.loads: map[num:123]
    Log("JSONParse:", JSONParse(s2))      # JSONParse:  map[num:123]

void main() {
    auto s1 = "{\"num\":8754613216564987646512354656874651651358}";
    Log("json::parse:", json::parse(s1));
    // Log("JSONParse:", JSONParse(s1));   // 不支持该函数
    
    auto s2 = "{\"num\":123}";
    Log("json::parse:", json::parse(s2));
    // Log("JSONParse:", JSONParse(s2));   // 不支持该函数
}

Benutzerdefinierte Farben

Jede Nachrichtengrube ist verfügbar.#ff0000Diese RGB-Werte werden am Ende der Bildfläche dargestellt, die angezeigt werden soll.#ff0000112233In diesem Format werden die letzten sechs Zeichen für die Hintergrundfarbe verwendet.

function main() {
    Log("红色", "#FF0000")
}

def main():
    Log("红色", "#FF0000")

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

Tagebericht

Log-Informationen werden während des Laufens der Festplatte in der Festplatten-Datenbank gespeichert. Die Festplatten-Datenbank verwendetsqlite3Datenbank, Festplatte Datenbankdateien auf dem Gerät, auf dem die Administratorprogramme liegen, Datenbankdateien auf dem AdministratorprogrammrobotDie Ausführbarkeit ist in der Verzeichnis.130350Die Datenbank-Dateien auf der Festplatte../logs/storage/130350In diesem Katalog..Das istrobotDie Datenbank wird in der Folge "Datenbank-Dateien" genannt.130350.db3Das ist nicht wahr. Die Logs im Retargeting-System können nach Beendigung des Retargetings auf der unteren rechten Ecke der Retargeting-Seite geklickt werden.Laden Sie das Tagebuch herunter[Schaltfläche zum Herunterladen]. Wenn ein Administrator die Festplatte auf einen anderen Server migrieren möchte, kann er die Datenbankdatei (die mit der Erweiterung "db3" bezeichnet wird) auf dem Festplatte auf den Migrationszielserver bewegen und den Dateinamen auf die entsprechende Festplatten-ID der Plattform setzen.

Das ist der Fall.

Log(message), eine Nachricht in die Logliste speichern.messageSie können beliebige Typen verwenden. Wenn man nach einer String addiert@Die Nachricht wird in die Push-Warteschlange geschickt und wird in die E-Mail-Box, Telegramm, WebHook usw., die in den Push-Einstellungen des aktuellen Erfinders installiert ist, geschickt.Das KontrollzentrumSeite, oben rechtsKonto-EinstellungDie Seite:Schub-EinstellungenDie Webseite ist gebunden.)

Bitte beachten Sie:

• Das Debugger-Tool unterstützt keine Push-Funktion.
• Das Push-System wird nicht unterstützt.

function main() {
    Log("发明者量化你好 !@")
    Sleep(1000 * 5)
    // 字符串内加入#ff0000，打印日志显示为红色，并且推送消息
    Log("你好, #ff0000@")
}

def main():
    Log("发明者量化你好 !@")
    Sleep(1000 * 5)
    Log("你好, #ff0000@")

void main() {
    Log("发明者量化你好 !@");
    Sleep(1000 * 5);
    Log("你好, #ff0000@");
}

WebHookSchieben:

NutzungGolangDas Programm wurde von DEMO geschrieben:

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

EinstellungenWebHook：http://XXX.XX.XXX.XX:9090/data?data=Hello_FMZ

Nach dem Ausführen eines Service-Programms wird eine Strategie ausgeführt, die Informationen über die Strategie schickt:

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

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

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

Der Service-Prozess druckt Informationen aus, wenn er sie empfängt:

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}

Druckenbase64Bild nach der Verschlüsselung LogFunktion unterstützt Druckenbase64Die Bilder wurden in einem Code mit der Bezeichnung`Ich beginne mit:`Das Ende, 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 direktes DruckenPythonDiematplotlib.pyplotEin Objekt, solange es ein Objekt enthältsavefigDie Methode kann direkt sein.LogDas bedeutet, dass die Menschen in der Welt nicht mehr in der Lage sind, sich zu bewegen.

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

Automatisches Sprachaustausch des Druckprotokolls LogDie Funktion unterstützt den Sprachwechsel.LogDie Funktion liefert Text, der automatisch in die entsprechende Sprache wechselt, je nachdem, in welcher Sprache die Plattformseite eingestellt ist, z. B.:

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

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

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

LogProfit ((Profit))

LogProfit(Profit), den Gewinn-und-Verlust-Wert zu erfassen, den Gewinn-und-Verlust-Wert zu drucken und eine Gewinn- und Verlust-Kurve nach dem Gewinn- und Verlust-Wert zu zeichnen.GewinnFür den Zahlentyp.

Die Funktion wird in Zeichen angezeigt.&Schließlich wird nur ein Einkommensdiagramm erstellt, kein Einkommensprotokoll gedruckt, zum Beispiel:LogProfit(10, '&')。

LogProfitReset (siehe unten)

LogProfitReset(), alle Einnahmeprotokolle zu löschen, kann mit einem ganzen Zahlenwert Parameter, um die reservierten Eintrag zu bestimmen.

function main() {
    // 在收益图表上打印30个点，然后重置，只保留最后10个点
    for(var i = 0; i < 30; i++) {
        LogProfit(i)
        Sleep(500)
    }
    LogProfitReset(10)
}

def main():
    for i in range(30):
        LogProfit(i)
        Sleep(500)
    LogProfitReset(10)

void main() {
    for(int i = 0; i < 30; i++) {
        LogProfit(i);
        Sleep(500);
    }
    LogProfitReset(10);
}

LogStatus (Msg)

LogStatus(Msg)Diese Informationen werden nicht in der Logliste gespeichert, sondern nur die Statusinformationen der aktuellen Festplatte werden aktualisiert.MsgSie können beliebige Typen verwenden.

function main() {
    LogStatus('这是一个普通的状态提示')
    LogStatus('这是一个红色字体的状态提示#ff0000')
    LogStatus('这是一个多行的状态信息\n我是第二行')
}

def main():
    LogStatus('这是一个普通的状态提示')
    LogStatus('这是一个红色字体的状态提示#ff0000')
    LogStatus('这是一个多行的状态信息\n我是第二行')

void main() {
    LogStatus("这是一个普通的状态提示");
    LogStatus("这是一个红色字体的状态提示#ff0000");
    LogStatus("这是一个多行的状态信息\n我是第二行");
}

LogStatus(Msg)Unterstützung für Druckenbase64Die Bilder wurden in einem Code mit der Bezeichnung`Ich beginne mit:`Das Ende, zum Beispiel:LogStatus("`data:image/png;base64,AAAA`")。 LogStatus(Msg)Unterstützt den direkten ZugriffPythonDiematplotlib.pyplotEin Objekt, solange es ein Objekt enthältsavefigDie Methode kann sich übertragen.LogStatus(Msg)Funktionen wie:

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

Ein Beispiel für die Ausgabe von Daten in der Statusliste:

function main() {
    var table = {type: 'table', title: '持仓信息', cols: ['列1', '列2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
    // JSON序列化后两边加上`字符,视为一个复杂消息格式(当前支持表格)
    LogStatus('`' + JSON.stringify(table) + '`')                    
    // 表格信息也可以在多行中出现
    LogStatus('第一行消息\n`' + JSON.stringify(table) + '`\n第三行消息')
    // 支持多个表格同时显示,将以TAB显示到一组里
    LogStatus('`' + JSON.stringify([table, table]) + '`')
    
    // 也可以构造一个按钮在表格中,策略用GetCommand接收cmd属性的内容                                
    var table = { 
        type: 'table', 
        title: '持仓操作', 
        cols: ['列1', '列2', 'Action'], 
        rows: [ 
            ['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': '平仓'}]
        ]
    }
    LogStatus('`' + JSON.stringify(table) + '`') 
    // 或者构造一单独的按钮
    LogStatus('`' + JSON.stringify({'type':'button', 'cmd': 'coverAll', 'name': '平仓'}) + '`') 
    // 可以自定义按钮风格(bootstrap的按钮属性)
    LogStatus('`' + JSON.stringify({'type':'button', 'class': 'btn btn-xs btn-danger', 'cmd': 'coverAll', 'name': '平仓'}) + '`')
}

import json
def main():
    table = {"type": "table", "title": "持仓信息", "cols": ["列1", "列2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]}
    LogStatus('`' + json.dumps(table) + '`')
    LogStatus('第一行消息\n`' + json.dumps(table) + '`\n第三行消息')
    LogStatus('`' + json.dumps([table, table]) + '`')

    table = {
        "type" : "table", 
        "title" : "持仓操作", 
        "cols" : ["列1", "列2", "Action"], 
        "rows" : [
            ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]
        ] 
    }
    LogStatus('`' + json.dumps(table) + '`')
    LogStatus('`' + json.dumps({"type": "button", "cmd": "coverAll", "name": "平仓"}) + '`')
    LogStatus('`' + json.dumps({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "平仓"}) + '`')

void main() {
    json table = R"({"type": "table", "title": "持仓信息", "cols": ["列1", "列2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
    LogStatus("`" + table.dump() + "`");
    LogStatus("第一行消息\n`" + table.dump() + "`\n第三行消息");
    json arr = R"([])"_json;
    arr.push_back(table);
    arr.push_back(table);
    LogStatus("`" + arr.dump() + "`");

    table = R"({
        "type" : "table", 
        "title" : "持仓操作", 
        "cols" : ["列1", "列2", "Action"], 
        "rows" : [
            ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]
        ] 
    })"_json;
    LogStatus("`" + table.dump() + "`");
    LogStatus("`" + R"({"type": "button", "cmd": "coverAll", "name": "平仓"})"_json.dump() + "`");
    LogStatus("`" + R"({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "平仓"})"_json.dump() + "`");
}

Einstellung der Status-Taste deaktiviert, Beschreibung der Funktion:

function main() {
    var table = {
        type: "table",
        title: "状态栏按钮的禁用、描述功能测试",
        cols: ["列1", "列2", "列3"], 
        rows: []
    }
    var button1 = {"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"}
    var button2 = {"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮，设置为禁用", "disabled": true}
    var button3 = {"type": "button", "name": "按钮3", "cmd": "button3", "description": "这是第三个按钮，设置为启用", "disabled": false}
    table.rows.push([button1, button2, button3])
    LogStatus("`" + JSON.stringify(table) + "`")
}

import json
def main():
    table = {
        "type": "table",
        "title": "状态栏按钮的禁用、描述功能测试",
        "cols": ["列1", "列2", "列3"], 
        "rows": []
    }
    button1 = {"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"}
    button2 = {"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮，设置为禁用", "disabled": True}
    button3 = {"type": "button", "name": "按钮3", "cmd": "button3", "description": "这是第三个按钮，设置为启用", "disabled": False}
    table["rows"].append([button1, button2, button3])
    LogStatus("`" + json.dumps(table) + "`")

void main() {
    json table = R"({
        "type": "table",
        "title": "状态栏按钮的禁用、描述功能测试",
        "cols": ["列1", "列2", "列3"], 
        "rows": []
    })"_json;
    json button1 = R"({"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"})"_json;
    json button2 = R"({"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮，设置为禁用", "disabled": true})"_json;
    json button3 = R"({"type": "button", "name": "按钮3", "cmd": "button3", "description": "这是第三个按钮，设置为启用", "disabled": false})"_json;
    json arr = R"([])"_json;
    arr.push_back(button1);
    arr.push_back(button2);
    arr.push_back(button3);
    table["rows"].push_back(arr);
    LogStatus("`" + table.dump() + "`");
}

Die Status-Button-Stil:

function main() {
    var table = {
        type: "table",
        title: "状态栏按钮样式",
        cols: ["默认", "原始", "成功", "信息", "警告", "危险"], 
        rows: [
            [
                {"type":"button", "class": "btn btn-xs btn-default", "name": "默认"},
                {"type":"button", "class": "btn btn-xs btn-primary", "name": "原始"},
                {"type":"button", "class": "btn btn-xs btn-success", "name": "成功"},
                {"type":"button", "class": "btn btn-xs btn-info", "name": "信息"},
                {"type":"button", "class": "btn btn-xs btn-warning", "name": "告警"},
                {"type":"button", "class": "btn btn-xs btn-danger", "name": "危险"}
            ]
        ]
    }
    LogStatus("`" + JSON.stringify(table) + "`")
}

import json
def main():
    table = {
        "type": "table",
        "title": "状态栏按钮样式",
        "cols": ["默认", "原始", "成功", "信息", "警告", "危险"], 
        "rows": [
            [
                {"type":"button", "class": "btn btn-xs btn-default", "name": "默认"},
                {"type":"button", "class": "btn btn-xs btn-primary", "name": "原始"},
                {"type":"button", "class": "btn btn-xs btn-success", "name": "成功"},
                {"type":"button", "class": "btn btn-xs btn-info", "name": "信息"},
                {"type":"button", "class": "btn btn-xs btn-warning", "name": "告警"},
                {"type":"button", "class": "btn btn-xs btn-danger", "name": "危险"}
            ]
        ]
    }
    LogStatus("`" + json.dumps(table) + "`")

void main() {
    json table = R"({
        "type": "table",
        "title": "状态栏按钮样式",
        "cols": ["默认", "原始", "成功", "信息", "警告", "危险"], 
        "rows": [
            [
                {"type":"button", "class": "btn btn-xs btn-default", "name": "默认"},
                {"type":"button", "class": "btn btn-xs btn-primary", "name": "原始"},
                {"type":"button", "class": "btn btn-xs btn-success", "name": "成功"},
                {"type":"button", "class": "btn btn-xs btn-info", "name": "信息"},
                {"type":"button", "class": "btn btn-xs btn-warning", "name": "告警"},
                {"type":"button", "class": "btn btn-xs btn-danger", "name": "危险"}
            ]
        ]
    })"_json;
    LogStatus("`" + table.dump() + "`");
}

ZusammenschlussGetCommand()Funktionen, Konstruktions- und Statusknopf-Interaktionen:

function test1() {
    Log("调用自定义函数")
}

function main() {
    while (true) {
        var table = {
            type: 'table',
            title: '操作',
            cols: ['列1', '列2', 'Action'],
            rows: [
                ['a', '1', {
                    'type': 'button',                       
                    'cmd': "CoverAll",                      
                    'name': '平仓'                           
                }],
                ['b', '1', {
                    'type': 'button',
                    'cmd': 10,                              
                    'name': '发送数值'
                }],
                ['c', '1', {
                    'type': 'button',
                    'cmd': _D(),                          
                    'name': '调用函数'
                }],
                ['d', '1', {
                    'type': 'button',
                    'cmd': 'test1',       
                    'name': '调用自定义函数'
                }]
            ]
        }
        LogStatus(_D(), "\n", '`' + JSON.stringify(table) + '`')

        var str_cmd = GetCommand()
        if (str_cmd) {
            Log("接收到的交互数据 str_cmd:", "类型：", typeof(str_cmd), "值：", str_cmd)
            if(str_cmd == "test1") {
                test1()
            }
        }

        Sleep(500)
    }
}

import json
def test1():
    Log("调用自定义函数")

def main():
    while True:
        table = {
            "type": "table", 
            "title": "操作", 
            "cols": ["列1", "列2", "Action"],
            "rows": [
                ["a", "1", {
                    "type": "button", 
                    "cmd": "CoverAll",
                    "name": "平仓"
                }],
                ["b", "1", {
                    "type": "button",
                    "cmd": 10,
                    "name": "发送数值" 
                }], 
                ["c", "1", {
                    "type": "button",
                    "cmd": _D(),
                    "name": "调用函数" 
                }],
                ["d", "1", {
                    "type": "button",
                    "cmd": "test1",
                    "name": "调用自定义函数" 
                }]
            ]
        }

        LogStatus(_D(), "\n", "`" + json.dumps(table) + "`")
        str_cmd = GetCommand()
        if str_cmd:
            Log("接收到的交互数据 str_cmd", "类型：", type(str_cmd), "值：", str_cmd)
            if str_cmd == "test1":
                test1()
        Sleep(500)

void test1() {
    Log("调用自定义函数");
}

void main() {
    while(true) {
        json table = R"({
            "type": "table", 
            "title": "操作", 
            "cols": ["列1", "列2", "Action"],
            "rows": [
                ["a", "1", {
                    "type": "button", 
                    "cmd": "CoverAll",
                    "name": "平仓"
                }],
                ["b", "1", {
                    "type": "button",
                    "cmd": 10,
                    "name": "发送数值" 
                }], 
                ["c", "1", {
                    "type": "button",
                    "cmd": "",
                    "name": "调用函数" 
                }],
                ["d", "1", {
                    "type": "button",
                    "cmd": "test1",
                    "name": "调用自定义函数" 
                }]
            ]
        })"_json;
        table["rows"][2][2]["cmd"] = _D();
        LogStatus(_D(), "\n", "`" + table.dump() + "`");
        auto str_cmd = GetCommand();
        if(str_cmd != "") {
            Log("接收到的交互数据 str_cmd", "类型：", typeid(str_cmd).name(), "值：", str_cmd);
            if(str_cmd == "test1") {
                test1();
            }
        }
        Sleep(500);
    }
}

Es wird auch unterstützt, Daten einzugeben, wenn die Konstruktions-Status-Knopfen interagieren. Die Interaktionsanweisungen werden letztendlich vonGetCommand()Funktionserfassung. Erhöhung der Datenstruktur der Tastenkontrollen in der Status-TabelleinputSie können also{"type": "button", "cmd": "open", "name": "开仓"}Zunahme"input": {"name": "开仓数量", "type": "number", "defValue": 1}Ein Sprungfenster mit einem Eingabefeld kann angezeigt werden, wenn die Taste angeklickt wird. Ein Sprungfenster mit einem Eingabefeld wird angezeigt, wenn die Taste mit dem Eingabefeld geklickt wird.111Dann klicken Sie auf "Bestätigen".GetCommandDie Funktion erfasst die Nachrichten:open:111。

function main() {
    var tbl = {
        type: "table",
        title: "操作",
        cols: ["列1", "列2"],
        rows: [
            ["开仓操作", {"type": "button", "cmd": "open", "name": "开仓", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}],
            ["平仓操作", {"type": "button", "cmd": "coverAll", "name": "全部平仓"}]
        ] 
    }

    LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
    while (true) {
        var cmd = GetCommand()
        if (cmd) {
            Log("cmd:", cmd)
        }
        Sleep(1000)
    }
}

import json

def main():
    tbl = {
        "type": "table", 
        "title": "操作", 
        "cols": ["列1", "列2"],
        "rows": [
            ["开仓操作", {"type": "button", "cmd": "open", "name": "开仓", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}],
            ["平仓操作", {"type": "button", "cmd": "coverAll", "name": "全部平仓"}]
        ]
    }

    LogStatus(_D(), "\n", "`" + json.dumps(tbl) + "`")
    while True:
        cmd = GetCommand()
        if cmd:
            Log("cmd:", cmd)
        Sleep(1000)

void main() {
    json tbl = R"({
        "type": "table", 
        "title": "操作", 
        "cols": ["列1", "列2"],
        "rows": [
            ["开仓操作", {"type": "button", "cmd": "open", "name": "开仓", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}],
            ["平仓操作", {"type": "button", "cmd": "coverAll", "name": "全部平仓"}]
        ]
    })"_json;

    LogStatus(_D(), "\n", "`" + tbl.dump() + "`");
    while(true) {
        auto cmd = GetCommand();
        if(cmd != "") {
            Log("cmd:", cmd);
        }
        Sleep(1000);
    }
}

ZusammenschlussLogStatus(Msg)Die Zelle in der Tabelle, in der die Funktion gezeichnet wird:

• Horizontale Verschmelzung

  function main() {
      var table = { 
          type: 'table', 
          title: '持仓操作', 
          cols: ['列1', '列2', 'Action'], 
          rows: [ 
              ['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': '平仓'}]
          ]
      } 
      var ticker = exchange.GetTicker()
      // 添加一行数据，第一个和第二个单元格合并，并且输出ticker变量在合并后的单元格内
      table.rows.push([{body : JSON.stringify(ticker), colspan : 2}, "abc"])    
      LogStatus('`' + JSON.stringify(table) + '`')
  }
  

  import json
  def main():
      table = {
          "type" : "table",
          "title" : "持仓操作",
          "cols" : ["列1", "列2", "Action"],
          "rows" : [
              ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]
          ]
      }
      ticker = exchange.GetTicker()
      table["rows"].append([{"body": json.dumps(ticker), "colspan": 2}, "abc"])
      LogStatus("`" + json.dumps(table) + "`")
  

  void main() {
      json table = R"({
          "type" : "table",
          "title" : "持仓操作",
          "cols" : ["列1", "列2", "Action"],
          "rows" : [
              ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]
          ]
      })"_json;
  
      auto ticker = exchange.GetTicker();
      json jsonTicker = R"({"Buy": 0, "Sell": 0, "High": 0, "Low": 0, "Volume": 0, "Last": 0, "Time": 0})"_json;
      jsonTicker["Buy"] = ticker.Buy;
      jsonTicker["Sell"] = ticker.Sell;
      jsonTicker["Last"] = ticker.Last;
      jsonTicker["Volume"] = ticker.Volume;
      jsonTicker["Time"] = ticker.Time;
      jsonTicker["High"] = ticker.High;
      jsonTicker["Low"] = ticker.Low;
  
      json arr = R"([{"body": {}, "colspan": 2}, "abc"])"_json;
      arr[0]["body"] = jsonTicker;
      table["rows"].push_back(arr);
      LogStatus("`" + table.dump() + "`");
  }
  

  

• Längsschnitt

  function main() {
      var table = { 
          type: 'table', 
          title: '表格演示', 
          cols: ['列A', '列B', '列C'], 
          rows: [ 
              ['A1', 'B1', {'type':'button', 'cmd': 'coverAll', 'name': 'C1'}]
          ]
      } 
  
      var ticker = exchange.GetTicker()
      var name = exchange.GetName()
  
      table.rows.push([{body : "A2 + B2:" + JSON.stringify(ticker), colspan : 2}, "C2"])
      table.rows.push([{body : "A3 + A4 + A5:" + name, rowspan : 3}, "B3", "C3"])
      // A3被上一行第一个单元格合并
      table.rows.push(["B4", "C4"])
      // A2被上一行第一个单元格合并
      table.rows.push(["B5", "C5"])                                            
      table.rows.push(["A6", "B6", "C6"])
      LogStatus('`' + JSON.stringify(table) + '`')
  }
  

  import json
  def main():
      table = {
          "type" : "table", 
          "title" : "表格演示", 
          "cols" : ["列A", "列B", "列C"], 
          "rows" : [
              ["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
          ]
      }
      
      ticker = exchange.GetTicker()
      name = exchange.GetName()
      
      table["rows"].append([{"body": "A2 + B2:" + json.dumps(ticker), "colspan": 2}, "C2"])
      table["rows"].append([{"body": "A3 + A4 + A5:" + name, "rowspan": 3}, "B3", "C3"])
      table["rows"].append(["B4", "C4"])
      table["rows"].append(["B5", "C5"])
      table["rows"].append(["A6", "B6", "C6"])
      LogStatus("`" + json.dumps(table) + "`")
  

  void main() {
      json table = R"({
          "type" : "table", 
          "title" : "表格演示", 
          "cols" : ["列A", "列B", "列C"], 
          "rows" : [
              ["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
          ]
      })"_json;
      // 为了测试，代码简短易读，这里使用构造的数据
      json jsonTicker = R"({"High": 0, "Low": 0, "Buy": 0, "Sell": 0, "Last": 0, "Time": 0, "Volume": 0})"_json;
      auto name = exchange.GetName();
      json arr1 = R"([{"body": "", "colspan": 2}, "C2"])"_json;
      arr1[0]["body"] = "A2 + B2:" + jsonTicker.dump();
      json arr2 = R"([{"body": "", "rowspan": 3}, "B3", "C3"])"_json;
      arr2[0]["body"] = "A3 + A4 + A5:" + name;
      table["rows"].push_back(arr1);
      table["rows"].push_back(arr2);
      table["rows"].push_back(R"(["B4", "C4"])"_json);
      table["rows"].push_back(R"(["B5", "C5"])"_json);
      table["rows"].push_back(R"(["A6", "B6", "C6"])"_json);
      LogStatus("`" + table.dump() + "`");
  }
  

  

Die Status-Tabelle zeigt:

function main() {
    var table1 = {type: 'table', title: 'table1', cols: ['列1', '列2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
    var table2 = {type: 'table', title: 'table2', cols: ['列1', '列2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
    LogStatus('`' + JSON.stringify([table1, table2]) + '`')
}

import json
def main():
    table1 = {"type": "table", "title": "table1", "cols": ["列1", "列2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
    table2 = {"type": "table", "title": "table2", "cols": ["列1", "列2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
    LogStatus("`" + json.dumps([table1, table2]) + "`")

void main() {
    json table1 = R"({"type": "table", "title": "table1", "cols": ["列1", "列2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
    json table2 = R"({"type": "table", "title": "table2", "cols": ["列1", "列2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
    json arr = R"([])"_json;
    arr.push_back(table1);
    arr.push_back(table2);
    LogStatus("`" + arr.dump() + "`");
}

Neben der möglichkeit, tabellen zu teilen, können mehrere tabellen von oben nach unten angeordnet angezeigt werden.

function main(){
    var tab1 = {
        type : "table",
        title : "表格1",
        cols : ["1", "2"],
        rows : []
    }
    var tab2 = {
        type : "table",
        title : "表格2",
        cols : ["1", "2", "3"],
        rows : []
    }
    var tab3 = {
        type : "table",
        title : "表格3",
        cols : ["A", "B", "C"],
        rows : []
    }

    tab1.rows.push(["jack", "lucy"])
    tab2.rows.push(["A", "B", "C"])
    tab3.rows.push(["A", "B", "C"])

    LogStatus('`' + JSON.stringify(tab1) + '`\n' + 
        '`' + JSON.stringify(tab2) + '`\n' +
        '`' + JSON.stringify(tab3) + '`')
  
    Log("exit")
}

import json
def main():
    tab1 = {
        "type": "table", 
        "title": "表格1", 
        "cols": ["1", "2"], 
        "rows": []
    }
    tab2 = {
        "type": "table", 
        "title": "表格2", 
        "cols": ["1", "2", "3"], 
        "rows": []
    }
    tab3 = {
        "type": "table", 
        "title": "表格3", 
        "cols": ["A", "B", "C"], 
        "rows": []
    }

    tab1["rows"].append(["jack", "lucy"])
    tab2["rows"].append(["A", "B", "C"])
    tab3["rows"].append(["A", "B", "C"])
    LogStatus("`" + json.dumps(tab1) + "`\n" + 
        "`" + json.dumps(tab2) + "`\n" + 
        "`" + json.dumps(tab3) + "`")

void main() {
    json tab1 = R"({
        "type": "table", 
        "title": "表格1", 
        "cols": ["1", "2"], 
        "rows": []
    })"_json;
    json tab2 = R"({
        "type": "table", 
        "title": "表格2", 
        "cols": ["1", "2", "3"], 
        "rows": []
    })"_json;
    json tab3 = R"({
        "type": "table", 
        "title": "表格3", 
        "cols": ["A", "B", "C"], 
        "rows": []
    })"_json;
    tab1["rows"].push_back(R"(["jack", "lucy"])"_json);
    tab2["rows"].push_back(R"(["A", "B", "C"])"_json);
    tab3["rows"].push_back(R"(["A", "B", "C"])"_json);
    LogStatus("`" + tab1.dump() + "`\n" + 
        "`" + tab2.dump() + "`\n" +
        "`" + tab3.dump() + "`");
}

Die Ergebnisse:

Bitte beachten: Wenn die Strategie auf der Festplatte ausgeführt wird, wird die Statusleiste im Falle eines Überblicks der Historie auf der Festplattenseite in den Ruhezustand versetzt und nicht mehr aktualisiert. Die Daten der Statusleiste werden nur auf der ersten Seite des Logs aktualisiert. Unterstützt den Ausgang in der Status-Tabellebase64Bild, das in der Statusleiste angezeigt wirdbase64Bild nach der Kodierung. Das Beispiel-Code wird nicht mehr angezeigt, da die Stringdaten von Bild nach der Kodierung in der Regel lang sind.

AktivierenLog (()

EnableLog(IsEnable)Die Log-Dateien, in denen die Bestellungen geöffnet oder geschlossen werden.isEnableFür den Typ Boole.IsEnableSetzen Sie auffalseSie werden nicht ausgedruckt und nicht in die Datenbank geschrieben.

Tabelle (**)

Chart(...), benutzerdefinierte Diagrammmalerei-Funktion.

Chart({...})Die Parameter sind:JSONSequenziertHighStocksDieHighcharts.StockChartParameter.__isStockEigenschaften, wenn angegeben__isStock:falseDas ist ein einfaches Diagramm.

Bitte beachten: Wenn es so ist__isStockEigenschaft istfalseDie Grafiken, die verwendet werden, sind:HochkartenDas Bild zeigt:

Wenn es so ist__isStockEigenschaft isttrueDie Grafiken, die verwendet werden, sind:Höchstbestände(Standardmäßig)__isStockFürtrueDas Bild zeigt:

Zurück zu den Anrufenadd(n, data)（nFürseriesDer Index (z. B. 0) ist ein Index, der die Daten der einzelnen Länder enthält.dataDaten, die in ein Diagramm geschrieben werden sollen) an den angegebenen Index geschickt werdenseriesDaten hinzufügen, aufrufenreset()Die Daten werden von der Grafik gelöscht.resetSie können mit einem Zahlenparameter die Anzahl der reservierten Elemente angeben.

Sie können rufenadd(n, data, i)（iDie Daten sind hier.seriesSie können die entsprechenden Daten in den Index einfügenseriesDie Daten sind hier.

Kann als Negativ, -1 als Letztes, -2 als Negativzweites, beispielsweise beim Zeichnen einer Linie, Daten am letzten Punkt der Linie modifizieren:

chart.add(0, [1574993606000, 13.5], -1), geändertseries[0].dataDie Daten des ersten Punktes der Negativzahl.

Unterstützt die Anzeige von mehreren Diagrammen, bei deren Konfiguration einfach Arrayparameter eingegeben werden können, wie:var chart = Chart([{...}, {...}, {...}])Zum Beispiel ein Diagramm mit zweiseriesUnd in Diagramm 2 gibt es eineseriesSchaubild 3 zeigt einenseriesUnd dann?addWenn Sie die Sequenz-IDs 0 und 1 angeben, die die Daten der beiden Sequenzen in Diagramm 1 repräsentieren, werden die Daten in Tabelle 1 aktualisiert.addWenn Sie die Serien-ID als 2 angeben, dann ist dies der erste Teil von Diagramm 2.seriesDie Daten, die in der Reihe 3 angegeben werden, beziehen sich auf den ersten Teil von Diagramm 3.seriesDie Daten sind hier:

HighStocks：http://api.highcharts.com/highstock

Die Multidiagramme zeigen einige der entsprechenden Eigenschaften:Beispiele

Ein Beispiel für ein Chartkonfigurationsobjekt:

var cfgA = {
    extension: {
        // 不参于分组，单独显示，默认为分组 'group'
        layout: 'single', 
        // 指定高度，可以设置为字符串，"300px"，设置数值300会自动替换为"300px"
        height: 300,      
        // 指定宽度占的单元值，总值为12
        col: 8            
    },
    title: {
        text: '盘口图表'
    },
    xAxis: {
        type: 'datetime'
    },
    series: [{
        name: '买一',
        data: []
    }, {
        name: '卖一',
        data: []
    }]
}

var cfgB = {
    title: {
        text: '差价图'
    },
    xAxis: {
        type: 'datetime'
    },
    series: [{
        name: '差价',
        type: 'column',
        data: []
    }]
}

var cfgC = {
    __isStock: false,
    title: {
        text: '饼图'
    },
    series: [{
        type: 'pie',
        name: 'one',
        // 指定初始数据后不需要用add函数更新,直接更改图表配置就可以更新序列
        data: [                    
            ["A", 25],
            ["B", 25],
            ["C", 25],
            ["D", 25]
        ]                
    }]
}

var cfgD = {
    extension: {
        layout: 'single',
        // 指定宽度占的单元值,总值为12
        col: 8,                    
        height: '300px'
    },
    title: {
        text: '盘口图表'
    },
    xAxis: {
        type: 'datetime'
    },
    series: [{
        name: '买一',
        data: []
    }, {
        name: '卖一',
        data: []
    }]
}

var cfgE = {
    __isStock: false,
    extension: {
        layout: 'single',
        col: 4,
        height: '300px'
    },
    title: {
        text: '饼图2'
    },
    series: [{
        type: 'pie',
        name: 'one',
        data: [
            ["A", 25],
            ["B", 25],
            ["C", 25],
            ["D", 25]
        ]
    }]
}

cfgA = {
    "extension" : {
        "layout" : "single", 
        "height" : 300,
        "col" : 8
    }, 
    "title" : {
        "text" : "盘口图表"
    },
    "xAxis" : {
        "type" : "datetime" 
    }, 
    "series" : [{
        "name" : "买一",
        "data" : []
    }, {
        "name" : "卖一", 
        "data" : []
    }]
}    

cfgB = {
    "title" : {
        "text" : "差价图"
    }, 
    "xAxis" : {
        "type" : "datetime"
    }, 
    "series" : [{
        "name" : "差价", 
        "type" : "column", 
        "data" : []
    }]
}    

cfgC = {
    "__isStock" : False,
    "title" : {
        "text" : "饼图"
    }, 
    "series" : [{
        "type" : "pie", 
        "name" : "one", 
        "data" : [
            ["A", 25],
            ["B", 25],
            ["C", 25],
            ["D", 25]
        ]
    }]
}    

cfgD = {
    "extension" : {
        "layout" : "single",
        "col" : 8,
        "height" : "300px"
    }, 
    "title" : {
        "text" : "盘口图表"
    }, 
    "series" : [{
        "name" : "买一", 
        "data" : []
    }, {
        "name" : "卖一",
        "data" : []
    }]
}    

cfgE = {
    "__isStock" : False, 
    "extension" : {
        "layout" : "single", 
        "col" : 4,
        "height" : "300px"
    }, 
    "title" : {
        "text" : "饼图2"
    },
    "series" : [{
        "type" : "pie",
        "name" : "one", 
        "data" : [
            ["A", 25], 
            ["B", 25], 
            ["C", 25], 
            ["D", 25]
        ]
    }]
}

json cfgA = R"({
    "extension" : {
        "layout" : "single", 
        "height" : 300,
        "col" : 8
    }, 
    "title" : {
        "text" : "盘口图表"
    },
    "xAxis" : {
        "type" : "datetime" 
    }, 
    "series" : [{
        "name" : "买一",
        "data" : []
    }, {
        "name" : "卖一", 
        "data" : []
    }]
})"_json;    

json cfgB = R"({
    "title" : {
        "text" : "差价图"
    }, 
    "xAxis" : {
        "type" : "datetime"
    }, 
    "series" : [{
        "name" : "差价", 
        "type" : "column", 
        "data" : []
    }]
})"_json;    

json cfgC = R"({
    "__isStock" : false,
    "title" : {
        "text" : "饼图"
    }, 
    "series" : [{
        "type" : "pie", 
        "name" : "one", 
        "data" : [
            ["A", 25],
            ["B", 25],
            ["C", 25],
            ["D", 25]
        ]
    }]
})"_json;    

json cfgD = R"({
    "extension" : {
        "layout" : "single",
        "col" : 8,
        "height" : "300px"
    }, 
    "title" : {
        "text" : "盘口图表"
    }, 
    "series" : [{
        "name" : "买一", 
        "data" : []
    }, {
        "name" : "卖一",
        "data" : []
    }]
})"_json;    

json cfgE = R"({
    "__isStock" : false, 
    "extension" : {
        "layout" : "single", 
        "col" : 4,
        "height" : "300px"
    }, 
    "title" : {
        "text" : "饼图2"
    },
    "series" : [{
        "type" : "pie",
        "name" : "one", 
        "data" : [
            ["A", 25], 
            ["B", 25], 
            ["C", 25], 
            ["D", 25]
        ]
    }]
})"_json;

• cfgA.extension.layoutEigenschaften

  Wenn diese Eigenschaft als "single" eingestellt ist, wird das Diagramm nicht überlagert (nicht als Seitenmarkierung angezeigt) und separat angezeigt (flächig angezeigt).

• cfgA.extension.heightEigenschaften

  Diese Eigenschaft wird verwendet, um die Höhe des Diagramms festzulegen, wobei der Wert als numerischer Typ oder als "300px" eingestellt werden kann.

• cfgA.extension.colEigenschaften

  Diese Eigenschaft wird verwendet, um die Breite des Diagramms zu setzen, wobei die Seitenbreite auf 12 Einheiten aufgeteilt ist, wobei 8 festgelegt wird, damit das Diagramm 8 Einheiten breit ist.

  Die Strategie, um das vollständige Beispiel zu verfolgen:

  • Versionen von JavaScript
  • Die Python-Version
  • C++ Version

  In den folgenden Beispielen werden die Effekte der Chartkonfigurationsobjekte angezeigt:

  

• Die Daten auf den Chartkonfigurationsobjekten können direkt geändert werden, um die Chartkonfiguration zu aktualisieren:

  Das ist ein Beispiel.JavaScriptEin Teil des Code-Paragraphs des BeispielsDas vollständige Beispiel）：

  cfgC.series[0].data[0][1] = Math.random() * 100
  cfgE.series[0].data[0][1] = Math.random() * 100
  // update实际上等于重置了图表的配置
  chart.update([cfgA, cfgB, cfgC, cfgD, cfgE])
  

  ÜbernommenaddMethoden, um die Daten zu aktualisieren, z. B. das Hinzufügen eines Elements zu einem Kuchen.JavaScriptEin Teil des Code-Paragraphs des BeispielsDas vollständige Beispiel）：

  // 为饼图增加一个数据点，add只能更新通过add方式添加的数据点，内置的数据点无法后期更新
  chart.add(3, {
      name: "ZZ",
      y: Math.random() * 100
  })
  

• NebeneffekteChartBeispiele für Funktionen

  Ein einfaches Beispiel:

  // 这个chart在JavaScript语言中是对象，在使用Chart函数之前我们需要声明一个配置图表的对象变量chart
  var chart = {                                           
      // 该字段标记图表是否为一般图表，有兴趣的可以改成false运行看看
      __isStock: true,                                    
      // 缩放工具
      tooltip: {xDateFormat: '%Y-%m-%d %H:%M:%S, %A'},    
      // 标题
      title : { text : '差价分析图'},                       
      // 选择范围
      rangeSelector: {                                    
          buttons:  [{type: 'hour',count: 1, text: '1h'}, {typ