Une technique de dissection de la machine à cueillir les légumineuses (2)

Une technique de dissection de la machine à cueillir les légumineuses (2)

Je suis là.En haut et en basJe ne suis pas d'accord.

La troisième fonction ajoutée:

    self.balanceAccount = function() {
        var account = exchange.GetAccount()
        if (!account) {
            return
        }
        self.account = account
        var now = new Date().getTime()
        if (self.orderBook.Bids.length > 0 && now - self.preCalc > (CalcNetInterval * 1000)) {
            self.preCalc = now
            var net = _N(account.Balance + account.FrozenBalance + self.orderBook.Bids[0].Price * (account.Stocks + account.FrozenStocks))
            if (net != self.preNet) {
                self.preNet = net
                LogProfit(net)
            }
        }
        self.btc = account.Stocks
        self.cny = account.Balance
        self.p = self.btc * self.prices[self.prices.length-1] / (self.btc * self.prices[self.prices.length-1] + self.cny)
        var balanced = false
        
        if (self.p < 0.48) {
            Log("开始平衡", self.p)
            self.cny -= 300
            if (self.orderBook.Bids.length >0) {
                exchange.Buy(self.orderBook.Bids[0].Price + 0.00, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.01, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.02, 0.01)
            }
        } else if (self.p > 0.52) {
            Log("开始平衡", self.p)
            self.btc -= 0.03
            if (self.orderBook.Asks.length >0) {
                exchange.Sell(self.orderBook.Asks[0].Price - 0.00, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.01, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.02, 0.01)
            }
        }
        Sleep(BalanceTimeout)
        var orders = exchange.GetOrders()
        if (orders) {
            for (var i = 0; i < orders.length; i++) {
                if (orders[i].Id != self.tradeOrderId) {
                    exchange.CancelOrder(orders[i].Id)
                }
            }
        }
    }

Fonction de constructionLeeksReaper()L'objectif est d'ajouter des données à un objet.balanceAccount()Le rôle de la fonction est de mettre à jour les informations sur les actifs du compte, de stockerself.accountC'est le type d'objets que nous avons construits.accountPropriété: << Calculer la valeur des gains en temps réel et l'imprimer << Calculer ensuite le pourcentage du solde monétaire en fonction des dernières informations sur les actifs du compte << Calculer le pourcentage du solde monétaire en temps réel << Calculer le solde monétaire en fonction des dernières informations sur les actifs du compte << Calculer le pourcentage du solde monétaire en temps réel << Calculer le pourcentage du solde monétaire en fonction des dernières informations sur les actifs du compte << Calculer le pourcentage du solde monétaire en temps réel << Calculer le solde monétaire en fonction des dernières informations sur les actifs du compte << Calculer le pourcentage du solde monétaire en temps réel << Calculer le solde monétaire en temps réel << Calculer le solde monétaire en fonction des dernières informations sur les actifs du compte << Calculer le pourcentage du solde monétaire en temps réel << Calculer le solde monétaire en fonction du solde monétaire en temps réel << Calculer le solde monétaire en temps réel

Nous allons examiner le code de cette fonction, phrase par phrase: Tout d'abord la première phrase.var account = exchange.GetAccount()C'est une variable locale déclarée.accountIl s'agit d'un outil qui permet d'identifier les utilisateurs et d'appeler l'API de l'inventeurexchange.GetAccount()Une fonction qui obtient les dernières données sur le compte actuel, attribue une valeur àaccountLes variables. Puis jugezaccountC'est une variable qui peut être calculée commenullLes valeurs (par exemple, les problèmes de retard, de réseau, d'interface d'échange, etc.) ne sont pas récupérées et sont retournées directement (par exemple, les problèmes de temps d'arrêt, d'interface d'échange)if (!account){...}Je suis très heureux de vous voir.

self.account = accountC'est une expression pour décrire une variable locale.accountC'est une valeur qui est attribuée à un objet.accountLes attributs sont utilisés pour enregistrer les dernières informations de compte dans les objets construits.

var now = new Date().getTime()Cette phrase déclare une variable locale.nowIl est également possible d'appeler des objets de date de temps dans le langage JavaScriptgetTime()La fonction renvoie le temps actuel.nowLes variables.

if (self.orderBook.Bids.length > 0 && now - self.preCalc > (CalcNetInterval * 1000)) {...}Ce code détermine la différence entre le fil d'heure actuel et le fil d'heure de la dernière fois enregistré si elle dépasse les paramètres.CalcNetInterval * 1000C'est plus que la dernière mise à jour.CalcNetInterval * 1000Une seconde.CalcNetIntervalLa fonction d'impression des bénéfices en temps réel est également limitée par les conditions, car les bénéfices sont calculés en fonction du prix d'achat.self.orderBook.Bids.length > 0Cette condition ((deep data, il doit y avoir des informations de classement valides dans la liste de paiement)). Lorsque cette condition est déclenchée, elle s'exécute.self.preCalc = nowMettre à jour les variables de l'horodatage pour la dernière fois que vous avez imprimé des gainsself.preCalcPour l'instantnowLes statistiques sur les bénéfices utilisent une méthode de calcul de la valeur nette, codée commevar net = _N(account.Balance + account.FrozenBalance + self.orderBook.Bids[0].Price * (account.Stocks + account.FrozenStocks))La valeur de la déclaration est la valeur de la transaction, c'est-à-dire la conversion de la monnaie en argent (monnaie de compte) au prix d'achat actuel, puis la somme de l'argent dans le compte et la variable locale attribuée à la déclaration.netPour déterminer si le total net actuel correspond au total net enregistré la dernière fois:

            if (net != self.preNet) {
                self.preNet = net
                LogProfit(net)
            }

Si ce n'est pas le cas,net != self.preNetJe ne peux pas.netMise à jour des variables pour enregistrer les propriétés de la valeur netteself.preNetEt puis imprime ceci.netLes données sur la valeur nette totale à l'inventeur sur le graphique de la courbe des gains de la plate-forme de trading quantifiée du robot (WEB peuvent être consultées dans la documentation de l'API FMZLogProfitC'est une fonction.

Si vous n'avez pas déclenché les revenus de l'impression en temps opportun, continuez avec le processus ci-dessous, et vous obtiendrez un résultat.account.StocksLe nombre de pièces disponibles sur les comptes courantsaccount.Balance(Nombre d'argent disponible sur le compte courant)self.btc，self.cnyLe calcul des proportions de déviation et l'attribution sont enregistrés dansself.p。

self.p = self.btc * self.prices[self.prices.length-1] / (self.btc * self.prices[self.prices.length-1] + self.cny)

L'algorithme est aussi simple: la valeur actuelle de la pièce est calculée en pourcentage de la valeur nette totale du compte.

Alors, quand décider de déclencher l'équilibre de la monnaie? L'auteur utilise ici un 50% en hausse et en baisse de 2 points de pourcentage comme tampon, dépassant l'équilibre de l'exécution de la zone de tampon, qui est la zone de l'équilibre de l'équilibre.self.p < 0.48Le décalage de l'équilibre monétaire est déclenché par la pensée qu'il y a moins de pièces, en achetant une position sur le marché et en augmentant le prix de 0.01 à chaque fois.self.p > 0.52Il a ensuite décidé de vendre une feuille de papier sur le marché en pensant qu'il y avait plus de billets.Sleep(BalanceTimeout)Nous avons donc décidé d'annuler toutes les commandes.

        var orders = exchange.GetOrders()                  # 获取当前所有挂单，存在orders变量
        if (orders) {                                      # 如果获取当前挂单数据的变量orders不为null
            for (var i = 0; i < orders.length; i++) {      # 循环遍历orders，逐个取消订单
                if (orders[i].Id != self.tradeOrderId) {
                    exchange.CancelOrder(orders[i].Id)     # 调用exchange.CancelOrder，根据orders[i].Id取消订单
                }
            }
        }

La quatrième fonction ajoutée:

Le cœur de la stratégie, les gros titres, sont là.self.poll = function() {...}Les fonctions sont la logique principale de l'ensemble de la stratégie.main()La fonction commence à s'exécuter, entrewhileAvant le cycle de la mort, nous avons utilisévar reaper = LeeksReaper()Nous avons construit l'objet de la moissonneuse de légumes, et nous l'avons placé dans une boîte.main()Appel en boucle dans une fonctionreaper.poll()C'est la fonction appelée.

self.pollLes fonctions commencent à s'exécuter, font des préparatifs avant chaque cycle, et ensuite, elles se déroulent.self.numTick++Le nombre de morts a augmenté.self.updateTrades()Il est également possible de mettre à jour les récents enregistrements de transactions sur le marché et de calculer les données utilisées.self.updateOrderBook()Les chiffres de l'offre sont mis à jour et les données sont calculées.self.balanceAccount()Les banques sont en train de vérifier le solde de leur monnaie.

        var burstPrice = self.prices[self.prices.length-1] * BurstThresholdPct   # 计算爆发价格
        var bull = false             # 声明牛市标记的变量，初始为假
        var bear = false             # 声明熊市标记的变量，初始为假
        var tradeAmount = 0          # 声明交易数量变量，初始为0

La prochaine étape est de juger si le marché à court terme est un taureau ou un ours.

        if (self.numTick > 2 && (
            self.prices[self.prices.length-1] - _.max(self.prices.slice(-6, -1)) > burstPrice ||
            self.prices[self.prices.length-1] - _.max(self.prices.slice(-6, -2)) > burstPrice && self.prices[self.prices.length-1] > self.prices[self.prices.length-2]
            )) {
            bull = true
            tradeAmount = self.cny / self.bidPrice * 0.99
        } else if (self.numTick > 2 && (
            self.prices[self.prices.length-1] - _.min(self.prices.slice(-6, -1)) < -burstPrice ||
            self.prices[self.prices.length-1] - _.min(self.prices.slice(-6, -2)) < -burstPrice && self.prices[self.prices.length-1] < self.prices[self.prices.length-2]
            )) {
            bear = true
            tradeAmount = self.btc
        }

Vous souvenez-vous de l'article précédent?self.updateOrderBook()Une fonction où nous utilisons un algorithme de moyenne pondérée pour construire une séquence chronologique en ordre.pricesArrays. Trois nouvelles fonctions sont utilisées dans ce code._.min，_.max，sliceLes trois fonctions sont très bien comprises.

• _.minLa fonction : est la valeur la plus petite de l'ensemble des paramètres recherchés.

• _.maxLa fonction : est de trouver la plus grande valeur de l'ensemble des paramètres.

• slice: est une fonction membre d'un objet d'une matrice JavaScript qui retourne une partie d'une matrice qui est coupée par indexation, par exemple:

  function main() {
      // index     .. -8 -7 -6 -5 -4 -3 -2 -1
      var arr = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
      Log(arr.slice(-5, -1))    // 会截取 4 ~ 1 这几个元素，返回一个新数组：[4,3,2,1]
  }
  

  

Les conditions pour juger un ours ou une vache sont les suivantes:

• self.numTick > 2Pour être établi, c'est-à-dire que lorsque le prix d'un nouveau cycle de détection éclate, il doit être déclenché après au moins trois cycles de détection et éviter de le déclencher dès le début.
• Séquence de prixself.pricesLa dernière statistique, qui est la plus récente, est la suivante:self.pricesLa différence maximale ou minimale entre les prix d'une gamme précédente doit être dépassée.burstPriceLe prix de l'explosion.

Si toutes les conditions sont remplies, marquezbullOu alorsbearPourtrueet donneztradeAmountIl y a aussi des gens qui se sont mis à faire des trucs pour les gens qui ne connaissent pas les choses.

Encore une foisself.updateTrades()Mise à jour, calcul dans les fonctionsself.volPour les paramètresBurstThresholdVolDécider de réduire l'intensité des transactions (réduire la quantité de transactions prévues).

        if (self.vol < BurstThresholdVol) {
            tradeAmount *= self.vol / BurstThresholdVol   // 缩减计划交易量，缩减为之前量的self.vol / BurstThresholdVol 倍
        }
        
        if (self.numTick < 5) {
            tradeAmount *= 0.8      // 缩减为计划的80%
        }
        
        if (self.numTick < 10) {    // 缩减为计划的80%
            tradeAmount *= 0.8
        }

Les signaux de transaction et le volume de transactions sont ensuite jugés:

        if ((!bull && !bear) || tradeAmount < MinStock) {   # 如果非牛市并且也非熊市，或者计划交易的量tradeAmount小于参数设置的最小交易量MinStock，poll函数直接返回，不做交易操作
            return
        }

Après avoir prononcé ce jugement, l'exécutionvar tradePrice = bull ? self.bidPrice : self.askPriceEn fonction du marché baissier ou du marché bovin, le prix de transaction est fixé et le prix de la soumission correspondant est attribué.

Il est enfin entré dans unwhileLa seule condition pour que le cycle s'arrête de sauter, c'esttradeAmount >= MinStockLe volume de transactions prévu est inférieur au volume de transactions minimum. Dans le cycle, exécutez la commande suivant l'état actuel du marché bœuf ou du marché baissier.orderId◎ Après chaque cycle de commandeSleep(200)Attendez 200 millisecondes.orderIdEst-ce que c'est vrai? (si la commande échoue et ne renvoie pas l'ID de commande, la condition if n'est pas déclenchée), si la condition est vraie.self.tradeOrderId。

Déclare une variable pour stocker les données d'ordreorderLa valeur initiale estnullL'id est ensuite recyclé pour obtenir les données de l'ordre et déterminer si l'ordre est en attente, si c'est le cas, annuler l'ordre de l'id et sauter le cycle de détection si ce n'est pas le cas.

                var order = null           // 声明一个变量用于保存订单数据
                while (true) {             // 一个while循环
                    order = exchange.GetOrder(orderId)    // 调用GetOrder查询订单ID为 orderId的订单数据
                    if (order) {                          // 如果查询到订单数据，查询失败order为null，不会触发当前if条件
                        if (order.Status == ORDER_STATE_PENDING) {   // 判断订单状态是不是正在挂单中
                            exchange.CancelOrder(orderId)            // 如果当前正在挂单，取消该订单
                            Sleep(200)
                        } else {                                     // 否则执行break跳出当前while循环
                            break
                        }
                    }
                }

Le processus suivant s'effectue:

                self.tradeOrderId = 0              // 重置self.tradeOrderId
                tradeAmount -= order.DealAmount    // 更新tradeAmount，减去提单的订单已经成交的数量
                tradeAmount *= 0.9                 // 减小下单力度
                if (order.Status == ORDER_STATE_CANCELED) {     // 如果订单已经是取消了
                    self.updateOrderBook()                      // 更新订单薄等数据
                    while (bull && self.bidPrice - tradePrice > 0.1) {   // 牛市时，更新后的提单价格超过当前交易价格0.1就减小交易力度，略微调整交易价格
                        tradeAmount *= 0.99
                        tradePrice += 0.1
                    }
                    while (bear && self.askPrice - tradePrice < -0.1) {  // 熊市时，更新后的提单价格超过当前交易价格0.1就减小交易力度，略微调整交易价格
                        tradeAmount *= 0.99
                        tradePrice -= 0.1
                    }
                }

Lorsque le processus de programmation sautewhile (tradeAmount >= MinStock) {...}Ce cycle indique que le processus de transaction de l'éclatement des prix est terminé. Exécutionself.numTick = 0Je suis en train d'essayer de vous aider.self.numTickIl est nul.

LeeksReaper()L'exécution de la fonction constructeur est terminéeselfL'objet retourné est:var reaper = LeeksReaper()Je suis un homme qui a beaucoup de respect pour les gens.reaper。

À ce stadeLeeksReaper()Nous avons analysé comment les fonctions de construction construisent ces objets et les différentes méthodes d'exécution des principales fonctions logiques. Nous sommes convaincus que vous aurez une compréhension plus claire de ce processus d'algorithme de stratégie haute fréquence.