개발자 양적 API 문서

이미 데이터를 받았고, 후속으로 EventLoop 감청을 시작했을 때 이러한 사건을 놓쳤다. // 첫 번째 코드 라인에서 EventLoop ((-1) 를 호출하기 시작하지 않고 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);
}

내장 함수

_G(K, V)

_G(K, V)이 함수는 저장 가능한 전 세계 사전 기능을 구현하고, 회색과 실제 디스크 모두 지원합니다. 회색이 끝나면 저장된 데이터가 삭제됩니다. 데이터 구조는KV테이블은 영구적으로 로컬 파일로 유지되며, 디스크마다 개별 데이터베이스를 가지고 있으며, 다시 시작하거나 관리자가 종료한 후에도 계속 존재합니다.K이 문서는 문자열로 작성되어야하며, 크기와 작이를 구분하지 않아야 합니다.V모든 것을 할 수 있습니다JSON서열화 된 내용._G()이 함수들은 어떤 함수도 전달하지 않는 경우_G()이 함수는 현재 디스크의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();
}

주의: 사용_G기능 영구화 저장 데이터의 경우, 하드웨어 장치의 메모리, 하드 디스크 공간을 합리적으로 사용해야 하며, 악용해서는 안 된다. 그렇지 않으면 발생할 수 있다.메모리 누출이 글은

시간표, FMT

_D(Timestamp, Fmt), 지정된 시간 에 대응하는 시간 문자열을 반환합니다.Timestamp숫자의 유형은 밀리 초수입니다.Fmt문자열 유형은Fmt이 글은 이쪽에서 읽었습니다.yyyy-MM-dd hh:mm:ss, 값을 반환합니다: 문자열 타입. 지정된 시간 (毫秒) 에 해당하는 문자열을 반환하고, 어떤 파라미터도 전달하지 않고 현재 시간을 반환합니다. 예를 들어:_D()또는_D(1478570053241)기본적으로는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);
}

주의:Python전략적으로 사용_D()이 경우, 입력된 매개 변수는 초 수준 시간 입니다.JavaScript、C++전략에서는 밀리초 수준 시간으로, 1초는 1000 밀리초에 해당한다.) 실시간 사용_D()함수는 시간대를 읽을 수 있는 시간 문자열로 분석할 때, 관리자 프로그램이 있는 운영 체제의 시간대, 시간 설정에 주의를 기울여야 한다._D()함수 해독 시간 을 읽기 가능한 시간 문자열로 관리자 시스템의 시간에 따라 설정합니다.

예를 들어, 시간대는1574993606000코드를 사용하여 분석:

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 (Num, 정밀)

_N(Num, Precision), 부동 소수점을 포맷합니다.Num이 문서는Precision전체 타입을 위해. 귀환 값: 숫자 타입.

예를 들어_N(3.1415, 2)삭제됩니다3.1415소수점 두 자리 뒤에 있는 값은 함수가 반환합니다3.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);
}

소수점 왼쪽에 있는 모든 n개의 숫자를 0으로 바꾸려면 이렇게 쓸 수 있습니다

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

_C(...)

_C(function, args...)이 함수는 재시험 함수로서, 시장, 완료되지 않은 주문 등을 획득하는 인터페이스의 오류 허용을 위해 사용됩니다.

이 인터페이스는 정해진 함수를 성공적으로 반환할 때까지 계속 호출합니다.function참조 함수 호출 때 빈값을 반환하거나false예를 들어, 전화가 끊어지면 전화가 끊어집니다._C(exchange.GetTicker)기본 반복 간격은 3초로 설정되어 있습니다._CDelay(...)재검토 간격을 설정하는 함수, 예를 들어_CDelay(1000)변화하는 것을 의미합니다_C함수 재시험 간격은 1초입니다.

다음 함수들에 대해:

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

이 모든 것이_C(...)이 함수는 오류를 허용하는 함수를 호출합니다._C(function, args...)함수는 위의 함수들에 국한되지 않습니다.function함수 참조가 아니라 함수 호출입니다._C(exchange.GetTicker)아니죠._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);
}

변수 함수들에 대한 사용_C(...)이 글은 이 부분의 일부입니다.

function main(){
    var records = _C(exchange.GetRecords, PERIOD_D1)
    Log(records)
}

def main():
    records = _C(exchange.GetRecords, PERIOD_D1)
    Log(records)

void main() {
    auto records = _C(exchange.GetRecords, PERIOD_D1);
    Log(records);
}

또한 사용자 정의 함수의 오류 처리에도 사용할 수 있습니다.

var test = function(a, b){
    var time = new Date().getTime() / 1000
    if(time % b == 3){
        Log("符合条件！", "#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++ 不支持这种方式对于自定义函数容错

_크로스 ((Arr1, Arr2)

_Cross(Arr1, Arr2)소수 항을 곱하기arr1그리고arr2횡단 주기의 수. 양수는 위를 통과하는 주기를 나타냅니다. 음수는 아래를 통과하는 주기를 나타냅니다. 0은 현재 가격과 같습니다.

데이터 테스트를 모방할 수 있습니다._Cross(Arr1, Arr2)함수:

// 快线指标
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));
}

모의 데이터를 시각화하여 관찰합니다

사용 설명서:내장 함수_크로스 분석 및 사용 설명

JSONParse ((strJson)

JSONParse(strJson)이 함수는 JSON 문자열을 분석하기 위해 사용됩니다. 더 큰 숫자를 포함하는 JSON 문자열을 올바르게 분석하면 더 큰 숫자를 문자열 유형으로 분석합니다. 회수 시스템은 이 함수를 지원하지 않습니다.

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));   // 不支持该函数
}

사용자 정의 색상

모든 문자열을 사용할 수 있습니다.#ff0000이러한 RGB 값은 끝으로 표시해야 할 전망을 나타냅니다.#ff0000112233이런 형식으로, 마지막 6자는 배경 색을 나타냅니다.

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

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

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

로그 정보

실제 디스크 실행 시 로그 정보는 실제 디스크의 데이터베이스에 기록되며, 실제 디스크의 데이터베이스가 사용된다sqlite3데이터베이스, 디스크의 데이터베이스 파일은 관리자 프로그램에 위치하는 장치, 데이터베이스 파일은 관리자 프로그램에 위치한다.robot실행 가능한 프로그램) 디렉토리. 예를 들어: ID는130350이 파일은../logs/storage/130350이 카탈로그에..그리고robot관리자 프로그램이 있는 디렉토리), 데이터베이스 파일의 이름은130350.db3ᅳ 검색 시스템에서의 로그는 검색이 끝나면 검색 페이지의 오른쪽 하단에서 클릭하면 됩니다.로그 다운로드[다운로드 버튼] 디스크를 다른 서버로 이동해야 할 경우, 디스크의 데이터베이스 파일을 (db3라고 확장된 데이터베이스 파일) 마이그레이션 대상 서버로 이동할 수 있으며, 파일 이름을 플랫폼에 해당하는 디스크 ID로 설정합니다. 이렇게하면 이전 디스크의 모든 로그 정보가 새로운 장치로 마이그레이션으로 손실되지 않습니다.

로그...

Log(message), 게시물을 로그 목록에 저장합니다.message어떤 타입이든 사용하실 수 있습니다. 만약 문자열 뒤에 더하면@문자 메시지는 푸시 큐에 들어가 현재 발명자의 양자 거래 플랫폼 계정 푸시 설정에 설정된 메일, 텔레그램, 웹 등에 푸시됩니다.제어 센터페이지, 오른쪽 상단계정 설정이 페이지에는푸시 설정페이지 설정 묶음) ^

주의:

• "Debug Tool"에서는 푸시를 지원하지 않습니다.
• "복사 시스템"에서는 푸시를 지원하지 않습니다.

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

웹후크:

사용GolangDEMO라는 프로그램으로 작성된 서비스:

package main
import (
    "fmt"
    "net/http"
)

func Handle (w http.ResponseWriter, r *http.Request) {
    defer func() {
        fmt.Println("req:", *r)
    }()
}

func main () {
    fmt.Println("listen http://localhost:9090")
    http.HandleFunc("/data", Handle)
    http.ListenAndServe(":9090", nil)
}

설정WebHook：http://XXX.XX.XXX.XX:9090/data?data=Hello_FMZ

서비스 프로그램을 실행한 후, 정책을 실행하고, 정책을 추진합니다.

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

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

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

이 사이트는 인터넷에 접속하여 인터넷에 접속하는 모든 사용자들을 대상으로 운영되고 있습니다.

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}

인쇄base64코딩된 이미지 Log문자를 지원하는 함수base64이 사진들은`이 글의 시작은`이 글의 끝은 다음과 같습니다.

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

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

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

Log직접 인쇄를 지원합니다Python이 모든 것은matplotlib.pyplot객체를 포함하는 경우savefig이 방법은 바로Log예를 들어:

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

인쇄 로그 자동 언어 전환 Log언어 전환을 지원하는 기능Log함수 출력 텍스트는 플랫폼 페이지의 언어 설정에 따라 해당 언어로 자동으로 전환됩니다. 예를 들어:

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

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

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

LogProfit ((이익)

LogProfit(Profit)이윤/손실 수치를 기록하고, 이윤/손실 수치를 인쇄하고, 이윤/손실 수치를 기준으로 수익 곡선을 그려라. 파라미터 값:수익숫자의 종류를 가리킨다.

이 함수는&그리고 마지막으로, 수익표만 그려서 수익기록을 인쇄하지 말고, 예를 들어:LogProfit(10, '&')。

로그프로프트리셋 (LogProfitReset)

LogProfitReset(), 모든 수익 로그를 비어, 전체 숫자 값의 매개 변수를 가지고 저장된 항목을 지정할 수 있습니다.

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

로그Status ((Msg)

LogStatus(Msg)이 정보는 로그 목록에 저장되지 않고 현재 디스크의 상태 정보를 업데이트합니다. 디스크 페이지의 로그 영역 위에 있는 상태 표시줄에서 업데이트 상태를 여러 번 호출할 수 있습니다.Msg어떤 타입이든 사용할 수 있습니다.

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

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

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

LogStatus(Msg)인쇄 지원base64이 사진들은`이 글의 시작은`이 글의 끝은 다음과 같습니다.LogStatus("`data:image/png;base64,AAAA`")。 LogStatus(Msg)직접 전송 지원Python이 모든 것은matplotlib.pyplot객체를 포함하는 경우savefig이 방법은LogStatus(Msg)예를 들어,

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

상태창에서 데이터를 출력하는 예제:

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() + "`");
}

정상 버튼 설정 비활성화, 설명 기능:

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() + "`");
}

상태 버튼 스타일 설정:

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() + "`");
}

결합GetCommand()함수, 구성 상태 버튼 상호 작용 기능:

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

구성 상태 버튼이 상호 작용할 때도 데이터 입력 지원, 상호 작용 명령어는 최종적으로GetCommand()함수 캡처. 상태 탭에 있는 버튼 컨트롤의 데이터 구조에 추가input예를 들어,{"type": "button", "cmd": "open", "name": "开仓"}증가"input": {"name": "开仓数量", "type": "number", "defValue": 1}, 버튼을 클릭할 때 입력장치 컨트롤이 있는 점포를 (입기장치에서 기본값이 1인 defValue로 설정된 데이터) 팝업할 수 있고, 버튼 명령과 함께 데이터를 입력하여 전송할 수 있다. 예를 들어, 다음 테스트 코드를 실행할 때, "투자" 버튼을 클릭한 후 입력장치가 있는 점포를 팝업하고, 입력장치에 입력한다.111그리고 "확인"을 클릭합니다.GetCommand이 함수는 메시지를 캡처합니다.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);
    }
}

합병LogStatus(Msg)함수가 그려낸 테이블 안의 셀은:

• 수평 합병

  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() + "`");
  }
  

  

• 수직 합병

  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() + "`");
  }
  

  

위와 같은 페이지가 있습니다.

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() + "`");
}

페이지를 나눌 수 있을 뿐만 아니라 여러 페이지를 위에서 아래로 배열하여 표시할 수 있습니다.

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() + "`");
}

실행 효과:

주의: 이 정책이 실제 디스크에서 실행되는 동안, 실제 디스크 페이지에서 역사 기록을 짚어보면 상태 탭이 휴면 상태로 들어가 업데이트를 중지한다. 로그가 첫 페이지에 있을 때만 상태 탭 데이터가 갱신된다. 상태 에서 출력을 지원합니다.base64코딩된 이미지, 또한 상태 탭에서 표시되는 표에 출력을 지원합니다base64코딩된 이미지. 코딩된 이미지의 문자열 데이터가 일반적으로 길기 때문에 예제 코드가 더 이상 표시되지 않습니다.

EnableLog (()

EnableLog(IsEnable), 주문 정보를 열고 닫는 로그 기록.isEnable의 종류는 입니다.IsEnable설정:false이 경우, 주문기록을 인쇄하지 않고, 실제 데이터베이스에 기록하지 않습니다.

차트 ((...)

Chart(...), 사용자 정의 그래프 그림 그림 函数.

Chart({...})이 경우,JSON배열된하이스토크이 모든 것은Highcharts.StockChart변수. 원래 변수보다 1 더하기__isStock속성, 지정하면__isStock:false이 그래프는 일반 그래프로 표시됩니다.

주의: 설정된 경우__isStock속성false이 그래프는 다음과 같습니다.하이라이트 차트이 사진에서 보시는 것처럼:

설정된 경우__isStock속성true이 그래프는 다음과 같습니다.높은 물류(디폴트)__isStock그 이유는true), 그림과 같이:

다시 호출할 수 있는add(n, data)（n그 이유는series인덱스 (예: 0),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과 그래프 2series이 그래프의 두 번째는series그리고 이 그림은series그럼,add0과 1의 일련 ID를 지정할 때 업데이트 그래프 1의 두 개의 일련의 데이터를 나타냅니다.add2로 지정된 시퀀스 ID는 차트 2의 첫 번째를 나타냅니다.series이 그래프의 첫 번째 행을 나타냅니다.series이 자료는

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

여러 그래프가 관련 속성 설정을 보여줍니다:예제

예를 들어, 그래프 구성 객체:

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.layout속성

  이 속성을 "single"로 설정하면, 그래프는 중첩되지 않습니다 (페이지별로 표시되지 않습니다), 개별적으로 표시됩니다 (평면 표시).

• cfgA.extension.height속성

  이 속성은 그래프의 높이를 설정하는 데 사용됩니다. 값은 숫자 유형으로 설정되거나 "300px"로 설정될 수 있습니다.

• cfgA.extension.col속성

  이 속성은 그래프의 폭을 설정하는 데 사용되며, 페이지의 폭은 12개로 나누어져 있으며, 8개로 설정하면 그래프의 폭이 8개이다.

  이 프로젝트의 주요 목표는

  • 자바스크립트 버전
  • 파이썬 버전
  • C++ 버전

  위의 예제에서 그래프 구성 객체가 효과를 보여줍니다:

  

• 그래프 구성 개체에 있는 데이터를 직접 변경하여 그래프 설정을 업데이트하면 데이터 업데이트가 가능합니다:

  예를 들어,JavaScript예제 일부 코드 문장완전한 예제）：

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

  통과add데이터 업데이트 방법, 예를 들어 피카드에 항목을 추가하는 방법JavaScript예제 일부 코드 문장완전한 예제）：

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

• 추가 사용Chart함수의 예

  간단한 그림 예:

  // 这个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