Guide de syntaxe

Les ressources ont été chargées... Je charge...

Le marché

exchange.GetTicker

Obtenez la structure {@struct/Ticker Ticker} du spot ou du contrat correspondant à la paire de négociation actuellement définie, le code du contrat, c'est-à-dire les données du ticker.GetTicker ()fonction est une fonction membre de l'objet d'échange {@var/EXCHANGE exchange}, l'utilisationexchangeles fonctions (méthodes) des membres d'objet liées uniquement à:exchange, et il ne sera pas répété dans le document.

Leexchange.GetTicker()fonction renvoie la structure {@struct/Ticker Ticker} lorsque la demande de données est réussie, et renvoie la valeur nulle lorsque la demande de données échoue. {@struct/Ticker Ticker}, valeur nulle

Je suis en train d' échanger. Je suis en train d'écrire une lettre.

Le paramètresymbolest utilisé pour spécifier la paire de négociation spécifique et le code de contrat correspondant aux données {@struct/Ticker Ticker} demandées. Lorsque vous appelez leexchange.GetTicker(symbol)fonction,exchangeSi vous avez besoin de demander des données de marché avec la monnaie libellée comme USDT et la monnaie de négociation comme BTC, le paramètresymbolest:"BTC_USDT", et le format est le format de paire de négociation défini par la plateforme FMZ. Lorsque vous appelez leexchange.GetTicker(symbol)fonction,exchangeSi vous avez besoin de demander les données du marché du contrat perpétuel U-standard de BTC, le paramètresymbolest:"BTC_USDT.swap", et le format est une combinaison despaire de négociationetcode du contratdéfinies par la plateforme FMZ, séparées par le caractère .. Lorsque vous appelez leexchange.GetTicker(symbol)fonction,exchangeSi vous avez besoin de demander les données du marché du contrat d'option U-standard de BTC, le paramètresymbolest:"BTC_USDT.BTC-240108-40000-C"(en prenant Binance Option BTC-240108-40000-C comme exemple), le format est la combinaison depaire de négociationdéfini par la plateforme FMZ et le code du contrat d'option spécifique défini par la bourse, séparés par le caractère ..

le symbole faux chaîne

function main(){
    // If it is a futures exchange object, set the contract code first, e.g. set it as a perpetual contract
    // exchange.SetContractType("swap")

    var ticker = exchange.GetTicker()
    /*
        The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
        At this point, the ticker is null, and it will cause an error when accessing ticker.High, so when testing this code, make sure that the exchange interface can be accessed.
    */
    Log("Symbol:", ticker.Symbol, "High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Open:", ticker.Open, "Volume:", ticker.Volume)
}

def main():
    ticker = exchange.GetTicker()
    Log("Symbol:", ticker["Symbol"], "High:", ticker["High"], "Low:", ticker["Low"], "Sell:", ticker["Sell"], "Buy:", ticker["Buy"], "Last:", ticker["Last"], "Open:", ticker.Open, "Volume:", ticker["Volume"])

void main() {
    auto ticker = exchange.GetTicker();
    Log("Symbol:", ticker.Symbol, "High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Open:", ticker.Open, "Volume:", ticker.Volume);
}

Pour les objets d'échange de contrats à terme (c.-à-d.exchangeouexchanges[0]), vous devez définir le code du contrat à l'aide duexchange.SetContractType()fonction avant d'appeler la fonction ticker, qui ne sera pas répétée.

function main() {
    var ticker = exchange.GetTicker("BTC_USDT")
    Log(ticker)
}

def main():
    ticker = exchange.GetTicker("BTC_USDT")
    Log(ticker)

void main() {
    auto ticker = exchange.GetTicker("BTC_USDT");
    Log(ticker);
}

Utilisez lesymbolparamètre permettant de demander des données de marché pour un symbole spécifique (symbole au comptant).

LeTickerLes données renvoyées par leexchange.GetTicker()Le système de backtesting est basé sur desHighetLowLes valeurs d'achat et de vente sont des valeurs simulées, tirées de la vente et de l'achat sur le marché à ce moment-là.TickerLes données renvoyées par leexchange.GetTicker()La situation actuelle est celle de laHighetLowles valeurs sont basées sur les données renvoyées par l'échange encapsuléTickl'interface, qui comprend les prix les plus élevés et les plus bas au cours d'une certaine période (généralement une période de 24 heures). Échanges qui ne soutiennent pas leexchange.GetTicker()fonction:

Nom de la fonction	Échanges au comptant non pris en charge	Échanges de contrats à terme non soutenus
GetTicker	–	Le montant de la garantie est calculé à partir du montant de la garantie

{@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange

exchange.GetDepth

Obtenir la structure {@struct/Depth Depth} du spot ou du contrat correspondant à la paire de négociation actuellement définie, le code du contrat, c'est-à-dire les données du carnet de commandes.

Leexchange.GetDepth()fonction renvoie la structure {@struct/Depth Depth} si la demande de données est réussie, et elle renvoie nul si la demande de données échoue. {@struct/Depth Depth}, valeur nulle

Je suis désolé. échange.Symbole GetDepth

Le paramètresymbolest utilisé pour spécifier la paire de négociation spécifique et le code de contrat correspondant aux données {@struct/Depth Depth} demandées. Si ce paramètre n'est pas passé, les données du carnet d'ordres de la paire de négociation actuellement définie et le code de contrat seront demandés par défaut.exchange.GetDepth(symbol)fonction,exchangeSi vous avez besoin de demander d'obtenir les données du carnet de commandes avec la monnaie libellée en USDT et la monnaie de la transaction en BTC, le paramètresymbolest:"BTC_USDT", et le format est le format de paire de négociation défini par la plateforme FMZ.exchange.GetDepth(symbol)fonction,exchangeSi vous avez besoin de demander les données du carnet de commandes du contrat perpétuel standard U de BTC, le paramètresymbolest:"BTC_USDT.swap", et le format est une combinaison despaire de négociationetcode du contratdéfinies par la plateforme FMZ, séparées par le caractère ..exchange.GetDepth(symbol)fonction,exchangeSi vous avez besoin de demander les données du carnet de commandes du contrat d'option U-standard de BTC, le paramètresymbolest:"BTC_USDT.BTC-240108-40000-C"(en prenant Binance Option BTC-240108-40000-C comme exemple), le format est la combinaison depaire de négociationdéfini par la plateforme FMZ et le code du contrat d'option spécifique défini par la bourse, séparés par le caractère .. le symbole faux chaîne

function main(){
    var depth = exchange.GetDepth()
    /*
        The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
        At this point, the depth is null, which will cause an error when accessing depth.Asks[1].Price, so make sure you can access the exchange interface when testing the code.
    */
    var price = depth.Asks[1].Price
    Log("Sell 2 price is:", price)
}

def main():
    depth = exchange.GetDepth()
    price = depth["Asks"][1]["Price"]
    Log("Sell 2 price is:", price)

void main() {
    auto depth = exchange.GetDepth();
    auto price = depth.Asks[1].Price;
    Log("Sell 2 price is:", price);
}

Test de détectionexchange.GetDepth()fonction:

function main() {
    // BTC U-based perpetual contract
    var depth = exchange.GetDepth("BTC_USDT.swap")
    Log(depth)
}

def main():
    depth = exchange.GetDepth("BTC_USDT.swap")
    Log(depth)

void main() {
    auto depth = exchange.GetDepth("BTC_USDT.swap");
    Log(depth);
}

Lorsque le configuréexchangel'objet est un objet d'échange de contrats à terme, utiliser lesymbolparamètre permettant de demander les données du carnet de commandes d'un symbole spécifique (symbole des contrats à terme).

Dans le système de backtesting, les données pour chaque grade renvoyées par leexchange.GetDepth()fonction lorsque l'on utilise leSimuler une tiqueDans le système de backtesting, les données renvoyées par leexchange.GetDepth()fonction lorsque l'on utilise leUne vraie tiqueLe backtesting est un instantané profond de deuxième niveau.

{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTicker exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTicker exchange.GetRecords}, {@fun/Market/exchange.GetTicker exchange.GetTicker exchange.GetTicker}, {@fun

exchange.GetTrades

Obtenez le tableau de structure {@struct/Trade Trade} du spot ou du contrat correspondant à la paire de négociation actuellement définie, le code du contrat, c'est-à-dire les données de transaction sur le marché.

Leexchange.GetTrades()la fonction renvoie un tableau de structures {@struct/Trade Trade} si la demande de données est réussie, et elle renvoie des valeurs nulles si la demande de données échoue. {@struct/Trade Trade} séries, valeurs nulles

Je suis en train d' échanger. Le symbole "GetTrades" est le symbole de l'échange.

Le paramètresymbolest utilisé pour spécifier la paire de négociation spécifique et le code de contrat correspondant aux données de tableau {@struct/Trade Trade} demandées. Si ce paramètre n'est pas passé, les dernières données d'enregistrement de transaction de la paire de négociation actuellement définie et le code de contrat seront demandés par défaut.exchange.GetTrades(symbol)fonction,exchangeSi vous avez besoin de demander à obtenir les données du carnet de commandes avec la monnaie libellée en USDT et la monnaie de négociation en BTC, le paramètresymbolest:"BTC_USDT", et le format est le format de paire de négociation défini par la plateforme FMZ.exchange.GetTrades(symbol)fonction,exchangeSi vous avez besoin de demander les données du carnet de commandes du contrat perpétuel standard U de BTC, le paramètresymbolest:"BTC_USDT.swap", et le format est une combinaison despaire de négociationetcode du contratdéfinies par la plateforme FMZ, séparées par le caractère ..exchange.GetTrades(symbol)fonction,exchangeSi vous avez besoin de demander les données du carnet de commandes du contrat d'option standard U de BTC, le paramètresymbolest:"BTC_USDT.BTC-240108-40000-C"(en prenant Binance Option BTC-240108-40000-C comme exemple), le format est la combinaison depaire de négociationdéfini par la plateforme FMZ et le code du contrat d'option spécifique défini par la bourse, séparés par le caractère .. le symbole faux chaîne

function main(){
    var trades = exchange.GetTrades()
    /*
        The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
        At this point, trade is null. When accessing trade[0].Id, it will cause an error. Therefore, when testing this code, ensure that you can access the exchange interface.
    */
    Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type)
}

def main():
    trades = exchange.GetTrades()
    Log("id:", trades[0]["Id"], "time:", trades[0]["Time"], "Price:", trades[0]["Price"], "Amount:", trades[0]["Amount"], "type:", trades[0]["Type"])

void main() {
    auto trades = exchange.GetTrades();
    Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type);
}

Testez leexchange.GetTrades()fonction:

function main() {
    // BTC's U-based perpetual contract
    var trades = exchange.GetTrades("BTC_USDT.swap")
    Log(trades)
}

def main():
    trades = exchange.GetTrades("BTC_USDT.swap")
    Log(trades)

void main() {
    auto trades = exchange.GetTrades("BTC_USDT.swap");
    Log(trades);
}

Lorsque le configuréexchangel'objet est un objet d'échange de contrats à terme, utiliser lesymbolparamètre permettant de demander des données d'enregistrement des transactions de marché pour un symbole spécifique (symbole des contrats à terme).

exchange.GetTrades()Les données retournées sont un tableau, où chaque élément de l'ordre chronologique etexchange.GetRecords ()la fonction renvoie le même ordre de données, c'est-à-dire que le dernier élément du tableau est les données les plus proches de l'heure actuelle. Leexchange.GetTrades()fonction renvoie un tableau vide en utilisantSimuler une tiqueLes données renvoyées par l'appareil deexchange.GetTrades()fonction lors de l'utilisationUne vraie tiquele backtesting dans le système de backtesting est les données instantanées du flux des ordres, c'est-à-dire le tableau de structure {@struct/Trade Trade}. Échanges qui ne soutiennent pas leexchange.GetTrades()fonction:

Nom de la fonction	Échanges au comptant non pris en charge	Échanges de contrats à terme non soutenus
GetTrades	–	Le montant de l'obligation est calculé à partir de la valeur de l'obligation.

{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTicker exchange.GetRecords}, {@fun/Market/exchange.GetTicker exchange.GetRecords}, {@fun/Market/Market/Exchange.

exchange.GetRecords

Obtenir le tableau de structure {@struct/Record Record} du spot ou du contrat correspondant à la paire de négociation actuellement définie, le code du contrat, c'est-à-dire les données de ligne K.

Leexchange.GetRecords()fonction renvoie un tableau de {@struct/Record Record} structures lorsque la demande de données réussit, et il renvoie des valeurs nulles lorsque la demande de données échoue. {@struct/Record Record} séries, valeurs nulles

Je suis en train d' échange.GetRecords Je suis en train de faire un test de détection. Je suis en train d'écrire une lettre. Le code de l'échange.GetRecords (symbole, période, limite) Je ne peux pas faire ça. Je ne sais pas si je peux vous aider.

Le paramètresymbolest utilisé pour spécifier la paire de négociation spécifique et le code de contrat correspondant aux données de tableau {@struct/Record Record} demandées. Si ce paramètre n'est pas passé, les données de ligne K de la paire de négociation actuellement définie et le code de contrat seront demandés par défaut.exchange.GetRecords(symbol)fonction,exchangeSi vous avez besoin de demander à obtenir les données avec la monnaie libellée en USDT et la monnaie de la transaction en BTC, le paramètresymbolest:"BTC_USDT", et le format est le format de paire de négociation défini par la plateforme FMZ.exchange.GetRecords(symbol)fonction,exchangeSi vous avez besoin de demander les données du carnet de commandes du contrat perpétuel standard U de BTC, le paramètresymbolest:"BTC_USDT.swap", et le format est une combinaison despaire de négociationetcode du contratdéfinies par la plateforme FMZ, séparées par le caractère ..exchange.GetRecords(symbol)fonction,exchangeSi vous avez besoin de demander les données du carnet de commandes du contrat d'option standard U de BTC, le paramètresymbolest:"BTC_USDT.BTC-240108-40000-C"(en prenant Binance Option BTC-240108-40000-C comme exemple), le format est la combinaison depaire de négociationdéfini par la plateforme FMZ et le code du contrat d'option spécifique défini par la bourse, séparés par le caractère .. le symbole faux chaîne Le paramètreperiodspécifie la période des données de ligne K demandées, par exemple: {@var/PERIOD/PERIOD_M1 PERIOD_M1}, {@var/PERIOD/PERIOD_M5 PERIOD_M5}, {@var/PERIOD/PERIOD_M15 PERIOD_M15}, etc. La valeur du paramètreperiodSi ce paramètre n'est pas passé, la période des données de ligne K demandées par défaut est la période de ligne K par défaut de la configuration de stratégie en temps réel / backtest en cours. période faux Numéro Le paramètrelimitest utilisé pour spécifier la longueur des données de ligne K demandées. Si ce paramètre n'est pas passé, la longueur de demande par défaut est le nombre maximum de barres de ligne K demandées à un moment de l'interface de ligne K d'échange. Ce paramètre peut provoquer une page à interroger les données de ligne K d'échange, et la consommation de temps de l'appel de fonction augmentera pendant la requête de page. limite faux Numéro

function main() {
    // Print K-line data with a K-line period of 120 seconds (2 minutes)
    Log(exchange.GetRecords(60 * 2))         
    // Print K-line data with a K-line period of 5 minutes
    Log(exchange.GetRecords(PERIOD_M5))      
}

def main():
    Log(exchange.GetRecords(60 * 2))
    Log(exchange.GetRecords(PERIOD_M5))

void main() {
    Log(exchange.GetRecords(60 * 2)[0]);
    Log(exchange.GetRecords(PERIOD_M5)[0]);
}

Obtenez les données de la ligne K pour une période personnalisée.

function main() {
    var records = exchange.GetRecords(PERIOD_H1)
    /*
        The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
        At this point, records is null. When accessing records[0].Time, it will cause an error. Therefore, when testing this code, ensure that you can access the exchange interface.
    */
    Log("The first k-line data is Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High)
    Log("The second k-line data is Time:", records[1].Time ,"Close:", records[1].Close)
    Log("Current K-line (latest)", records[records.length-1], "Previous K-line", records[records.length-2])
}

def main():
    records = exchange.GetRecords(PERIOD_H1)
    Log("The first k-line data is Time:", records[0]["Time"], "Open:", records[0]["Open"], "High:", records[0]["High"])
    Log("The second k-line data Time:", records[1]["Time"], "Close:", records[1]["Close"])
    Log("Current K-line (latest)", records[-1], "Previous K-line", records[-2])

void main() {
    auto records = exchange.GetRecords(PERIOD_H1);
    Log("The first k-line data is Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High);
    Log("The second k-line data Time:", records[1].Time, "Close:", records[1].Close);
    Log("Current K-line (latest)", records[records.size() - 1], "Previous K-line", records[records.size() - 2]);
}

Données de sortie de la barre K:

function main() {
    var records = exchange.GetRecords("BTC_USDT.swap", 60, 100)
    Log(records)
}

def main():
    records = exchange.GetRecords("BTC_USDT.swap", 60, 100)
    Log(records)

void main() {
    auto records = exchange.GetRecords("BTC_USDT.swap", 60, 100);
    Log(records);
}

Lorsque le configuréexchangel'objet est un objet d'échange de contrats à terme, utiliser lesymbol, period, etlimitles paramètres permettant de demander les données de ligne K d'un produit spécifique (produit futur).

Si vous spécifiez un paramètre lors de l'appel de la ligne K, vous pouvez définir la période par défaut dans les pages de backtest et de trading réel.exchange.GetRecords()Si aucun paramètre n'est spécifié lors de l'appel de la fonction, les données de ligne correspondantes seront renvoyées selon la période de ligne définie dans le backtest et les paramètres réels du marché. La valeur retournée est un tableau deRecordLes données de ligne K renvoyées seront accumulées au fil du temps, la limite supérieure des barres de ligne K accumulées est affectée par leexchange.SetMaxBarLen()La limite par défaut est de 5000 bar quand elle n'est pas définie. Lorsque les données de ligne K atteignent la limite d'accumulation de la barre de ligne K, elles seront mises à jour en ajoutant une barre de ligne K et en supprimant la barre de ligne K la plus ancienne (par exemple, file d'attente d'entrée/sortie).TradeLes données sont extraites en temps réel pour générer des lignes K. Si l'interface K-line de l'échange prend en charge les requêtes de pagination, plusieurs requêtes API seront effectuées lors de l'appel de l'interfaceexchange.SetMaxBarLen()fonction pour définir une plus grande longueur de ligne K. Lorsque leexchange.GetRecords()- Le système de backtesting obtiendra un certain nombre de barres de K-line avant le début de l'intervalle de temps de backtesting à l'avance (le paramètre par défaut est 5000, les paramètres du système de backtesting et la quantité de données affecteront le nombre final renvoyé), comme les données de K-line initiales. - Le nombre de barres de K-line obtenues pendant le trading réel est basé sur la quantité maximale de données pouvant être obtenues à partir de l'interface K-line de l'échange. LeperiodLe paramètre est réglé sur 5, qui est une demande d'obtention de données de ligne K avec une période de 5 secondes.periodLe système sous-jacent utilise l'interface correspondante deexchange.GetTrades()Les données de l'enregistrement de transaction doivent être collectées et synthétisées.periodsi le paramètre est divisible par 60, les données de ligne K requises sont synthétisées à l'aide d'un minimum de données de ligne K d'une minute (si possible, les données de ligne K requises sont synthétisées à l'aide d'une période plus longue). Le backtesting de niveau simulé dans le système de backtesting nécessite le réglage de la période de ligne K sous-jacente (lorsque le système de backtesting simule le backtesting de niveau, les données de ligne K correspondantes sont utilisées pour générer des données Tick en fonction de la période de ligne K sous-jacente). LeC++le langage a l'exemple de code suivant si vous avez besoin de construire vos propres données de ligne K:

#include <sstream>
void main() { 
    Records r;
    r.Valid = true;
    for (auto i = 0; i < 10; i++) {
        Record ele;
        ele.Time = i * 100000;
        ele.High = i * 10000;
        ele.Low = i * 1000;
        ele.Close = i * 100;
        ele.Open = i * 10;
        ele.Volume = i * 1;
        r.push_back(ele);
    }
    // Output display: Records[10]
    Log(r);                      
    auto ma = TA.MA(r,10);       
    // Output display: [nan,nan,nan,nan,nan,nan,nan,nan,nan,450]
    Log(ma);                     
}

Les échanges qui ne soutiennent pas leexchange.GetRecords()fonction:

Nom de la fonction	Échanges au comptant non pris en charge	Échanges de contrats à terme non soutenus
Obtenez des enregistrements	Il est à la recherche d'un emploi.	Le montant de la garantie est calculé à partir du montant de la garantie

{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.SetMaxBarLen exchange.SetMaxBarLen}, {@fun/Market/exchange.SetMaxBarLen exchange.SetMaxBarLen}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetDepth exchange.GetDepth exchange

exchange.GetPeriod

Obtenez la période de la ligne K définie sur la page du site Web de la plateforme de trading FMZ Quant lors du backtesting et de l'exécution de la stratégie dans le trading en direct, c'est-à-dire la période de la ligne K par défaut utilisée lors de l'appel de laexchange.GetRecords()fonctionner sans passer de paramètres.

Période de ligne K en secondes, valeur entière en secondes. Numéro

Je suis en train d'écrire une lettre.

function main() {
    // For example, the K-line period set on the website page of the FMZ Quant Trading platform during backtesting and live trading is 1 hour.
    var period = exchange.GetPeriod()
    Log("K-line period:", period / (60 * 60), "hours")
}

def main():
    period = exchange.GetPeriod()
    Log("K-line period:", period / (60 * 60), "hours")

void main() {
    auto period = exchange.GetPeriod();
    Log("K-line period:", period / (60 * 60.0), "hours");
}

{@fun/Marché/échange.GetRecords échange.GetRecords}

exchange.SetMaxBarLen

Réglez la longueur maximale de la ligne K.

Je vous en prie, échangez.

Le paramètrenest utilisé pour spécifier la longueur maximale de la ligne K. n vrai Numéro

function main() {
    exchange.SetMaxBarLen(50)
    var records = exchange.GetRecords()
    Log(records.length, records)
}

def main():
    exchange.SetMaxBarLen(50)
    r = exchange.GetRecords()
    Log(len(r), r)

void main() {
    exchange.SetMaxBarLen(50);
    auto r = exchange.GetRecords();
    Log(r.size(), r[0]);
}

Leexchange.SetMaxBarLen()La fonction affecte deux aspects pour le temps d'exécution de la stratégie de crypto-monnaie:

Affecte le nombre de barres de ligne K (Bars) obtenues lors du premier appel.
Affecte le nombre maximal de barres de ligne K (barres).

{@fun/Marché/échange.GetRecords échange.GetRecords}

exchange.GetRawJSON

Obtenez le contenu original retourné par la dernièrerestdemande pour l'objet d'échange en cours ({@var/EXCHANGE exchange}, {@var/EXCHANGE/exchanges exchanges}).

Les données de réponse pour lerestune demande. chaîne

Je suis en train d'écrire un article.

function main(){
    exchange.GetAccount(); 
    var obj = JSON.parse(exchange.GetRawJSON());
    Log(obj);
}

import json
def main():
    exchange.GetAccount()
    obj = json.loads(exchange.GetRawJSON())
    Log(obj)

void main() {
    auto obj = exchange.GetAccount();
    // C++ does not support the GetRawJSON function
    Log(obj);
}

Leexchange.GetRawJSON()La fonction n'est prise en charge que pour le trading réel.C++ language.

{@var/EXCHANGE échange}

exchange.GetRate

Obtenez le taux de change actuellement défini pour l'objet d'échange.

La valeur courante du taux de change de l'objet de change. Numéro

Je suis en train de changer.

function main(){
    Log(exchange.GetTicker())
    // Set up exchange rate conversion
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    Log("Current exchange rate:", exchange.GetRate())
}

def main():
    Log(exchange.GetTicker())
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    Log("Current exchange rate:", exchange.GetRate())

void main() {
    Log(exchange.GetTicker());
    exchange.SetRate(7);
    Log(exchange.GetTicker());
    Log("Current exchange rate:", exchange.GetRate());
}

Siexchange.SetRate()n'a pas été appelée à fixer le taux de conversion, leexchange.GetRate()La fonction renvoie une valeur de taux par défaut de 1, c'est-à-dire que les données relatives à la devise actuellement affichée (quoteCurrency) n'ont pas été converties. Si une valeur de taux de change a été définie en utilisantexchange.SetRate(), par exemple,exchange.SetRate(7). Ensuite, toutes les informations sur les prix, telles que les cotations, les profondeurs et les prix des commandes obtenus par leexchangel'objet d'échange sera converti en multipliant par le taux de change fixé7- Je ne sais pas. Siexchangecorrespond à un échange avec USD comme monnaie de dénomination, après avoir appeléexchange.SetRate(7), tous les prix sur le marché en direct seront convertis en un prix proche du yuan en multipliant7À ce stade, la valeur du taux de change obtenue enexchange.GetRate()est7.

{@fun/Trade/exchange.SetRate échange.SetRate} Je suis désolé.

exchange.SetData

Leexchange.SetData()fonction est utilisée pour définir les données chargées lorsque la stratégie est exécutée.

La longueur de la chaîne après le paramètrevalueLe code JSON. Numéro

Le code de l'appareil est le même que le code de l'appareil.

Le nom de la collecte de données. clé vrai chaîne Les données à charger par leexchange.SetData()La structure de données est la même que le format de données demandé par leexchange.GetData()fonction lors de la demande de données externes, c'est-à-dire:"schema": ["time", "data"]- Je ne sais pas. valeur vrai séquence

/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
    var data = [
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
    exchange.SetData("test", data)
    while(true) {
        Log(exchange.GetData("test"))
        Sleep(1000)
    }
}

'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''              

def main():
    data = [
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
    exchange.SetData("test", data)
    while True:
        Log(exchange.GetData("test"))
        Sleep(1000)

/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/              

void main() {
    json data = R"([
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ])"_json;
    
    exchange.SetData("test", data);
    while(true) {
        Log(exchange.GetData("test"));
        Sleep(1000);
    }
}

Elle exige que les données du paramètrevalueêtre dans le même format que ledataVous pouvez voir que l'horodatage1579622400000correspond à l'heure2020-01-22 00:00:00, et que lorsque le programme de stratégie est exécuté après ce temps, appeler leexchange.GetData()fonction pour obtenir les données avant le prochain horodatage1579708800000, c'est-à-dire le temps2020-01-23 00:00:00Ce que vous obtenez[1579622400000, 123]le contenu de ces données, au fur et à mesure que le programme continue à s'exécuter, l'heure change, et ainsi de suite pour obtenir l'élément de données par élément. Dans l'exemple suivant, à l'exécution (backtesting ou trading en direct), le moment actuel atteint ou dépasse l'horodatage1579795200000, leexchange.GetData()la fonction est appelée et la valeur de retour est:{"Time":1579795200000,"Data":["abc", 123,{"price":123}]}. "Time":1579795200000correspond à1579795200000dans les données[1579795200000, ["abc", 123, {"price": 123}]]. "Data":["abc", 123, {"price": 123}]correspond aux données["abc", 123, {"price": 123}]]dans[1579795200000, ["abc", 123, {"price": 123}]].

Les données chargées peuvent être des indicateurs économiques, des données sectorielles, des indicateurs pertinents, etc., utilisés pour une évaluation quantitative stratégique de toutes les informations quantifiables.

{@fun/Marché/échange.GetData échange.GetData}

exchange.GetData

Leexchange.GetData()fonction est utilisée pour obtenir les données chargées par leexchange.SetData()fonction ou fournie par un lien externe.

Enregistrements dans la collecte de données. objet

Je suis en train d' échanger. Je ne sais pas si je peux le faire.

Le nom de la collecte de données. clé vrai chaîne Utilisé pour définir le temps d'arrêt du cache en millisecondes. Par défaut à une minute de temps d'arrêt du cache pour les transactions en direct. Le temps mort faux Numéro

/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
    exchange.SetData("test", [[1579536000000, _D(1579536000000)], [1579622400000, _D(1579622400000)], [1579708800000, _D(1579708800000)]])
    while(true) {
        Log(exchange.GetData("test"))
        Sleep(1000 * 60 * 60 * 24)
    }
}

'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''  
def main():
    exchange.SetData("test", [[1579536000000, _D(1579536000000/1000)], [1579622400000, _D(1579622400000/1000)], [1579708800000, _D(1579708800000/1000)]])
    while True:
        Log(exchange.GetData("test"))
        Sleep(1000 * 60 * 60 * 24)

/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/    
void main() {
    json arr = R"([[1579536000000, ""], [1579622400000, ""], [1579708800000, ""]])"_json;
    arr[0][1] = _D(1579536000000);
    arr[1][1] = _D(1579622400000);
    arr[2][1] = _D(1579708800000);
    exchange.SetData("test", arr);
    while(true) {
        Log(exchange.GetData("test"));
        Sleep(1000 * 60 * 60 * 24);
    }
}

L'appel pour obtenir les données écrites directement.

/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
    while(true) {
        Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
        Sleep(1000)
    }
}

'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''              

def main():
    while True:
        Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
        Sleep(1000)

/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/              

void main() {
    while(true) {
        Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
        Sleep(1000);
    }
}

Il prend en charge la demande de données via des liens externes, le format des données demandées pour:

{
    "schema":["time","data"],
    "data":[
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
}

Où?schemaest le format de données pour chaque enregistrement dans le corps des données chargées, qui est fixé à["time", "data"]correspondant au format des données entrées par entrées dans ledataattribut. Ce qui est stocké dans ledatal'attribut est le corps des données, chaque entrée étant constituée d'un horodatage de niveau milliseconde et du contenu des données (qui peut être n'importe quelle donnée codable JSON). Le programme de service pour les tests, écrit en Go:

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

func Handle (w http.ResponseWriter, r *http.Request) {
    defer func() {
        fmt.Println("req:", *r)
        ret := map[string]interface{}{
            "schema": []string{"time","data"},
            "data": []interface{}{
                []interface{}{1579536000000, "abc"},
                []interface{}{1579622400000, 123},
                []interface{}{1579708800000, map[string]interface{}{"price":123}},
                []interface{}{1579795200000, []interface{}{"abc", 123, map[string]interface{}{"price":123}}},
            },
        }
        b, _ := json.Marshal(ret)
        w.Write(b)
    }()
}                

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

Les données de réponse du programme à la réception de la demande:

{
    "schema":["time","data"],
    "data":[
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
}

Code de stratégie de test:

function main() {
    Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
    Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))
}

def main():
    Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
    Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))

void main() {
    Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
    Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"));
}

La méthode d'appel pour obtenir les données d'un lien externe.

function main() {
    Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"))   // The xxx part of the link is the code of the query data, here xxx is an example.
}

def main():
    Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"))

void main() {
    Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"));
}

Demande de données pour une requête créée sur la plateformedonnées données, demandant que le format de données de la réponse soit (doit comporter le temps, les champs de données décrits dans le schéma):

{
    "data": [],
    "schema": ["time", "data"]
}

Le champ data est le contenu de données requis, et les données du champ data doivent être les mêmes que celles convenues dans le schema.exchange.GetData()une fonction est appelée, un objet JSON est renvoyé, par exemple:{"Time":1579795200000, "Data":"..."}.

Obtenez les données à la fois pour le backtesting et cache une minute de données pour le trading en direct.from(horodatage en secondes),to(horodatage en secondes) à la demande, paramètres tels queperiod(période de ligne K sous-jacente, timestampée en millisecondes) sont utilisées pour déterminer la période pendant laquelle les données doivent être acquises.

{@fun/Market/exchange.SetData exchange.SetData} Vous avez une idée?

exchange.GetMarkets

Leexchange.GetMarkets()fonction est utilisée pour obtenir des informations sur le marché des changes.

Le dictionnaire contient la structure {@struct/Market Market}. objet

Je suis en train d'écrire.

function main() {
    var markets = exchange.GetMarkets()
    var currency = exchange.GetCurrency()

    // Get the current contract code can also use exchange.GetContractType() function
    var ct = "swap"

    var key = currency + "." + ct
    Log(key, ":", markets[key])
}

def main():
    markets = exchange.GetMarkets()
    currency = exchange.GetCurrency()
    ct = "swap"

    key = currency + "." + ct
    Log(key, ":", markets[key])

void main() {
    auto markets = exchange.GetMarkets();
    auto currency = exchange.GetCurrency();

    auto ct = "swap";
    auto key = currency + "." + ct;
    Log(key, ":", markets[key]);
}

Exemple d'appel à un objet d'échange à terme:

/*backtest
start: 2023-05-10 00:00:00
end: 2023-05-20 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

function main() {
    var arrSymbol = ["SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]

    var tbl1 = {
        type: "table",
        title: "markets1",
        cols: ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
        rows: []
    }

    var markets1 = exchange.GetMarkets()
    for (var key in markets1) {
        var market = markets1[key]
        tbl1.rows.push([key, market.Symbol, market.BaseAsset, market.QuoteAsset, market.TickSize, market.AmountSize, market.PricePrecision, market.AmountPrecision, market.MinQty, market.MaxQty, market.MinNotional, market.MaxNotional, market.CtVal])
    }

    for (var symbol of arrSymbol) {
        exchange.GetTicker(symbol)
    }

    var tbl2 = {
        type: "table",
        title: "markets2",
        cols: ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
        rows: []
    }

    var markets2 = exchange.GetMarkets()
    for (var key in markets2) {
        var market = markets2[key]
        tbl2.rows.push([key, market.Symbol, market.BaseAsset, market.QuoteAsset, market.TickSize, market.AmountSize, market.PricePrecision, market.AmountPrecision, market.MinQty, market.MaxQty, market.MinNotional, market.MaxNotional, market.CtVal])
    }

    LogStatus("`" + JSON.stringify([tbl1, tbl2]) + "`")
}

'''backtest
start: 2023-05-10 00:00:00
end: 2023-05-20 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''

import json

def main():
    arrSymbol = ["SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]

    tbl1 = {
        "type": "table",
        "title": "markets1",
        "cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
        "rows": []
    }

    markets1 = exchange.GetMarkets()
    for key in markets1:
        market = markets1[key]
        tbl1["rows"].append([key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]])

    for symbol in arrSymbol:
        exchange.GetTicker(symbol)

    tbl2 = {
        "type": "table",
        "title": "markets2",
        "cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
        "rows": []
    }

    markets2 = exchange.GetMarkets()
    for key in markets2:
        market = markets2[key]
        tbl2["rows"].append([key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]])

    LogStatus("`" + json.dumps([tbl1, tbl2]) + "`")

/*backtest
start: 2023-05-10 00:00:00
end: 2023-05-20 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

void main() {
    auto arrSymbol = {"SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};

    json tbl1 = R"({
        "type": "table",
        "title": "markets1",
        "cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
        "rows": []
    })"_json;

    auto markets1 = exchange.GetMarkets();
    for (auto& [key, market] : markets1.items()) {
        json arrJson = {key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]};
        tbl1["rows"].push_back(arrJson);
    }

    for (const auto& symbol : arrSymbol) {
        exchange.GetTicker(symbol);
    }

    json tbl2 = R"({
        "type": "table",
        "title": "markets2",
        "cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
        "rows": []
    })"_json;

    auto markets2 = exchange.GetMarkets();
    for (auto& [key, market] : markets2.items()) {
        json arrJson = {key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]};
        tbl2["rows"].push_back(arrJson);
    }

    json tbls = R"([])"_json;
    tbls.push_back(tbl1);
    tbls.push_back(tbl2);
    LogStatus("`" + tbls.dump() + "`");
}

Utilisez l'objet d'échange de contrats à terme pour appeler leexchange.GetMarkets()Avant d'appeler une fonction de marché, GetMarkets ne renvoie que les données de marché de la paire de négociation par défaut actuelle. Après avoir appelé la fonction de marché, il renvoie les données de marché de toutes les variétés demandées. Vous pouvez vous référer à l'exemple de test suivant:

Leexchange.GetMarkets()fonction renvoie un dictionnaire avec une clé nommée le nom de la variété de négociation, et pour les fixes au comptant formatés comme une paire de négociation, par exemple:

{
    "BTC_USDT" : {...},  // The key value is the Market structure
    "LTC_USDT" : {...},  
    ...
}

Pour les échanges de contrats à terme, car il peut y avoir plusieurs contrats pour une même variété, par exempleBTC_USDTIl existe des contrats perpétuels, des contrats trimestriels, etc.exchange.GetMarkets()fonction renvoie un dictionnaire avec le nom de clé de la paire combiné avec le code du contrat, par exemple:

{
    "BTC_USDT.swap" : {...},     // The key value is the Market structure
    "BTC_USDT.quarter" : {...}, 
    "LTC_USDT.swap" : {...},
    ...
}

Leexchange.GetMarkets()La fonction prend en charge les transactions en direct, le système de backtesting.
Leexchange.GetMarkets()La fonction renvoie des informations de marché uniquement pour les variétés qui sont négociées en ligne sur la bourse.
Leexchange.GetMarkets()fonction ne prend pas en charge les contrats d'options.

Les échanges qui ne soutiennent pas leexchange.GetMarkets()fonction:

Nom de la fonction	Échanges au comptant non pris en charge	Échanges de contrats à terme non soutenus
GetMarkets	Coincheck / Bithumb / BitFlyer	–

{@struct/Marché du marché}

exchange.GetTickers

Leexchange.GetTickers()La fonction est utilisée pour obtenir des données de ticker agrégées d'échange (le tableau de la structure {@struct/Ticker Ticker}).exchangerenvoie les données de ticker pour toutes les paires de négociation lorsqu'il s'agit d'un objet d'échange au comptant;exchangerenvoie des données de ticker pour tous les contrats lorsqu'il s'agit d'un objet d'échange de contrats à terme.

Leexchange.GetTickers()fonction renvoie un tableau de {@struct/Ticker Ticker} structures quand il réussit à demander des données, et nul quand il échoue. {@struct/Ticker Ticker} les tableaux, les valeurs nulles

Je suis en train de changer.

function main() {
    var tickers = exchange.GetTickers()
    if (tickers && tickers.length > 0) {
        Log("Number of tradable items on the exchange:", tickers.length)
    }
}

def main():
    tickers = exchange.GetTickers()
    if tickers and len(tickers) > 0:
        Log("Number of tradable items on the exchange:", len(tickers))

void main() {
    auto tickers = exchange.GetTickers();
    if (tickers.Valid && tickers.size() > 0) {
        Log("Number of tradable items on the exchange:", tickers.size());
    }
}

Appelez leexchange.GetTickers()fonction pour obtenir des données de marché agrégées.

/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/

function main() {
    var arrSymbol = ["ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"]
    
    // Before requesting other trading pair market data, call Get Tickers
    var tickers1 = exchange.GetTickers()
    var tbl1 = {type: "table", title: "tickers1", cols: ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], rows: []}
    for (var ticker of tickers1) {
        tbl1.rows.push([ticker.Symbol, ticker.High, ticker.Open, ticker.Low, ticker.Last, ticker.Buy, ticker.Sell, ticker.Time, ticker.Volume])
    }
    
    // Request market data for other trading pairs
    for (var symbol of arrSymbol) {
        exchange.GetTicker(symbol)
    }

    // Call GetTickers again
    var tickers2 = exchange.GetTickers()
    var tbl2 = {type: "table", title: "tickers2", cols: ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], rows: []}
    for (var ticker of tickers2) {
        tbl2.rows.push([ticker.Symbol, ticker.High, ticker.Open, ticker.Low, ticker.Last, ticker.Buy, ticker.Sell, ticker.Time, ticker.Volume])
    }

    LogStatus("`" + JSON.stringify([tbl1, tbl2]) +  "`")
}

'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
'''

import json

def main():
    arrSymbol = ["ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"]
        
    tickers1 = exchange.GetTickers()
    tbl1 = {"type": "table", "title": "tickers1", "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], "rows": []}
    for ticker in tickers1:
        tbl1["rows"].append([ticker["Symbol"], ticker["High"], ticker["Open"], ticker["Low"], ticker["Last"], ticker["Buy"], ticker["Sell"], ticker["Time"], ticker["Volume"]])
    
    for symbol in arrSymbol:
        exchange.GetTicker(symbol)
    
    tickers2 = exchange.GetTickers()
    tbl2 = {"type": "table", "title": "tickers2", "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], "rows": []}
    for ticker in tickers2:
        tbl2["rows"].append([ticker["Symbol"], ticker["High"], ticker["Open"], ticker["Low"], ticker["Last"], ticker["Buy"], ticker["Sell"], ticker["Time"], ticker["Volume"]])
    
    LogStatus("`" + json.dumps([tbl1, tbl2]) +  "`")

/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/

json tickerToJson(const Ticker& ticker) {
    json arrJson;

    arrJson.push_back(ticker.Symbol);
    arrJson.push_back(ticker.High);
    arrJson.push_back(ticker.Open);
    arrJson.push_back(ticker.Low);
    arrJson.push_back(ticker.Last);
    arrJson.push_back(ticker.Buy);
    arrJson.push_back(ticker.Sell);
    arrJson.push_back(ticker.Time);
    arrJson.push_back(ticker.Volume);

    return arrJson;
}

void main() {
    std::string arrSymbol[] = {"ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"};
    
    auto tickers1 = exchange.GetTickers();
    json tbl1 = R"({
        "type": "table", 
        "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"],
        "rows": []
    })"_json;
    tbl1["title"] = "tickers1";
    
    for (const auto& ticker : tickers1) {
        json arrJson = tickerToJson(ticker);
        tbl1["rows"].push_back(arrJson);
    }
    
    for (const std::string& symbol : arrSymbol) {
        exchange.GetTicker(symbol);
    }
    
    auto tickers2 = exchange.GetTickers();
    json tbl2 = R"({
        "type": "table", 
        "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"],
        "rows": []
    })"_json;
    tbl2["title"] = "tickers2";
    
    for (const auto& ticker : tickers2) {
        json arrJson = tickerToJson(ticker);
        tbl2["rows"].push_back(arrJson);
    }
    
    json tbls = R"([])"_json;
    tbls.push_back(tbl1);
    tbls.push_back(tbl2);
    LogStatus("`" + tbls.dump() + "`");
}

Utilisez l'objet d'échange au comptant et appelezexchange.GetTickers()Avant d'appeler une fonction de marché, GetTickers renvoie uniquement les données de ticker de la paire de trading par défaut actuelle. Après avoir appelé la fonction de marché, il renvoie les données de ticker de toutes les variétés demandées. Vous pouvez vous référer à l'exemple de test suivant:

Cette fonction demande à l'échange d'agréger l'interface des tickers, pas besoin de configurer des paires de négociation, code de contrat avant d'appeler.
Le système de backtesting prend en charge cette fonction.
Les objets Exchange qui ne fournissent pas une interface de ticker agrégée ne prennent pas en charge cette fonction.
Cette fonction ne prend pas en charge les contrats d'options.

Les échanges qui ne soutiennent pas leexchange.GetTickers()fonction:

Nom de la fonction	Échanges au comptant non pris en charge	Échanges de contrats à terme non soutenus
- Je ne sais pas.	Il est aussi connu sous le nom de "Gemini".	Les titres de titres de créance détenus par les établissements de crédit sont considérés comme des titres de titres détenus par les établissements de crédit.

{@struct/TickerTicker}, {@fun/Marché/échange.GetTicker échange.GetTicker} Je suis désolée.

Le journal Le commerce

2019 FMZ - Tous les droits réservés