[TOC]

Les mots-clés, la grammaire et les paramètres

Structure du code

La structure générale du code de Pine est la suivante:

<version>
<declaration_statement>
<code>

Notes de rédaction

Les marqueurs de commentaires supportés par le langage Pine de FMZ: commentaires en une seule ligne//Je ne sais pas si je vais le faire./* */L’écriture des commentaires dans l’exemple suivant:

[macdLine, signalLine, histLine] = ta.macd(close, 12, 26, 9)  // 计算MACD指标

/*
plot函数在图表上画出指标线
*/
plot(macdLine, color = color.blue, title='macdLine')
plot(signalLine, color = color.orange, title='signalLine')
plot(histLine, color = color.red, title='histLine')

La version

Les instructions du compilateur sous la forme suivante indiquent à l’éditeur la version de Pine dans laquelle le script a été écrit:

//@version=5

La version v5 par défaut peut être omise dans le code//@version=5。

Déclaration de déclaration

• indicator()
• strategy()

Les déclarations déterminent le type de script, ce qui détermine à son tour ce qui est autorisé et comment il est utilisé et exécuté. Elles définissent les attributs clés du script, tels que son nom, où il apparaîtra lorsqu’il sera ajouté au graphique, la précision et le format des valeurs qu’il affichera, ainsi que les valeurs qui régissent certains comportements lors de son exécution, tels que le nombre maximal d’objets de graphique qu’il affichera dans le graphique.indicator()oustrategy()La déclaration suivante:

Le code

Les lignes qui ne sont pas des commentaires ou des instructions du compilateur dans un script sont des déclarations, elles implémentent l’algorithme du script. Une déclaration peut être l’un de ces éléments.

• Déclaration de la variable
• Réattribution de la variable
• Déclaration de fonction
• Appels de fonctions intégrés, appels de fonctions définis par l’utilisateur
• if，for，whileouswitchStructure de l’équation

Les phrases peuvent être classées de plusieurs façons.

• Certaines expressions peuvent être exprimées en une seule ligne, comme la plupart des déclarations de variables, qui ne contiennent qu’une seule ligne d’appel de fonction ou une seule ligne de déclaration de fonction. D’autres, comme les structures, ont toujours besoin de plusieurs lignes, car elles nécessitent un bloc local.
• Les déclarations globales d’un script (c’est-à-dire les parties qui ne font pas partie d’un bloc local) ne peuvent pas être considérées comme空格ou制表符Les lignes qui commencent à la première position de la ligne font, par définition, partie de la portée globale du script.
• Les déclarations de structures ou de fonctions à plusieurs lignes nécessitent toujours unlocal block。 Un bloc local doit se réduire à un sigle ou à quatre espaces (sinon, il sera décodé comme une suite de la ligne de code précédente, c’est-à-dire jugé comme une continuité de la ligne de code précédente), chaque bloc local définissant un autre domaine local。
• Plusieurs phrases à une seule ligne peuvent être enchaînées dans une seule ligne en utilisant la virgule ((,) comme séparateur.
• Une ligne peut contenir des commentaires ou seulement des commentaires.
• Les lignes peuvent également être enroulées (continuer sur plusieurs lignes).

Par exemple, comprenant trois blocs locaux, un dans la déclaration de fonction personnalisée et deux dans la déclaration de variable utilisant la structure if, le code suivant:

indicator("", "", true)             // 声明语句(全局范围)，可以省略不写

barIsUp() =>                        // 函数声明(全局范围)
    close > open                    // 本地块(本地范围)

plotColor = if barIsUp()            // 变量声明 (全局范围)
    color.green                     // 本地块 (本地范围)
else
    color.red                       // 本地块 (本地范围)

runtime.log("color", color = plotColor)  // 调用一个内置函数输出日志 (全局范围)

Modifier le code

Les lignes longues peuvent être divisées en plusieurs lignes, ou “ enroulées ” vers le haut. Les lignes enroulées doivent être réduites dans n’importe quel nombre d’espaces, à condition qu’elles ne soient pas des multiples de 4 (ces limites sont utilisées pour réduire les blocs locaux).

a = open + high + low + close

Le nombre d’espaces à réduire par ligne n’est pas un multiple de 4):

a = open +
      high +
          low +
             close

Un appel à un long plot ((() peut être condensé en:

close1 = request.security(syminfo.tickerid, "D", close)      // syminfo.tickerid 当前交易对的日线级别收盘价数据系列
close2 = request.security(syminfo.tickerid, "240", close)    // syminfo.tickerid 当前交易对的240分钟级别收盘价数据系列
plot(ta.correlation(close, open, 100),                       // 一行长的plot()调用可以被包装
   color = color.new(color.purple, 40),
   style = plot.style_area,
   trackprice = true)

Cependant, comme le bloc local doit grammaticalement commencer par une incrustation (((4 espaces ou 1 sigle), lorsque vous le divisez sur la ligne suivante, la partie continue de l’instruction doit commencer par plus d’une incrustation (((qui n’est pas égal au multiple de 4 espaces). Par exemple:

test(c, o) =>
    ret = c > o ?
       (c > o+5000 ? 
          1 :
              0):
       (c < o-5000 ? 
          -1 : 
              0)

a = test(close, open)
plot(a, title="a")

Séquence chronologique

La séquence temporelle n’est pas un type ou un format de données, mais un concept de structure de base dans le langage PINE. Elle est utilisée pour stocker des valeurs qui changent continuellement dans le temps, chacune correspondant à un point de temps. La structure de ce concept est adaptée au traitement et à l’enregistrement d’une série de données qui changent avec le temps. avec des variables intégréesopenPar exemple:openLa variable intégrée enregistre le prix d’ouverture de chaque ligne KBAR, si celle-ci estopenC’est le nombre de cycles de 5 minutes de la ligne K.openLa variable qui est enregistrée est le prix d’ouverture de chaque ligne K BAR (colonne) toutes les 5 minutes. Lorsque votre programme de stratégie est exécuté, le code fait référenceopenOn cite le prix d’ouverture de la ligne BAR de la ligne K actuelle. Pour citer la valeur précédente dans la séquence temporelle (la valeur passée), on utilise[]L’opérateur d’historique, lorsque la stratégie est exécutée sur une ligne KBAR,open[1]Le prix de l’opération est le prix d’ouverture de la première ligne K BAR de la ligne K BAR actuelle.

Bien queSéquence chronologiqueIl est facile de se souvenir de la structure de données “array”, bien que le langage PINE ait aussi des types d’arrayons. Cependant, ils sont complètement différents de la notion de séquence temporelle.

Le langage PINE a conçu une séquence de temps qui permet de calculer facilement les valeurs cumulées des prix de clôture dans le code de la stratégie, sans avoir besoin d’utiliser des structures cycliques telles que for, mais uniquement des fonctions intégrées du langage PINE.ta.cum(close)Pour donner un autre exemple, nous avons besoin de calculer la moyenne de la différence entre la valeur maximale et la valeur minimale des 14 dernières lignes K BAR (c’est-à-dire les 14 lignes K BAR les plus proches à l’heure actuelle de l’exécution du code).ta.sma(high - low, 14)

Les résultats d’appels de fonctions sur une séquence de temps laissent également une trace sur la séquence de temps.[]L’opérateur historique cite la valeur précédente. Par exemple, pour tester si le prix de clôture de la ligne K BAR actuelle est supérieur à la valeur maximale de la valeur la plus élevée des 10 dernières lignes K BAR, on peut écrire:breach = close > ta.highest(close, 10)[1]On peut aussi écrire:breach = close > ta.highest(close[1], 10)Alors ?ta.highest(close, 10)[1]etta.highest(close[1], 10)C’est équivalent.

Les codes suivants permettent de vérifier:

strategy("test pine", "test", true) 

a = ta.highest(close, 10)[1]
b = ta.highest(close[1], 10)

plotchar(true, title="a", char=str.tostring(a), location=location.abovebar, color=color.red)
plotchar(true, title="b", char=str.tostring(b), location=location.belowbar, color=color.green)

Les codes de test ci-dessus produisent les valeurs de a et b dans leur séquence de temps correspondante sur chaque BAR. On peut voir que les valeurs de a et b sont toujours égales, donc les deux modes de représentation sont équivalents.

Citation de données historiques

Trading View a une limite de maximum de lignes pour les citations historiques (jusqu’à 5000 lignes), par exemple le code suivant:

//@version=6
indicator("test")

ema = ta.ema(close, 10000)      // 报错：Error on bar 0: The 'ema'->'sum' function references too many historical candles (10000), the limit is 5000.
plot(ema, "ema")

// pre10000 = ema[10000]        // 报错：Invalid number of bars back specified in the history-referencing operator. It accepts a value between 0 and 5000.
// plot(pre10000, "pre10000")

Les paramètres de transaction dans la bibliothèque de transactions en langage Pine utilisent la stratégie de langage PINE sur FMZ. Le paramètre “ nombre maximal de cycles de variables ” définit le nombre maximal d’articles de données qui peuvent être référencés.

indicator("test")

ema = ta.ema(close, 1000)  // ema = ta.ema(close, 3000) 则报错：Invalid number 3000 of bars back specified in the history-referencing operator. It accepts a value between 0 and 2000.
plot(ema, "ema")

Le paramètre “le nombre de cycles le plus long d’une variable” ne doit pas être trop grand, la portée des données citées dans la stratégie appropriée est acceptable.

Paramètres de modélisation de la classe de transaction de la langue Pine

Définition des paramètres de la bibliothèque de classes d’échange de langage Pine, le modèle intégré de la stratégie PINE.

Paramètres de négociation

• Exécution Modèle de prix de clôture: le modèle est exécuté à la fin de la BAR actuelle et la transaction est exécutée au début de la BAR sous-jacente Modèle de prix en temps réel: chaque fois que le prix change, le modèle est exécuté et le signal est immédiatement exécuté.
• Numéro d’ouverture de position par défaut: si l’instruction de négociation ne spécifie pas le nombre de transactions, les transactions sont exécutées en fonction de ce nombre.
• Maximum nombre d’ordres pour une seule transaction: en fonction de l’offre réelle, en combinaison avec le paramètre, déterminez le nombre maximal d’ordres pour chaque transaction, en évitant d’impacter le plateau.
• Points de dérapage:定价货币精度Le paramètre et ce paramètre déterminent le prix de glissement au moment de la commande. Par exemple, si la précision de la devise est fixée à 2, c’est-à-dire à la seconde décimale, elle est fixée à 0,01. Chaque point de glissement représente 0,01 unité de prix. Si le nombre de points de glissement est fixé à 5, le prix de glissement au moment de la commande est de 0,05.
• Le nombre de cycles maximaux de la variable: le nombre de lignes KBAR affectant le graphique, avecjavascriptAppel dans la stratégieSetMaxBarLenLes fonctions sont les mêmes.

Options sur contrats à terme

• Code de variété: code de contrat, à définir uniquement si l’objet de la bourse est un objet de la bourse non en place.
• Nombre minimum de contrats: le nombre minimum de transactions pour un contrat au moment de la commande.

Options réelles

• Retour automatique: Retour automatique à l’état d’avant l’arrêt de la dernière stratégie.
• Nombre de tentatives de ré-commande: si la commande n’est pas passée, la commande est annulée et la transaction est tentée à nouveau. Ce paramètre est utilisé pour limiter le nombre maximal de tentatives de ré-commande.
• Intervalle de sondage réseau ((millisecondes): valable uniquement pour les protocoles REST, contrôler l’intervalle de requête réseau, éviter que les requêtes soient trop fréquentes et dépassent les limites de l’échange.
• Temps de synchronisation des comptes (en secondes): périodes de synchronisation des données des comptes.
• Temps de synchronisation des positions après l’ouverture de la position (millisecondes): pour les positions à ouverture répétée causées par des retards de données de certaines bourses, un temps de synchronisation plus long peut atténuer ce problème.
• Le multiplicateur de levier: définir le multiplicateur de levier.

Opérations en espèces et autres réglages

• Volume de transaction unique: le volume de transaction unique par défaut est valable uniquement pour les transactions en espèces.
• Le montant minimum de la transaction est le montant minimum de la transaction.
• La précision de la devise: la précision du prix, c’est-à-dire le petit nombre de chiffres du prix.
• Précision de la variété de transaction: Précision de la quantité suivante, c’est-à-dire le petit chiffre de la quantité suivante.
• Frais de traitement: Pour calculer certains chiffres selon ce paramètre, 0,002 représente 2 pour mille.
• Intervalles de pertes et pertes: les pertes et pertes sont affichées uniquement sur le disque dur.
• Intervalle de répétition après l’échec d’une requête réseau.
• Utilisez un proxy: uniquement pour les protocoles REST.
• Cacher les erreurs courantes du réseau: Cacher les erreurs courantes du journal dans la zone de journal.
• Adresse de base de commutation: valable uniquement pour les protocoles REST.
• Notifications de diffusion: diffusion de messages dans les boîtes aux lettres, etc.

Passer une commande

Ouverture de position

strategy(title = "open long example", pyramiding = 3)                                // pyramiding 允许的同方向下单的次数
strategy.entry("long1", strategy.long, 0.01)                                         // 市价开多仓，指定分组标签为long1
strategy.entry("long2", strategy.long, 0.02, when = close > ta.ema(close, 10))       // 条件触发，执行下单，市价开多仓
strategy.entry("long3", strategy.long, 0.03, limit = 30000)                          // 指定（较低的）价格，计划下买单订单，等待成交开仓，限价开仓

Périmètre

strategy(title = "close long example", pyramiding = 2)                              // pyramiding 允许的同方向下单的次数
strategy.entry("long1", strategy.long, 0.1)                                         // 市价开多仓，指定分组标签为long1
strategy.entry("long2", strategy.long, 0.1)                                         // 市价开多仓，指定分组标签为long2
strategy.close("long1", when = strategy.position_size > 0.1, qty_percent = 50, comment = "close buy entry for 50%")   // 平仓，指定平掉分组标签为long1的仓位的50%持仓
strategy.close("long2", when = strategy.position_size > 0.1, qty_percent = 80, comment = "close buy entry for 80%")   // 平仓，指定平掉分组标签为long2的仓位的80%持仓

Mécanisme de négociation

Le mécanisme de détention du langage PINE est similaire à celui de la détention de positions unidirectionnelles. Par exemple, lorsque des positions dans plusieurs directions sont détenues, si des ordres de vente, des ordres de planification, etc. sont déclenchés par rapport à la direction opposée de la détention des positions, les positions dans plusieurs directions sont d’abord nivelées, puis les ordres déclenchés sont exécutés.

Le plan

L’instruction de commande est utilisée pour commander une commande qui, si aucun prix n’est spécifié, prend la commande en cours par défaut. En plus de la commande en cours, la commande peut également être commandée via la commande planifiée, mais la commande ne sera pas immédiatement actionnée. La commande planifiée peut être placée dans la file d’attente de la commande planifiée qui n’existe pas au moment du déclenchement.Disque réel / rétrospectiveLe système n’effectue de véritables commandes que lorsque les prix du marché en temps réel répondent aux conditions de déclenchement de ces commandes planifiées. Il est donc normal que ces commandes soient légèrement déviées du prix de transaction.strategy.entryQuand la fonction commande, nous pouvons spécifierlimit、stopParamètres

var isTrade = false 
if not barstate.ishistory and not isTrade
    isTrade := true 
    strategy.entry("test 1", strategy.long, 0.1, stop=close*1.3, comment="test 1 order")                     // stop
    strategy.entry("test 2", strategy.long, 0.2, limit=close*0.7, comment="test 2 order")                    // limit
    strategy.entry("test 3", strategy.short, 0.3, stop=close*0.6, limit=close*1.4, comment="test 3 order")   // stop-limit    

• commande limitée

Le prix limite d’une commande est fixé lorsque la commande est payante (c’est-à-diredirectionLes paramètres sontstrategy.longLa commande n’est déclenchée que lorsque le prix actuel du marché est inférieur à ce prix. Quand la commande est pour vendre des billets (c’est à diredirectionLes paramètres sontstrategy.shortLa commande n’est déclenchée que lorsque le prix actuel du marché est supérieur à ce prix.

• Arrêtez la commande

Il s’agit d’un ordre qui est déclenché lorsque le prix actuel du marché est supérieur au prix d’achat. Lorsqu’une commande est en cours de vente, elle n’est déclenchée que lorsque le prix actuel du marché est inférieur à ce prix.

• Commande avec un stop-limit

Peut être configuré simultanémentlimit、stopParamètre: la commande est déclenchée au premier prix admissible.

Pourcentage des droits et intérêts

//@version=5
strategy("Percent of Equity Order", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100)  

// 简单的均线交叉策略
longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))  

// 如果均线交叉条件满足，则买入或卖出
if (longCondition)
    strategy.entry("Long", strategy.long)  

if (shortCondition)
    strategy.entry("Short", strategy.short)
  

Nommédefault_qty_type=strategy.percent_of_equityAprès, réglagedefault_qty_valuePourcentage de la quantité ((0 ~ 100), 1 est de 1%. Le montant de la commande est calculé en fonction du nombre de devises cotées dans le compte. Par exemple: le compte actuel a 10000 USDT, le paramètre de commande de 1%, c’est-à-dire l’utilisation de 100 USDT de la taille de la commande de commande (en fonction du prix actuel lors de la vente).

Déclarations, mots clés de la structure logique

var

var est le mot-clé pour les variables d’allocation et d’initialisation ponctuelle. En règle générale, la syntaxe d’attribution de variables qui ne contient pas le mot-clé var entraîne une couverture de la valeur de la variable chaque fois que les données sont mises à jour. En revanche, lorsqu’on utilise le mot-clé var pour attribuer des variables, elles peuvent conserver leur état parallèle malgré la mise à jour des données et ne le modifier que si les conditions des expressions-if sont remplies.

var variable_name = expression

Il explique:

• variable_name- n’importe quel nom de variable utilisateur autorisé dans Pine Script, qui peut contenir des caractères latins majuscules et minuscules, des chiffres et des soulignements_), mais sans numéros au début) 。
• expression- toute expression arithmétique, comme la définition d’une variable régulière. On calcule l’expression et on l’attribue à la variable une fois.

Exemple

// Var keyword example
var a = close
var b = 0.0
var c = 0.0
var green_bars_count = 0
if close > open
    var x = close
    b := x
    green_bars_count := green_bars_count + 1
    if green_bars_count >= 10
        var y = close
        c := y
plot(a, title = "a")
plot(b, title = "b")
plot(c, title = "c")

La variable ‘a’ conserve le prix de clôture du premier pilier de chaque ligne de la série. La variable ‘b’ maintient le prix de clôture de la première barre de prix de l’aluminium vert de la série. La variable ‘c’ maintient le prix de clôture de la dixième pomme de terre verte de la série.

Sur la FMZ, il existe des modèles de prix en temps réel, des modèles de prix de clôture et des modèles de prix de rupture.var、varipLes variables déclarées sont testées avec le code suivant:

strategy("test pine", "test 1", true) 

// 测试 var varip
var i = 0
varip ii = 0

// 将策略逻辑每轮改变的i、ii打印在图上
plotchar(true, title="ii", char=str.tostring(ii), location=location.abovebar, color=color.red)
plotchar(true, title="i", char=str.tostring(i), location=location.belowbar, color=color.green)

// 每轮逻辑执行都给i、ii递增1
if true
    i := i + 1
    ii := ii + 1

• Modèle de prix en temps réel Le code de test ci-dessus est divisé en deux phases au moment de l’exécution: 1) la phase de la ligne K historique; 2) la phase de la ligne K en temps réel; 3) la phase de la ligne K historique.var、varipLes variables i et ii de la déclaration exécutent des opérations incrémentielles à chaque tour du code de stratégie (parce queif trueOn peut donc voir que les chiffres affichés sur la ligne BAR du résultat de la rétroanalyse sont chacun en augmentation de 1. Lorsque la phase de la ligne K historique se termine, la phase de la ligne K en temps réel commence.var、varipLes variables déclarées commencent à changer. Comme il s’agit d’un modèle de prix en temps réel, le code de stratégie est exécuté une fois pour chaque variation de prix dans une ligne KBAR, et le code de stratégie est exécuté une fois pour chaque variation de prix dans une ligne KBAR.i := i + 1etii := ii + 1La différence est que ii est modifié à chaque fois. Bien que i soit modifié à chaque fois, la logique de stratégie d’exécution du prochain tour reprend la valeur précédente, jusqu’à ce que la ligne KBAR actuelle soit terminée. La valeur de i est déterminée jusqu’à ce que la valeur de i soit définie.

• Modèle de prix de clôture Puisque le modèle de prix de clôture n’exécute une logique stratégique qu’une fois chaque ligne K BAR terminée. Dans le modèle de prix de clôture, les phases de la ligne K historique et la phase de la ligne K en temps réel sont séparées par des phases de K historique et de K réel.var、varipLa variante déclarée s’exprime de manière parfaitement homogène dans l’exemple ci-dessus, avec une augmentation de 1BAR pour chaque ligne K.

varip

varip ((var intrabar persist) est un mot-clé pour les variables d’allocation et d’initialisation ponctuelle. Il est similaire au mot-clé var, mais les variables utilisant la déclaration varip conservent leur valeur entre les mises à jour en ligne K en temps réel.

varip variable_name = expression

Il explique:

• variable_name- n’importe quel nom de variable utilisateur autorisé dans le script Pine, qui peut contenir des lettres latines majuscules et minuscules, des chiffres et des soulignements_), mais sans numéros au début) 。
• expression- toute expression arithmétique, comme pour la définition d’une variable régulière. Sur la première ligne K, l’expression n’est calculée qu’une seule fois et attribuée à la variable une seule fois.

Exemple

// varip
varip int v = -1
v := v + 1
plot(v)

Avec var, le graphique renvoie la valeur de bar_index. Avec varip, le même comportement se produit sur la ligne K historique, mais sur la ligne K en temps réel, le graphique renvoie une valeur qui augmente d’un pour chaque tick.

À noter Ne peut être utilisé qu’avec des types simples, tels que float, int, bool, string, et des tableaux de ces types 。

true

Indique la valeur d’une variable de type Boole, ou quand l’expression est utiliséeComparaisonouLa logiqueLes valeurs que l’opérateur peut calculer.

À noter Voir aussiComparaisonLes opérateurs etLa logiqueDescription de l’opérateur

Voir aussi bool

false

Indique la valeur d’une variable de type Boole, ainsi que le résultat des opérations de comparaison et des opérations logiques.

À noter Voir aussiComparaisonLes opérateurs etLa logiqueDescription de l’opérateur

Voir aussi bool

if

Les déclarations if définissent les blocs de déclarations qui doivent être exécutés pour satisfaire aux conditions de l’expression. La 4e édition du langage de script Pine vous permet d’utiliser la syntaxe else if.

Le code générique provient de:

var_declarationX = if condition
    var_decl_then0
    var_decl_then1
    ...
    var_decl_thenN
    return_expression_then
else if [optional block]
    var_decl_else0
    var_decl_else1
    ...
    var_decl_elseN
    return_expression_else
else
    var_decl_else0
    var_decl_else1
    ...
    var_decl_elseN
    return_expression_else

À noter var_declarationX- Cette variable récupère la valeur de la phrase if condition- Utilisez un bloc de phrase si la condition est vraiethenLa logique est là.var_decl_then0，var_decl_then1Si la condition est “false”, utilisez le bloc de phraseelse ifouelseLa logique est là.var_decl_else0，var_decl_else1Le monde est en train de changer. return_expression_then , return_expression_else- La dernière expression du module ou celle du blocelse renvoie la valeur finale de l’instruction. Si la variable est déclarée à la fin, sa valeur est la valeur résultante.

Le type de valeur retournée par l’instruction if dépend dereturn_expression_thenetreturn_expression_elseLes types doivent correspondre pour être exécutés sur TradingView: il est impossible de retourner une valeur entière à partir d’un bloc de phrases then lorsque vous avez une valeur de chaîne dans le bloc else. Exécuté sur FMZ, l’exemple suivant ne fera pas d’erreur, et le nombre à tracer lors de l’option “open” pour les valeurs y est n/a.

Exemple

// This code compiles
x = if close > open
    close
else
    open  

// This code doesn’t compile by trading view
// y = if close > open
//     close
// else
//     "open"
plot(x)

Vous pouvez l’ignorer.elseDans ce cas, si la condition est false, la variable var_declarationX est affectée à une valeur de seuil empty ({na, false ou ):

Exemple

// if
x = if close > open
    close
// If current close > current open, then x = close.
// Otherwise the x = na.
plot(x)

On peut utiliser plusieurs blocs de else if ou pas du tout. Les blocs de then, else if et else sont déplacés de quatre espaces:

Exemple

// if
x = if open > close
    5
else if high > low
    close
else
    open
plot(x)

Je peux ignorer.ifLa valeur de résultat de l’expression ((var_declarationX= peut être omis) peut être utile si vous avez besoin d’effets secondaires de l’expression, par exemple dans le trading stratégique:

Exemple

if (ta.crossover(high, low))
    strategy.entry("BBandLE", strategy.long, stop=low)
else
    strategy.cancel(id="BBandLE")

Les déclarations If peuvent être contenues les unes dans les autres:

Exemple

// if
float x = na
if close > open
    if close > close[1]
        x := close
    else
        x := close[1]
else
    x := open
plot(x)

for

La structure ‘for’ permet d’exécuter plusieurs déclarations à plusieurs reprises:

[var_declaration =] for counter = from_num to to_num [by step_num]
    statements | continue | break
    return_expression

var_declaration- une déclaration de variable sélective qui sera assignée à la valeur de return_expression de la boucle de retour. counter- une variable qui conserve la valeur du compteur de tournée, augmentant/diminuant de 1 ou de la valeur step_num à chaque iteration de la tournée. from_num- La valeur initiale du compteur. Il est permis d’utiliser une série de valeurs / expressions int/float. to_num- la valeur finale du compteur. Le cycle est interrompu lorsque le compteur est supérieur à to_num (ou inférieur à to_num dans le cas de from_num > to_num). L’utilisation de valeurs/expressions de la série int/float est autorisée, mais elles ne sont évaluées que lors de la première iteration du cycle. step_num- Le compteur augmente / diminue. Il est facultatif. La valeur par défaut est +1 ou -1, en fonction du plus grand de from_num ou to_num. statements | continue | break- un nombre quelconque de phrases, ou des mots-clés ‘continue’ ou ‘break’, réduits à 4 espaces ou à un seul onglet. return_expression- les valeurs de retour de la boucle, si elles existent, sont attribuées à la variable dans la déclaration var. Si la boucle est abandonnée en raison de la clé de la boucle continue ou de la boucle de rupture, la valeur de retour de la boucle est la valeur de retour de la dernière variable à laquelle la valeur d’allocation a été attribuée avant la sortie de la boucle. continue- Un mot-clé qui ne peut être utilisé que dans la boucle de retour. Il entraîne l’exécution de la prochaine iteration de la boucle de retour. break- Les mots clés pour quitter le cercle de retour.

Exemple

// Here, we count the quantity of bars in a given 'lookback' length which closed above the current bar's close
qtyOfHigherCloses(lookback) =>
    int result = 0
    for i = 1 to lookback
        if close[i] > close
            result += 1
    result
plot(qtyOfHigherCloses(14))

Voir aussi for...in while

for…in

for...inLa structure permet d’exécuter plusieurs expressions pour chaque élément de l’array. Elle peut être utilisée avec n’importe quel paramètre:array_element, ou avec deux arguments:[index, array_element]La deuxième forme n’affecte pas la fonction de la boucle. Elle suit l’index de l’incrédulité actuelle dans la première variable du module.

[var_declaration =] for array_element in array_id
    statements | continue | break
    return_expression

[var_declaration =] for [index, array_element] in array_id
    statements | continue | break
    return_expression

var_declaration- une déclaration de variable à choisir, qui sera donnée à la circulationreturn_expressionLa valeur de index- une variable facultative qui suit l’index de l’encodage en cours. L’index commence à 0. La variable est immuable dans le corps de la boucle. Lorsqu’elle est utilisée, elle doit être incluse dans une autre variable.array_elementDans le sous-groupe de array_element- contient la variable de chaque élément de l’array continu qui doit être traité dans le cycle. Cette variable est immuable dans le corps du cycle. array_id- ID d’array pour l’incrédulité du cercle. statements | continue | break- un nombre quelconque de phrases, ou des mots-clés ‘continue’ ou ‘break’, réduits à 4 espaces ou à un seul onglet. return_expression- le retour de la boucle est attribué àvar_declarationLes variables, si elles existent. Si le cycle s’arrête à cause du mot-clé “continue” ou “break”, la valeur de retour du cycle est la dernière variable attribuée avant le cycle. continue- Un mot-clé qui ne peut être utilisé que dans la boucle de retour. Il entraîne l’exécution de la prochaine iteration de la boucle de retour. break- Les mots clés pour quitter le cercle de retour.

Modifier les éléments de la matrice ou sa taille dans le cycle est autorisé. Ici, nous avons utiliséfor...inLa formule monoparamétrique pour déterminer le nombre de lignes K dont la valeur OHLC est supérieure à la valeur SMA de ‘close’ sur chaque ligne K:

Exemple

// Here we determine on each bar how many of the bar's OHLC values are greater than the SMA of 'close' values
float[] ohlcValues = array.from(open, high, low, close)
qtyGreaterThan(value, array) =>
    int result = 0
    for currentElement in array
        if currentElement > value
            result += 1
        result
plot(qtyGreaterThan(ta.sma(close, 20), ohlcValues))

Nous avons utilisé deux arguments de la forme for…in pour nous rendre notreisPosLa valeur de l’array est définie sur trueQuand ils sont chez nous,valuesArrayLes valeurs correspondantes dans l’arrêté sont des temps réels:

Exemple

// for...in
var valuesArray = array.from(4, -8, 11, 78, -16, 34, 7, 99, 0, 55)
var isPos = array.new_bool(10, false)  

for [index, value] in valuesArray
    if value > 0
        array.set(isPos, index, true)  

if barstate.islastconfirmedhistory
    runtime.log(str.tostring(isPos))

Voir aussi for while array.sum array.min array.max

while

whileLes expressions permettent une itération conditionnelle des blocs de code locaux.

variable_declaration = while boolean_expression
    ...
    continue
    ...
    break
    ...
    return_expression

Il explique: variable_declaration- Déclarations de variables à choisir.return expressionOn peut donner une valeur d’initialisation à cette variable. boolean_expression- Si vrai, alors exécutéwhileLe bloc local de la phrase.whileLe scénario est exécuté après la phrase. continue - continueLes mots-clés conduisent à la branche de la boucle à la prochaine iteration. break - breakLes mots clés provoquent l’arrêt de la boucle.whileLa phrase a été restaurée. return_expression- Je vous en prie.whileUne ligne optionnelle qui renvoie une valeur.

Exemple

// This is a simple example of calculating a factorial using a while loop.
int i_n = input.int(10, "Factorial Size", minval=0)
int counter   = i_n
int factorial = 1
while counter > 0
    factorial := factorial * counter
    counter   := counter - 1

plot(factorial)

À noter Les débutswhileLe bloc de code local qui suit la ligne doit être réduit à quatre espaces ou à un marqueur.whileLe cycle.whileL’expression suivante de Boole doit être définitivement transformée en false, ou elle doit être exécutée.break。

switch

L’opérateur switch transfère le contrôle à l’une des plusieurs expressions en fonction de la condition et de la valeur de l’expression.

[variable_declaration = ] switch expression
    value1 => local_block
    value2 => local_block
    ...
    => default_local_block

[variable_declaration = ] switch
    boolean_expression1 => local_block
    boolean_expression2 => local_block
    ...
    => default_local_block

Le mot “switch” est une expression qui signifie:

Exemple

// Switch using an expression

string i_maType = input.string("EMA", "MA type", options = ["EMA", "SMA", "RMA", "WMA"])

float ma = switch i_maType
    "EMA" => ta.ema(close, 10)
    "SMA" => ta.sma(close, 10)
    "RMA" => ta.rma(close, 10)
    // Default used when the three first cases do not match.
    => ta.wma(close, 10)

plot(ma)

Switch sans l’expression:

Exemple

strategy("Switch without an expression", overlay = true)

bool longCondition  = ta.crossover( ta.sma(close, 14), ta.sma(close, 28))
bool shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))

switch
    longCondition  => strategy.entry("Long ID", strategy.long)
    shortCondition => strategy.entry("Short ID", strategy.short)

Retourne une valeur La valeur de la dernière expression dans le bloc d’instructions locales exécuté.

À noter Ne peut être exécuté quelocal_blockExemple oudefault_local_blockUne seule.default_local_blockSeulement avec=>Les balises sont introduites ensemble et ne sont exécutées que si le bloc précédent n’a pas été exécuté.switchLe résultat de la phrase est attribué à une variable et n’est pas spécifiédefault_local_blockSi ce n’est pas fait,local_block, la phrase revientnaJe vous en prie.switchLorsque le résultat d’une phrase est attribué à une variable, tous leslocal_blockL’instance doit renvoyer une valeur du même type que la précédente.

Voir aussi if ?:

series

series est un mot-clé qui indique le type de série de données.seriesLes mots clés sont généralement inutiles.

Outil de calcul

=

Utilisé pour attribuer une valeur à une variable, mais uniquement lors de la déclaration de la variable ((Utilisé pour la première fois)) [2].

:=

Opérateur d’attribution, attribuant une valeur à la variable de gauche. Utilisé pour attribuer une valeur à la variable précédemment déclarée.

!=

Il n’est pas égal à ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠

expr1 != expr2

Retourne une valeur Une valeur de Boole, ou une série de valeurs de Boole.

%

Les nombres modulaires sont des nombres entiers. Les nombres modulaires sont des nombres entiers.

expr1 % expr2

Retourne une valeur Un nombre entier ou une valeur de point flottant, ou une série de valeurs.

À noter Dans le script Pine, le vendeur sera interrompu lorsque le reste de l’entier sera calculé. C’est-à-dire qu’il sera relégué au plus petit nombre absolu. La valeur reçue aura le même symbole que le dividende.

Exemple: -1 % 9 = -1 - 9 * truncate ((-¹⁄₉) = -1 - 9 * truncate ((-0.111) = -1 - 9 * 0 = -1。

%=

Les modules sont désignés. Ils s’appliquent aux expressions numériques.

expr1 %= expr2

Exemple

// Equals to expr1 = expr1 % expr2.
a = 3
b = 3
a %= b
// Result: a = 0.
plot(a)

Retourne une valeur Un nombre entier ou une valeur de point flottant, ou une série de valeurs.

*

La multiplication. Elle s’applique aux expressions numériques.

expr1 * expr2

Retourne une valeur Un nombre entier ou une valeur de point flottant, ou une série de valeurs.

*=

La désignation de la multiplication. Elle s’applique aux expressions numériques.

expr1 *= expr2

Exemple

// Equals to expr1 = expr1 * expr2.
a = 2
b = 3
a *= b
// Result: a = 6.
plot(a)

Retourne une valeur Un nombre entier ou une valeur de point flottant, ou une série de valeurs.

+

Ajout ou unité positive pour une expression numérique ou une chaîne de caractères

expr1 + expr2

+ expr

Retourne une valeur Binary des chaînes de caractères+Retourne la fusion des expressions 1 et 2 Les chiffres renvoient des valeurs entières ou des valeurs de points flottants, ou une série de valeurs: Le binaire ‘+’ renvoie expr1 plus expr2。 Le symbole de l’opérateur unitaire n’est pas ajouté.

À noter Vous pouvez utiliser des opérateurs d’arithmétique avec des chiffres, ainsi que des ensembles de variables. Dans le cas des ensembles, les opérateurs sont appliqués aux éléments.

+=

Désignation de l’additif pour une expression numérique ou une chaîne de caractères

expr1 += expr2

Exemple

// Equals to expr1 = expr1 + expr2.
a = 2
b = 3
a += b
// Result: a = 5.
plot(a)

Retourne une valeur Pour les chaînes de caractères, renvoie la séquence expr1 et expr2. Pour les chiffres, renvoie une valeur entière ou un nombre à points flottants, ou une série de valeurs.

À noter Vous pouvez utiliser des opérateurs d’arithmétique avec des chiffres, ainsi que des ensembles de variables. Dans le cas des ensembles, les opérateurs sont appliqués aux éléments.

-

La soustraction ou unité négative est utilisée pour les expressions numériques

expr1 - expr2

- expr

Retourne une valeur Retourne une valeur entière ou une valeur en points flottants, ou une série de valeurs: Le binaire ‘+’ renvoie expr1 moins expr2。 Une unité-Retourne l’expression négative de l’expr。

À noter Vous pouvez utiliser des opérateurs d’arithmétique avec des chiffres, ainsi que des ensembles de variables. Dans le cas des ensembles, les opérateurs sont appliqués aux éléments.

-=

Désignation de la soustraction. Elle s’applique aux expressions numériques.

expr1 -= expr2

Exemple

// Equals to expr1 = expr1 - expr2.
a = 2
b = 3
a -= b
// Result: a = -1.
plot(a)

Retourne une valeur Un nombre entier ou une valeur de point flottant, ou une série de valeurs.

/

Les exceptions ◄ s’appliquent aux expressions numériques ◄ .

expr1 / expr2

Retourne une valeur Un nombre entier ou une valeur de point flottant, ou une série de valeurs.

/=

Désignation de l’exclusion pour une expression numérique

expr1 /= expr2

Exemple

// Equals to expr1 = expr1 / expr2.
a = 3
b = 3
a /= b
// Result: a = 1.
plot(a)

Retourne une valeur Un nombre entier ou une valeur de point flottant, ou une série de valeurs.

<

Moins de ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠

expr1 < expr2

Retourne une valeur Une valeur de Boole, ou une série de valeurs de Boole.

<=

Moins ou égal à ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠

expr1 <= expr2

Retourne une valeur Une valeur de Boole, ou une série de valeurs de Boole.

==

Il est égal à … …

expr1 == expr2

Retourne une valeur Une valeur de Boole, ou une série de valeurs de Boole.

=>

L’opérateur ‘=>’ est utilisé pour les déclarations de fonctions définies par l’utilisateur etswitchDans la phrase:

La syntaxe de la déclaration de fonction est:

<identifier>([<parameter_name>[=<default_value>]], ...) =>
    <local_block>
    <function_result>

Une seule.<local_block>Il est composé de zéro ou plus de phrases de Pine. <function_result>est une variable, une expression ou un sous-ensemble.

Exemple

// single-line function
f1(x, y) => x + y
// multi-line function
f2(x, y) => 
    sum = x + y
    sumChange = ta.change(sum, 10)
    // Function automatically returns the last expression used in it
plot(f1(30, 8) + f2(1, 3))

À noter Vous trouverez plus d’informations sur les fonctions définies par l’utilisateur dans le manuel de l’utilisateur.

>

Plus de ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠

expr1 > expr2

Retourne une valeur Une valeur de Boole, ou une série de valeurs de Boole.

>=

Plus grand ou égal à. Pour les expressions numériques.

expr1 >= expr2

Retourne une valeur Une valeur de Boole, ou une série de valeurs de Boole.

?:

L’opérateur conditionnel triangulaire ≠

expr1 ? expr2 : expr3

Exemple

// Draw circles at the bars where open crosses close
s2 = ta.cross(open, close) ? math.avg(open,close) : na
plot(s2, style=plot.style_circles, linewidth=2, color=color.red)  

// Combination of ?: operators for 'switch'-like logic
c = timeframe.isintraday ? color.red : timeframe.isdaily ? color.green : timeframe.isweekly ? color.blue : color.gray
plot(hl2, color=c)

Retourne une valeur Si expr1 est évalué comme vrai, expr2 est évalué comme vrai, sinon expr3 ≠ expr. Les valeurs zéro ((0 et NaN+, Infinity, -Infinity) sont considérées comme fausses, les autres valeurs sont considérées comme vraies ≠ expr3.

À noter Si vous n’en avez pas besoin, utilisez na comme branche de la colonne vertébrale. Vous pouvez combiner deux ou plusieurs opérateurs ?: pour réaliser des expressions similaires à celles de la colonne de commutation (voir l’exemple ci-dessus) [2]. Vous pouvez utiliser des opérateurs d’arithmétique avec des chiffres, ainsi que des ensembles de variables. Dans le cas des ensembles, les opérateurs sont appliqués aux éléments.

Voir aussi na

[]

Les sous-titres des séries ≠ fournissent un accès aux valeurs précédentes de la série expr1 ≠ expr2 est le nombre de lignes k précédentes, qui doit être un nombre ≠ flottant sera arrondi vers le bas ≠

expr1[expr2]

Exemple

// [] can be used to "save" variable value between bars
a = 0.0 // declare `a`
a := a[1] // immediately set current value to the same as previous. `na` in the beginning of history
if high == low // if some condition - change `a` value to another
    a := low
plot(a)

Retourne une valeur Une série de valeurs.

Voir aussi math.floor

and

La logique AND ≠ est utilisée pour les expressions de Boole.

expr1 and expr2

Retourne une valeur Une valeur de Boole, ou une série de valeurs de Boole.

or

La logique OR ≠ s’applique aux expressions de Boole ≠

expr1 or expr2

Retourne une valeur Une valeur de Boole, ou une série de valeurs de Boole.

not

La logique inverse ((NOT) ) s’applique à une expression Boolean .

not expr1

Retourne une valeur Une valeur de Boole, ou une série de valeurs de Boole.

Type de données mots clés

bool

Le mot-clé du type bool pour déclarer explicitement une variable ou un paramètre. Les valeurs de la variable “Bool” peuvent être vraies, fausses ou na.

Exemple

// bool
bool b = true    // Same as `b = true`
b := na
plot(b ? open : close)

À noter La mention explicite du type dans la déclaration de variable est facultative, sauf s’il est initialité par na. Vous trouverez plus d’informations sur le type Pine sur la page du manuel de l’utilisateur du système de type.

Voir aussi var varip int float color string true false

int

Le mot-clé de type int () pour déclarer explicitement une variable ou un paramètre.

Exemple

// int
int i = 14    // Same as `i = 14`
i := na
plot(i)

À noter La mention explicite du type dans la déclaration de variable est facultative, sauf s’il est initialité par na. Vous trouverez plus d’informations sur le type Pine sur la page du manuel de l’utilisateur du système de type.

Voir aussi var varip float bool color string

float

Mots-clés du type float pour déclarer explicitement une variable ou un paramètre.

Exemple

// float
float f = 3.14    // Same as `f = 3.14`
f := na
plot(f)

À noter La mention explicite du type dans la déclaration de la variable est facultative, sauf si elle est initializée par na.

Voir aussi var varip int bool color string

string

Le mot-clé de type “string” utilisé pour déclarer explicitement une variable ou un paramètre.

Exemple

// string
string s = "Hello World!"    // Same as `s = "Hello world!"`
// string s = na // same as "" 
plot(na, title=s)

À noter La mention explicite du type dans la déclaration de variable est facultative, sauf s’il est initialité par na. Vous trouverez plus d’informations sur le type Pine sur la page du manuel de l’utilisateur du système de type.

Voir aussi var varip int float bool str.tostring str.format

color

Le mot-clé du type “color” utilisé pour déclarer explicitement une variable ou un paramètre.

Exemple

// color
color textColor = color.green
if barstate.islastconfirmedhistory
    runtime.log("test", textcolor = textColor)

À noter Les lettres de couleur ont le format suivant: #RRGGBB ou #RRGGBBAA. Les paires de lettres représentent les seize décimales de 00 à FF ((décimales de 0 à 255), où RR, GG et BB sont les valeurs de la partition rouge, verte et bleue de la couleur. AA est la transparence de la couleur (ou la partition alpha), où 00 est invisible et FF est opaque. La mention explicite du type dans la déclaration de variable est facultative, sauf s’il est initialité par na. Vous trouverez plus d’informations sur le type Pine sur la page du manuel de l’utilisateur du système de type.

Voir aussi var varip int float string color.rgb color.new

array

Les mots-clés de type argon de la matrice argon utilisés pour déclarer explicitement une variable ou un paramètre.array.new<type>,array.fromLa fonction crée un objet d’array ((ou ID) }}.

Exemple

// array
array<float> a = na
a := array.new<float>(1, close)
plot(array.get(a, 0))

À noter Les objets de l’array sont toujours en forme de série de piles.

Voir aussi var array.new array.from

Objects

L’objet Objects du langage PINE est un exemple de type défini par l’utilisateur ((UDT), qui peut être compris comme une classe sans méthode, permettant à l’utilisateur de créer des types personnalisés dans la stratégie pour organiser des valeurs différentes dans une seule entité.

Définir le type

Définissons un type d’ordre pour stocker des informations sur les commandes:

type order
    float price
    float amount
    string symbol

• utilisertypeType de déclaration de mot-clé
• Le mot clé type est suivi du nom du type.
• La première ligne type définit le nom du type, puis s’enroule dans quatre espaces pour définir les champs qu’il contient.
• Chaque champ doit déclarer son type de données, par exemple int, float, string.

Objets créés

Utilisez le type déclaré, appelnew()Objet de création de la fonction:

order1 = order.new()

order1 = order.new(100, 0.1, "BTC_USDT")

order1 = order.new(amount = 0.1, symbol = "BTC_USDT", price = 100)

Vous pouvez également créer des objets vides:

order order1 = na

Voici un exemple réel:

type order
    float price
    float amount
    string symbol

if strategy.position_size == 0 and open > close
    strategy.entry("long", strategy.long, 1)

order1 = order.new(strategy.opentrades.entry_price(strategy.opentrades - 1), strategy.opentrades.size(strategy.opentrades - 1), syminfo.ticker)
// runtime.log(order1)   // 输出 {"data":{"price":46002.8,"amount":1,"symbol":"swap"},"_meta":0,"_type":"order"}

La phrase suivante est un exemple:

order1 = order.new(strategy.opentrades.entry_price(strategy.opentrades - 1), strategy.opentrades.size(strategy.opentrades - 1), syminfo.ticker)

On peut aussi écrire ceci:

order order1 = na
order1 := order.new(strategy.opentrades.entry_price(strategy.opentrades - 1), strategy.opentrades.size(strategy.opentrades - 1), syminfo.ticker)

Type d’objet Utilisation du mot-clé var

“pine //@version=5 indicator("Objects usingvar` demo”)

//@type A custom type to hold index, price, and volume information. type BarInfo int i