[TOC]
La structure générale du code de Pine est la suivante:
<version>
<declaration_statement>
<code>
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')
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
。
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:
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.
if
,for
,while
ouswitch
Structure de l’équationLes phrases peuvent être classées de plusieurs façons.
空格
ou制表符
Les lignes qui commencent à la première position de la ligne font, par définition, partie de la portée globale du script.local 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。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) // 调用一个内置函数输出日志 (全局范围)
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")
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éesopen
Par exemple:open
La variable intégrée enregistre le prix d’ouverture de chaque ligne KBAR, si celle-ci estopen
C’est le nombre de cycles de 5 minutes de la ligne K.open
La 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érenceopen
On 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.
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.
定价货币精度
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.javascript
Appel dans la stratégieSetMaxBarLen
Les fonctions sont les mêmes.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) // 指定(较低的)价格,计划下买单订单,等待成交开仓,限价开仓
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%持仓
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.
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.entry
Quand la fonction commande, nous pouvons spécifierlimit
、stop
Paramè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
Le prix limite d’une commande est fixé lorsque la commande est payante (c’est-à-diredirection
Les paramètres sontstrategy.long
La 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 à diredirection
Les paramètres sontstrategy.short
La commande n’est déclenchée que lorsque le prix actuel du marché est supérieur à ce prix.
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.
Peut être configuré simultanémentlimit
、stop
Paramètre: la commande est déclenchée au premier prix admissible.
//@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_equity
Après, réglagedefault_qty_value
Pourcentage 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).
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
、varip
Les 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
、varip
Les variables i et ii de la déclaration exécutent des opérations incrémentielles à chaque tour du code de stratégie (parce queif true
On 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
、varip
Les 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 + 1
etii := ii + 1
La 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
、varip
La 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 ((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 。
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
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
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 vraiethen
La logique est là.var_decl_then0
,var_decl_then1
Si la condition est “false”, utilisez le bloc de phraseelse if
ouelse
La logique est là.var_decl_else0
,var_decl_else1
Le 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_then
etreturn_expression_else
Les 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.else
Dans 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.if
La 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)
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
La 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_expression
La 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_element
Dans 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_declaration
Les 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...in
La 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 notreisPos
La valeur de l’array est définie sur true
Quand ils sont chez nous,valuesArray
Les 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
Les 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 expression
On peut donner une valeur d’initialisation à cette variable.
boolean_expression
- Si vrai, alors exécutéwhile
Le bloc local de la phrase.while
Le scénario est exécuté après la phrase.
continue
- continue
Les mots-clés conduisent à la branche de la boucle à la prochaine iteration.
break
- break
Les mots clés provoquent l’arrêt de la boucle.while
La phrase a été restaurée.
return_expression
- Je vous en prie.while
Une 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ébutswhile
Le bloc de code local qui suit la ligne doit être réduit à quatre espaces ou à un marqueur.while
Le cycle.while
L’expression suivante de Boole doit être définitivement transformée en false, ou elle doit être exécutée.break
。
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_block
Exemple oudefault_local_block
Une seule.default_local_block
Seulement 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é.switch
Le résultat de la phrase est attribué à une variable et n’est pas spécifiédefault_local_block
Si ce n’est pas fait,local_block
, la phrase revientna
Je vous en prie.switch
Lorsque le résultat d’une phrase est attribué à une variable, tous leslocal_block
L’instance doit renvoyer une valeur du même type que la précédente.
Voir aussi
if
?:
series est un mot-clé qui indique le type de série de données.series
Les mots clés sont généralement inutiles.
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) = -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 etswitch
Dans 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
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.
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.
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.
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
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
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
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
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
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.from
La 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
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
type
Type de déclaration de mot-clé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 using
var` demo”)
//@type A custom type to hold index, price, and volume information. type BarInfo int i