리소스 로딩... 로딩...

FMZ API 지침

저자:제로, 제작: 2020-04-20 10:19:00, 업데이트: 2023-04-12 14:44:56

 ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "close position"}]
      ]
  })"_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() + "`");

}


![](![img](/upload/asset/26902c1e3ac979aff2b49.png))

- Vertical merger

```js
function main() {
    var table = { 
        type: 'table', 
        title: 'Table demo', 
        cols: ['ColumnA', 'ColumnB', 'ColumnC'], 
        rows: [ 
            ['A1', 'B1', {'type':'button', 'cmd': 'coverAll', 'name': 'C1'}]
        ]
    } 

    var ticker = exchange.GetTicker()
    var name = exchange.GetName()

    table.rows.push([{body : "A2 + B2:" + JSON.stringify(ticker), colspan : 2}, "C2"])
    table.rows.push([{body : "A3 + A4 + A5:" + name, rowspan : 3}, "B3", "C3"])
    // A3 is merged by the first cell in the previous row
    table.rows.push(["B4", "C4"])
    // A2 is merged by the first cell in the previous row
    table.rows.push(["B5", "C5"])                                            
    table.rows.push(["A6", "B6", "C6"])
    LogStatus('`' + JSON.stringify(table) + '`')
}
import json
def main():
    table = {
        "type" : "table", 
        "title" : "Table demo", 
        "cols" : ["ColumnA", "ColumnB", "ColumnC"], 
        "rows" : [
            ["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
        ]
    }
    
    ticker = exchange.GetTicker()
    name = exchange.GetName()
    
    table["rows"].append([{"body": "A2 + B2:" + json.dumps(ticker), "colspan": 2}, "C2"])
    table["rows"].append([{"body": "A3 + A4 + A5:" + name, "rowspan": 3}, "B3", "C3"])
    table["rows"].append(["B4", "C4"])
    table["rows"].append(["B5", "C5"])
    table["rows"].append(["A6", "B6", "C6"])
    LogStatus("`" + json.dumps(table) + "`")
void main() {
    json table = R"({
        "type" : "table", 
        "title" : "Table demo", 
        "cols" : ["ColumnA", "ColumnB", "ColumnC"], 
        "rows" : [
            ["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
        ]
    })"_json;
    // In order to test, the code is short and easy to read, and the constructed data is used here
    json jsonTicker = R"({"High": 0, "Low": 0, "Buy": 0, "Sell": 0, "Last": 0, "Time": 0, "Volume": 0})"_json;
    auto name = exchange.GetName();
    json arr1 = R"([{"body": "", "colspan": 2}, "C2"])"_json;
    arr1[0]["body"] = "A2 + B2:" + jsonTicker.dump();
    json arr2 = R"([{"body": "", "rowspan": 3}, "B3", "C3"])"_json;
    arr2[0]["body"] = "A3 + A4 + A5:" + name;
    table["rows"].push_back(arr1);
    table["rows"].push_back(arr2);
    table["rows"].push_back(R"(["B4", "C4"])"_json);
    table["rows"].push_back(R"(["B5", "C5"])"_json);
    table["rows"].push_back(R"(["A6", "B6", "C6"])"_json);
    LogStatus("`" + table.dump() + "`");
}

상태 표시줄의 테이블 페이지링 표시:

function main() {
    var table1 = {type: 'table', title: 'table1', cols: ['Column1', 'Column2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
    var table2 = {type: 'table', title: 'table2', cols: ['Column1', 'Column2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
    LogStatus('`' + JSON.stringify([table1, table2]) + '`')
}
import json
def main():
    table1 = {"type": "table", "title": "table1", "cols": ["Column1", "Column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
    table2 = {"type": "table", "title": "table2", "cols": ["Column1", "Column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
    LogStatus("`" + json.dumps([table1, table2]) + "`")
void main() {
    json table1 = R"({"type": "table", "title": "table1", "cols": ["Column1", "Column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
    json table2 = R"({"type": "table", "title": "table2", "cols": ["Column1", "Column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
    json arr = R"([])"_json;
    arr.push_back(table1);
    arr.push_back(table2);
    LogStatus("`" + arr.dump() + "`");
}

img

페이지링 테이블 외에도 여러 테이블을 위에서 아래로 배치 할 수 있습니다.

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

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

    LogStatus('`' + JSON.stringify(tab1) + '`\n' + 
        '`' + JSON.stringify(tab2) + '`\n' +
        '`' + JSON.stringify(tab3) + '`')
  
    Log("exit")
}
import json
def main():
    tab1 = {
        "type": "table", 
        "title": "table1", 
        "cols": ["1", "2"], 
        "rows": []
    }
    tab2 = {
        "type": "table", 
        "title": "table2", 
        "cols": ["1", "2", "3"], 
        "rows": []
    }
    tab3 = {
        "type": "table", 
        "title": "table3", 
        "cols": ["A", "B", "C"], 
        "rows": []
    }

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

작동 결과:

참고: 전략 봇이 봇 페이지에서 실행될 때, 로그 기록을 스크롤하면 상태 표시줄은 잠복 상태로 들어가 업데이트를 중지합니다. 상태 표시줄 데이터는 로그가 첫 페이지에 있을 때만 갱신됩니다. 상태 표시줄은base64, 그리고 또한 코딩 된 이미지를 출력 지원base64표시된 태블릿에 표시됩니다. 코딩된 이미지의 문자열 길이가 일반적으로 매우 길기 때문에 샘플 코드는 제공되지 않습니다.

EnableLog (()

EnableLog(IsEnable)주문 정보에 대한 로그 기록을 켜거나 끄는 경우isEnablebool 타입입니다.IsEnable설정되어 있습니다false, 주문 로그는 인쇄되지 않을 것입니다 그리고 그것은 봇 데이터베이스에 기록되지 않을 것입니다.

차트 ((...)

Chart(...), 차트 도면을 사용자 정의하는 기능.

Chart({…}); 파라미터는HighCharts.StockChart매개 변수하이스토크그 중에서도 연재할 수 있습니다JSON, 추가로_isStock네이티브 매개 변수에 속성을 지정하면_isStock:false, 그것은 정상적인 차트로 표시됩니다.

참고: 이 속성을 설정하면_isStockfalse, 사용된 차트는:하이라이트 차트, 도표에서 보이는 것처럼:

Highcharts chart

이 속성을 설정하면_isStocktrue, 사용된 차트는:높은 물류(디폴트)_isStock사실로) 도표에서 보이는 것처럼:

Highstocks chart

객체로 돌아가려면add(n, data) (n(예를 들어 0) 는series, 그리고data도표에 기록 된 데이터입니다) 지정 된 인덱스에 데이터를 추가하기 위해series; 호출reset()차트 데이터를 클리어하기 위해, 그리고reset숫자 매개 변수를 가지고 예약된 항목의 수를 지정할 수 있습니다.

전화해도 돼요add(n, data, i) (i이 데이터의 지수가series) 에 해당하는 데이터 변경series.

음수가 될 수 있고, -1은 마지막을 가리키고, -2은 준 마지막을 가리키고 있다. 예를 들어, 직선을 그리는 경우, 직선의 마지막 지점에서 데이터를 수정한다.

chart.add(0, [1574993606000, 13.5], -1), 마지막 점의 데이터를 변경series[0].data.

여러 차트를 표시하는 것을 지원하기 때문에, 당신은 단지 구성 중에 배열 매개 변수를 전달해야 합니다.var chart = Chart([{…}, {…}, {…}])예를 들어, 차트 1에는 두 개의series그래프 2에는 하나 있습니다.series, 그리고 그래프 3는 하나series다음, 추가 할 때 시리즈 ID 0 및 1을 지정 하 고 표시 하 고, 차트 1의 두 순서 열의 데이터를 업데이트 하 고; 추가 할 때 시리즈 ID 2를 지정 하 여 첫 번째 참조series차트 2의 데이터; 시리즈를 지정하는 ID3는 첫 번째 데이터에 해당합니다.series차트 3의

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

멀티 차트 표시와 관련된 속성 설정:예제

예를 들어, 차트 구성 객체:

var cfgA = {
    extension: {
        // It does not participate in grouping, displayed separately, and its default is 'group'
        layout: 'single', 
        // This is the specified height, which can be set to string "300px" (set "300", and "300px" will be displayed instead automatically)
        height: 300,      
        // It is the unit value of the specified width, with a total value of 12
        col: 8            
    },
    title: {
        text: 'Market Chart'
    },
    xAxis: {
        type: 'datetime'
    },
    series: [{
        name: 'Buy 1',
        data: []
    }, {
        name: 'Sell 1',
        data: []
    }]
}

var cfgB = {
    title: {
        text: 'Spread chart'
    },
    xAxis: {
        type: 'datetime'
    },
    series: [{
        name: 'Spread',
        type: 'column',
        data: []
    }]
}

var cfgC = {
    _isStock: false,
    title: {
        text: 'Pie Chart'
    },
    series: [{
        type: 'pie',
        name: 'one',
        // After specifying the initial data, you don't need to update it with the "add" function; Changing the chart configuration directly will update the series
        data: [                    
            ["A", 25],
            ["B", 25],
            ["C", 25],
            ["D", 25]
        ]                
    }]
}

var cfgD = {
    extension: {
        layout: 'single',
        // The unit value of the specified width, with a total value of 12
        col: 8,                    
        height: '300px'
    },
    title: {
        text: 'Market Chart'
    },
    xAxis: {
        type: 'datetime'
    },
    series: [{
        name: 'Buy 1',
        data: []
    }, {
        name: 'Sell 1',
        data: []
    }]
}

var cfgE = {
    __isStock: false,
    extension: {
        layout: 'single',
        col: 4,
        height: '300px'
    },
    title: {
        text: 'Pie Chart2'
    },
    series: [{
        type: 'pie',
        name: 'one',
        data: [
            ["A", 25],
            ["B", 25],
            ["C", 25],
            ["D", 25]
        ]
    }]
}
cfgA = {
    "extension" : {
        "layout" : "single", 
        "height" : 300,
        "col" : 8
    }, 
    "title" : {
        "text" : "Market Chart"
    },
    "xAxis" : {
        "type" : "datetime" 
    }, 
    "series" : [{
        "name" : "Buy 1",
        "data" : []
    }, {
        "name" : "Sell 1", 
        "data" : []
    }]
}    

cfgB = {
    "title" : {
        "text" : "Spread chart"
    }, 
    "xAxis" : {
        "type" : "datetime"
    }, 
    "series" : [{
        "name" : "Spread", 
        "type" : "column", 
        "data" : []
    }]
}    

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

cfgD = {
    "extension" : {
        "layout" : "single",
        "col" : 8,
        "height" : "300px"
    }, 
    "title" : {
        "text" : "Market Chart"
    }, 
    "series" : [{
        "name" : "Buy 1", 
        "data" : []
    }, {
        "name" : "Sell 1",
        "data" : []
    }]
}    

cfgE = {
    "__isStock" : False, 
    "extension" : {
        "layout" : "single", 
        "col" : 4,
        "height" : "300px"
    }, 
    "title" : {
        "text" : "Pie Chart2"
    },
    "series" : [{
        "type" : "pie",
        "name" : "one", 
        "data" : [
            ["A", 25], 
            ["B", 25], 
            ["C", 25], 
            ["D", 25]
        ]
    }]
}
json cfgA = R"({
    "extension" : {
        "layout" : "single", 
        "height" : 300,
        "col" : 8
    }, 
    "title" : {
        "text" : "Market Chart"
    },
    "xAxis" : {
        "type" : "datetime" 
    }, 
    "series" : [{
        "name" : "Buy 1",
        "data" : []
    }, {
        "name" : "Sell 1", 
        "data" : []
    }]
})"_json;    

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

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

json cfgD = R"({
    "extension" : {
        "layout" : "single",
        "col" : 8,
        "height" : "300px"
    }, 
    "title" : {
        "text" : "Market Chart"
    }, 
    "series" : [{
        "name" : "Buy 1", 
        "data" : []
    }, {
        "name" : "Sell 1",
        "data" : []
    }]
})"_json;    

json cfgE = R"({
    "__isStock" : false, 
    "extension" : {
        "layout" : "single", 
        "col" : 4,
        "height" : "300px"
    }, 
    "title" : {
        "text" : "Pie Chart2"
    },
    "series" : [{
        "type" : "pie",
        "name" : "one", 
        "data" : [
            ["A", 25], 
            ["B", 25], 
            ["C", 25], 
            ["D", 25]
        ]
    }]
})"_json;
  • cfgA.extension.layout속성

    이 속성이 설정되어 있고 값이 single인 경우, 차트는 중첩되지 않습니다 (타브 라벨로 표시되지 않습니다) 그리고 별도로 표시됩니다 (타일 표시).

  • cfgA.extension.height속성

    이 속성은 차트의 높이를 설정하는 데 사용됩니다. 값은 수치 유형 또는 300px 모드로 설정 될 수 있습니다.

  • cfgA.extension.col속성

    이 속성은 차트의 폭을 설정하는 데 사용됩니다. 페이지 폭은 총 12 단위로 나뉘며, 8을 설정하면 차트가 폭 8 단위를 차지한다는 것을 의미합니다.

    전체 예제 전략을 실행:

    위의 예제에서 차트 구성 객체의 효과 표시:

  • 차트 구성 객체에 있는 데이터에 대해, 차트 구성을 직접 수정하고, 데이터 업데이트를 실현하기 위해 차트를 업데이트합니다:

    예를 들어,JavaScript예제 코드 부분 (완전 한 예):

    cfgC.series[0].data[0][1] = Math.random() * 100
    cfgE.series[0].data[0][1] = Math.random() * 100
    // "Update" is actually equivalent to resetting the configuration of the chart
    chart.update([cfgA, cfgB, cfgC, cfgD, cfgE])
    

    데이터 업데이트add도형 차트에 항목을 추가하는 것과 같은 방법, 그리고 여기에 다음JavaScript예제 코드 부분 (완전 한 예):

    // Add a data point to the pie chart; "add" can only update the data points added by the "add" method, the built-in data points cannot be updated later
    chart.add(3, {
        name: "ZZ",
        y: Math.random() * 100
    })
    
  • 부속된 사용 예제Chart기능

    간단한 그림 예제:

    // This chart is an object in JavaScript language. Before using the "Chart" function, we need to declare an object variable of a chart configuration 
    var chart = {                                           
        // It is marked as a general chart; if you are interested, you can change it to false and run it
        __isStock: true,                                    
        // Zoom tool
        tooltip: {xDateFormat: '%Y-%m-%d %H:%M:%S, %A'},    
        // Title
        title : { text : 'Spread analysis chart'},                       
        // Choose a range
        rangeSelector: {                                    
            buttons:  [{type: 'hour',count: 1, text: '1h'}, {type: 'hour',count: 3, text: '3h'}, {type: 'hour', count: 8, text: '8h'}, {type: 'all',text: 'All'}],
            selected: 0,
            inputEnabled: false
        },
        // The horizontal axis of the coordinate axis is: x axis, and the currently set "Types of" is: time
        xAxis: { type: 'datetime'},                         
        // The vertical axis of the coordinate axis is: y axis, and the default value is adjusted with the data size
        yAxis : {                                           
            // Title
            title: {text: 'Spread'},                           
            // Whether to enable the right vertical axis
            opposite: false                                 
        },
        // Data system column; this attribute holds each data system column (line, K-line diagram, label, etc.)
        series : [                                          
            // The index is 0, and the data in the data column is stored in the data array.
            {name : "line1", id : "line 1,buy1Price", data : []},                          
            // The index is 1, and set dashStyle: 'shortdash', namely: set the dashed line
            {name : "line2", id : "line 2,lastPrice", dashStyle : 'shortdash', data : []}  
        ]
    }
    function main(){
        // Call the "Chart" function to initialize the chart
        var ObjChart = Chart(chart)         
        // Empty
        ObjChart.reset()                      
        while(true){
            // Get the timestamp of this polling, that is, a millisecond timestamp, used to determine the position of the X axis written to the chart
            var nowTime = new Date().getTime()
            // Get market data
            var ticker = _C(exchange.GetTicker)
            // Get "Buy 1" price from the return value of market data
            var buy1Price = ticker.Buy    
            // To obtain the last executed price, in order to avoid the overlap of the 2 lines, we add 1
            var lastPrice = ticker.Last + 1
            // Use timestamp as X value and "Buy 1" price as Y value, and pass them into the data sequence of index 0
            ObjChart.add(0, [nowTime, buy1Price])
            // Same as above
            ObjChart.add(1, [nowTime, lastPrice])
            Sleep(2000)
        }
    }
    
    import time
    chart = {
        "__isStock" : True,
        "tooltip" : {"xDateFormat" : "%Y-%m-%d %H:%M:%S, %A"},  
        "title" : {"text" : "Spread analysis chart"}, 
        "rangeSelector" : {
            "buttons" : [{"type": "count", "count": 1, "text": "1h"}, {"type": "hour", "count": 3, "text": "3h"}, {"type": "hour", "count": 8, "text": "8h"}, {"type": "all", "text": "All"}], 
            "selected": 0,
            "inputEnabled": False 
        }, 
        "xAxis": {"type": "datetime"}, 
        "yAxis": {
            "title": {"text": "Spread"},
            "opposite": False
        },
        "series": [{
            "name": "line1", "id": "line 1,buy1Price", "data": []
        }, {
            "name": "line2", "id": "line 2,lastPrice", "dashStyle": "shortdash", "data": []
        }]
    }
    def main():
        ObjChart = Chart(chart)
        ObjChart.reset()
        while True:
            nowTime = time.time() * 1000
            ticker = exchange.GetTicker()
            buy1Price = ticker["Buy"]
            lastPrice = ticker["Last"] + 1
            ObjChart.add(0, [nowTime, buy1Price])
            ObjChart.add(1, [nowTime, lastPrice])
            Sleep(2000)
    
    void main() {
        // When write strategies in C++, try not to declare global variables that are not basic types, so the declaration of the chart configuration objects is in the "main" function
        json chart = R"({
            "__isStock" : true,
            "tooltip" : {"xDateFormat" : "%Y-%m-%d %H:%M:%S, %A"},  
            "title" : {"text" : "Spread analysis chart"}, 
            "rangeSelector" : {
                "buttons" : [{"type": "count", "count": 1, "text": "1h"}, {"type": "hour", "count": 3, "text": "3h"}, {"type": "hour", "count": 8, "text": "8h"}, {"type": "all", "text": "All"}], 
                "selected": 0,
                "inputEnabled": false 
            }, 
            "xAxis": {"type": "datetime"}, 
            "yAxis": {
                "title": {"text": "Spread"},
                "opposite": false
            },
            "series": [{
                "name": "line1", "id": "line 1,buy1Price", "data": []
            }, {
                "name": "line2", "id": "line 2,lastPrice", "dashStyle": "shortdash", "data": []
            }]
        })"_json;
        auto ObjChart = Chart(chart);
        ObjChart.reset();
        while(true) {
            auto nowTime = Unix() * 1000;
            auto ticker = exchange.GetTicker();
            auto buy1Price = ticker.Buy;
            auto lastPrice = ticker.Last + 1.0;
            ObjChart.add(0, {nowTime, buy1Price});
            ObjChart.add(1, {nowTime, lastPrice});
            Sleep(2000);
        }
    }
    

    삼각형 곡선을 그리는 예제:

    // The object used to initialize the chart
    var chart = {                                   
        // Chart title
        title: {text: "line value triggers plotLines value"},    
        // The related settings of Y axis
        yAxis: {                                    
            // The horizontal line perpendicular to y axis, used as a trigger line, is an array of structures where multiple trigger lines can be set
            plotLines: [{                           
                // Trigger line value; set a number, and this line will be displayed in the corresponding numerical position
                value: 0,                           
                // Set the color of the trigger line
                color: 'red',                       
                // Width
                width: 2,                           
                // Labels displayed
                label: {                            
                    // Label text
                    text: 'Trigger value',                  
                    // Center label position
                    align: 'center'                 
                }
            }]
        },
        // The related settings of X axis, and here the setting type is the time axis
        xAxis: {type: "datetime"},                  
        series: [
            {name: "sin", type: "spline", data: []},
            // This is a more important data system column; you can set multiple data system column, according to the array index control
            {name: "cos", type: "spline", data: []}
        ]  
    }
    function main(){
        // Pi
        var pi = 3.1415926535897
        // Variable for recording timestamp
        var time = 0                   
        // Angle
        var angle = 0                        
        // Coordinate y value, used to receive sine and cosine values
        var y = 0          
        // Call the API to initialize charts with "chart" objects
        var objChart = Chart(chart)        
        // When initializing, clear the chart
        objChart.reset()
        // Set the value of the trigger line to 1
        chart.yAxis.plotLines[0].value = 1
        // Loop
        while(true){                          
            // Get the timestamp of the current moment
            time = new Date().getTime() 
            // The angle is increased by 5 degrees every 500ms, and the sine value is calculated
            y = Math.sin(angle * 2 * pi / 360)
            // Write the calculated y value to the data of the corresponding index of the chart; the first parameter of the "add" function is the specified index
            objChart.add(0, [time, y])
            // Calculate the cosine value
            y = Math.cos(angle * 2 * pi / 360)
            objChart.add(1, [time, y])
            // Increase by 5 degrees
            angle += 5
            // Pause for 5 seconds, to avoid drawing too frequently and the data growing too fast
            Sleep(5000)     
        }
    }
    
    import math
    import time
    chart = {
        "title": {"text": "line value triggers plotLines value"}, 
        "yAxis": {
            "plotLines": [{
                "value": 0,
                "color": "red",
                "width": 2,
                "label": {
                    "text": "Trigger value", 
                    "align": "center"
                }
            }]
        },
        "xAxis": {"type": "datetime"},
        "series": [{"name": "sin", "type": "spline", "data": []},
                   {"name": "cos", "type": "spline", "data": []}]
    }
    def main():
        pi = 3.1415926535897
        ts = 0
        angle = 0
        y = 0
        objChart = Chart(chart)
        objChart.reset()
        chart["yAxis"]["plotLines"][0]["value"] = 1
        while True:
            ts = time.time() * 1000
            y = math.sin(angle * 2 * pi / 360)
            objChart.add(0, [ts, y])
            y = math.cos(angle * 2 * pi / 360)
            objChart.add(1, [ts, y])
            angle += 5
            Sleep(5000)
    
    void main() {
        json chart = R"({
            "title": {"text": "line value triggers plotLines value"}, 
            "yAxis": {
                "plotLines": [{
                    "value": 0,
                    "color": "red",
                    "width": 2,
                    "label": {
                        "text": "Trigger value", 
                        "align": "center"
                    }
                }]
            },
            "xAxis": {"type": "datetime"},
            "series": [{"name": "sin", "type": "spline", "data": []},
                       {"name": "cos", "type": "spline", "data": []}]     
        })"_json;
    
        auto pi = 3.1415926535897;
        auto ts = 0;
        auto angle = 0.0;
        auto y = 0.0;
        auto objChart = Chart(chart);
        objChart.reset();
        chart["yAxis"]["plotLines"][0]["value"] = 1;
        while(true) {
            ts = Unix() * 1000;
            y = sin(angle * 2 * pi / 360);
            objChart.add(0, {ts, y});
            y = cos(angle * 2 * pi / 360);
            objChart.add(1, {ts, y});
            angle += 5;
            Sleep(5000);
        }
    }
    

    이 지역에서는cpp전략,Chart이 함수는 또한 도표를 구성하기 위해 암호화된 문자열을 사용할 수 있습니다.

    void main () {
        Chart c = Chart(R"EOF({"chart":{"type":"line"},"title":{"text":"Simple chart"},"xAxis":{"title":{"text":"Date"}},"yAxis":{"title":{"text":"Number"}},"series":[{"name":"number","data":[]}]})EOF");
        c.reset();
        for (size_t i = 0; i < 10; i++) {
            // For example, int64 of "sprintf" function has different parameters in 32-bit and 64-bit, so it is best to use "toString" to transfer the platform-related types into strings and then pass
            c.add(0, format("[%s, %d]", toString(Unix() + i).c_str(), rand() % 100));
        }
    }
    

  • 혼합 차트의 복잡한 예자바스크립트 전략 주소

/*backtest
start: 2020-03-11 00:00:00
end: 2020-04-09 23:59:00
period: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/

var chartCfg = {
    subtitle: {
        text: "subtitle",
    },
    yAxis: [{
        height: "40%",
        lineWidth: 2,
        title: {
            text: 'PnL',
        },
        tickPixelInterval: 20,
        minorGridLineWidth: 1,
        minorTickWidth: 0,
        opposite: true,
        labels: {
            align: "right",
            x: -3,
        }
    }, {
        title: {
            text: 'Profit',
        },
        top: "42%",
        height: "18%",
        offset: 0,
        lineWidth: 2
    }, {
        title: {
            text: 'Vol',
        },
        top: '62%',
        height: '18%',
        offset: 0,
        lineWidth: 2
    }, {
        title: {
            text: 'Asset',
        },
        top: '82%',
        height: '18%',
        offset: 0,
        lineWidth: 2
    }],
    series: [{
        name: 'PnL',
        data: [],
        id: 'primary',
        tooltip: {
            xDateFormat: '%Y-%m-%d %H:%M:%S'
        },
        yAxis: 0
    }, {
        type: 'column',
        lineWidth: 2,
        name: 'Profit',
        data: [],
        yAxis: 1,
    }, {
        type: 'column',
        name: 'Trade',
        data: [],
        yAxis: 2
    }, {
        type: 'area',
        step: true,
        lineWidth: 0,
        name: 'Long',
        data: [],
        yAxis: 2
    }, {
        type: 'area',
        step: true,
        lineWidth: 0,
        name: 'Short',
        data: [],
        yAxis: 2
    }, {
        type: 'line',
        step: true,
        color: '#5b4b00',
        name: 'Asset',
        data: [],
        yAxis: 3
    }, {
        type: 'pie',
        innerSize: '70%',
        name: 'Random',
        data: [],
        center: ['3%', '6%'],
        size: '15%',
        dataLabels: {
            enabled: false
        },
        startAngle: -90,
        endAngle: 90,
    }],
};

function main() {
    let c = Chart(chartCfg);
    let preTicker = null;
    while (true) {
        let t = exchange.GetTicker();
        
        c.add(0, [t.Time, t.Last]); // PnL
        c.add(1, [t.Time, preTicker ? t.Last - preTicker.Last : 0]); // profit
        let r = Math.random();
        var pos = parseInt(t.Time/86400);
        c.add(2, [t.Time, pos/2]); // Vol
        c.add(3, [t.Time, r > 0.8 ? pos : null]); // Long
        c.add(4, [t.Time, r < 0.8 ? -pos : null]); // Short
        c.add(5, [t.Time, Math.random() * 100]); // Asset
        // update pie
        chartCfg.series[chartCfg.series.length-1].data = [
            ["A", Math.random()*100],
            ["B", Math.random()*100],
         ];
        c.update(chartCfg)
        preTicker = t;
    }
}
'''backtest
start: 2020-03-11 00:00:00
end: 2020-04-09 23:59:00
period: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''

import random

chartCfg = {
    "subtitle": {
        "text": "subtitle"
    },
    "yAxis": [{
        "height": "40%",
        "lineWidth": 2,
        "title": {
            "text": 'PnL'
        },
        "tickPixelInterval": 20,
        "minorGridLineWidth": 1,
        "minorTickWidth": 0,
        "opposite": True,
        "labels": {
            "align": "right",
            "x": -3
        }
    }, {
        "title": {
            "text": 'Profit'
        },
        "top": "42%",
        "height": "18%",
        "offset": 0,
        "lineWidth": 2
    }, {
        "title": {
            "text": 'Vol'
        },
        "top": '62%',
        "height": '18%',
        "offset": 0,
        "lineWidth": 2
    }, {
        "title": {
            "text": 'Asset'
        },
        "top": '82%',
        "height": '18%',
        "offset": 0,
        "lineWidth": 2
    }],
    "series": [{
        "name": 'PnL',
        "data": [],
        "id": 'primary',
        "tooltip": {
            "xDateFormat": '%Y-%m-%d %H:%M:%S'
        },
        "yAxis": 0
    }, {
        "type": 'column',
        "lineWidth": 2,
        "name": 'Profit',
        "data": [],
        "yAxis": 1
    }, {
        "type": 'column',
        "name": 'Trade',
        "data": [],
        "yAxis": 2
    }, {
        "type": 'area',
        "step": True,
        "lineWidth": 0,
        "name": 'Long',
        "data": [],
        "yAxis": 2
    }, {
        "type": 'area',
        "step": True,
        "lineWidth": 0,
        "name": 'Short',
        "data": [],
        "yAxis": 2
    }, {
        "type": 'line',
        "step": True,
        "color": '#5b4b00',
        "name": 'Asset',
        "data": [],
        "yAxis": 3
    }, {
        "type": 'pie',
        "innerSize": '70%',
        "name": 'Random',
        "data": [],
        "center": ['3%', '6%'],
        "size": '15%',
        "dataLabels": {
            "enabled": False
        },
        "startAngle": -90,
        "endAngle": 90
    }]
}

def main():
    c = Chart(chartCfg)
    preTicker = None
    while True:
        t = exchange.GetTicker()
        c.add(0, [t["Time"], t["Last"]])
        profit = t["Last"] - preTicker["Last"] if preTicker else 0
        c.add(1, [t["Time"], profit])
        r = random.random()
        pos = t["Time"] / 86400
        c.add(2, [t["Time"], pos / 2])
        long = pos if r > 0.8 else None
        c.add(3, [t["Time"], long])
        short = -pos if r < 0.8 else None
        c.add(4, [t["Time"], short])
        c.add(5, [t["Time"], random.random() * 100])

        # update pie
        chartCfg["series"][len(chartCfg["series"]) - 1]["data"] = [
            ["A", random.random() * 100], 
            ["B", random.random() * 100]
        ]
        c.update(chartCfg)
        preTicker = t

/*backtest
start: 2020-03-11 00:00:00
end: 2020-04-09 23:59:00
period: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/

void main() {
    json chartCfg = R"({
        "subtitle": {
            "text": "subtitle"
        },
        "yAxis": [{
            "height": "40%",
            "lineWidth": 2,
            "title": {
                "text": "PnL"
            },
            "tickPixelInterval": 20,
            "minorGridLineWidth": 1,
            "minorTickWidth": 0,
            "opposite": true,
            "labels": {
                "align": "right",
                "x": -3
            }
        }, {
            "title": {
                "text": "Profit"
            },
            "top": "42%",
            "height": "18%",
            "offset": 0,
            "lineWidth": 2
        }, {
            "title": {
                "text": "Vol"
            },
            "top": "62%",
            "height": "18%",
            "offset": 0,
            "lineWidth": 2
        }, {
            "title": {
                "text": "Asset"
            },
            "top": "82%",
            "height": "18%",
            "offset": 0,
            "lineWidth": 2
        }],
        "series": [{
            "name": "PnL",
            "data": [],
            "id": "primary",
            "tooltip": {
                "xDateFormat": "%Y-%m-%d %H:%M:%S"
            },
            "yAxis": 0
        }, {
            "type": "column",
            "lineWidth": 2,
            "name": "Profit",
            "data": [],
            "yAxis": 1
        }, {
            "type": "column",
            "name": "Trade",
            "data": [],
            "yAxis": 2
        }, {
            "type": "area",
            "step": true,
            "lineWidth": 0,
            "name": "Long",
            "data": [],
            "yAxis": 2
        }, {
            "type": "area",
            "step": true,
            "lineWidth": 0,
            "name": "Short",
            "data": [],
            "yAxis": 2
        }, {
            "type": "line",
            "step": true,
            "color": "#5b4b00",
            "name": "Asset",
            "data": [],
            "yAxis": 3
        }, {
            "type": "pie",
            "innerSize": "70%",
            "name": "Random",
            "data": [],
            "center": ["3%", "6%"],
            "size": "15%",
            "dataLabels": {
                "enabled": false
            },
            "startAngle": -90,
            "endAngle": 90
        }]
    })"_json;
    
    Chart c = Chart(chartCfg);
    Ticker preTicker;
    while(true) {
        auto t = exchange.GetTicker();
        c.add(0, {t.Time, t.Last});
        auto profit = preTicker.Valid ? t.Last - preTicker.Last : 0;
        c.add(1, {t.Time, profit});    
        auto r = rand() % 100;
        auto pos = t.Time / 86400.0;
        c.add(2, {t.Time, pos / 2.0});
        auto longPos = r > 0.8 ? pos : NULL;
        c.add(3, {t.Time, longPos});
        auto shortPos = r < 0.8 ? -pos : NULL;
        c.add(4, {t.Time, shortPos});
        c.add(5, {t.Time, rand() % 100});
        
        // update pie 
        json pie = R"([["A", 0], ["B", 0]])"_json;
        pie[0][1] = rand() % 100;
        pie[1][1] = rand() % 100;
        chartCfg["series"][chartCfg["series"].size() - 1]["data"] = pie;
        
        c.update(chartCfg);
        preTicker = t;
    }
}

차트 중,pie그래프는 시간 축이 없는 그래프이고, 데이터 업데이트를 할 때 그래프 구성은 직접 업데이트되어야 합니다. 예를 들어 위의 예제에서 코드를, 데이터를 업데이트 한 후,c.update(chartCfg)차트를 다음과 같이 업데이트합니다.

    // update pie
    chartCfg.series[chartCfg.series.length-1].data = [
        ["A", Math.random()*100],
        ["B", Math.random()*100],
    ];
    c.update(chartCfg)
    # update pie
    chartCfg["series"][len(chartCfg["series"]) - 1]["data"] = [
        ["A", random.random() * 100], 
        ["B", random.random() * 100]
    ]
    c.update(chartCfg)
    // update pie 
    json pie = R"([["A", 0], ["B", 0]])"_json;
    pie[0][1] = rand() % 100;
    pie[1][1] = rand() % 100;
    chartCfg["series"][chartCfg["series"].size() - 1]["data"] = pie;
    c.update(chartCfg);

작업 결과:img

KLineChart (클라인차트)

KLineChart(chartCfg), 이 함수는 전략을 실행할 때 사용자 지정 도면을 위해 파이인 언어와 유사한 도화 방법을 사용 합니다. 전략 사용자 지정 도화는KLineChart()방법 또는Chart() methods.

참조 코드:

function main() {
    // Call the KLineChart function to create a chart control object c
    let c = KLineChart({
        overlay: true
    })

    // Use the spot exchange object test to obtain K-line data. If you use the futures exchange object test, you need to set up the contract first.
    let bars = exchange.GetRecords()
    if (!bars) {
        return
    }

    bars.forEach(function(bar, index) {
        c.begin(bar)
        c.barcolor(bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(0, 0, 0, 0.2)')
        if (bar.Close > bar.Open) {
            c.bgcolor('rgba(0, 255, 0, 0.5)')
        }
        let h = c.plot(bar.High, 'high')
        let l = c.plot(bar.Low, 'low')

        c.fill(h, l, {
            color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0.2)'
        })
        c.hline(bar.High)
        c.plotarrow(bar.Close - bar.Open)
        c.plotshape(bar.Low, {
            style: 'diamond'
        })
        c.plotchar(bar.Close, {
            char: 'X'
        })
        c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
        if (bar.Close > bar.Open) {
            // long/short/closelong/closeshort
            c.signal("long", bar.High, 1.5)
        } else if (bar.Close < bar.Open) {
            c.signal("closelong", bar.Low, 1.5)
        }
        c.close()
    })
}
def main():
    # Call the KLineChart function to create a chart control object c
    c = KLineChart({
        "overlay": True
    })

    # Use the spot exchange object test to obtain K-line data. If you use the futures exchange object test, you need to set up the contract first.
    bars = exchange.GetRecords()
    if not bars:
        return

    for bar in bars:
        c.begin(bar)
        c.barcolor('rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(0, 0, 0, 0.2)')
        if bar.Close > bar.Open:
            c.bgcolor('rgba(0, 255, 0, 0.5)')

        h = c.plot(bar.High, 'high')
        l = c.plot(bar.Low, 'low')

        c.fill(h, l, 'rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(255, 0, 0, 0.2)')
        c.hline(bar.High)
        c.plotarrow(bar.Close - bar.Open)        
        c.plotshape(bar.Low, style = 'diamond')
        c.plotchar(bar.Close, char = 'X')
        c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
        if bar.Close > bar.Open:
            # long/short/closelong/closeshort
            c.signal("long", bar.High, 1.5)
        elif bar.Close < bar.Open:
            c.signal("closelong", bar.Low, 1.5)

        c.close()
// Not supported currently

전략의 사용자 정의 도면 영역에 도영 제어 객체가 있어야 하는 경우, 함수를 사용KLineChart이 객체를 만들기 위해.KLineChart함수는 차트 구성 구조입니다. 참조 코드에서 사용되는 차트 구조는 매우 간단합니다.{overlay: true})이 차트 구성 구조는 주요 차트에서 출력 될 그림 콘텐츠만 설정합니다.overlay설정되어 있습니다false, 차트의 콘텐츠는 하위 차트에 출력됩니다. 당신은 주요 차트에 그리기 도영 함수를 지정해야 하는 경우, 당신은 또한 매개 변수를 지정할 수 있습니다overlay그 외true특정 함수 호출에서

그림 작업은 K-선 데이터에 걸쳐서 실행됩니다. 그림 작업은c.begin(bar)함수 호출 및 a와 끝c.close()함수 호출. 그림 작업에 지원되는 파이어 언어의 그림 인터페이스 기능은 다음과 같습니다.

  • 바 컬러: K 라인 색을 설정

    바콜러 (barcolor, offset, 편집가능, show_last, title, display)

    c.barcolor(bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(0, 0, 0, 0.2)')   // Use the example illustrated in the reference code in this example, without giving unnecessary details 
    
    c.barcolor('rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(0, 0, 0, 0.2)')
    
    • display선택적 매개 변수: 무도, 모든
  • bgcolor: 지정된 색으로 K줄의 배경을 채우

    bgcolor ((color, offset, 편집가능, show_last, title, display, overlay)

    c.bgcolor('rgba(0, 255, 0, 0.5)')
    
    c.bgcolor('rgba(0, 255, 0, 0.5)')
    
    • display선택적 매개 변수: 무도, 모든
  • 그래프: 그래프에 일련의 데이터를 그래프

    plot ((series, title, color, linewidth, style, trackprice, histbase, offset, join, editable, show_last, display) 그라운드, 제목, 색상, 줄 너비, 스타일, 트랙 프라이스, 히스트베이스, 오프셋, 유닛, 편집 가능, 쇼_러스트, 디스플레이)

    c.plot(bar.High, 'high')
    
    h = c.plot(bar.High, 'high')
    
    • style선택적 매개 변수: stepline_diamond, stepline, cross, areabr, area, circles, columns, histogram, linebr, line
    • display선택적 매개 변수: 무도, 모든
  • 채우기: 제공된 색으로 두 개의 도면 또는 줄 사이의 배경을 채우기

    Fill (프리플), HLine (프리플), HLine (프리플), Color (프리플), Title (프리플), Editable (프리플), Fill (프리플), Display (프리플)

    let h = c.plot(bar.High, 'high')
    let l = c.plot(bar.Low, 'low')
    
    c.fill(h, l, {color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0.2)'})
    
    h = c.plot(bar.High, 'high')
    l = c.plot(bar.Low, 'low')
    
    c.fill(h, l, {"color": 'rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(255, 0, 0, 0.2)'})
    
    • display선택적 매개 변수: 무도, 모든

    그 이후JavaScript언어는 함수의 이름에 따라 입력 매개 변수를 지정할 수 없습니다{key: value}구조를 특정 형식적인 매개 변수 이름에서 전달되는 매개 변수를 지정하는 데 사용할 수 있습니다. 예를 들어 참조 코드, 사용{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0.2)'}정렬하기color매개 변수fill여러 개의 매개 변수 이름을 연속으로 지정해야 한다면,{key1: value1, key2: value2, key3: value3}예를 들어, 이 예제에서, a를 지정하는 매개 변수를 추가title: {color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0.2)', title: 'fill'}.

    색상 값은'rgba(255, 0, 0, 0.2)'설정, 또는 사용 방법'#FF0000'설정하는 방법

  • hline: 정해진 가격 수준에서 수평선을 나타냅니다.

    hline ((가격, 제목, 색상, 라인 스타일, 라인 너비, 편집 가능, 표시)

    c.hline(bar.High)
    
    c.hline(bar.High)
    
    • linestyle선택적 매개 변수: 단선, , 고체
    • display선택적 매개 변수: 무도, 모든
  • 플로타로우: 차트에 위아래 화살표를 그려라

    plotarrow ((시리즈, 제목, 컬러업, 컬러다운, 오프셋, 미인 높이, 최대 높이, 편집 가능, show_last, display)

    c.plotarrow(bar.Close - bar.Open)
    
    c.plotarrow(bar.Close - bar.Open)
    
    • display선택적 매개 변수: 무도, 모든
  • plotshape: 그래프에 시각적인 모양을 그리기

    plotshape (시리즈, 제목, 스타일, 위치, 색상, 오프셋, 텍스트, 텍스트 색상, 편집, 크기, show_last, display)

    c.plotshape(bar.Low, {style: 'diamond'})
    
    c.plotshape(bar.Low, style = 'diamond')
    
    • style선택적 매개 변수: 다이아몬드, 제곱, 라벨_다운, 라벨_업, 화살_다운, 화살_업, , 깃발, 삼각형_다운, 삼각형_업, 십자, x 십자

    • location선택적 매개 변수: 상단, 아래단, 상단, 아래단, 결정

    • size선택적 매개 변수: 10px, 14px, 20px, 40px, 80pxsize.tiny, size.small, size.normal, size.large, size.huge소나무 언어size.autosize.small.

    • display선택적 매개 변수: 무도, 모든

  • plotchar: 주어진 유니코드 문자를 사용하여 차트에 가시적인 모양을 그리기

    plotchar ((시리즈, 제목, char, 위치, 색상, 오프셋, 텍스트, 텍스트색, 편집, 크기, show_last, display)

    c.plotchar(bar.Close, {char: 'X'})
    
    c.plotchar(bar.Close, char = 'X')
    
    • location선택적 매개 변수: 상단, 아래단, 상단, 아래단, 결정

    • size선택적 매개 변수: 10px, 14px, 20px, 40px, 80pxsize.tiny, size.small, size.normal, size.large, size.huge소나무 언어size.autosize.small.

    • display선택적 매개 변수: 무도, 모든

  • plotcandle: 그래프에 K-라인 차트를 그리기

    plotcandle ((open, high, low, close, title, color, wickcolor, editable, show_last, bordercolor, display) (열리고, 높고, 낮고, 닫고, 제목, 색상, wickcolor, 편집할 수 있는, show_last, bordercolor, display)

    c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
    
    c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
    
    • display선택적 매개 변수: 무도, 모든
  • 신호: 파이어 언어에서 사용할 수 없는 함수는 여기에 구매 및 판매 신호를 그리기 위해 사용됩니다.

    신호 (방향, 가격, qty, id)

    c.signal("long", bar.High, 1.5)
    
    c.signal("long", bar.High, 1.5)
    

    입력 매개 변수"long"거래 방향, 선택"long", "closelong", "short", "closeshort"입력된 매개 변수bar.High마커 신호의 Y 축 위치입니다. 입력 매개 변수1.5신호의 거래 수를 나타냅니다. 네 번째 매개 변수는 기본으로 도출된 텍스트 콘텐츠를 대체하기 위해 전달 될 수 있습니다. 도출된 신호 마커의 기본 텍스트는 거래 방향입니다. 예를 들어:"closelong".

위의 함수 호출에서 사용되는 일부 색상, 스타일 및 다른 설정에 대해 참조하십시오.KLineChart 함수로 그림을 그리는 특별 기사

로그리셋 (LogReset)

LogReset()로그를 클리어하는 데 사용됩니다. 저장해야 할 최근 로그의 수를 지정하고 나머지 로그를 클리어하기 위해 정수 매개 변수를 전달할 수 있습니다. 시작 로그는 시작 할 때마다 계산됩니다. 따라서 매개 변수가 전달되지 않고 전략의 시작에서 로그 출력이 없으면 로그는 전혀 표시되지 않으며 도커 로그가 반환되도록 기다립니다. 함수는 반환 값이 없습니다.

function main() {
    // Mainta

더 많은