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:

            pine
            
            
[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:

            pine
            
            
//@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:

            pine
            
            
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).

            pine
            
            
a = open + high + low + close

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

            pine
            
            
a = open +
      high +
          low +
             close

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

            pine
            
            
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:

            pine
            
            
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:

            pine
            
            
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:

            pine
            
            
//@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.

            pine
            
            
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

            pine
            
            
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

            pine
            
            
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

            pine
            
            
//@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

            pine
            
            
// 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:

            pine
            
            
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

            pine
            
            
// 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 <unk>else if<unk>.

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

            pine
            
            
// 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 <unk>empty ({na, false ou <unk>):

Exemple

            pine
            
            
// 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 <unk>else if<unk> ou pas du tout. Les blocs de <unk>then<unk>, <unk>else if<unk> et <unk>else<unk> sont déplacés de quatre espaces:

Exemple

            pine
            
            
// 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 ((<unk>var_declarationX=<unk> peut être omis) <unk> peut être utile si vous avez besoin d'effets secondaires de l'expression, par exemple dans le trading stratégique:

Exemple

            pine
            
            
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

            pine
            
            
// 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

            pine
            
            
// 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

            pine
            
            
// 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

            pine
            
            
// 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

            pine
            
            
// 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

            pine
            
            
// 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

            pine
            
            
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) = -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

            pine
            
            
// 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

            pine
            
            
// 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 <unk> pour une expression numérique ou une chaîne de caractères <unk>

            
            
            
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 <unk> pour une expression numérique ou une chaîne de caractères <unk>

            
            
            
expr1 += expr2

Exemple

            pine
            
            
// 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 <unk> est utilisée pour les expressions numériques <unk>

            
            
            
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

            pine
            
            
// 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 <unk> pour une expression numérique <unk>

            
            
            
expr1 /= expr2

Exemple

            pine
            
            
// 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

            pine
            
            
// 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

            pine
            
            
// 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

            pine
            
            
// [] 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) <unk>) s'applique à une expression Boolean <unk>.

            
            
            
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

            pine
            
            
// 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

            pine
            
            
// 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

            pine
            
            
// 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

            pine
            
            
// 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

            pine
            
            
// 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

            pine
            
            
// 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:

            pine
            
            
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:

            pine
            
            
order1 = order.new()

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

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

Vous pouvez également créer des objets vides:

            pine
            
            
order order1 = na

Voici un exemple réel:

            pine
            
            
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:

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

On peut aussi écrire ceci:

            pine
            
            
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   index = bar_index
    float price = close
    float vol   = volume

//@variable A `BarInfo` instance whose fields persist through all iterations, starting from the first bar.
var BarInfo firstBar = BarInfo.new()
//@variable A `BarInfo` instance declared on every bar.
BarInfo currentBar = BarInfo.new()

// Plot the `index` fields of both instances to compare the difference.
plot(firstBar.index, "firstBar")
plot(currentBar.index, "currentBar")

Lorsqu'une variable d'un objet de type défini par l'utilisateur est attribuée à l'aide d'une déclaration de mot-clé var, ce mot-clé s'applique automatiquement à tous les champs de cet objet. Cela signifie qu'un objet déclaré par le mot-clé var conserve son état entre chaque itération sans avoir à réinitialiser sa valeur de champ à chaque itération.

• L'objet firstBar est déclaré avec le mot-clé var, de sorte que son champ {index, price, vol} conserve sa valeur à chaque iteration, depuis le premier à la fin du dernier.
• L'objet currentBar n'utilise pas de déclaration de mot-clé var, de sorte que ses champs sont réinitialisés à chaque entrée et qu'il y a un nouvel objet à chaque itération.

Vous pouvez comparer les différences entre les deux en traçant les champs d'index de deux objets. firstBar.index conserve la valeur précédemment définie à chaque iteration, tandis que currentBar.index est réinitialisé à chaque iteration comme la valeur bar_index de l'élément en cours.

Type d'objet Utilisation du mot-clé varip

            pine
            
            
//@version=5
indicator("Objects using `varip` fields demo")

//@type A custom type that counts the bars and ticks in the script's execution.
type Counter
    int       bars  = 0
    varip int ticks = 0

//@variable A `Counter` object whose reference persists throughout all bars.
var Counter counter = Counter.new()

// Add 1 to the `bars` and `ticks` fields. The `ticks` field is not subject to rollback on unconfirmed bars.
counter.bars  += 1
counter.ticks += 1

// Plot both fields for comparison.
plot(counter.bars, "Bar counter", color.blue, 3)
plot(counter.ticks, "Tick counter", color.purple, 3)

Dans Pine, l'utilisation du mot-clé varip permet d'indiquer que le champ de l'objet persiste tout au long de l'exécution du script et ne se retourne pas dans la colonne non confirmée.
Dans les déclarations de type Counter, le champ bars n'utilise pas le mot-clé varip, donc il se retourne dans chaque colonne non confirmée. Le champ ticks utilise le mot-clé varip, donc il ne se retourne pas dans la colonne non confirmée.
L'objet counter est déclaré à l'aide du mot-clé var, donc il persistera tout au long de l'exécution du script.
Dans chaque iteration, les champs bars et les champs ticks sont augmentés de 1 ≠. Les champs bars sont renvoyés dans chaque colonne non confirmée, tandis que les champs ticks ne le sont pas.
Enfin, en traçant les champs counter.bars et counter.ticks, il est possible de comparer les différences entre eux. La valeur de counter.bars sera renvoyée dans chaque colonne non confirmée, tandis que la valeur de counter.ticks continuera d'augmenter jusqu'à la fin de l'exécution du script.

Modifier la valeur du champ

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

if strategy.position_size != 0
    runtime.log(order1)
    order1.price := 999
    order1.amount := 100
    runtime.log(order1)
    runtime.error("stop")

À utiliser:=L'opérateur de réattribution modifie la valeur du champ objet.

Ensemble d'objets

L'exemple déclare un tableau vide qui conserve les objets de type order définis par l'utilisateur:

            pine
            
            
type order
    float price
    float amount
    string symbol

arrOrder = array.new<order>()

order1 = order.new(99, 1, "BTC_USDT")
order2 = order.new(100, 2, "ETH_USDT")

array.push(arrOrder, order1)
array.push(arrOrder, order2)

runtime.log(arrOrder)
runtime.error("stop")

ou

            pine
            
            
type order
    float price
    float amount
    string symbol

var array<order> arrOrder = na
arrOrder := array.new<order>()

order1 = order.new(99, 1, "BTC_USDT")
order2 = order.new(100, 2, "ETH_USDT")

array.push(arrOrder, order1)
array.push(arrOrder, order2)

runtime.log(arrOrder)
runtime.error("stop")

Objets à copier

Dans Pine, les objets sont attribués par référence. Lorsqu'un objet existant est attribué à une nouvelle variable, ils pointent tous les deux vers le même objet.

            pine
            
            
//@version=5
indicator("")
type pivotPoint
    int x
    float y
pivot1 = pivotPoint.new()
pivot1.x := 1000
pivot2 = pivot1
pivot2.x := 2000
// Both plot the value 2000.
plot(pivot1.x)
plot(pivot2.x)

Dans l'exemple ci-dessous, nous créons un objet pivot1 et nous définissons son champ x à 1000。 Ensuite, nous déclarons qu'un pivot2 contient une variable qui fait référence à cet objet pivot1 et donc les deux pointent vers la même instance。 Par conséquent, modifier pivot2.x modifie aussi pivot1.x, car les deux font référence au champ x du même objet。

Pour créer une copie indépendante de l'objet d'origine, dans ce cas nous pouvons utiliser la méthode built-in copy (). Dans cet exemple, nous déclarons que pivot2 fait référence à une variable de l'instance de copie de l'objet pivot1. Maintenant, changer pivot2.x ne change pas pivot1.x, car il fait référence à un champ de x un objet séparé:

            pine
            
            
//@version=5
indicator("")
type pivotPoint
    int x
    float y
pivot1 = pivotPoint.new()
pivot1.x := 1000
pivot2 = pivotPoint.copy(pivot1)
pivot2.x := 2000
// Plots 1000 and 2000.
plot(pivot1.x)
plot(pivot2.x)

Il est à noter que la méthode de copie de TradingView est une copie superficielle. Si un objet a des champs de type spécial (array, etc.), les champs de la copie superficielle de cet objet pointeront vers la même instance que l'objet.
La plate-forme FMZ implémente directement la copie profonde sans avoir besoin d'un traitement supplémentaire, par exemple:

Copies détaillées

            pine
            
            
//@version=5

indicator("test deepCopy")

type orderInfo
    float price
    float amount

type labelInfo
    orderInfo order
    string labelMsg

labelInfo1 = labelInfo.new(orderInfo.new(100, 0.1), "test labelInfo1")
labelInfo2 = labelInfo.copy(labelInfo1)

labelInfo1.labelMsg := "labelInfo1->2"    // 修改 labelInfo1 的基础类型字段，看是否影响 labelInfo2
labelInfo1.order.price := 999             // 修改 labelInfo1 的复合类型字段，看是否影响 labelInfo2

runtime.log(labelInfo1)
runtime.log(labelInfo2)
runtime.error("stop")

Le résultat du test, labelInfo.copy ((labelInfo1) est une copie profonde lors de l'exécution, modifier labelInfo1 n'affecte aucun champ de labelInfo2。

Methods

Les méthodes du langage Pine sont des fonctions spécialisées associées à des types intégrés ou définis par l'utilisateur pour une instance particulière. Dans la plupart des cas, elles sont fondamentalement les mêmes que les fonctions ordinaires, mais offrent une grammaire plus courte et plus pratique. Les utilisateurs peuvent accéder aux méthodes directement en utilisant des points sur les variables, comme s'ils accédaient à des champs d'objets Pine.

Méthode intégrée

Un exemple de ce type de script:

            pine
            
            
//@version=5
indicator("Custom Sample BB", overlay = true)

float sourceInput  = input.source(close, "Source")
int   samplesInput = input.int(20, "Samples")
int   n            = input.int(10, "Bars")
float multiplier   = input.float(2.0, "StdDev")

var array<float> sourceArray = array.new<float>(samplesInput)
var float        sampleMean  = na
var float        sampleDev   = na

// Identify if `n` bars have passed.
if bar_index % n == 0
    // Update the queue.
    array.push(sourceArray, sourceInput)
    array.shift(sourceArray)
    // Update the mean and standard deviaiton values.
    sampleMean := array.avg(sourceArray)
    sampleDev  := array.stdev(sourceArray) * multiplier

// Calculate bands.
float highBand = sampleMean + sampleDev
float lowBand  = sampleMean - sampleDev

plot(sampleMean, "Basis", color.orange)
plot(highBand, "Upper", color.lime)
plot(lowBand, "Lower", color.red)

L'équivalent peut s'écrire

            pine
            
            
//@version=5
indicator("Custom Sample BB", overlay = true)

float sourceInput  = input.source(close, "Source")
int   samplesInput = input.int(20, "Samples")
int   n            = input.int(10, "Bars")
float multiplier   = input.float(2.0, "StdDev")

var array<float> sourceArray = array.new<float>(samplesInput)
var float        sampleMean  = na
var float        sampleDev   = na

// Identify if `n` bars have passed.
if bar_index % n == 0
    // Update the queue.
    sourceArray.push(sourceInput)
    sourceArray.shift()
    // Update the mean and standard deviaiton values.
    sampleMean := sourceArray.avg()
    sampleDev  := sourceArray.stdev() * multiplier

// Calculate band values.
float highBand = sampleMean + sampleDev
float lowBand  = sampleMean - sampleDev

plot(sampleMean, "Basis", color.orange)
plot(highBand, "Upper", color.lime)
plot(lowBand, "Lower", color.red)

Vous pouvez voir que PINE est d'accord.MethodsEnsuite, le code.array.avg(sourceArray)Si vous utilisez la formule de méthodes, vous pouvez écrire:sourceArray.avg()。
Attention, FMZ n'est pas encore pris en chargearray.avgIl y a un appel à ce genre.

Méthode définie par l'utilisateur

Pine permet à l'utilisateur de définir des méthodes personnalisées qui peuvent être utilisées avec n'importe quel type d'objet intégré ou défini par l'utilisateur. Les méthodes de définition sont essentiellement les mêmes que les fonctions de définition, mais avec deux différences clés:

1, le mot clé method doit être inclus avant le nom de la fonction.
2. les paramètres de la méthode, dont le premier type doit être une déclaration explicite, car il indique le type d'objets auxquels la méthode sera associée.

Par exemple, le code de calcul de l'indice de Brin est encapsulé dans le code suivant comme une méthode personnalisée:

            pine
            
            
//@version=5
indicator("Custom Sample BB", overlay = true)

float sourceInput  = input.source(close, "Source")
int   samplesInput = input.int(20, "Samples")
int   n            = input.int(10, "Bars")
float multiplier   = input.float(2.0, "StdDev")

var array<float> sourceArray = array.new<float>(samplesInput)
var float        sampleMean  = na
var float        sampleDev   = na

// Identify if `n` bars have passed.
if bar_index % n == 0
    // Update the queue.
    sourceArray.push(sourceInput)
    sourceArray.shift()
    // Update the mean and standard deviaiton values.
    sampleMean := sourceArray.avg()
    sampleDev  := sourceArray.stdev() * multiplier

// Calculate band values.
float highBand = sampleMean + sampleDev
float lowBand  = sampleMean - sampleDev

plot(sampleMean, "Basis", color.orange)
plot(highBand, "Upper", color.lime)
plot(lowBand, "Lower", color.red)

Modifié en:

            pine
            
            
//@version=5
indicator("Custom Sample BB", overlay = true)

float sourceInput  = input.source(close, "Source")
int   samplesInput = input.int(20, "Samples")
int   n            = input.int(10, "Bars")
float multiplier   = input.float(2.0, "StdDev")

var array<float> sourceArray = array.new<float>(samplesInput)
method maintainQueue(array<float> srcArray, float value, bool takeSample = true) =>
    if takeSample
        srcArray.push(value)
        srcArray.shift()
    srcArray

method calcBB(array<float> srcArray, float mult, bool calculate = true) =>
    var float mean = na
    var float dev  = na
    if calculate
        mean := srcArray.avg()
        dev  := srcArray.stdev() * mult
    [mean, mean + dev, mean - dev]

bool newSample = bar_index % n == 0

[sampleMean, highBand, lowBand] = sourceArray.maintainQueue(sourceInput, newSample).calcBB(multiplier, newSample)

plot(sampleMean, "Basis", color.orange)
plot(highBand, "Upper", color.lime)
plot(lowBand, "Lower", color.red)

On peut voir que la méthode utilisateur qui utilise la déclaration de méthode de la clé:maintainQueue, calcBB, est la première dans la liste des paramètres.array<float>type ≠ indique que la méthode estarray<float>La méthode des variables de type, donc on peut voir que l'on appelle le code suivant pour calculer l'indicateur de Bryn.

            pine
            
            
[sampleMean, highBand, lowBand] = sourceArray.maintainQueue(sourceInput, newSample).calcBB(multiplier, newSample)

Reload de méthodes

Les méthodes définies par l'utilisateur peuvent superposer et surcharger des méthodes existantes avec le même identifiant et des méthodes définies par l'utilisateur. Cette fonctionnalité permet à l'utilisateur de définir plusieurs routines associées à des signatures de paramètres différents sous le même nom de méthode. À titre d'exemple simple, supposons que nous voulions définir une méthode pour identifier les types de variables.

            pine
            
            
//@version=5
indicator("Type Inspection")

// @function   Identifies an object's type.
// @param this Object to inspect.
// @returns    (string) A string representation of the type.
method getType(int this) =>
    na(this) ? "int(na)" : "int"

method getType(float this) =>
    na(this) ? "float(na)" : "float"

method getType(bool this) =>
    na(this) ? "bool(na)" : "bool"

method getType(color this) =>
    na(this) ? "color(na)" : "color"

method getType(string this) =>
    na(this) ? "string(na)" : "string"

a = 1             // a.getType(): float
b = 1.0           // b.getType(): float
c = true          // c.getType(): bool
d = color.white   // d.getType(): string(na)
e = "1"           // e.getType(): string

runtime.log("a.getType():", a.getType())
runtime.log("b.getType():", b.getType())
runtime.log("c.getType():", c.getType())
runtime.log("d.getType():", d.getType())
runtime.log("e.getType():", e.getType())
runtime.error("stop")

Déterminer le type de base de chaque variablegetType()Quel type de surcharge sera utilisé? Sur la plateforme FMZ, les types de valeur numériques seront jugés comme des données de type float car la base de script PINE est implémentée dans le langage Javascript.

Fonctions intégrées

Les paramètres peuvent être transmis lors de l'appel d'une fonction, l'attribution d'un nom de paramètre peut être spécifiée, les variables peuvent être transmises directement à la position de paramètre correspondante, et l'utilisation mixte est également prise en charge. Par exemple:

            pine
            
            
plot(close, title="test plot")     // 直接传参数 close ；指定参数 title ，赋值字符串"test plot"

Une fois que le nom d'un paramètre a été attribué, il n'est plus possible de transmettre directement la variable en tant que paramètre, et les paramètres ultérieurs doivent être écrits sous la forme d'une attribution de nom de paramètre.

            pine
            
            
// plot(close, title="test", color.red)    // 虽然plot第三个参数是颜色值，但是这样写就会报错
plot(close, title="test", color=color.red) // 正确写法
plot(close, "test", color.red)             // 正确写法

timeframe

timeframe.in_seconds

Elle sera transmise àtimeframeLa période de temps du paramètre est convertie en secondes.

            
            
            
timeframe.in_seconds(timeframe)

Exemple

            pine
            
            
// Get chart timeframe:
i_tf = input.timeframe("1D")

// Convert timeframe to the int value (number of seconds in 1 Day):
tf = timeframe.in_seconds(i_tf)

plot(tf)

Retourne une valeur
timeframeLe nombre de secondes d'une ligne K est représenté sous la forme int ≠ ∞.

paramètre

• timeframe(simple string) Période de temps。 est facultative。 par défaut timeframe.period。

À noter
Pourtimeframe>= La fonction '1M' est calculée en fonction du nombre de secondes de 30,4167 (365/12) jours d'un mois.

Voir aussi
input.timeframe timeframe.period

ticker

ticker.heikinashi

Créer un identifiant de code qui demande une moyenne lisse de la valeur de la ligne K。

            
            
            
ticker.heikinashi(symbol)

Exemple

            pine
            
            
heikinashi_close = request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, close)

heikinashi_aapl_60_close = request.security(ticker.heikinashi(syminfo.tickerid), "60", close)
plot(heikinashi_close)
plot(heikinashi_aapl_60_close)

Retourne une valeur
La valeur de chaîne de caractères du code de stock peut être fournie à la fonction request.security 。

paramètre

• symbol(simple string) Identificateur de code de produit。

Voir aussi
syminfo.tickerid syminfo.ticker request.security

request

request.data

Nous demandons des données externes

            
            
            
request.data(url, attribute)

Exemple

            pine
            
            
/*backtest
start: 2024-09-01 16:00:00
end: 2024-10-10 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
args: [["RunMode",1,358374],["ZPrecision",0,358374]]
*/

var chart_data = "https://www.datadata.com/api/v1/query/ebe46218-c5c6-4366-8c72-413694417976/data"
spotPrice = request.data(chart_data, "$.spot_close_price")
futuresPrice = request.data(chart_data, "$.future_close_price")
diff = futuresPrice - spotPrice

plot(diff, "永续-现货差价")
plot(futuresPrice, "期货价格", overlay=true)
plot(spotPrice, "现货价格", overlay=true)

if diff > 80 and strategy.position_size >= 0
    runtime.log("diff > 80")
    strategy.entry("Enter Short", strategy.short)
if diff < 60 and strategy.position_size <= 0
    runtime.log("diff < 60")
    strategy.entry("Enter Short", strategy.long)

Retourne une valeur
paramètreattributeSéries de données désignées.

paramètre

• url(simple string) La requête est envoyée au format suivant:{"data": [], "schema": ["time", "data"]}Vous pouvez vous référer aux formats de données de l'exemple:

  
              json
              
              
  {
      "data": [
          [1720051200000, "{\"spot_close_price\" : 57050.01, \"future_close_price\" : 57045.9}"],
          [1720137600000, "{\"spot_close_price\" : 56628.79, \"future_close_price\" : 56604.9}"],
          // ...
      ],
      "schema": ["time", "data"]
  }
  

• attribute(simple string) Indique le nom de l'attribut et renvoie les données souhaitées. Par exemple:"$.spot_close_price",utiliser$.En tant que préfixe, le nom de l'attribut correspond à l'attribut dans le champ data dans les données qui sont répondues à la source de données de la requête

Si le message est erroné, vérifiez.request.dataSi la plage de temps demandée correspond à la plage de temps de réglage de la rétroaction, une erreur de requête de données non trouvées sur la séquence de temps de rétroaction sera signalée.

Dans cet exemple, data-data est une requête SQL:

            sql
            
            
WITH latest_data AS (
    SELECT 
        klines.spot_1d.Time AS time,
        CONCAT('{\"spot_close_price\" : ', klines.spot_1d.Close, ', \"future_close_price\" : ', klines.future_1d.Close, '}') AS data
    FROM 
        klines.spot_1d
    JOIN 
        klines.future_1d
    ON 
        klines.spot_1d.Time = klines.future_1d.Time
    WHERE
        klines.spot_1d.Symbol = 'btc_usdt'
    AND 
        klines.future_1d.Symbol = 'btc_usdt.swap'
    AND 
        klines.spot_1d.Exchange = 'Binance'
    AND 
        klines.future_1d.Exchange = 'Binance'
    ORDER BY 
        klines.spot_1d.Time DESC
    LIMIT 100
)
SELECT * FROM latest_data
ORDER BY time ASC;

Les vidéos sont disponibles sur la plateforme FMZExploration des donnéesRecherche de page, création de liens de données, comme dans l'exemplehttps://www.datadata.com/api/v1/query/ebe46218-c5c6-4366-8c72-413694417976/data。

request.security

Demandez une autre variété/résolution.

            
            
            
request.security(symbol, timeframe, expression, gaps, lookahead, ignore_invalid_symbol, currency) 

Exemple

            pine
            
            
s = request.security(syminfo.tickerid, "D", close)   // 1 Day
plot(s)

expr = ta.sma(close, 10)
s1 = request.security(syminfo.tickerid, "240", expr) // 240 Minutes
plot(s1)

// To avoid difference in calculation on history/realtime you can request not latest values and use merge strategy flags as follows:
s2 = request.security(syminfo.tickerid, "D", close[1], barmerge.gaps_off, barmerge.lookahead_on)
plot(s2)
f() => [open, high]
[o, h] = request.security(syminfo.tickerid, "D", f())
[l, c] = request.security(syminfo.tickerid, "D", [low, close])
plot((o + h + l + c) / 4)

Retourne une valeur
Séries de requêtes

paramètre

• symbol(simple string) Le code du produit.
• timeframe(simple string) Période de temps。 La chaîne vide sera interprétée comme étant la période de temps actuelle de la figure。
• expression(series int/float/bool/color) peut être calculé à partir d'un appel request.security et renvoie une expression. Il peut s'agir d'une série ou d'un sous-ensemble contenant des éléments qui peuvent être convertis en série.
• gaps(barmerge_gaps) Politique de fusion des données demandées (qui demande que les données soient fusionnées automatiquement avec les données de la série principale de l'OHLC). Valeur possible: barmerge.gaps_on, barmerge.gaps_off. barmerge.gaps_on - Les données demandées sont fusionnées avec les écarts possibles (valeur na).
• lookahead(barmerge_lookahead) Donne la stratégie de fusion de données demandée. Valeur possible: barmerge.lookahead_on, barmerge.lookahead_off. Depuis la version 3, la valeur par défaut est barmerge.lookahead_off.
• ignore_invalid_symbol(const bool) un paramètre optionnel. Si le produit spécifié n'est pas trouvé, le comportement de la fonction est déterminé: si false, le script s'arrête et retourne une erreur lors de l'exécution; si true, la fonction retourne na et continue l'exécution. La valeur par défaut est false.
• currency(simple string) Convertir la valeur relative à la devise de la marchandise (... par exemple OHLC) en devise. Puis calculer la valeur après la conversion. <unk>expression <unk>. Le taux de conversion utilisé est basé sur le taux de change quotidien du jour précédent de la paire FX_IDC (... par rapport à la ligne K calculée). Optionnel.

À noter
Le code PineScript qui utilise cette fonctionnalité permet d'effectuer des calculs différents pour les enregistrements historiques et les données en temps réel.
Si vous souhaitez spécifier des paramètres supplémentaires pour la marchandise demandée, tels que la période de transaction ou le type d'ajustement, vous pouvez utiliser la fonction ticker.new ().
Impossible d'utiliser la variable 'ticker' pour transmettre le décalage à cette fonction. Vous pouvez utiliser la variable 'ticker.new' ou la représentation en chaînes de caractères du code d'actions, par exemple AAPL+MSFT*TSLA”。
Actuellement, un script peut contenir jusqu'à 40 appels request.security.
Veuillez noter que l'utilisation de cette variable/fonction peut entraîner une redéfinition de l'indicateur.
Les paramètres de résolution autorisés sont:
1S, 5S, 15S, 30S - intervalles de secondes (la période du graphique doit être inférieure ou égale à la période demandée)
De 1 à 1440 minutes
de 1 à 365 jours
De 1 W à 52 W en quelques semaines
De 1 M à 12 M, plusieurs mois

Voir aussi
syminfo.ticker syminfo.tickerid timeframe.period ta.correlation barmerge.lookahead_off barmerge.lookahead_on

str

str.contains

Si voussourceLa chaîne contientstrLa sous-chaîne, retourne true, sinon retourne false

            
            
            
str.contains(source, str)

Exemple

            pine
            
            
// If the current chart is a continuous futures chart, e.g “BTC1!”, then the function will return true, false otherwise.
var isFutures = str.contains(syminfo.tickerid, "!")
plot(isFutures ? 1 : 0)

Retourne une valeur
Dans le cassourceTrouver dans une chaîne de caractèresstr, alors c'est vrai, sinon c'est faux.

paramètre

• source(series string) Chaîne de source
• str(series string) La sous-chaîne à rechercher.

Voir aussi
str.pos str.match

str.endswith

Si voussourceLes chaînes de caractèresstrLa sous-chaîne indiquée au début de la chaîne de caractères retourne true ou false.

            
            
            
str.endswith(source, str)

Retourne une valeur
Si voussourceLes chaînes de caractèresstrLa sous-chaîne indiquée dans la ligne de fin est vraie ou fausse.

paramètre

• source(series string) Chaîne de source
• str(series string) La sous-chaîne à rechercher.

Voir aussi
str.startswith

str.startswith

Si voussourceLes chaînes de caractèresstrLa sous-chaîne indiquée au début de la chaîne de caractères retourne true ou false.

            
            
            
str.startswith(source, str)

Retourne une valeur
Si voussourceLes chaînes de caractèresstrLa chaîne de caractères désignée dans le champ de la sous-chaîne débute par true, sinon par false.

paramètre

• source(series string) Chaîne de source
• str(series string) La sous-chaîne à rechercher.

Voir aussi
str.endswith

str.substring

Retourne une nouvelle chaîne, qui estsourceLes sous-chaînes de chaînes de caractères.begin_posLes caractères commencent à l'index spécifié et s'étendent àsourceLe "end_pos - 1'" de la chaîne de caractères.

            
            
            
str.substring(source, begin_pos)

            
            
            
str.substring(source, begin_pos, end_pos)

Exemple

            pine
            
            
sym= "EXCHANGE_NAME:SYMBOL_NAME"
pos = str.pos(sym, ":")        // Get position of ":" character
tkr= str.substring(sym, pos+1) // "SYMBOL_NAME"
if barstate.islastconfirmedhistory
    runtime.log(tkr)

Retourne une valeur
Les sous-chaînes extraites de la chaîne de caractères source.

paramètre

• source(series string) La chaîne de source à partir de laquelle est extraite la chaîne de sous-chaîne。
• begin_pos(series int) La position initiale de la sous-chaîne extraite。 elle est exclusive ((la sous-chaîne extraite inclut les caractères de cette position)。
• end_pos(series int) Localisation de la fin. Il est exclusif (la chaîne extraite n'inclut pas les caractères de cette position).sourceLa longueur de la chaîne de caractères

À noter
L'indexation de chaîne de caractères commence par 0 ≠ 0 ≠ 0 ≠ 0 ≠ 0 ≠ 0 ≠ 0 ≠ 0 ≠ 0 ≠ 0 ≠ 0 ≠ 0begin_poségalend_pos, la fonction renvoie une chaîne de caractères vide ≠ .

Voir aussi
str.contains str.pos str.match

str.tonumber

            
            
            
str.tonumber(string)

Retourne une valeur
Si elle contient des nombres valides, elle est de type floating point, sinon na。

paramètre

• string(series string) est une expression de type int ou float.

str.format

Conversion de chaînes de format et de valeurs en chaînes de format. Les chaînes de format peuvent contenir du texte et une case {} dans les parenthèses de chaque valeur à formater. Chaque case contient un index qui remplace les paramètres nécessaires (commençant par 0) et une case de format optionnelle. L'index indique la position du paramètre dans la liste de paramètres str.format.

            
            
            
str.format(formatString, arg0, arg1, ...)

Exemple

            pine
            
            
// The format specifier inside the curly braces accepts certain modifiers:
// - Specify the number of decimals to display:
s1 = str.format("{0,number,#.#}", 1.34) // returns: 1.3
runtime.log(s1)

// - Round a float value to an integer:
s2 = str.format("{0,number,integer}", 1.34) // returns: 1
runtime.log(s2)

// - Display a number in currency:
s3 = str.format("{0,number,currency}", 1.34) // returns: $1.34
runtime.log(s3)

// - Display a number as a percentage:
s4 = str.format("{0,number,percent}", 0.5) // returns: 50%
runtime.log(s4)

// EXAMPLES WITH SEVERAL ARGUMENTS
// returns: Number 1 is not equal to 4
s5 = str.format("Number {0} is not {1} to {2}", 1, "equal", 4)
runtime.log(s5)

// returns: 1.34 != 1.3
s6 = str.format("{0} != {0, number, #.#}", 1.34)
runtime.log(s6)

// returns: 1 is equal to 1, but 2 is equal to 2
s7 = str.format("{0, number, integer} is equal to 1, but {1, number, integer} is equal to 2", 1.34, 1.52)
runtime.log(s7)

// returns: The cash turnover amounted to $1,340,000.00
s8 = str.format("The cash turnover amounted to {0, number, currency}", 1340000)
runtime.log(s8)

// returns: Expected return is 10% - 20%
s9 = str.format("Expected return is {0, number, percent} - {1, number, percent}", 0.1, 0.2)
runtime.log(s9)

Retourne une valeur
Une chaîne de caractères formatée.

paramètre

• formatString(series string) est une chaîne de caractères formatée。
• arg0, arg1, ... (series int/float/bool/string/na/int[]/float[]/bool[]/string[]) La valeur à formater.

À noter
Tous les parenthèses dans les styles non cités doivent être équilibrés. Par exemple, "ab {0} de" et "ab '}' de" sont des styles valides, mais "ab {0'}' de", "ab } de" et "'{''" ne le sont pas.

str.length

Renvoie un nombre entier correspondant au nombre de caractères de la chaîne.

            
            
            
str.length(string)

Retourne une valeur
Nombre de caractères dans la chaîne de caractères source.

paramètre

• string(series string) Chaîne de source

str.lower

Retourne une nouvelle chaîne de caractères où toutes les lettres ont été converties en minuscules.

            
            
            
str.lower(source)

Retourne une valeur
Toutes les lettres sont converties en une nouvelle chaîne de caractères minuscules.

paramètre

• source(series string) La chaîne de caractères à convertir

Voir aussi
str.upper

str.upper

Renvoie une nouvelle chaîne de caractères où toutes les lettres sont transposées en majuscules.

            
            
            
str.upper(source)

Retourne une valeur
Toutes les lettres ont été converties en une nouvelle chaîne de caractères en majuscules.

paramètre

• source(series string) La chaîne de caractères à convertir

Voir aussi
str.lower

str.match

Si une correspondanceregexUne expression régulière renvoiesourceLa nouvelle sous-chaîne de la chaîne de caractères retourne 'na'

            
            
            
str.match(source, regex) 

Exemple

            pine
            
            
s = input.string("It's time to sell some EXCHANGE_NAME:SYMBOL_NAME!")

// finding first substring that matches regular expression "[\w]+:[\w]+"
var string tickerid = str.match(s, "[\\w]+:[\\w]+")

if barstate.islastconfirmedhistory
    runtime.log(tickerid) // "EXCHANGE_NAME:SYMBOL_NAME"

Retourne une valeur
sourceLa nouvelle sous-chaîne de chaîne de caractères, si elle correspond à unregexL'expression régulière est 'na' <unk>

paramètre

• source(series string) Chaîne de source
• regex(series string) Expression régulière correspondant à cette chaîne de caractères。

À noter
Fonction RenvoiesourceExpression régulière qui apparaît pour la première fois dans une chaîne de caractères:
regexLes caractères en contre-classique <unk> dans une chaîne de caractères nécessitent l'utilisation de contre-classiques supplémentaires pour la translittération, par exemple <unk>\d<unk> représente l'expression régulière <unk>\d<unk>。

Voir aussi
str.contains str.substring

str.pos

Le retour.sourcePremière apparition dans la chaînestrLa position de la chaîne de caractères, sinon retourne 'na'。

            
            
            
str.pos(source, str)

Retourne une valeur
strLa chaîne de caractèressourcePosition dans la chaîne de caractères.

paramètre

• source(series string) Chaîne de source
• str(series string) La sous-chaîne à rechercher.

À noter
L'index de chaîne de caractères commence par 0。

Voir aussi
str.contains str.match str.substring

str.replace

Renvoie une nouvelle chaîne de caractères dont la première occurrence est N+1targetChaînes de caractères et précédentstargetLa chaîne est remplacée parreplacementUne chaîne de caractères où N estoccurrenceN est l'index de correspondance qui apparaît dans la chaîne de source.

            
            
            
str.replace(source, target, replacement, occurrence)

Exemple

            pine
            
            
var source = "EXCHANGE1:SYMBOL1 / EXCHANGE1:SYMBOL2"

// Replace first occurrence of "EXCHANGE1" with "EXCHANGE2" replacement string
var newSource = str.replace(source, "EXCHANGE1",  "EXCHANGE2", 0)

if barstate.islastconfirmedhistory
    // Display "EXCHANGE2:SYMBOL1 / EXCHANGE1:SYMBOL2"
    runtime.log(newSource)

Retourne une valeur
Chaînes traitées

paramètre

• source(series string) Chaîne de source
• target(series string) est remplacé par une chaîne
• replacement(series string) La chaîne à insérer au lieu de la chaîne cible.
• occurrence(series int) L'index de correspondance de la chaîne cible à remplacer apparaît dans la chaîne source. Le premier index de correspondance commence à 0.

Voir aussi
str.replace_all str.match

str.replace_all

On remplace les chaînes de caractères par des chaînes de caractères cibles qui apparaissent à chaque fois dans la chaîne source.

            
            
            
str.replace_all(source, target, replacement)

Retourne une valeur
Chaînes traitées

paramètre

• source(series string) Chaîne de source
• target(series string) est remplacé par une chaîne
• replacement(series string) Chaque fois que la chaîne cible apparaît, elle est remplacée par une chaîne

str.split

Divise les chaînes en sous-chaînes et renvoie leur ID d'array.

            
            
            
str.split(string, separator)

Retourne une valeur
ID de la chaîne de caractères

paramètre

• string(series string) Chaîne de source
• separator(series string) Une chaîne séparant chaque sous-chaîne.

str.tostring

            
            
            
str.tostring(value)

            
            
            
str.tostring(value, format)

            
            
            
str.tostring(value[])

            
            
            
str.tostring(value[], format)

Retourne une valeur
valueLes chaînes de caractères des paramètres sont représentées sous la forme:
Si vousvalueSi le paramètre est une chaîne de caractères, elle est renvoyée comme telle.
QuandvaluePour na, la fonction renvoie la chaîne de caractères NaN<unk>.

paramètre

• value (series int/float/bool/string/int[]/float[]/bool[]/string[]) dont l'élément est converti en une valeur de chaîne ou en un ID d'array.
• format (series string) Format string. Accepts these format.* constants: format.mintick, format.percent, format.volume. Optional. The default value is '#.##########'.

À noter
Les formats avec des valeurs en floats sont également encadrés si nécessaire, par exemple str.tostring ((3.99, '#') renvoie <unk>4<unk>。
Pour afficher le zéro suivi d'un zéro, utilisez '0' au lieu de '#'. Par exemple, '#.000'
Lorsqu'on utilise format.mintick, cette valeur est ronde jusqu'au nombre le plus proche qui peut être divisé par syminfo.mintick sans résidu. Les chaînes retournées sont suivies de zéros.
Si le paramètre x est une chaîne de caractères, elle renvoie la même valeur de chaîne de caractères。
Les arguments de type Bool renvoient soit true soit false.
Lorsque x est na, la fonction renvoie <unk>NaN<unk>。

color

color.new

La couleur de fonction spécifie la transparence appliquée à une couleur donnée.

            
            
            
color.new(color, transp)

Exemple

            pine
            
            
plot(close, color=color.new(color.red, 50))

Retourne une valeur
Les couleurs ont une certaine transparence.

paramètre

• color (series color)
• transp(series int/float) Les valeurs disponibles sont de 0 (non visible) à 100 (non visible)

À noter
L'utilisation d'un nombre exorbitant de paramètres (par exemple, <unk>simple<unk>, <unk>input<unk> ou <unk>series<unk>) affectera la couleur affichée dans la page de balises des paramètres / balises de style du script. Veuillez consulter le manuel de l'utilisateur pour plus d'informations.

color.rgb

Créer de nouvelles couleurs avec transparence en utilisant le modèle de couleur RGB.

            
            
            
color.rgb(red, green, blue, transp)

Exemple

            pine
            
            
plot(close, color=color.rgb(255, 0, 0, 50))

Retourne une valeur
Les couleurs ont une certaine transparence.

paramètre

• red(series int/float) Couleur rouge. Les valeurs possibles sont de 0 à 255
• green(series int/float) Le vert. Les valeurs possibles sont de 0 à 255
• blue(series int/float) La tonalité bleue. Les valeurs possibles sont de 0 à 255.
• transp(series int/float) est facultative. La couleur est transparente. Les valeurs possibles vont de 0 (non-transparent) à 100 (transparent). La valeur par défaut est 0 (transparent).

À noter
L'utilisation d'un nombre exorbitant de paramètres (par exemple, <unk>simple<unk>, <unk>input<unk> ou <unk>series<unk>) affectera la couleur affichée dans la page de balises des paramètres / balises de style du script. Veuillez consulter le manuel de l'utilisateur pour plus d'informations.

runtime

runtime.debug

Imprimer les informations sur les variables dans la console.

FMZ PINE possède une fonctionnalité spécifique.runtime.debug(value)Il n'y a qu'un seul paramètre.

runtime.log

La sortie du journal.

FMZ PINE possède une fonctionnalité spécifique.runtime.log(1, 2, 3, close, high, ...), qui peut transmettre plusieurs paramètres.

runtime.error

L'appel peut entraîner des erreurs de fonctionnement et entraîner des erreurs de connexion.messageLe message d'erreur indiqué dans le paramètre:

            
            
            
runtime.error(message)

paramètre
message (series string) est un message d'erreur.

input

input

Ajoutez l'input à la page de balises d'entrée des paramètres du script, qui vous permet de fournir des options de configuration aux utilisateurs du script. Cette fonction détecte automatiquement le type de paramètre utilisé dans la barre de défilement et utilise le plugin d'entrée correspondant.

            
            
            
input(defval, title, tooltip, inline, group)

            
            
            
input(defval, title, inline, group, tooltip)

Exemple

            pine
            
            
i_switch = input(true, "On/Off")     // 设置true，默认勾选
plot(i_switch ? open : na)

i_len = input(7, "Length")
i_src = input(close, "Source")       // 下拉框，默认选择close
plot(ta.sma(i_src, i_len))

i_col = input(color.red, "Plot Color")
plot(close, color=i_col)

i_text = input("Hello!", "Message")
runtime.log(i_text)

Retourne une valeur
Valeur de la variable

paramètre

• defval(const int/float/bool/string/color or source-type built-ins) Définit la valeur par défaut de la variable d'entrée recommandée dans la page de balises de balises / balises d'entrée du script, à partir de laquelle les utilisateurs du script peuvent la modifier. La fonction de balisage de type source est une variable de balisage de série intégrée spécifiant la source de calcul:close、hlc3Et ainsi de suite.
• title(const string) Titre de la chaîne de caractères. Si ce n'est pas spécifié, le nom de la variable est utilisé comme titre de la chaîne de caractères. Si un titre est spécifié mais vide, le nom est une chaîne de caractères vide.
• tooltip(const string) Cette chaîne est affichée à l'utilisateur lorsque la souris est suspendue sur l'icône de l'invite de l'outil.
• inline(const string) Combine tous les appels d'entrée utilisant les mêmes paramètres dans une seule ligne. Il n'affiche pas les chaînes utilisées comme paramètres. Il est utilisé uniquement pour identifier les entrées appartenant à la même ligne.
• group(const string) Création d'un titre au-dessus de toutes les entrées en utilisant la même chaîne de caractères composite. Cette chaîne de caractères est également utilisée comme texte de titre.

À noter
Le retour d'une fonction d'entrée doit toujours être attribué à une variable. Voir l'exemple ci-dessus.

Voir aussi
input.bool input.color input.int input.float input.string input.timeframe input.source

input.source

Ajouter l'input à la page de balises d'entrée des paramètres du script, qui vous permet de fournir des options de configuration aux utilisateurs du script. Cette fonctionnalité a ajouté un menu déroulant permettant aux utilisateurs de choisir la source de calcul, par exemple close, hl2 etc. Si le script ne contient qu'un seul appel input.source (), les utilisateurs peuvent également choisir un autre indicateur sur le graphique comme source de sortie.

            
            
            
input.source(defval, title, tooltip, inline, group)

Exemple

            pine
            
            
i_src = input.source(close, "Source")
plot(i_src)

Retourne une valeur
Valeur de la variable

paramètre

• defval(series int/float) Détermine la valeur par défaut de la variable d'entrée recommandée dans la page de balises de balises / balises d'entrée du script, à partir de laquelle l'utilisateur peut la modifier.
• title(const string) Titre de la chaîne de caractères. Si ce n'est pas spécifié, le nom de la variable est utilisé comme titre de la chaîne de caractères. Si un titre est spécifié mais vide, le nom est une chaîne de caractères vide.
• tooltip(const string) Cette chaîne est affichée à l'utilisateur lorsque la souris est suspendue sur l'icône de l'invite de l'outil.
• inline(const string) Combine tous les appels d'entrée utilisant les mêmes paramètres dans une seule ligne. Il n'affiche pas les chaînes utilisées comme paramètres. Il est utilisé uniquement pour identifier les entrées appartenant à la même ligne.
• group(const string) Création d'un titre au-dessus de toutes les entrées en utilisant la même chaîne de caractères composite. Cette chaîne de caractères est également utilisée comme texte de titre.

À noter
Le résultat de la fonction input.source doit toujours être attribué à une variable, comme dans l'exemple ci-dessus.

Voir aussi
input.bool input.int input.float input.string input.timeframe input.color input

input.string

Ajouter l'input à la barre d'options d'entrée du script, qui vous permet de fournir des options de configuration aux utilisateurs du script. Cette fonction ajoute le champ d'entrée de chaîne à l'entrée du script.

            
            
            
input.string(defval, title, options, tooltip, inline, group, confirm)

Exemple

            pine
            
            
i_text = input.string("Hello!", "Message")
runtime.log(i_text)

Retourne une valeur
Valeur de la variable

paramètre

• defval(const string) Définit la valeur par défaut d'une variable d'entrée recommandée dans la page de balises de balises / balises d'entrée du script, à partir de laquelle l'utilisateur peut la modifier.optionsLorsque les paramètres sont utilisés ensemble, la valeur doit être l'une d'entre elles.
• title(const string) Titre de la chaîne de caractères. Si ce n'est pas spécifié, le nom de la variable est utilisé comme titre de la chaîne de caractères. Si un titre est spécifié mais vide, le nom est une chaîne de caractères vide.
• options (List of constants: [La liste des options disponibles.
• tooltip(const string) Cette chaîne est affichée à l'utilisateur lorsque la souris est suspendue sur l'icône de l'invite de l'outil.
• inline(const string) Combine tous les appels d'entrée utilisant les mêmes paramètres dans une seule ligne. Il n'affiche pas les chaînes utilisées comme paramètres. Il est utilisé uniquement pour identifier les entrées appartenant à la même ligne.
• group(const string) Création d'un titre au-dessus de toutes les entrées en utilisant la même chaîne de caractères composite. Cette chaîne de caractères est également utilisée comme texte de titre.
• confirm(const bool) Si true, l'utilisateur est invité à confirmer les valeurs de saisie. La valeur par défaut est false.

À noter
Le résultat de la fonction input.string devrait toujours être attribué à une variable, comme dans l'exemple ci-dessus.

Voir aussi
input.bool input.int input.float input.timeframe input.source input.color input

input.bool

Ajoutez l'input à la page de balises d'entrée des paramètres du script, qui vous permet de fournir des options de configuration aux utilisateurs du script. Cette fonction ajoute une balise de sélection aux entrées du script.

            
            
            
input.bool(defval, title, tooltip, inline, group, confirm)

Exemple

            pine
            
            
i_switch = input.bool(true, "On/Off")
plot(i_switch ? open : na)

Retourne une valeur
Valeur de la variable

paramètre

• defval(const bool) Détermine la valeur par défaut de la variable d'entrée recommandée dans la page de balises de balises / balises d'entrée du script, à partir de laquelle l'utilisateur peut la modifier.
• title(const string) Titre de la chaîne de caractères. Si ce n'est pas spécifié, le nom de la variable est utilisé comme titre de la chaîne de caractères. Si un titre est spécifié mais vide, le nom est une chaîne de caractères vide.
• tooltip(const string) Cette chaîne est affichée à l'utilisateur lorsque la souris est suspendue sur l'icône de l'invite de l'outil.
• inline(const string) Combine tous les appels d'entrée utilisant les mêmes paramètres dans une seule ligne. Il n'affiche pas les chaînes utilisées comme paramètres. Il est utilisé uniquement pour identifier les entrées appartenant à la même ligne.
• group(const string) Création d'un titre au-dessus de toutes les entrées en utilisant la même chaîne de caractères composite. Cette chaîne de caractères est également utilisée comme texte de titre.
• confirm(const bool) Si true, l'utilisateur est invité à confirmer les valeurs de saisie. La valeur par défaut est false.

À noter
Le résultat de la fonction input.bool doit toujours être attribué à une variable, comme dans l'exemple ci-dessus.

Voir aussi
input.int input.float input.string input.timeframe input.source input.color input

input.int

Ajouter l'input à la page de balises d'entrée des paramètres du script, qui vous permet de fournir des options de configuration aux utilisateurs du script. Cette fonction ajoute les champs d'entrée entiers à l'entrée du script.

            
            
            
input.int(defval, title, minval, maxval, step, tooltip, inline, group, confirm) 

            
            
            
input.int(defval, title, options, tooltip, inline, group, confirm)

Exemple

            pine
            
            
i_len1 = input.int(10, "Length 1", minval=5, maxval=21, step=1)
plot(ta.sma(close, i_len1))

i_len2 = input.int(10, "Length 2", options=[5, 10, 21])
plot(ta.sma(close, i_len2))

Retourne une valeur
Valeur de la variable

paramètre

• defval(const int) Détermine la valeur par défaut d'une variable d'entrée recommandée dans la page de balises de balises / balises d'entrée du script, à partir de laquelle l'utilisateur du script peut la modifier.optionsLorsque les paramètres sont utilisés ensemble, la valeur doit être l'une d'entre elles.
• title(const string) Titre de la chaîne de caractères. Si ce n'est pas spécifié, le nom de la variable est utilisé comme titre de la chaîne de caractères. Si un titre est spécifié mais vide, le nom est une chaîne de caractères vide.
• minval(const int) La valeur la plus petite possible de la variable d'entrée.
• maxval(const int) La valeur maximale possible de la variable d'entrée.
• step(const int) valeur de longueur d'étape utilisée pour augmenter/réduire l'entrée. Optionnel. La valeur par défaut est 1
• options (tuple of const int values: [val1, val2, ...]) Liste des options sélectionnées dans le menu déroulant, séparées par des virgules et encadrées par des parenthèses carrées:[val1, val2, ...] <unk> ne peut pas être utilisé avec ce paramètreminval、maxvaletstepParamètres
• tooltip(const string) Cette chaîne est affichée à l'utilisateur lorsque la souris est suspendue sur l'icône de l'invite de l'outil.
• inline(const string) Combine tous les appels d'entrée utilisant les mêmes paramètres dans une seule ligne. Il n'affiche pas les chaînes utilisées comme paramètres. Il est utilisé uniquement pour identifier les entrées appartenant à la même ligne.
• group(const string) Création d'un titre au-dessus de toutes les entrées en utilisant la même chaîne de caractères composite. Cette chaîne de caractères est également utilisée comme texte de titre.
• confirm(const bool) Si true, l'utilisateur est invité à confirmer les valeurs de saisie. La valeur par défaut est false.

À noter
Le résultat de la fonction input.int doit toujours être attribué à une variable, comme dans l'exemple ci-dessus.

Voir aussi
input.bool input.float input.string input.timeframe input.source input.color input

input.float

Ajouter l'input à la page de balises d'entrée des paramètres du script, qui vous permet d'offrir des options de configuration aux utilisateurs du script. Cette fonction ajoute le champ d'entrée des points flottants à l'entrée du script.

            
            
            
input.float(defval, title, minval, maxval, step, tooltip, inline, group, confirm)

            
            
            
input.float(defval, title, options, tooltip, inline, group, confirm)

Exemple

            pine
            
            
i_angle1 = input.float(0.5, "Sin Angle", minval=-3.14, maxval=3.14, step=0.02)
plot(math.sin(i_angle1) > 0 ? close : open, "sin", color=color.green)

i_angle2 = input.float(0, "Cos Angle", options=[-3.14, -1.57, 0, 1.57, 3.14])
plot(math.cos(i_angle2) > 0 ? close : open, "cos", color=color.red)

Retourne une valeur
Valeur de la variable

paramètre

• defval(const int/float) Détermine la valeur par défaut d'une variable d'entrée recommandée dans la page de balises de paramétrage / balise d'entrée du script, à partir de laquelle l'utilisateur du script peut la modifier.optionsLorsque les paramètres sont utilisés ensemble, la valeur doit être l'une d'entre elles.
• title(const string) Titre de la chaîne de caractères. Si ce n'est pas spécifié, le nom de la variable est utilisé comme titre de la chaîne de caractères. Si un titre est spécifié mais vide, le nom est une chaîne de caractères vide.
• minval(const int/float) La valeur la plus petite possible de la variable d'entrée.
• maxval(const int/float) La valeur la plus élevée possible pour une variable de saisie.
• step(const int/float) valeur de longueur d'étape utilisée pour augmenter/réduire l'entrée. Optionnel. La valeur par défaut est 1
• options (tuple of const int/float values: [val1, val2, ...]) Liste des options sélectionnées dans le menu déroulant, séparées par des virgules et encadrées par des parenthèses carrées:[val1, val2, ...] <unk> ne peut pas être utilisé avec ce paramètreminval、maxvaletstepParamètres
• tooltip(const string) Cette chaîne est affichée à l'utilisateur lorsque la souris est suspendue sur l'icône de l'invite de l'outil.
• inline(const string) Combine tous les appels d'entrée utilisant les mêmes paramètres dans une seule ligne. Il n'affiche pas les chaînes utilisées comme paramètres. Il est utilisé uniquement pour identifier les entrées appartenant à la même ligne.
• group(const string) Création d'un titre au-dessus de toutes les entrées en utilisant la même chaîne de caractères composite. Cette chaîne de caractères est également utilisée comme texte de titre.
• confirm(const bool) Si true, l'utilisateur est invité à confirmer les valeurs de saisie. La valeur par défaut est false.

À noter
Le résultat de la fonction input.float devrait toujours être attribué à une variable, comme dans l'exemple ci-dessus.

Voir aussi
input.bool input.int input.string input.timeframe input.source input.color input

input.color

Ajoutez l'input à la page de balises d'entrée des paramètres du script, qui vous permet de fournir des options de configuration aux utilisateurs du script. Cette fonction ajoute un sélecteur de couleur qui permet aux utilisateurs de choisir la couleur et la transparence à partir d'une palette de couleurs ou de valeurs à 16 chiffres.

            
            
            
input.color(defval, title, tooltip, inline, group, confirm) 

Exemple

            pine
            
            
i_col = input.color(color.red, "Plot Color")
plot(close, color=i_col)

Retourne une valeur
Valeur de la variable

paramètre

• defval(const color) Détermine la valeur par défaut de la variable d'entrée recommandée dans la page de balises de balises / balises d'entrée du script, à partir de laquelle l'utilisateur peut la modifier.
• title(const string) Titre de la chaîne de caractères. Si ce n'est pas spécifié, le nom de la variable est utilisé comme titre de la chaîne de caractères. Si un titre est spécifié mais vide, le nom est une chaîne de caractères vide.
• tooltip(const string) Cette chaîne est affichée à l'utilisateur lorsque la souris est suspendue sur l'icône de l'invite de l'outil.
• inline(const string) Combine tous les appels d'entrée utilisant les mêmes paramètres dans une seule ligne. Il n'affiche pas les chaînes utilisées comme paramètres. Il est utilisé uniquement pour identifier les entrées appartenant à la même ligne.
• group(const string) Création d'un titre au-dessus de toutes les entrées en utilisant la même chaîne de caractères composite. Cette chaîne de caractères est également utilisée comme texte de titre.
• confirm(const bool) Si true, l'utilisateur est invité à confirmer les valeurs de saisie. La valeur par défaut est false.

À noter
Le résultat de la fonction input.color doit toujours être attribué à une variable, comme dans l'exemple ci-dessus.

Voir aussi
input.bool input.int input.float input.string input.timeframe input.source input

input.price

Ajouter une entrée de prix à la page de balises des paramètres / entrées de balises du script. Utiliserconfirm = trueActivez le mode d'entrée interactif et sélectionnez le prix en cliquant sur le graphique.

            
            
            
input.price(defval, title, tooltip, inline, group, confirm) 

Exemple

            pine
            
            
price1 = input.price(title="Date", defval=42)
plot(price1)

price2 = input.price(54, title="Date")
plot(price2)

Retourne une valeur
Valeur de la variable

paramètre

• defval(const int/float) Détermine la valeur par défaut d'une variable d'entrée recommandée dans la page de balises de paramétrage / balise d'entrée du script, à partir de laquelle l'utilisateur peut la modifier.
• title(const string) Titre de la chaîne de caractères. Si ce n'est pas spécifié, le nom de la variable est utilisé comme titre de la chaîne de caractères. Si un titre est spécifié mais vide, le nom est une chaîne de caractères vide.
• tooltip(const string) Cette chaîne est affichée à l'utilisateur lorsque la souris est suspendue sur l'icône de l'invite de l'outil.
• inline(const string) Combine tous les appels d'entrée utilisant les mêmes paramètres dans une seule ligne. Il n'affiche pas les chaînes utilisées comme paramètres. Il est utilisé uniquement pour identifier les entrées appartenant à la même ligne.
• group(const string) Création d'un titre au-dessus de toutes les entrées en utilisant la même chaîne de caractères composite. Cette chaîne de caractères est également utilisée comme texte de titre.
• confirm(const bool) Si true, le mode d'entrée interactive est activé et la sélection est effectuée en cliquant sur le graphique lorsque l'indicateur est ajouté au graphique, ou en sélectionnant l'indicateur et en déplaçant la sélection par la suite. Optionnel. La valeur par défaut est false.

À noter
En mode interactif, si deux fonctions s'appellent l'une sur l'autreinlineSi les paramètres utilisent les mêmes paramètres, l'entrée de temps peut être combinée à l'entrée de prix.

Voir aussi
input.bool input.int input.float input.string input.resolution input.source input.color input

input.timeframe

Ajoutez l'input à la page de balises d'entrée des paramètres du script, qui vous permet de fournir des options de configuration aux utilisateurs du script. Cette fonction ajoute une liste déroulante qui permet à l'utilisateur de sélectionner une période de temps spécifique via le sélecteur de période de temps et de la renvoyer sous forme de chaîne de caractères. Le sélecteur inclut les périodes de temps que l'utilisateur peut utiliser dans le graphique et les périodes de temps personnalisées ajoutées par le menu déroulant.

            
            
            
input.timeframe(defval, title, options, tooltip, inline, group, confirm)

Exemple

            pine
            
            
i_res = input.timeframe('D', "Resolution", options=['D', 'W', 'M'])
s = request.security(syminfo.tickerid, i_res, close)
plot(s)

Retourne une valeur
Valeur de la variable

paramètre

• defval(const string) Définit la valeur par défaut d'une variable d'entrée recommandée dans la page de balises de balises / balises d'entrée du script, à partir de laquelle l'utilisateur peut la modifier.optionsLorsque les paramètres sont utilisés ensemble, la valeur doit être l'une d'entre elles.
• title(const string) Titre de la chaîne de caractères. Si ce n'est pas spécifié, le nom de la variable est utilisé comme titre de la chaîne de caractères. Si un titre est spécifié mais vide, le nom est une chaîne de caractères vide.
• options (tuple of const string values: [val1, val2, ...]) liste des options à choisir.
• tooltip(const string) Cette chaîne est affichée à l'utilisateur lorsque la souris est suspendue sur l'icône de l'invite de l'outil.
• inline(const string) Combine tous les appels d'entrée utilisant les mêmes paramètres dans une seule ligne. Il n'affiche pas les chaînes utilisées comme paramètres. Il est utilisé uniquement pour identifier les entrées appartenant à la même ligne.
• group(const string) Création d'un titre au-dessus de toutes les entrées en utilisant la même chaîne de caractères composite. Cette chaîne de caractères est également utilisée comme texte de titre.
• confirm(const bool) Si true, l'utilisateur est invité à confirmer les valeurs de saisie. La valeur par défaut est false.

À noter
Le résultat de la fonction input.timeframe doit toujours être attribué à une variable, comme dans l'exemple ci-dessus.

Voir aussi
input.bool input.int input.float input.string input.source input.color input

input.integer

Pas encore

input.resolution

Pas encore

ta

ta.alma

La moyenne mobile d'Arnaud Legoux. Elle utilise la distribution de Gauss comme pondération de la moyenne mobile.

            
            
            
ta.alma(series, length, offset, sigma) 

            
            
            
ta.alma(series, length, offset, sigma, floor) 

Exemple

            pine
            
            
plot(ta.alma(close, 9, 0.85, 6))

// same on pine, but much less efficient
pine_alma(series, windowsize, offset, sigma) =>
    m = offset * (windowsize - 1)
    //m = math.floor(offset * (windowsize - 1)) // Used as m when math.floor=true
    s = windowsize / sigma
    norm = 0.0
    sum = 0.0
    for i = 0 to windowsize - 1
        weight = math.exp(-1 * math.pow(i - m, 2) / (2 * math.pow(s, 2)))
        norm := norm + weight
        sum := sum + series[windowsize - i - 1] * weight
    sum / norm
plot(pine_alma(close, 9, 0.85, 6))

Retourne une valeur
Arnaud Legoux avec une moyenne mobile

paramètre

• series(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).
• offset(simple int/float) Le contrôle de la balance entre la fluidité (plus proche de 1) et la réactivité (plus proche de 0).
• sigma(simple int/float) modifie la douceur d'ALMA. Plus la sigma est grande, plus ALMA est douce.
• floor(simple bool) Paramètre facultatif. Avant de calculer ALMA, spécifiez si le calcul de la déviation est une limite inférieure. La valeur par défaut est false.

Voir aussi
ta.sma ta.ema ta.rma ta.wma ta.vwma ta.swma

ta.sma

La fonction sma renvoie la moyenne mobile, c'est-à-dire la dernière valeur y de x, divisée par y。

            
            
            
ta.sma(source, length) 

Exemple

            pine
            
            
plot(ta.sma(close, 15))

// same on pine, but much less efficient
pine_sma(x, y) =>
    sum = 0.0
    for i = 0 to y - 1
        sum := sum + x[i] / y
    sum
plot(pine_sma(close, 15))

Retourne une valeur
lengthLa ligne K est retournéesourceLa moyenne mobile simple des résultats de l'enquête.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

Voir aussi
ta.ema ta.rma ta.wma ta.vwma ta.swma ta.alma

ta.cog

cog est un indicateur basé sur la statistique et le ratio d'or de Fibonacci.

            
            
            
ta.cog(source, length) 

Exemple

            pine
            
            
plot(ta.cog(close, 10))

// the same on pine
pine_cog(source, length) =>
    sum = math.sum(source, length)
    num = 0.0
    for i = 0 to length - 1
        price = source[i]
        num := num + price * (i + 1)
    -num / sum

plot(pine_cog(close, 10))

Retourne une valeur
Le cœur

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

Voir aussi
ta.stoch

ta.dev

Différence entre une série de mesures et une autre

            
            
            
ta.dev(source, length) 

Exemple

            pine
            
            
plot(ta.dev(close, 10))

// the same on pine
pine_dev(source, length) =>
    mean = ta.sma(source, length)
    sum = 0.0
    for i = 0 to length - 1
        val = source[i]
        sum := sum + math.abs(val - mean)
    dev = sum/length
plot(pine_dev(close, 10))

Retourne une valeur
lengthLa ligne K est retournéesourceLe décalage.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

Voir aussi
ta.variance ta.stdev

ta.stdev

            
            
            
ta.stdev(source, length, biased) 

Exemple

            pine
            
            
plot(ta.stdev(close, 5))

//the same on pine
isZero(val, eps) => math.abs(val) <= eps

SUM(fst, snd) =>
    EPS = 1e-10
    res = fst + snd
    if isZero(res, EPS)
        res := 0
    else
        if not isZero(res, 1e-4)
            res := res
        else
            15

pine_stdev(src, length) =>
    avg = ta.sma(src, length)
    sumOfSquareDeviations = 0.0
    for i = 0 to length - 1
        sum = SUM(src[i], -avg)
        sumOfSquareDeviations := sumOfSquareDeviations + sum * sum

    stdev = math.sqrt(sumOfSquareDeviations / length)
plot(pine_stdev(close, 5))

Retourne une valeur
Échelle de référence

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).
• biased(series bool) Détermine quelle estimation doit être utilisée. Optionnel. La valeur par défaut est true.

À noter
Si vousbiasedSi c'est vrai, la fonction utilise une estimation partielle de l'ensemble, et si c'est faux, une estimation sans partialité de l'échantillon.

Voir aussi
ta.dev ta.variance

ta.ema

La fonction ema renvoie une moyenne mobile pondérée. Dans ema, le facteur de pondération est décroissant. Elle est calculée selon la formule suivante: EMA = alpha * source + (1 - alpha) * EMA[1], où alpha = 2 / (longueur + 1) ◦

            
            
            
ta.ema(source, length) 

Exemple

            pine
            
            
plot(ta.ema(close, 15))

//the same on pine
pine_ema(src, length) =>
    alpha = 2 / (length + 1)
    sum = 0.0
    sum := na(sum[1]) ? src : alpha * src + (1 - alpha) * nz(sum[1])
plot(pine_ema(close,15))

Retourne une valeur
sourceLa moyenne mobile exponentielle, alpha = 2 / (longueur + 1) ◦

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(simple int) Nombre de lignes K (longueur).

À noter
Veuillez noter que l'utilisation de cette variable/fonction peut entraîner une redéfinition de l'indicateur.

Voir aussi
ta.sma ta.rma ta.wma ta.vwma ta.swma ta.alma

ta.wma

La fonction wma renvoielengthLa ligne KsourceDans wma, le facteur de pondération est décroissant en degrés arithmétiques.

            
            
            
ta.wma(source, length) 

Exemple

            pine
            
            
plot(ta.wma(close, 15))

// same on pine, but much less efficient
pine_wma(x, y) =>
    norm = 0.0
    sum = 0.0
    for i = 0 to y - 1
        weight = (y - i) * y
        norm := norm + weight
        sum := sum + x[i] * weight
    sum / norm
plot(pine_wma(close, 15))

Retourne une valeur
lengthLa ligne K est retournéesourceUne moyenne mobile pondérée.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

Voir aussi
ta.sma ta.ema ta.rma ta.vwma ta.swma ta.alma

ta.swma

Moyenne symétrique pondérée en mouvement de longueur fixe: 4.[1/6,2 / 6,2 / 6,1 / 6]。

            
            
            
ta.swma(source)

Exemple

            pine
            
            
plot(ta.swma(close))

// same on pine, but less efficient
pine_swma(x) =>
    x[3] * 1 / 6 + x[2] * 2 / 6 + x[1] * 2 / 6 + x[0] * 1 / 6
plot(pine_swma(close))

Retourne une valeur
Moyenne symétrique pondérée.

paramètre

• source(series int/float) Série source

Voir aussi
ta.sma ta.ema ta.rma ta.wma ta.vwma ta.alma

ta.hma

La fonction hma renvoie la moyenne mobile du corps de la navette HMA。

            
            
            
ta.hma(source, length)

Exemple

            pine
            
            
src = input(defval=close, title="Source")
length = input(defval=9, title="Length")
hmaBuildIn = ta.hma(src, length)
plot(hmaBuildIn, title="Hull MA", color=#674EA7)

Retourne une valeur
Hull Moving Average qui renvoie la moyenne mobile de la coque de la source dans la colonne 'length'.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(simple int) Nombre de lignes

Voir aussi
ta.ema ta.rma ta.wma ta.vwma ta.sma

ta.rma

La moyenne mobile utilisée dans le RSI. Il s'agit d'une moyenne mobile pondérée par l'indicateur, la valeur pondérée alpha = 1 / longueur.

            
            
            
ta.rma(source, length)

Exemple

            pine
            
            
plot(ta.rma(close, 15))

//the same on pine
pine_rma(src, length) =>
  alpha = 1/length
  sum = 0.0
  sum := na(sum[1]) ? ta.sma(src, length) : alpha * src + (1 - alpha) * nz(sum[1])
plot(pine_rma(close, 15))

Retourne une valeur
sourceLa moyenne mobile de l'indicateur, alpha = 1 /length。

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(simple int) Nombre de lignes K (longueur).

Voir aussi
ta.sma ta.ema ta.wma ta.vwma ta.swma ta.alma ta.rsi

ta.rsi

L'intensité relative. Elle est utilisée dans le dernier.lengthK en lignesourceles changements à la hausse et à la baisseta.rma()Les chiffres sont là.

            
            
            
ta.rsi(source, length)

Exemple

            pine
            
            
plot(ta.rsi(close, 7))

// same on pine, but less efficient
pine_rsi(x, y) => 
    u = math.max(x - x[1], 0) // upward ta.change
    d = math.max(x[1] - x, 0) // downward ta.change
    rs = ta.rma(u, y) / ta.rma(d, y)
    res = 100 - 100 / (1 + rs)
    res

plot(pine_rsi(close, 7))

Retourne une valeur
Indicateur relativement faible (RSI)

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(simple int) Nombre de lignes K (longueur).

Voir aussi
ta.rma

ta.tsi

L'indice des forces et des faiblesses réelles est une moyenne mobile de la dynamique potentielle des instruments financiers.

            
            
            
ta.tsi(source, short_length, long_length)

Retourne une valeur
Indice de force réelle et de faiblesse.[La valeur dans −1,1]

paramètre

• source(series int/float) Série source
• short_length(simple int) La longueur est courte.
• long_length(simple int) Longueur de la ligne

ta.roc

La fonction roc{\displaystyle roc{\mathrm {c}}} est affichée.sourceLa valeur actuelle desourceIl y a quelques jours.lengthDifférences entre les valeurs
Elle est calculée par la formule suivante: 100 * change(src, length) / src[length]。

            
            
            
ta.roc(source, length)

Retourne une valeur
lengthLa ligne K est retournéesourceLe taux de variation

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

ta.range

Retourne la différence entre les valeurs minimales et maximales de la séquence.

            
            
            
ta.range(source, length)

Retourne une valeur
Différence entre les valeurs minimales et maximales de la séquence.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

ta.macd

Le MACD est une moyenne asymétrique lisse. Il devrait révéler la force, la direction, la dynamique et la durée des variations des tendances des cours des actions.

            
            
            
ta.macd(source, fastlen, slowlen, siglen) 

Exemple

            pine
            
            
[macdLine, signalLine, histLine] = ta.macd(close, 12, 26, 9)
plot(macdLine, color=color.blue)
plot(signalLine, color=color.orange)
plot(histLine, color=color.red, style=plot.style_histogram)

Si vous n'avez besoin que d'une seule valeur, utilisez des signes de ponctuation comme '_'：

Exemple

            pine
            
            
[_, signalLine, _] = ta.macd(close, 12, 26, 9)
plot(signalLine, color=color.orange)

Retourne une valeur
Les trois modules de la série MACD sont les lignes MACD, les lignes de signal et les lignes de diagramme orthogonal.

paramètre

• source(series int/float) Valeur de série à exécuter。
• fastlen(simple int) Paramètre de ligne rapide
• slowlen(simple int) Paramètre de longueur lente。
• siglen(simple int) Paramètre de longueur du signal。

Voir aussi
ta.sma ta.ema

ta.mode

Retourne le mode de la séquence. Si plusieurs valeurs ont la même fréquence, retourne la valeur la plus petite.

            
            
            
ta.mode(source, length)

Retourne une valeur
Modèle de la séquence

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

ta.median

Retourne le médium de la séquence.

            
            
            
ta.median(source, length) 

Retourne une valeur
Le nombre médian de la séquence.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

ta.linreg

La courbe de régression linéaire. Une ligne qui correspond le mieux au prix spécifié dans la période définie par l'utilisateur. Elle est calculée en utilisant la méthode du plus petit carré. Les résultats de cette fonction sont calculés en utilisant la formule suivante: linreg = intercept + slope * (length - 1 - offset), où intercept et slope sont utilisés.sourceLa valeur calculée pour le plus petit carré d'une série ≠

            
            
            
ta.linreg(source, length, offset) 

Retourne une valeur
Curve de régression linéaire

paramètre

• source(series int/float) Série source
• length (series int)
• offset(simple int) déviation

ta.bb

Les bandes de Brin sont un outil d'analyse technique défini par un ensemble de lignes qui sont séparées par deux écarts standard (positifs et négatifs) par rapport à la moyenne mobile simple (SMA) des prix des titres, mais qui peuvent être ajustées en fonction des préférences de l'utilisateur.

            
            
            
ta.bb(series, length, mult) 

Exemple

            pine
            
            
[middle, upper, lower] = ta.bb(close, 5, 4)
plot(middle, color=color.yellow)
plot(upper, color=color.yellow)
plot(lower, color=color.yellow)

// the same on pine
f_bb(src, length, mult) =>
    float basis = ta.sma(src, length)
    float dev = mult * ta.stdev(src, length)
    [basis, basis + dev, basis - dev]

[pineMiddle, pineUpper, pineLower] = f_bb(close, 5, 4)

plot(pineMiddle)
plot(pineUpper)
plot(pineLower)

Retourne une valeur
Il y a des gens qui ont été tués.

paramètre

• series(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).
• mult(simple int/float) Facteur de différence standard ≠

Voir aussi
ta.sma ta.stdev ta.kc

ta.bbw

La largeur de la bande de broyage est la distance entre la voie supérieure et la voie inférieure et la voie médiane.

            
            
            
ta.bbw(series, length, mult) 

Exemple

            pine
            
            
plot(ta.bbw(close, 5, 4), color=color.yellow)

// the same on pine
f_bbw(src, length, mult) =>
    float basis = ta.sma(src, length)
    float dev = mult * ta.stdev(src, length)
    ((basis + dev) - (basis - dev)) / basis

plot(f_bbw(close, 5, 4))

Retourne une valeur
La bande passante de Brin

paramètre

• series(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).
• mult(simple int/float) Facteur de différence standard ≠

Voir aussi
ta.bb ta.sma ta.stdev

ta.cci

L'indice CCI est calculé en divisant la différence entre le prix typique d'une marchandise et sa moyenne mobile simple par la moyenne de son écart absolu par rapport au prix typique. L'indice est découpé par une inversion de 0,015 pour fournir un nombre plus lisible.

            
            
            
ta.cci(source, length) 

Retourne une valeur
Indice de la chaîne de marchandises de la source dont la longueur est la ligne K.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

ta.change

Différence entre la valeur actuelle et la valeur précédente, source - source[length]。

            
            
            
ta.change(source, length) 

            
            
            
ta.change(source) 

Retourne une valeur
Résultats de la réduction de la loi

paramètre

• source(series int/float) Série source
• length(series int) décalé de la ligne k actuelle à la ligne k précédente. Optionnel, si non donné, longueur = 1

Voir aussi
ta.mom ta.cross

ta.mom

sourceLes prix etsourceLe prixlengthLa dynamique avant K est une différence: source - source[length]。

            
            
            
ta.mom(source, length) 

Retourne une valeur
sourceLes prix etsourceLe prixlengthLa dynamique avant la ligne K.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) décalé de la ligne k actuelle vers la ligne k précédente。

Voir aussi
ta.change

ta.cmo

Indicateur de fluctuation de la dynamique de Chandra. Calculer la somme des points de hausse les plus récents par rapport aux points de baisse les plus récents, puis les subtraire, puis diviser le résultat par la somme de toutes les variations de prix au cours de la même période

            
            
            
ta.cmo(series, length) 

Exemple

            pine
            
            
plot(ta.cmo(close, 5), color=color.yellow)

// the same on pine
f_cmo(src, length) =>
    float mom = ta.change(src)
    float sm1 = math.sum((mom >= 0) ? mom : 0.0, length)
    float sm2 = math.sum((mom >= 0) ? 0.0 : -mom, length)
    100 * (sm1 - sm2) / (sm1 + sm2)

plot(f_cmo(close, 5))

Retourne une valeur
Indicateur de fluctuation de la dynamique de Chand

paramètre

• series(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

Voir aussi
ta.rsi ta.stoch math.sum

ta.percentile_linear_interpolation

Le pourcentage est calculé en utilisant la méthode d'intercalation linéaire entre les deux classements les plus récents.

            
            
            
ta.percentile_linear_interpolation(source, length, percentage) 

Retourne une valeur
lengthLa ligne K est retournéesourceLe premier pourcentage P de la série ≠

paramètre

• source(series int/float) Valeur de la série à exécuter ((source))
• length(series int) Nombre de lignes K précédentes (longueur)
• percentage(simple int/float) Pourcentage, chiffre compris entre 0 et 100

À noter
Veuillez noter que les pourcentages calculés avec cette méthode ne sont pas tous des entrées.

Voir aussi
ta.percentile_nearest_rank

ta.percentile_nearest_rank

Pourcentage calculé selon la méthode de classement la plus récente.

            
            
            
ta.percentile_nearest_rank(source, length, percentage) 

Retourne une valeur
lengthLa ligne K est retournéesourceLe premier pourcentage P de la série ≠

paramètre

• source(series int/float) Valeur de la série à exécuter ((source))
• length(series int) Nombre de lignes K précédentes (longueur)
• percentage(simple int/float) Pourcentage, chiffre compris entre 0 et 100

À noter
L'utilisation d'un classement récent de moins de 100 k de la dernière ligne peut entraîner l'utilisation du même chiffre pour plusieurs pourcentages.
Les pourcentages calculés par le classement récent font partie de l'ensemble de données d'entrée.
Le centième point est défini comme la valeur maximale de l'ensemble de données d'entrée.

Voir aussi
ta.percentile_linear_interpolation

ta.percentrank

La portée en pourcentage est le pourcentage de la valeur précédente inférieure ou égale à la valeur actuelle d'une série donnée.

            
            
            
ta.percentrank(source, length) 

Retourne une valeur
lengthLa ligne K est retournéesourcePourcentage de classement:

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

ta.variance

La divergence est une valeur attendue (ta.sma) d'une série de déviations au carré de sa moyenne, qui mesure informellement la distance d'une série de chiffres par rapport à leur moyenne.

            
            
            
ta.variance(source, length, biased) 

Retourne une valeur
lengthLa ligne K est retournéesourceLa différence est énorme.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).
• biased(series bool) Détermine quelle estimation doit être utilisée. Optionnel. La valeur par défaut est true.

À noter
Si vousbiasedSi c'est vrai, la fonction utilise une estimation partielle de l'ensemble, et si c'est faux, une estimation sans partialité de l'échantillon.

Voir aussi
ta.dev ta.stdev

ta.tr

            
            
            
ta.tr(handle_na) 

Retourne une valeur
La portée réelle est math.max (haute - basse, math.abs (haute - proche)[1]), math.abs(low - close[1]))。

paramètre

• handle_na(simple bool) Comment traiter une valeur NaN. Si c'est vrai et que le prix de clôture de la journée précédente est NaN, tr sera calculé comme le haut-bas de la journée. Sinon, (tr) si c'est faux, tr renverra NaN.

À noter
ta.tr(false)etta.trExactement la même chose.

Voir aussi
ta.atr

ta.mfi

L'indicateur de flux de trésorerie est un indicateur technique qui utilise le prix et le volume de transactions pour déterminer si un actif est suracheté ou survendu.

            
            
            
ta.mfi(series, length) 

Exemple

            pine
            
            
plot(ta.mfi(hlc3, 14), color=color.yellow)

// the same on pine
pine_mfi(src, length) =>
    float upper = math.sum(volume * (ta.change(src) <= 0.0 ? 0.0 : src), length)
    float lower = math.sum(volume * (ta.change(src) >= 0.0 ? 0.0 : src), length)
    mfi = 100.0 - (100.0 / (1.0 + upper / lower))
    mfi

plot(pine_mfi(hlc3, 14))

Retourne une valeur
Indicateur des flux de trésorerie

paramètre

• series(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

Voir aussi
ta.rsi math.sum

ta.kc

Le canal de Kentner est un indicateur technique qui contient une moyenne mobile intermédiaire et un canal ascendant et descendant.

            
            
            
ta.kc(series, length, mult) 

            
            
            
ta.kc(series, length, mult, useTrueRange) 

Exemple

            pine
            
            
[middle, upper, lower] = ta.kc(close, 5, 4)
plot(middle, color=color.yellow)
plot(upper, color=color.yellow)
plot(lower, color=color.yellow)


// the same on pine
f_kc(src, length, mult, useTrueRange) =>
    float basis = ta.ema(src, length)
    float span = (useTrueRange) ? ta.tr : (high - low)
    float rangeEma = ta.ema(span, length)
    [basis, basis + rangeEma * mult, basis - rangeEma * mult]
    
[pineMiddle, pineUpper, pineLower] = f_kc(close, 5, 4, true)

plot(pineMiddle)
plot(pineUpper)
plot(pineLower)

Retourne une valeur
Le passage de Kettner

paramètre

• series(series int/float) Valeur de série à exécuter。
• length(simple int) Nombre de lignes K (longueur).
• mult(simple int/float) Facteur de différence standard ≠
• useTrueRange(simple bool) paramètre optionnel. Indique si la portée est vraie; par défaut, elle est vraie. Si la valeur est fausse, la portée est calculée à l'aide de l'expression (high-low).

Voir aussi
ta.ema ta.atr ta.bb

ta.kcw

La largeur du canal de Kentner. La largeur du canal de Kentner est la différence entre le canal supérieur et le canal inférieur divisée par la valeur du canal intermédiaire.

            
            
            
ta.kcw(series, length, mult) 

            
            
            
ta.kcw(series, length, mult, useTrueRange) 

Exemple

            pine
            
            
plot(ta.kcw(close, 5, 4), color=color.yellow)

// the same on pine
f_kcw(src, length, mult, useTrueRange) =>
    float basis = ta.ema(src, length)
    float span = (useTrueRange) ? ta.tr : (high - low)
    float rangeEma = ta.ema(span, length)
    
    ((basis + rangeEma * mult) - (basis - rangeEma * mult)) / basis

plot(f_kcw(close, 5, 4, true))

Retourne une valeur
La largeur du canal de Kettner

paramètre

• series(series int/float) Valeur de série à exécuter。
• length(simple int) Nombre de lignes K (longueur).
• mult(simple int/float) Facteur de différence standard ≠
• useTrueRange(simple bool) paramètre optionnel. Indique si la portée est vraie; par défaut, elle est vraie. Si la valeur est fausse, la portée est calculée à l'aide de l'expression (high-low).

Voir aussi
ta.kc ta.ema ta.atr ta.bb

ta.correlation

Le coefficient de corrélation décrit le degré auquel deux séries tendent à s'écarter de leur valeur de ta.sma.

            
            
            
ta.correlation(source1, source2, length) 

Retourne une valeur
Coefficients relatifs

paramètre

• source1(series int/float) Série source
• source2(series int/float) Série cible
• length(series int) longueur (nombre de lignes K)

Voir aussi
request.security

ta.cross

            
            
            
ta.cross(source1, source2) 

Retourne une valeur
Si les deux séries se croisent, alors c'est vrai, sinon c'est faux.

paramètre

• source1(series int/float) Première série de données。
• source2(series int/float) Deuxième série de données。

Voir aussi
ta.change

ta.crossover

source1-series est définie comme une traverséesource2-series, si vous êtes sur la ligne K actuelle,source1est supérieure àsource2Et on va voir que la première ligne de K est la valeur de l'équation.source2valeur de source1小于source2`La valeur de

            
            
            
ta.crossover(source1, source2) 

Retourne une valeur
Si voussource1À traverssource2Le résultat est vrai ou faux.

paramètre

• source1(series int/float) Première série de données。
• source2(series int/float) Deuxième série de données。

ta.crossunder

source1-series est définie comme étantsource2-series sous la croix, si sur la ligne K actuelle,source1est inférieure àsource2Et on va voir que la première ligne K est la valeur de la valeur de la valeur de la valeur de la valeur de la valeur de la valeur de la valeur.source1est supérieure àsource2La valeur de

            
            
            
ta.crossunder(source1, source2) 

Retourne une valeur
Si voussource1existersource2Si vous croisez en bas, c'est vrai, sinon c'est faux.

paramètre

• source1(series int/float) Première série de données。
• source2(series int/float) Deuxième série de données。

ta.atr

La fonction ATR (moyenne de l'amplitude réelle) renvoie une RMA de la plage réelle. L'amplitude réelle est max (haute - basse, abs (haute - proche)[1]), abs(low - close[1]))。

            
            
            
ta.atr(length) 

Exemple

            pine
            
            
plot(ta.atr(14))

//the same on pine
pine_atr(length) =>
    trueRange = na(high[1])? high-low : math.max(math.max(high - low, math.abs(high - close[1])), math.abs(low - close[1]))
    //true range can be also calculated with ta.tr(true)
    ta.rma(trueRange, length)

plot(pine_atr(14))

Retourne une valeur
La moyenne des fluctuations réelles (ATR)

paramètre
longueur (simple int)

Voir aussi
ta.tr ta.rma

ta.sar

La déviation de la parallèle (en anglais: parallax shift) est une méthode conçue par J. Welles Wilder, Jr. pour détecter un potentiel renversement de la direction des prix sur un marché de négociation.

            
            
            
ta.sar(start, inc, max) 

Exemple

            pine
            
            
plot(ta.sar(0.02, 0.02, 0.2), style=plot.style_cross, linewidth=3)

// The same on Pine
pine_sar(start, inc, max) =>
  var float result = na
  var float maxMin = na
  var float acceleration = na
  var bool isBelow = na
  bool isFirstTrendBar = false
  
  if bar_index == 1
    if close > close[1]
      isBelow := true
      maxMin := high
      result := low[1]
    else
      isBelow := false
      maxMin := low
      result := high[1]
    isFirstTrendBar := true
    acceleration := start
  
  result := result + acceleration * (maxMin - result)
  
  if isBelow
    if result > low
      isFirstTrendBar := true
      isBelow := false
      result := math.max(high, maxMin)
      maxMin := low
      acceleration := start
  else
    if result < high
      isFirstTrendBar := true
      isBelow := true
      result := math.min(low, maxMin)
      maxMin := high
      acceleration := start
      
  if not isFirstTrendBar
    if isBelow
      if high > maxMin
        maxMin := high
        acceleration := math.min(acceleration + inc, max)
    else
      if low < maxMin
        maxMin := low
        acceleration := math.min(acceleration + inc, max)
  
  if isBelow
    result := math.min(result, low[1])
    if bar_index > 1
      result := math.min(result, low[2])
    
  else
    result := math.max(result, high[1])
    if bar_index > 1
      result := math.max(result, high[2])
  
  result
  
plot(pine_sar(0.02, 0.02, 0.2), style=plot.style_cross, linewidth=3)

Retourne une valeur
La ligne de parallèle se tourne vers l'indicateur.

paramètre

• start(simple int/float) commence par
• inc(simple int/float) ajout
• max(simple int/float) Le plus grand.

ta.barssince

Calculer le nombre de lignes K à partir de la dernière condition vraie.

            
            
            
ta.barssince(condition) 

Exemple

            pine
            
            
// get number of bars since last color.green bar
plot(ta.barssince(close >= open))

Retourne une valeur
Le nombre de lignes k dont la condition est vraie.

À noter
Si cette condition n'a jamais été remplie avant la ligne K actuelle, la fonction renvoie na。
Veuillez noter que l'utilisation de cette variable/fonction peut entraîner une redéfinition de l'indicateur.

Voir aussi
ta.lowestbars ta.highestbars ta.valuewhen ta.highest ta.lowest

ta.cum

sourceLa somme de tout est la somme de la somme de tout.sourceLa somme de tous les éléments de .

            
            
            
ta.cum(source) 

Retourne une valeur
Résumé de la série.

paramètre

• source (series int/float)

Voir aussi
math.sum

ta.dmi

La fonction dmi renvoie l'indice dynamique DMI。

            
            
            
ta.dmi(diLength, adxSmoothing) 

Exemple

            pine
            
            
len = input.int(17, minval=1, title="DI Length")
lensig = input.int(14, title="ADX Smoothing", minval=1, maxval=50)
[diplus, diminus, adx] = ta.dmi(len, lensig)
plot(adx, color=color.red, title="ADX")
plot(diplus, color=color.blue, title="+DI")
plot(diminus, color=color.orange, title="-DI")

Retourne une valeur
Les trois sous-groupes de la série DMI sont le mouvement dans la direction positive ((+DI), le mouvement dans la direction négative ((-DI) et l'indice de mouvement dans la direction moyenne ((ADX)).

paramètre

• diLength (simple int) DI Period。
• adxSmoothing(simple int) cycle de lissage ADX

Voir aussi
ta.rsi ta.tsi ta.mfi

ta.falling

Des tests.sourceSérie pourlengthLa ligne Klong est-elle en baisse ?

            
            
            
ta.falling(source, length) 

Retourne une valeur
Si c'était le cas...sourceinférieure àlengthLes lignes K renvoient à n'importe quelle précédente.sourceLa valeur est vraie ou fausse.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

Voir aussi
ta.rising

ta.rising

Des tests.sourceSérie pourlengthKlinelong est en train d'évoluer.

            
            
            
ta.rising(source, length) 

Retourne une valeur
Si c'était le cas...sourceÇa vaut plus que ça.lengthLes lignes K renvoient à n'importe quelle précédente.sourceLa valeur est vraie ou fausse.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

Voir aussi
ta.falling

ta.pivothigh

Cette fonction renvoie le prix du point culminant de l'axe. Si aucun point culminant n'existe, elle renvoie <unk>NaN<unk>.

            
            
            
ta.pivothigh(source, leftbars, rightbars) 

            
            
            
ta.pivothigh(leftbars, rightbars) 

Exemple

            pine
            
            
leftBars = input(2)
rightBars=input(2)
ph = ta.pivothigh(leftBars, rightBars)
plot(ph, style=plot.style_cross, linewidth=3, color= color.red, offset=-rightBars)

Retourne une valeur
Le prix à ce point, ou "NaN".

paramètre

• source(series int/float) Paramètre sélectionnable. Valeur de calcul de la séquence de données. Valeur par défaut 'High'
• leftbars(series int/float) Force à gauche
• rightbars(series int/float) Longueur à droite。

À noter
Si le paramètre 'leftbars' ou 'rightbars' est une série, vous devriez utiliser la fonction max_bars_back comme variable 'source' [2].

ta.pivotlow

Cette fonction renvoie le prix du point le plus bas de l'axe. S'il n'y a pas de point le plus bas de l'axe, elle renvoie <unk>NaN<unk>.

            
            
            
ta.pivotlow(source, leftbars, rightbars) 

            
            
            
ta.pivotlow(leftbars, rightbars) 

Exemple

            pine
            
            
leftBars = input(2)
rightBars=input(2)
pl = ta.pivotlow(close, leftBars, rightBars)
plot(pl, style=plot.style_cross, linewidth=3, color= color.blue, offset=-rightBars)

Retourne une valeur
Le prix à ce point, ou "NaN".

paramètre

• source(series int/float) Paramètre sélectionnable ◦ Valeur calculée de la série de données ◦ Par défaut ◦ Low ◦
• leftbars(series int/float) Force à gauche
• rightbars(series int/float) Longueur à droite。

À noter
Si le paramètre 'leftbars' ou 'rightbars' est une série, vous devriez utiliser la fonction max_bars_back comme variable 'source' [2].

ta.highest

La valeur la plus élevée d'un nombre donné de lignes k passées.

            
            
            
ta.highest(source, length) 

            
            
            
ta.highest(length) 

Retourne une valeur
La valeur la plus élevée de la série.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

À noter
Les deux versions de args:sourceC'est une série.lengthest le nombre de lignes K renvoyées.
Une version arg:lengthest le nombre de lignes K. L'algorithme utilise high commesourceSérie

Voir aussi
ta.lowest ta.lowestbars ta.highestbars ta.valuewhen ta.barssince

ta.highestbars

Le décalage maximal d'un nombre donné de lignes k au-delà.

            
            
            
ta.highestbars(source, length) 

            
            
            
ta.highestbars(length) 

Retourne une valeur
Déviation vers la ligne k la plus élevée.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

À noter
Les deux versions de args:sourceC'est une série.lengthest le nombre de lignes K renvoyées.
Une version arg:lengthest le nombre de lignes K. L'algorithme utilise high commesourceSérie

Voir aussi
ta.lowest ta.highest ta.lowestbars ta.barssince ta.valuewhen

ta.stoch

L'indicateur aléatoire. L'équation de calcul est: 100 * (close - lowest, length)) / (highest, high, length) - lowest, length).

            
            
            
ta.stoch(source, high, low, length) 

Retourne une valeur
Le hasard

paramètre

• source(series int/float) Série source
• high(series int/float) Séries élevées
• low(series int/float) Séries inférieures
• length(series int) longueur (nombre de lignes K)

Voir aussi
ta.cog

ta.supertrend

L'indicateur de super-tendance est un indicateur qui suit une tendance.

            
            
            
ta.supertrend(factor, atrPeriod)

Exemple

            pine
            
            
//@version=5
indicator("Pine Script™ Supertrend")

[supertrend, direction] = ta.supertrend(3, 10)
plot(direction < 0 ? supertrend : na, "Up direction", color = color.green, style=plot.style_linebr)
plot(direction > 0 ? supertrend : na, "Down direction", color = color.red, style=plot.style_linebr)

// The same on Pine Script™
pine_supertrend(factor, atrPeriod) =>
  src = hl2
  atr = ta.atr(atrPeriod)
  upperBand = src + factor * atr
  lowerBand = src - factor * atr
  prevLowerBand = nz(lowerBand[1])
  prevUpperBand = nz(upperBand[1])

  lowerBand := lowerBand > prevLowerBand or close[1] < prevLowerBand ? lowerBand : prevLowerBand
  upperBand := upperBand < prevUpperBand or close[1] > prevUpperBand ? upperBand : prevUpperBand
  int direction = na
  float superTrend = na
  prevSuperTrend = superTrend[1]
  if na(atr[1])
    direction := 1
  else if prevSuperTrend == prevUpperBand
    direction := close > upperBand ? -1 : 1
  else
    direction := close < lowerBand ? 1 : -1
  superTrend := direction == -1 ? lowerBand : upperBand
  [superTrend, direction]

[pineSupertrend, pineDirection] = pine_supertrend(3, 10)
plot(pineDirection < 0 ? pineSupertrend : na, "Up direction", color = color.green, style=plot.style_linebr)
plot(pineDirection > 0 ? pineSupertrend : na, "Down direction", color = color.red, style=plot.style_linebr)

Retourne une valeur
Les deux sous-groupes de la série hypertrend: la ligne hypertrend et la direction de la tendance. Les valeurs possibles sont 1 (en direction vers le bas) et -1 (en direction vers le haut).

paramètre

• factor(series int/float) ATR sera multiplié par le nombre de fois que les valeurs sont multipliées.
• atrPeriod(simple int) Longueur d'onde réelle moyenne

Voir aussi
ta.macd

ta.lowest

La valeur minimale d'un nombre donné de lignes passées k.

            
            
            
ta.lowest(source, length) 

            
            
            
ta.lowest(length) 

Retourne une valeur
La valeur la plus basse de la série.

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

À noter
Les deux versions de args:sourceC'est une série.lengthest le nombre de lignes K renvoyées.
Une version arg:lengthest le nombre de lignes K. L'algorithme utilise low commesourceSérie

Voir aussi
ta.highest ta.lowestbars ta.highestbars ta.valuewhen ta.barssince

ta.lowestbars

Déviation minimale d'un nombre donné de lignes k au-delà.

            
            
            
ta.lowestbars(source, length) 

            
            
            
ta.lowestbars(length) 

Retourne une valeur
Déviation vers la ligne k la plus basse

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) renvoie le nombre de lignes K。

À noter
Les deux versions de args:sourceC'est une série.lengthest le nombre de lignes K renvoyées.
Une version arg:lengthest le nombre de lignes K. L'algorithme utilise low commesourceSérie

Voir aussi
ta.lowest ta.highest ta.highestbars ta.barssince ta.valuewhen

ta.valuewhen

Retourne la série de valeurs de la source de l'élément de la ligne K où l'élément de la condition de l'élément de l'élément de l'élément de l'élément de l'élément de l'élément de l'élément de l'élément de l'élément est vrai.

            
            
            
ta.valuewhen(condition, source, occurrence) 

Exemple

            pine
            
            
slow = ta.sma(close, 7)
fast = ta.sma(close, 14)
// Get value of `close` on second most recent cross
plot(ta.valuewhen(ta.cross(slow, fast), close, 1))

paramètre

• condition(series bool) Condition à rechercher:
• source(series int/float/bool/color) La valeur à retourner à partir de la ligne K qui remplit les conditions.
• occurrenceL'apparition d'une condition (simple int) ≠ est numérotée à partir de 0 et est rétroactive dans le temps, de sorte que 0 est la condition la plus récente, 1 la deuxième plus récente, et ainsi de suite ≠ doit être un entier >= 0 ≠.

À noter
Cette fonction doit être exécutée sur chaque ligne K. Il n'est pas recommandé de l'utiliser dans une structure cyclique for ou while, car son comportement peut être inattendu. Veuillez noter que l'utilisation de cette fonction peut entraîner un redessiné des indicateurs.

Voir aussi
ta.lowestbars ta.highestbars ta.barssince ta.highest ta.lowest

ta.vwap

Prix moyen pondéré

            
            
            
ta.vwap(source) 

Retourne une valeur
Moyenne pondérée des transactions

paramètre

• source(series int/float) Série source

Voir aussi
ta.vwap

ta.vwma

La fonction vwma renvoielengthLa ligne KsourceLa moyenne mobile pondérée de la quantité d'échange ≠ est égale à: sma (source * volume, length) / sma (volume, length) ≠

            
            
            
ta.vwma(source, length) 

Exemple

            pine
            
            
plot(ta.vwma(close, 15))

// same on pine, but less efficient
pine_vwma(x, y) =>
    ta.sma(x * volume, y) / ta.sma(volume, y)
plot(pine_vwma(close, 15))

Retourne une valeur
lengthLa ligne K est retournéesourceLa moyenne mobile pondérée du volume des transactions

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

Voir aussi
ta.sma ta.ema ta.rma ta.wma ta.swma ta.alma

ta.wpr

L'indicateur Williams %R。。 est un indicateur d'oscillation qui montre la relation entre le prix de clôture actuel et le prix haut/bas d'une période passée.

            
            
            
ta.wpr(length) 

Exemple

            pine
            
            
plot(ta.wpr(14), title="%R", color=color.new(#ff6d00, 0))

Retourne une valeur
Williams %R。

paramètre

• length(series int) Nombre de lignes K。

Voir aussi
ta.mfi ta.cmo

plot

plot

Une série de données est dessinée sur un graphique.

            
            
            
plot(series, title, color, linewidth, style, trackprice, histbase, offset, join, editable, show_last, display) 

Exemple

            pine
            
            
plot(high+low, title='Title', color=color.new(#00ffaa, 70), linewidth=2, style=plot.style_area, offset=15, trackprice=true)

// You may fill the background between any two plots with a fill() function:
p1 = plot(open)
p2 = plot(close)
fill(p1, p2, color=color.new(color.green, 90))

Retourne une valeur
Les objets de dessin utilisés pour le remplissage:

paramètre

• series(series int/float) La série de données à tracer. Les paramètres requis.
• title(const string) Titre du dessin.
• color(series color) Couleur de la série. Vous pouvez utiliser des constantes telles que "color = red" ou "color =#ff001a" et des expressions complexes telles que "color = close >= open ? green: red". Paramètres optionnels.
• linewidth(input int) La largeur de la ligne de dessin ≠ 1 ≠ n'est pas valable pour tous les styles ≠
• style(plot_style) le type de plot. Les valeurs possibles sont les suivantes: plot.style_line, plot.style_stepline, plot.style_stepline_diamond, plot.style_histogram, plot.style_cross, plot.style_area, plot.style_columns, plot.style_circles, plot.style_linebr, plot.style_areabr. La valeur par défaut est le type de plot.style_line.
• trackprice(input bool) Si true, la ligne de prix horizontale est affichée au niveau de la dernière valeur de l'indicateur.
• histbase(input int/float) La valeur de niveau de référence est utilisée lors de la représentation d'un graphique dans les styles plot.style_histogram, plot.style_columns ou plot.style_area. La valeur par défaut est 0.0。
• offset(series int) Déplacez le dessin vers la gauche ou vers la droite sur un certain nombre de lignes k. La valeur par défaut est 0
• join(input bool) Si c'est vrai, alors le point de tracé est connecté à la ligne, ce qui ne s'applique qu'aux styles plot.style_cross et plot.style_circles. La valeur par défaut est false.
• editable(const bool) Si true, le style du dessin peut être modifié dans la boîte de dialogue format. La valeur par défaut est true.
• show_last(input int) Définit le nombre de lignes k tracées sur le graphique (depuis la dernière ligne k)
• display(plot_display) Le contrôle affiche l'emplacement du dessin. Les valeurs possibles sont: display.none, display.all. La valeur par défaut est display.all.
• overlay(const bool) Paramètre de l'extension de la plate-forme FMZ, utilisé pour définir la fonction actuelle sur le diagramme principal (true) ou sur le diagramme secondaire (faux). La valeur par défaut est false. Sans spécifier ce paramètre, on obtientstrategyouindicatorDansoverlayParamètres définisstrategyouindicatorAucun réglageoverlayLes paramètres sont traités comme des paramètres par défaut.

Voir aussi
plotshape plotchar bgcolor

plotshape

Dessiner une forme visuelle sur un graphique.

            
            
            
plotshape(series, title, style, location, color, offset, text, textcolor, editable, size, show_last, display) 

Exemple

            pine
            
            
data = close >= open
plotshape(data, style=shape.xcross)

paramètre

• series(series bool) Une série de données représentées sous forme de forme 。 La série est considérée comme une série de valeurs bool de toutes les valeurs de position sauf location.absolute 。 Paramètre requis 。
• title(const string) Titre du dessin.
• style(input string) Type de dessin。 Les valeurs possibles sont: shape.xcross, shape.cross, shape.triangleup, shape.triangledown, shape.flag, shape.circle, shape.arrowup, shape.arrowdown, shape.labelup, shape.labeldown, shape.square, shape.diamond。 La valeur par défaut est shape.xcross。
• location(input string) La forme est positionnée sur le graphique. Les valeurs possibles sont: location.abovebar, location.belowbar, location.top, location.bottom, location.absolute. La valeur par défaut est location.abovebar.
• colorVous pouvez utiliser des constantes telles que "color = red" ou "color =#ff001a" ainsi que des expressions complexes telles que "color = close >= open ? green: red". Paramètres optionnels.
• offset(series int) déplace la forme vers la gauche ou vers la droite sur un nombre donné de lignes k. La valeur par défaut est 0
• text(const string) Le texte est affiché en forme. Vous pouvez utiliser plusieurs lignes de texte, séparées par des lignes de séquences de traduction '\n'. Exemple: 'line one\nline two'
• textcolor(series color) La couleur du texte. Vous pouvez utiliser des constantes telles que 'textcolor=red' ou 'textcolor=#ff001a', ainsi que des expressions complexes telles que 'textcolor = close >= open ? green: red'. Paramètres optionnels.
• editable(const bool) Si true, le style plotshape peut être modifié dans la boîte de dialogue format. La valeur par défaut est true.
• show_last(input int) Définit le nombre de formes dessinées sur le graphique si elle est définie ((de la dernière ligne k pour revenir au passé))
• size(const string) La taille des caractères dans le graphique. Les valeurs possibles sont: size.auto, size.tiny, size.small, size.normal, size.large, size.huge. La valeur par défaut est size.auto.
• display(plot_display) Le contrôle affiche l'emplacement du dessin. Les valeurs possibles sont: display.none, display.all. La valeur par défaut est display.all.
• overlay(const bool) Paramètre de l'extension de la plate-forme FMZ, utilisé pour définir la fonction actuelle sur le diagramme principal (true) ou sur le diagramme secondaire (faux). La valeur par défaut est false. Sans spécifier ce paramètre, on obtientstrategyouindicatorDansoverlayParamètres définisstrategyouindicatorAucun réglageoverlayLes paramètres sont traités comme des paramètres par défaut.

Voir aussi
plot plotchar bgcolor

plotchar

Les formes visuelles sont dessinées sur le graphique en utilisant n'importe quel caractère Unicode donné.

            
            
            
plotchar(series, title, char, location, color, offset, text, textcolor, editable, size, show_last, display) 

Exemple

            pine
            
            
data = close >= open
plotchar(data, char='❄')

paramètre

• series(series bool) Une série de données représentées sous forme de forme 。 La série est considérée comme une série de valeurs bool de toutes les valeurs de position sauf location.absolute 。 Paramètre requis 。
• title(const string) Titre du dessin.
• char(input string) Caractère utilisé comme forme visuelle
• location(input string) La forme est positionnée sur le graphique. Les valeurs possibles sont: location.abovebar, location.belowbar, location.top, location.bottom, location.absolute. La valeur par défaut est location.abovebar.
• colorVous pouvez utiliser des constantes telles que "color = red" ou "color =#ff001a" ainsi que des expressions complexes telles que "color = close >= open ? green: red". Paramètres optionnels.
• offset(series int) déplace la forme vers la gauche ou vers la droite sur un nombre donné de lignes k. La valeur par défaut est 0
• text(const string) Le texte est affiché en forme. Vous pouvez utiliser plusieurs lignes de texte, séparées par des lignes de séquences de traduction '\n'. Exemple: 'line one\nline two'
• textcolor(series color) La couleur du texte. Vous pouvez utiliser des constantes telles que 'textcolor=red' ou 'textcolor=#ff001a', ainsi que des expressions complexes telles que 'textcolor = close >= open ? green: red'. Paramètres optionnels.
• editable(const bool) Si true, le style plotchar peut être modifié dans la boîte de dialogue format. La valeur par défaut est true.
• show_last(input int) Définit le nombre de diagrammes à tracer sur le graphique (depuis la dernière ligne k).
• size(const string) La taille des caractères dans le graphique. Les valeurs possibles sont: size.auto,size.tiny,size.small,size.normal,size.large,size.huge. La valeur par défaut est size.auto.
• display(plot_display) Le contrôle affiche l'emplacement du dessin. Les valeurs possibles sont: display.none, display.all. La valeur par défaut est display.all.
• overlay(const bool) Paramètre de l'extension de la plate-forme FMZ, utilisé pour définir la fonction actuelle sur le diagramme principal (true) ou sur le diagramme secondaire (faux). La valeur par défaut est false. Sans spécifier ce paramètre, on obtientstrategyouindicatorDansoverlayParamètres définisstrategyouindicatorAucun réglageoverlayLes paramètres sont traités comme des paramètres par défaut.

Voir aussi
plot plotshape bgcolor

plotcandle

Dessinez le zéro sur le graphique.

            
            
            
plotcandle(open, high, low, close, title, color, wickcolor, editable, show_last, bordercolor, display)

Exemple

            pine
            
            
indicator("plotcandle example", overlay=true)
plotcandle(open, high, low, close, title='Title', color = open < close ? color.green : color.red, wickcolor=color.black)

paramètre

• open(series int/float) Les séries de données ouvertes sont utilisées comme valeurs d'ouverture de la colonne. Les paramètres nécessaires.
• high(series int/float) La hauteur de la série de données utilisée pour la colonne. Les paramètres nécessaires.
• low(series int/float) Les données de la série inférieure sont utilisées comme valeurs inférieures de la colonne. Paramètre requis.
• close(series int/float) Fermeture de la série de données comme valeur de la ligne de fermeture k。 Paramètre requis。
• title(const string) titre de la plotcandle. Paramètres sélectifs.
• color(series color) La couleur de la série. Vous pouvez utiliser des constantes comme color = red ou color = #ff001a, ainsi que des expressions complexes comme color = close >= open ? green: red. Paramètres optionnels.
• wickcolor(series color) La couleur du noyau de l'ampoule. Un paramètre facultatif.
• editable(const bool) Si true, le style plotcandle peut être modifié dans la boîte de dialogue de format. La valeur par défaut est true.
• show_last(input int) Définit le nombre d'angles dessinés sur le graphique ((à partir de la dernière ligne k pour revenir en arrière) }}, si elle est définie.
• bordercolor(series color) La couleur de la bordure de la colonne. Un paramètre facultatif.
• display(plot_display) Le contrôle affiche l'emplacement du dessin. Les valeurs possibles sont: display.none, display.all. La valeur par défaut est display.all.
• overlay(const bool) Paramètre de l'extension de la plate-forme FMZ, utilisé pour définir la fonction actuelle sur le diagramme principal (true) ou sur le diagramme secondaire (faux). La valeur par défaut est false. Sans spécifier ce paramètre, on obtientstrategyouindicatorDansoverlayParamètres définisstrategyouindicatorAucun réglageoverlayLes paramètres sont traités comme des paramètres par défaut.

À noter
Si le NaN est le plus élevé ou le plus bas, alors la ligne K n'a pas besoin d'être affichée.
Les valeurs maximales d'ouverture, de hauteur, de basse et d'arrêt seront réglées sur une valeur plus élevée et les valeurs minimales sur une valeur plus basse.

Voir aussi
plotbar

plotarrow

Dessiner des flèches vers le haut et vers le bas sur le graphique: les flèches vers le haut sont dessinées sur chaque indicateur positif, tandis que les flèches vers le bas sont dessinées sur chaque valeur négative. Si l'indicateur renvoie na, les flèches ne sont pas dessinées. Les flèches ont des hauteurs différentes, et plus la valeur absolue de l'indicateur est grande, plus la flèche est longue.

            
            
            
plotarrow(series, title, colorup, colordown, offset, minheight, maxheight, editable, show_last, display)

Exemple

            
            
            
codiff = close - open
plotarrow(codiff, colorup=color.new(color.teal,40), colordown=color.new(color.orange, 40), overlay=true)

paramètre

• series(series int/float) Pour tracer une série de données en flèches. Les paramètres nécessaires.
• title(const string) Titre du dessin.
• colorup(series color) Couleur de la flèche vers le haut. Paramètres optionnels.
• colordown(series color) Couleur de la flèche vers le bas. Paramètres optionnels.
• offset(series int) Déplacez la flèche vers la gauche ou vers la droite sur un nombre donné de lignes K. La valeur par défaut est 0
• minheight(input int) La plus petite hauteur de flèche possible en pixels. La valeur par défaut est 5
• maxheight(input int) Hauteur de la flèche maximale possible en pixels. La valeur par défaut est 100
• editable(const bool) Si true, le style de la file d'attente peut être modifié dans la boîte de dialogue de formatage. La valeur par défaut est true.
• show_last(input int) Définit le nombre de flèches à tracer sur le graphique (depuis la dernière ligne k).
• display(plot_display) Le contrôle affiche l'emplacement du dessin. Les valeurs possibles sont: display.none, display.all. La valeur par défaut est display.all.
• overlay(const bool) Paramètre de l'extension de la plate-forme FMZ, utilisé pour définir la fonction actuelle sur le diagramme principal (true) ou sur le diagramme secondaire (faux). La valeur par défaut est false. Sans spécifier ce paramètre, on obtientstrategyouindicatorDansoverlayParamètres définisstrategyouindicatorAucun réglageoverlayLes paramètres sont traités comme des paramètres par défaut.

Voir aussi
plot plotshape plotchar barcolor bgcolor

array

array.pop

Cette fonction supprime le dernier élément de l'array et renvoie sa valeur.

array.pop(id)

Exemple

            pine
            
            
// array.pop example
a = array.new_float(5,high)
removedEl = array.pop(a)
plot(array.size(a))
plot(removedEl)

Retourne une valeur
La valeur de l'élément supprimé.

paramètre

• id(any array type) Objets de la liste.

Voir aussi
array.new_float array.set array.push array.remove array.insert array.shift

array.shift

Cette fonction supprime le premier élément de l'array et renvoie sa valeur。

array.shift(id)

Exemple

            pine
            
            
// array.shift example
a = array.new_float(5,high)
removedEl = array.shift(a)
plot(array.size(a))
plot(removedEl)

Retourne une valeur
La valeur de l'élément supprimé.

paramètre

• id(any array type) Objets de la liste.

Voir aussi
array.unshift array.set array.push array.remove array.includes

array.unshift

Cette fonction insère une valeur dans la position initiale de l'array.

array.unshift(id, value)

Exemple

            pine
            
            
// array.unshift example
a = array.new_float(5, 0)
array.unshift(a, open)
plot(array.get(a, 0))

paramètre

• id(any array type) Objets de la liste.
• value (series <type of the array's elements>) à ajouter à la position initiale de l'array.

Voir aussi
array.shift array.set array.insert array.remove array.indexof

array.size

Cette fonction renvoie le nombre d'éléments dans l'array.

array.size(id)

Exemple

            pine
            
            
// array.size example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
// note that changes in slice also modify original array
slice = array.slice(a, 0, 5)
array.push(slice, open)
// size was changed in slice and in original array
plot(array.size(a))
plot(array.size(slice))

Retourne une valeur
Nombre d'éléments dans l'array.

paramètre

• id(any array type) Objets de la liste.

Voir aussi
array.new_float array.sum array.slice array.sort

array.slice

Cette fonction crée des fragments à partir d'une matrice existante. Si des modifications sont apportées aux objets du fragment, les modifications seront appliquées à la nouvelle matrice et à la matrice d'origine.

            
            
            
array.slice(id, index_from, index_to)

Exemple

            pine
            
            
// array.slice example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
// take elements from 0 to 4
// *note that changes in slice also modify original array 
slice = array.slice(a, 0, 5)
plot(array.sum(a) / 10)
plot(array.sum(slice) / 5)

Retourne une valeur
Une copie superficielle de l'array fragmenté.

paramètre

• id(any array type) Objets de la liste.
• index_from(series int) L'index commençant à zéro est utilisé pour commencer l'extraction.
• index_to(series int) L'index commençant à zéro avant que l'extraction soit terminée. La fonction extrait les éléments précédant cet index.

Voir aussi
array.new_float array.get array.sort

array.abs

Renvoie une matrice contenant les valeurs absolues de chaque élément de la matrice initiale.

            
            
            
array.abs(id)

paramètre

• id (int[]/float[Objets de la matrice.

Voir aussi
array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.binary_search

Cette fonction renvoie l'index de la valeur, et si la valeur n'est pas trouvée, elle renvoie −1. Les tableaux à rechercher doivent être classés par ordre décroissant.

            
            
            
array.binary_search(id, val)

Exemple

            pine
            
            
// array.binary_search
a = array.from(5, -2, 0, 9, 1)
array.sort(a) // [-2, 0, 1, 5, 9]
position = array.binary_search(a, 0) // 1
plot(position)

paramètre

• id (int[]/float[Objets de la matrice.
• val(series int/float) La valeur recherchée dans une matrice.

À noter
La recherche binaire s'applique à des arrays pré-sélectionnés par ordre croissant. Elle compare d'abord les éléments du milieu de l'array avec les valeurs cibles. Si les éléments correspondent aux valeurs cibles, elle renvoie leur position dans l'array.

Voir aussi
array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.binary_search_leftmost

Si la valeur est trouvée, la fonction renvoie l'index de cette valeur. Si la valeur n'est pas trouvée, la fonction renvoie l'index du plus petit élément suivant, si celui-ci se trouve dans l'array, à gauche de la position de la valeur. L'array à rechercher doit être ordonné par ordre croissant.

            
            
            
array.binary_search_leftmost(id, val)

Exemple

            pine
            
            
// array.binary_search_leftmost
a = array.from(5, -2, 0, 9, 1)
array.sort(a) // [-2, 0, 1, 5, 9]
position = array.binary_search_leftmost(a, 3) // 2
plot(position)

paramètre

• id (int[]/float[Objets de la matrice.
• val(series int/float) La valeur recherchée dans une matrice.

À noter
La recherche binaire s'applique à des arrays pré-sélectionnés par ordre croissant. Elle compare d'abord les éléments du milieu de l'array avec les valeurs cibles. Si les éléments correspondent aux valeurs cibles, elle renvoie leur position dans l'array.

Voir aussi
array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.binary_search_rightmost

Si la valeur est trouvée, la fonction renvoie l'index de la valeur. Si la valeur n'est pas trouvée, la fonction renvoie l'index de l'élément à droite de la position de la valeur dans l'array. L'array doit être ordonné par ordre croissant.

            
            
            
array.binary_search_rightmost(id, val)

Exemple

            pine
            
            
// array.binary_search_rightmost
a = array.from(5, -2, 0, 9, 1)
array.sort(a) // [-2, 0, 1, 5, 9]
position = array.binary_search_rightmost(a, 3) // 3
plot(position)

paramètre

• id (int[]/float[Objets de la matrice.
• val(series int/float) La valeur recherchée dans une matrice.

À noter
La recherche binaire fonctionne sur une matrice ordonnée en ordre croissant. Elle compare d'abord les éléments du milieu de la matrice aux valeurs cibles. Si les éléments correspondent aux valeurs cibles, elle renvoie leur position dans la matrice.

Voir aussi
array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.sort

Cette fonction ordonne les éléments de l'array.

            
            
            
array.sort(id, order)

Exemple

            pine
            
            
// array.sort example
a = array.new_float(0,0)
for i = 0 to 5
    array.push(a, high[i])
array.sort(a, order.descending)
if barstate.islast
    runtime.log(str.tostring(a))

paramètre

• id (int[]/float[]/string[Objets de la matrice.
• order(sort_order) ordre de sélection: order.ascending (par défaut) ou order.descending

Voir aussi
array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.sort_indices

Retourne une indexation d'une matrice qui, lorsqu'elle est utilisée pour indexer la matrice d'origine, accède à ses éléments dans l'ordre de leur sélection. Elle ne modifie pas la matrice d'origine.

            
            
            
array.sort_indices(id, order)

Exemple

            pine
            
            
// array.sort_indices
a = array.from(5, -2, 0, 9, 1)
sortedIndices = array.sort_indices(a) // [1, 2, 4, 0, 3]
indexOfSmallestValue = array.get(sortedIndices, 0) // 1
smallestValue = array.get(a, indexOfSmallestValue) // -2
plot(smallestValue)

paramètre

• id (int[]/float[]/string[Objets de la matrice.
• order(sort_order) L'ordre de sélection est l'ordre.ascending ou l'ordre.descending.

Voir aussi
array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.clear

Cette fonction supprime tous les éléments de l'array.

            
            
            
array.clear(id)

Exemple

            pine
            
            
// array.clear example
a = array.new_float(5,high)
array.clear(a)
array.push(a, close)
plot(array.get(a,0))
plot(array.size(a))

paramètre

• id(any array type) Objets de la liste.

Voir aussi
array.new_float array.insert array.push array.remove array.pop

array.concat

Cette fonction est utilisée pour fusionner deux matrices. Elle pousse tous les éléments de la deuxième matrice vers la première, puis retourne vers la première.

            
            
            
array.concat(id1, id2)

Exemple

            pine
            
            
// array.concat example
a = array.new_float(0,0)
b = array.new_float(0,0)
for i = 0 to 4
    array.push(a, high[i])
    array.push(b, low[i])
c = array.concat(a,b)
plot(array.size(a))
plot(array.size(b))
plot(array.size(c))

Retourne une valeur
Le premier tableau contient des éléments de fusion provenant du second tableau.

paramètre

• id1(any array type) Objet de la première ligne
• id2(any array type) Objet de la deuxième rangée。

Voir aussi
array.new_float array.insert array.slice

array.copy

Cette fonction crée une copie d'une matrice existante.

            
            
            
array.copy(id)

Exemple

            pine
            
            
// array.copy example
length = 5
a = array.new_float(length, close)
b = array.copy(a)
a := array.new_float(length, open)
plot(array.sum(a) / length)
plot(array.sum(b) / length)

Retourne une valeur
Une copie de la matrice.

paramètre

• id(any array type) Objets de la liste.

Voir aussi
array.new_float array.get array.slice array.sort

array.stdev

Cette fonction renvoie la différence standard des éléments de l'array.

            
            
            
array.stdev(id, biased)

Exemple

            pine
            
            
// array.stdev example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
plot(array.stdev(a))

Retourne une valeur
La norme des éléments de la matrice est différente.

paramètre

• id (int[]/float[Objets de la matrice.
• biased(series bool) Détermine quelle estimation doit être utilisée. Optionnel. La valeur par défaut est true.

À noter
Si vousbiasedSi c'est vrai, la fonction utilise une estimation partielle de l'ensemble, et si c'est faux, une estimation sans partialité de l'échantillon.

Voir aussi
array.new_float array.max array.min array.avg

array.standardize

Cette fonction renvoie un tableau d'éléments normalisés.

            
            
            
array.standardize(id)

Exemple

            pine
            
            
// array.standardize example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
b = array.standardize(a)
plot(array.min(b))
plot(array.max(b))

Retourne une valeur
Arrayes d'éléments normalisés.

paramètre

• id (int[]/float[Objets de la matrice.

Voir aussi
array.max array.min array.mode array.avg array.variance array.stdev

array.variance

Cette fonction renvoie le carré des éléments de l'array.

            
            
            
array.variance(id, biased)

Exemple

            pine
            
            
// array.variance example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
plot(array.variance(a))

Retourne une valeur
Le carré des éléments de l'array.

paramètre

• id (int[]/float[Objets de la matrice.
• biased(series bool) Détermine quelle estimation doit être utilisée. Optionnel. La valeur par défaut est true.

À noter
Si vousbiasedSi c'est vrai, la fonction utilise une estimation partielle de l'ensemble, et si c'est faux, une estimation sans partialité de l'échantillon.

Voir aussi
array.new_float array.stdev array.min array.avg array.covariance

array.covariance

Cette fonction renvoie la co-différence entre les deux matrices.

            
            
            
array.covariance(id1, id2, biased)

Exemple

            pine
            
            
// array.covariance example
a = array.new_float(0)
b = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
    array.push(b, open[i])
plot(array.covariance(a, b))

Retourne une valeur
La coïncidence des deux ensembles.

paramètre

• id1 (int[]/float[Objets de la matrice.
• id2 (int[]/float[Objets de la matrice.
• biased(series bool) Détermine quelle estimation doit être utilisée. Optionnel. La valeur par défaut est true.

À noter
Si vousbiasedSi c'est vrai, la fonction utilise une estimation partielle de l'ensemble, et si c'est faux, une estimation sans partialité de l'échantillon.

Voir aussi
array.new_float array.max array.stdev array.avg array.variance

array.fill

Cette fonction définit les éléments de l'array comme des valeurs individuelles. Si aucun index n'est spécifié, tous les éléments sont définis. Si seulement l'index initial est fourni (par défaut 0), les éléments commençant par cet index sont définis. Si deux paramètres d'index sont utilisés simultanément, les éléments sont définis de l'index initial à l'index final (par défaut na).

            
            
            
array.fill(id, value, index_from, index_to)

Exemple

            pine
            
            
// array.fill example
a = array.new_float(10)
array.fill(a, close)
plot(array.sum(a))

paramètre

• id(any array type) Objets de la liste.
• value (series <type of the array's elements>) est la valeur utilisée pour remplir un tableau.
• index_from(series int) Indice de démarrage, 0。 par défaut
• index_to(series int) Index de fin, par défaut na。 doit être supérieur à l'index du dernier élément à définir。

Voir aussi
array.new_float array.set array.slice

array.includes

Si cette valeur est trouvée dans l'array, la fonction retourne true, sinon false.

            
            
            
array.includes(id, value)

Exemple

            pine
            
            
// array.includes example
a = array.new_float(5,high)
p = close
if array.includes(a, high)
    p := open
plot(p)

Retourne une valeur
Si cette valeur est trouvée dans l'array, elle est vraie, sinon elle est fausse.

paramètre

• id(any array type) Objets de la liste.
• value (series <type of the array's elements>Les valeurs à rechercher dans l'array sont les suivantes:

Voir aussi
array.new_float array.indexof array.shift array.remove array.insert

array.insert

Cette fonction modifie le contenu de l'array en y ajoutant de nouveaux éléments au bon endroit.

            
            
            
array.insert(id, index, value)

Exemple

            pine
            
            
// array.insert example
a = array.new_float(5, close)
array.insert(a, 0, open)
plot(array.get(a, 5))

paramètre

• id(any array type) Objets de la liste.
• index(series int) Index des valeurs insérées.
• value (series <type of the array's elements>) à ajouter à l'array.

Voir aussi
array.new_float array.set array.push array.remove array.pop array.unshift

array.join

La fonction construit et renvoie de nouvelles chaînes en connectant tous les éléments de l'array, séparés par les chaînes de séparateurs spécifiées.

            
            
            
array.join(id, separator)

Exemple

            pine
            
            
// array.join example
a = array.new_float(5, 5)
runtime.log(array.join(a, ","))

paramètre

• id (int[]/float[]/string[Objets de la matrice.
• separator(series string) Une chaîne de caractères utilisée pour séparer les éléments d'un tableau.

Voir aussi
array.new_float array.set array.insert array.remove array.pop array.unshift

array.lastindexof

Cette fonction renvoie l'index de la dernière occurrence de la valeur. Si cette valeur n'est pas trouvée, elle renvoie -1.

            
            
            
array.lastindexof(id, value)

Exemple

            pine
            
            
// array.lastindexof example
a = array.new_float(5,high)
index = array.lastindexof(a, high)
plot(index)

Retourne une valeur
Index des éléments

paramètre

• id(any array type) Objets de la liste.
• value (series <type of the array's elements>Les valeurs à rechercher dans l'array sont les suivantes:

Voir aussi
array.new_float array.set array.push array.remove array.insert

array.max

Cette fonction renvoie la valeur maximale, ou la nème plus grande valeur de la matrice donnée.

            
            
            
array.max(id, nth)

Exemple

            pine
            
            
// array.max
a = array.from(5, -2, 0, 9, 1)
secondHighest = array.max(a, 2) // 1
plot(secondHighest)

Retourne une valeur
La plus grande valeur de l'array ou la nème plus grande valeur.

paramètre

• id (int[]/float[Objets de la matrice.
• nth(series int) renvoie la valeur la plus grande n, où 0 est la plus grande valeur. Optionnel. Zéro par défaut.

Voir aussi
array.new_float array.min array.sum

array.min

Cette fonction renvoie la valeur minimale, ou la n° minimale, d'une séquence donnée.

            
            
            
array.min(id, nth)

Exemple

            pine
            
            
// array.min
a = array.from(5, -2, 0, 9, 1)
secondLowest = array.min(a, 1) // 0
plot(secondLowest)

Retourne une valeur
La valeur la plus petite ou la nème plus petite de l'array.

paramètre

• id (int[]/float[Objets de la matrice.
• nth(series int) La valeur minimale n à retourner, où 0 est la valeur minimale. Optionnel. Zéro par défaut.

Voir aussi
array.new_float array.max array.sum

array.median

Cette fonction renvoie la médiane des éléments de l'array.

            
            
            
array.median(id)

Exemple

            pine
            
            
// array.median example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
plot(array.median(a))

Retourne une valeur
La médiane des éléments de l'array.

paramètre

• id (int[]/float[Objets de la matrice.

Voir aussi
array.avg array.variance array.min

array.mode

Cette fonction renvoie le mode des éléments de l'array. Si plusieurs valeurs ont la même fréquence, elle renvoie la valeur minimale.

            
            
            
array.mode(id)

Exemple

            pine
            
            
// array.mode example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
plot(array.mode(a))

Retourne une valeur
Modèle des éléments de la matrice.

paramètre

• id (int[]/float[Objets de la matrice.

Voir aussi
array.new_float array.avg array.variance array.min

array.percentile_linear_interpolation

Retourne le pourcentage spécifié de la valeur de l'arrayon (le pourcentage) inférieur ou égal à sa valeur, en utilisant une insertion linéaire.

            
            
            
array.percentile_linear_interpolation(id, percentage) 

paramètre

• id (int[]/float[Objets de la matrice.
• percentage(series int/float) doit être égal ou inférieur au pourcentage de la valeur retournée.

À noter
Dans les statistiques, le pourcentage est le pourcentage d'éléments du classement qui apparaissent à un certain score ou en dessous d'un certain score. Cette mesure indique le pourcentage de fractions dans la distribution de fréquence standard inférieure au pourcentage que vous mesurez. L'intervalle linéaire est estimé entre deux classements.

Voir aussi
array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.percentile_nearest_rank

La méthode du dernier rang renvoie la valeur de l'array pour laquelle le pourcentage spécifié (la décimale de pourcentage) est inférieur ou égal à sa valeur.

            
            
            
array.percentile_nearest_rank(id, percentage) 

paramètre

• id (int[]/float[Objets de la matrice.
• percentage(series int/float) doit être égal ou inférieur au pourcentage de la valeur retournée.

À noter
Dans les statistiques, un pourcentage est le pourcentage d'éléments de classement qui apparaissent à un certain score ou en dessous d'un certain score. Cette mesure indique le pourcentage de centièmes dans la distribution de fréquence standard de classement de pourcentage que vous mesurez.

Voir aussi
array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.percentrank

Retourne le pourcentage de la moyenne de la matrice.

            
            
            
array.percentrank(id, index) 

paramètre

• id (int[]/float[Objets de la matrice.
• index(series int) Calcule la valeur de son classement en pourcentage。

À noter
Le classement en pourcentage est le pourcentage d'éléments dans l'array inférieur ou égal à la valeur de référence.

Voir aussi
array.new_float array.insert array.slice array.reverse order.ascending order.descending

array.range

Cette fonction renvoie la différence entre les valeurs minimales et maximales d'un tableau donné.

            
            
            
array.range(id) 

Exemple

            pine
            
            
// array.range example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
plot(array.range(a))

Retourne une valeur
La différence entre les valeurs minimales et maximales de l'array.

paramètre

• id (int[]/float[Objets de la matrice.

Voir aussi
array.new_float array.min array.max array.sum

array.remove

Cette fonction modifie le contenu de l'array en supprimant les éléments dont l'index est spécifié.

array.remove(id, index)

Exemple

            pine
            
            
// array.remove example
a = array.new_float(5,high)
removedEl = array.remove(a, 0)
plot(array.size(a))
plot(removedEl)

Retourne une valeur
La valeur de l'élément supprimé.

paramètre

• id(any array type) Objets de la liste.
• index(series int) Index des éléments à supprimer

Voir aussi
array.new_float array.set array.push array.insert array.pop array.shift

array.reverse

Cette fonction inverse l'array. Le premier élément de l'array devient le dernier, et le dernier élément de l'array devient le premier.

            
            
            
array.reverse(id)

Exemple

            pine
            
            
// array.reverse example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
plot(array.get(a, 0))
array.reverse(a)
plot(array.get(a, 0))

paramètre

• id(any array type) Objets de la liste.

Voir aussi
array.new_float array.sort array.push array.set array.avg

array.from

Cette fonction prend un nombre variable de paramètres de l'un des types suivants: int, float, bool, string, line, color, linefill, et renvoie un tableau du type correspondant.

            
            
            
array.from(arg0, arg1, ...)

Exemple

            pine
            
            
// array.from_example
arr = array.from("Hello", "World!") // arr (string[]) will contain 2 elements: {Hello}, {World!}.
plot(close)

Retourne une valeur
Valeur de l'élément de la matrice.

paramètre

• arg0, arg1, ...(series int/float/bool/color/string/line/linefill) Paramètre de la série

array.new

Cette fonction crée une nouvelle<type>Objets de l'array élémentaire.

            
            
            
array.new(size, initial_value)

Exemple

            pine
            
            
// array.new<string> example
a = array.new<string>(1, "Hello, World!")
runtime.log(array.get(a, 0))

Exemple

            pine
            
            
// array.new<color> example
a = array.new<color>()
array.push(a, color.red)
array.push(a, color.green)
plot(close, color = array.get(a, close > open ? 1 : 0))

Exemple

            pine
            
            
// array.new<float> example
length = 5
var a = array.new<float>(length, close)
if array.size(a) == length
  array.remove(a, 0)
  array.push(a, close)
plot(array.sum(a) / length, "SMA")

Exemple

            pine
            
            
// array.new<line> example
// draw last 15 lines
var a = array.new<line>()
array.push(a, line.new(bar_index - 1, close[1], bar_index, close))
if array.size(a) > 15
    ln = array.shift(a)
    line.delete(ln)

Retourne une valeur
Identifiant d'un objet d'array pouvant être utilisé avec d'autres arrays.*La fonction () ≠

paramètre

• sizeLa taille initiale de la séquence (series int) est optionnelle. La valeur par défaut est 0
• initial_value(series <type>) La valeur initiale de tous les éléments de la séquence。 est facultative。 La valeur par défaut est <unk>na<unk>。

À noter
L'indexation de l'array commence par 0 [2].
Si vous souhaitez initialier un tableau et spécifier tous ses éléments en même temps, utilisez la fonction array.from。

Voir aussi
array.from array.push array.get array.size array.remove array.shift array.sum

array.new_bool

Cette fonction crée un nouvel objet d'array composé d'éléments de type bool。

            
            
            
array.new_bool(size, initial_value)

Exemple

            pine
            
            
// array.new_bool example
length = 5
a = array.new_bool(length, close > open)
plot(array.get(a, 0) ? close : open)

Retourne une valeur
Identifiant d'un objet d'array pouvant être utilisé avec d'autres arrays.*La fonction () ≠

paramètre

• sizeLa taille initiale de la séquence (series int) est optionnelle. La valeur par défaut est 0
• initial_value(series bool) La valeur initiale de tous les éléments de la séquence。 est facultative。 La valeur par défaut est <unk>na<unk>。

À noter
L'indexation de l'array commence par 0 [2].

Voir aussi
array.new_float array.get array.slice array.sort

array.new_float

Cette fonction crée un nouvel objet d'array d'éléments de type float.

            
            
            
array.new_float(size, initial_value)

Exemple

            pine
            
            
// array.new_float example
length = 5
a = array.new_float(length, close)
plot(array.sum(a) / length)

Retourne une valeur
Identifiant d'un objet d'array pouvant être utilisé avec d'autres arrays.*La fonction () ≠

paramètre

• sizeLa taille initiale de la séquence (series int) est optionnelle. La valeur par défaut est 0
• initial_value(series int/float) La valeur initiale de tous les éléments de la séquence。 est optionnelle。 la valeur par défaut est <unk>na<unk>。

À noter
L'indexation de l'array commence par 0 [2].

Voir aussi
array.new_bool array.get array.slice array.sort

array.new_int

Cette fonction crée un nouvel objet d'array composé d'éléments de type int。

            
            
            
array.new_int(size, initial_value)

Exemple

            pine
            
            
// array.new_int example
length = 5
a = array.new_int(length, int(close))
plot(array.sum(a) / length)

Retourne une valeur
Identifiant d'un objet d'array pouvant être utilisé avec d'autres arrays.*La fonction () ≠

paramètre

• sizeLa taille initiale de la séquence (series int) est optionnelle. La valeur par défaut est 0
• initial_value(series int) La valeur initiale de tous les éléments de la séquence。 est optionnelle。 La valeur par défaut est <unk>na<unk>。

À noter
L'indexation de l'array commence par 0 [2].

Voir aussi
array.new_float array.get array.slice array.sort

array.new_string

Cette fonction crée un nouvel objet d'array d'un élément de type string。

            
            
            
array.new_string(size, initial_value)

Exemple

            pine
            
            
// array.new_string example
length = 5
a = array.new_string(length, "text")
runtime.log(array.get(a, 0))

Retourne une valeur
Identifiant d'un objet d'array pouvant être utilisé avec d'autres arrays.*La fonction () ≠

paramètre

• sizeLa taille initiale de la séquence (series int) est optionnelle. La valeur par défaut est 0
• initial_value(series string) La valeur initiale de tous les éléments de la séquence。 est optionnelle。 La valeur par défaut est <unk>na<unk>。

À noter
L'indexation de l'array commence par 0 [2].

Voir aussi
array.new_float array.get array.slice

array.get

Cette fonction renvoie la valeur de l'élément dans l'index spécifié.

array.get(id, index)

Exemple

            pine
            
            
// array.get example
a = array.new_float(0)
for i = 0 to 9
  array.push(a, close[i] - open[i])
plot(array.get(a, 9))

Retourne une valeur
Valeur de l'élément de la matrice.

paramètre

• id(any array type) Objets de la liste.
• index(series int) Indice de l'élément dont la valeur est renvoyée.

Voir aussi
array.new_float array.set array.slice array.sort

array.push

Cette fonction applique une valeur à l'array ▽.

            
            
            
array.push(id, value)

Exemple

            pine
            
            
// array.push example
a = array.new_float(5, 0)
array.push(a, open)
plot(array.get(a, 5))

paramètre

• id(any array type) Objets de la liste.
• value (series <type of the array's elements>) Ajouter la valeur de l'élément à la fin de l'array。

Voir aussi
array.new_float array.set array.insert array.remove array.pop array.unshift

array.set

Cette fonction définit la valeur de l'élément comme l'index spécifié.

            
            
            
array.set(id, index, value) 

Exemple

            pine
            
            
// array.set example
a = array.new_float(10)
for i = 0 to 9
  array.set(a, i, close[i])
plot(array.sum(a) / 10)

paramètre

• id(any array type) Objets de la liste.
• index(series int) Modifier l'index des éléments.
• value (series <type of the array's elements>) La nouvelle valeur à définir.

Voir aussi
array.new_float array.get array.slice

array.sum

Cette fonction renvoie la somme des éléments de l'array.

            
            
            
array.sum(id) 

Exemple

            pine
            
            
// array.sum example
a = array.new_float(0)
for i = 0 to 9
  array.push(a, close[i])
plot(array.sum(a))

Retourne une valeur
La somme des éléments de l'array.

paramètre

• id (int[]/float[Objets de la matrice.

Voir aussi
array.new_float array.max array.min

array.avg

Cette fonction renvoie la moyenne des éléments de l'array.

            
            
            
array.avg(id)

Exemple

            pine
            
            
// array.avg example
a = array.new_float(0)
for i = 0 to 9
  array.push(a, close[i])
plot(array.avg(a))

Retourne une valeur
La moyenne des éléments de l'array.

paramètre

• id (int[]/float[Objets de la matrice.

Voir aussi
array.new_float array.max array.min array.stdev

array.indexof

Cette fonction renvoie l'index de la première occurrence de la valeur. Si la valeur n'est pas trouvée, elle renvoie -1.

            
            
            
array.indexof(id, value)

Exemple

            pine
            
            
// array.indexof example
a = array.new_float(5,high)
index = array.indexof(a, high)
plot(index)

Retourne une valeur
Index des éléments

paramètre

• id(any array type) Objets de la liste.
• value (series <type of the array's elements>Les valeurs à rechercher dans l'array sont les suivantes:

Voir aussi
array.lastindexof array.get array.lastindexof array.remove array.insert

strategy

existerstrategyDans les fonctions intégrées correspondantes, le nombre de points d'arrêt et de points de rupture est défini comme le nombre de fois que le prix a sauté. Par exemple:strategy.exitLa fonctionprofit、lossLes paramètres en points représentent les paramètres stop, stop, paramètreprofit10 est le nombre de sauts de prix multiplié par 10 comme différence de stop-loss, le saut de prix étant la variable internesyminfo.mintick。

strategy

Cette fonction définit plusieurs attributs de stratégie:
Attention, les références ne sont que pour soutenirtitle，shorttitle，overlay，pyramiding，default_qty_type，default_qty_valueParamètres, les autres paramètres peuvent être définis par les paramètres d'interface de la stratégie du langage PINE.

            
            
            
strategy(title, shorttitle, overlay, format, precision, scale, pyramiding, calc_on_order_fills, calc_on_every_tick, max_bars_back, backtest_fill_limits_assumption, default_qty_type, default_qty_value, initial_capital, currency, slippage, commission_type, commission_value, process_orders_on_close, close_entries_rule, margin_long, margin_short, explicit_plot_zorder, max_lines_count, max_labels_count, max_boxes_count, risk_free_rate) 

Exemple

            pine
            
            
strategy("Strategy", overlay = true)

// Enter long by market if current open is greater than previous high.
strategy.entry("Long", strategy.long, 1, when = open > high[1])
// Generate a full exit bracket (profit 10 points, loss 5 points per contract) from the entry named "Long".
strategy.exit("Exit", "Long", profit = 10, loss = 5)

paramètre

• title(const string) Le titre de l'indicateur que vous verrez dans le plugin Indicateur/stratégie. Les paramètres sont requis.
• shorttitle(const string) Le titre court de l'indicateur que vous verrez dans l'exemple de graphique. Les paramètres sont optionnels.
• overlay(const bool) Si true, l'indicateur est ajouté comme superposition de la série principale. Si false - il est ajouté dans une fenêtre de graphique séparée. False par défaut.
• format(const string) Le type de valeur possible pour formater une valeur d'indicateur sur l'axe de prix est: format.inherit, format.price, format.volume. Le format.inherit par défaut.
• precision(const int) Le nombre de chiffres après le nombre de points flottants de la valeur de l'indicateur sur l'axe des prix. Il doit être un nombre entier non négatif et ne pas être supérieur à 16. Si vous l'omettez, utilisez le format de la chaîne parentale. Si format est format.inherit et que vous définissez ce paramètre, format devient format.price
• scale(scale_type) L'indicateur doit suivre les coordonnées du prix. Les valeurs possibles sont: scale.right, scale.left, scale.none. La valeur scale.none ne peut être utilisée qu'en combinaison avec le paramètre 'overlay=true'.
• pyramiding(const int) Le nombre maximal d'entrées dans la même direction. Si cette valeur est 0, une seule entrée peut être ouverte dans la même direction et toute autre entrée sera rejetée. La valeur par défaut est 0。
• calc_on_order_fills(const bool) Calcul des commandes intrabar supplémentaires. Si le paramètre est défini sur <unk>true<unk>, la stratégie est recalculée une fois que la ligne K est remplie à l'intérieur de l'ordre (et pas seulement lorsque la ligne k est fermée). La valeur par défaut est <unk>false<unk>.
• calc_on_every_tick(const bool) Calcul de la stratégie intrabar supplémentaire. Si le paramètre est <unk>true<unk>, la stratégie calcule chaque minute en temps réel, sans fermer la ligne k. Le paramètre n'affecte pas le calcul de la stratégie pour les données historiques. La valeur par défaut est <unk>false<unk>.
• max_bars_back(const int) Le nombre maximal d'arcs pouvant être utilisés pour la stratégie de référence historique. Si les données historiques des variables sont citées dans le code du script, on utilise[Le paramètre sera appliqué à chaque variable intégrée ou variable utilisateur dans le script. La taille de la zone de mise en cache variable dans un script Pine est généralement détectée automatiquement. Cependant, dans certains cas, cela n'est pas possible, ce qui explique pourquoi le paramètre permet à l'utilisateur de définir manuellement la limite inférieure de cette valeur.
• backtest_fill_limits_assumption(const int) Supposition d'exécution de l'option de plafonnement. L'option de plafonnement ne sera négociée dans l'intrabar que si le prix du marché dépasse le nombre de ticks indiqué pour le niveau de plafonnement.
• default_qty_type(const string) défini pourqtyLes valeurs des paramètres sont indiquées dans les fonctions strategy.entry ou strategy.order. Les valeurs possibles sont: strategy.fixed pour les contrats / actions / numéros, strategy.cash pour le montant monétaire, ou strategy.percent_of_equity pour le pourcentage de droits d'intérêt disponibles.
• default_qty_value(const int/float) Le nombre de transactions par défaut d'une fonction strategy.entry ou strategy.order, dont l'unité est déterminée par le paramètre utilisé avec le paramètre 'default_qty_type' lorsque leur paramètre 'qty' n'est pas défini.
• currency(const string) La devise de compte de cette stratégie。 est facultative。 La valeur par défaut est la devise de la marchandise sur le graphique。 les valeurs possibles sont: currency.NONE, currency.USD, currency.EUR, currency.AUD, currency.GBP, currency.NZD, currency.CAD, currency.CHF, currency.HKD, currency.JPY, currency.NOK, currency.SEK, currency.SGD, currency.TRY, currency.ZAR, currency.BTC, currency.ETH, currency.MYR, currency.KRW。
• slippage(const int) Le point de glissement de tick est ajouté ou soustrait du prix d'achat ou de vente d'un ordre d'achat ou d'arrêt. Si mintick = 0.01 et le point de glissement est égal à 5, le point de glissement total sera 5 * 0.01 = 0.05
• commission_type(const string) Type de commission pour chaque commande. Les valeurs autorisées sont: strategy.commission.percent, strategy.commission.cash_per_contract, strategy.commission.cash_per_order.
• commission_value(const int/float) Valeur de commission de la commande ≠ % ou montant, selon le type de commission choisi ≠
• ~~process_orders_on_close~~Si (const bool) est configuré sur la case true, d'autres tentatives d'exécution d'ordres sont générées après que la carte ait été clôturée et que le calcul de la stratégie ait été terminé. Si les ordres sont des ordres au marché, le simulateur de courtage les exécute avant l'ouverture de la carte suivante. Si les ordres sont des prix limites, les ordres ne sont exécutés que si les conditions de prix sont remplies.
• close_entries_rule(const string) Détermine l'ordre de fermeture des ordres. Les valeurs autorisées sont: 'FIFO' ou 'ANY'. FIFO (First-In, First-Out) signifie que lorsque plusieurs transactions sont ouvertes, la première transaction doit être fermée.
• max_lines_count(const int) affiche le nombre de diagrammes à barres les plus récents. La valeur par défaut est 50, la valeur maximale autorisée est 500.
• max_labels_count(const int) affiche le nombre de balises les plus récentes. La valeur par défaut est de 50, la valeur maximale autorisée est de 500.
• max_boxes_count(const int) Le nombre de dessins de boîtes de la dernière boîte affiché. La valeur par défaut est 50, la valeur maximale autorisée est de 500.
• margin_long(const int/float) La prime de plusieurs titres est le pourcentage du prix d'achat d'un titre dont la position de plusieurs titres doit être couverte en espèces ou par une caution. Elle doit être non négative. Elle est facultative. La valeur par défaut est 100
• margin_short(const int/float) La garantie de tête vide est le pourcentage du prix d'achat d'un titre dont la position de tête vide doit être couverte en espèces ou par un colis. Elle doit être non négative.
• explicit_plot_zorder(const bool) Définit le tracé, le remplissage et l'ordre d'affichage des lignes horizontales des indicateurs. Si true, le graphique est tracé dans l'ordre dans lequel ils apparaissent dans le code de l'indicateur, chaque nouveau graphique est tracé sur le graphique précédent.*Les fonctions () , fill et hline. sont optionnelles. La valeur par défaut est false.
• initial_capital(const int/float) La quantité de fonds initialement disponible pour les transactions stratégiques, représentée par la devise définie dans la devise de la devise. Optionnel. La valeur par défaut est 1000000
• risk_free_rate(const int/float) Le taux de rendement sans risque est la variation annuelle en pourcentage de la valeur d'un investissement avec un risque minimal ou nul, utilisée pour calculer le ratio Sharpe et Sortino. La valeur par défaut est 2

À noter
Chaque script de stratégie doit avoir un appel de stratégie.
Le code PineScript qui utilise le paramètre calc_on_every_tick = true peut effectuer des calculs différents pour les enregistrements historiques et les données en temps réel.
Lorsque vous utilisez un type de graphique non standard comme base de stratégie, vous devez savoir que les résultats peuvent varier. Les ordres seront exécutés au prix de ce type de graphique (par exemple, pour Heikin Ashi, le prix de Heikin Ashi sera utilisé (en moyenne) et non le prix réel du marché). Nous vous recommandons fortement d'utiliser le type de graphique standard dans votre stratégie.

Voir aussi
indicator

strategy.entry

Il s'agit d'un ordre d'entrée sur le marché. Si un ordre avec le même ID est déjà en suspens, l'ordre peut être modifié. Si aucun ordre avec le même ID n'est spécifié, un nouvel ordre est émis. Pour désactiver l'ordre d'entrée, l'ordre doit être utilisé.

            
            
            
strategy.entry(id, direction, qty, limit, stop, oca_name, oca_type, comment, when, alert_message) 

Exemple

            pine
            
            
strategy(title = "simple strategy entry example")
strategy.entry("enter long", strategy.long, 1, when = open > high[1]) // enter long by market if current open great then previous high
strategy.entry("enter short", strategy.short, 1, when = open < low[1]) // enter short by market if current open less then previous low

paramètre

• id(series string) Paramètre requis。 Identificateur de commande。 Les commandes peuvent être annulées ou modifiées en se référant à leur identifiant。
• direction(strategy_direction) Un paramètre nécessaire. Direction de la position du marché: 'strategy.long' est une direction multiple et 'strategy.short' est une direction vide.
• qty(series int/float) Paramètres à choisir. Nombre de contrats/actions/heures/unités négociés. La valeur par défaut est 'NaN'
• limit(series int/float) Paramètre facultatif。 le prix limite de la commande。 le type de commande est "limit" ou "stop-limit" si spécifié。 les autres types de commande sont "NaN"。
• stop(series int/float) Paramètre facultatif. Le type d'ordre est "stop" ou "stop-limit" si spécifié. Les autres types d'ordres sont "NaN".
• oca_name(series string) Paramètre facultatif. La commande appartient au nom du groupe OCA. Si la commande n'appartient à aucun groupe OCA, il devrait y avoir un caractère blanc.Remarque: FMZ ne prend pas en charge ce paramètre.
• oca_type(input string) Paramètres optionnels. Type de groupe d'ordres OCA. Les valeurs autorisées sont: strategy.oca.none - l'ordre ne doit pas appartenir à un groupe OCA spécifique; strategy.oca.cancel - l'ordre doit appartenir à un groupe OCA, et une fois que l'ordre est passé, tous les autres ordres du même groupe seront annulés; strategy.oca.reduce - l'ordre doit appartenir à un groupe OCA, et si X nombre de contrats d'ordres ont été placés, le nombre d'autres contrats d'ordres du même groupe OCA est réduit par X.Remarque: FMZ ne prend pas en charge ce paramètre.
• comment(series string) Paramètres à choisir. Les autres détails de la commande.
• when(series bool) Paramètre facultatif。 État de la commande。 Si "true", la commande est placée。 Si "false", rien ne se passe ((une commande avec le même ID placée précédemment n'est pas annulée)。 La valeur par défaut est "true"。
• alert_message(series string) Un paramètre à choisir lorsque le symbole {{strategy.order.alert_message}} est utilisé dans le champ de message d'alerte de la boîte de dialogue de création d'une alerte.

strategy.close

Il s'agit d'un ordre de sortie avec un identifiant spécifié. S'il y a plusieurs ordres d'entrée avec le même identifiant, ils seront tous sortis en même temps. Si aucun ordre d'ouverture avec un identifiant spécifié n'a été déclenché au moment du déclenchement de l'ordre, l'ordre n'aura pas d'effet. L'ordre utilise un ordre de marché.

            
            
            
strategy.close(id, when, comment, qty, qty_percent, alert_message) 

Exemple

            pine
            
            
strategy("closeEntry Demo", overlay=false)
strategy.entry("buy", strategy.long, when = open > close)
strategy.close("buy", when = open < close, qty_percent = 50, comment = "close buy entry for 50%")
plot(strategy.position_size)

paramètre

• id(series string) Paramètre requis。 Identificateur de commande。 La commande peut être fermée en citant son identifiant。
• when(series bool) Paramètre sélectionnable。 Condition de la commande。
• qty(series int/float) Paramètre sélectionnable. Le nombre de contrats/actions/heures/unités de sortie de la transaction. La valeur par défaut est 'NaN'
• qty_percent(series int/float) Définit le pourcentage de placement en bourse ((0-100) ◦ dont la priorité est inférieure à la priorité du paramètre 'qty'). Optionnel. La valeur par défaut est 100
• comment(series string) Paramètres à choisir. Les autres détails de la commande.
• alert_message(series string) Un paramètre à choisir lorsque le symbole {{strategy.order.alert_message}} est utilisé dans le champ de message d'alerte de la boîte de dialogue de création d'une alerte.

strategy.close_all

Il s'agit d'une opération de liquidation d'une position sur le marché pour la stabiliser.

            
            
            
strategy.close_all(when, comment, alert_message) 

Exemple

            pine
            
            
strategy("closeAll Demo", overlay=false)
strategy.entry("buy", strategy.long, when = open > close)
strategy.close_all(when = open < close, comment = "close all entries")
plot(strategy.position_size)

paramètre

• when(series bool) Paramètre sélectionnable。 Condition de la commande。
• comment(series string) Paramètres à choisir. Les autres détails de la commande.
• alert_message(series string) Un paramètre à choisir lorsque le symbole {{strategy.order.alert_message}} est utilisé dans le champ de message d'alerte de la boîte de dialogue de création d'une alerte.

strategy.exit

Il s'agit d'un ordre de sortie désignant une entrée ou une position sur l'ensemble du marché. Si un ordre avec le même ID est déjà en suspens, l'ordre peut être modifié. Si un ordre d'entrée n'a pas été négocié, mais qu'un ordre de sortie apparaît, l'ordre de sortie est suspendu jusqu'à ce que l'ordre de sortie puisse être placé après la négociation d'un ordre d'entrée.

            
            
            
strategy.exit(id, from_entry, qty, qty_percent, profit, limit, loss, stop, trail_price, trail_points, trail_offset, oca_name, comment, when, alert_message) 

Exemple

            pine
            
            
strategy(title = "simple strategy exit example")
strategy.entry("long", strategy.long, 1, when = open > high[1]) // enter long by market if current open great then previous high
strategy.exit("exit", "long", profit = 10, loss = 5) // generate full exit bracket (profit 10 points, loss 5 points per contract) from entry with name "long"

paramètre

• id(series string) Paramètre requis。 Identificateur de commande。 Les commandes peuvent être annulées ou modifiées en se référant à leur identifiant。
• from_entry(series string) Paramètre sélectionnable。 Exit avec un identifiant d'ordre d'entrée spécifié。 Exit de toutes les positions avec une chaîne vide。 La valeur par défaut est une chaîne vide。
• qty(series int/float) Paramètre sélectionnable. Le nombre de contrats/actions/heures/unités de sortie de la transaction. La valeur par défaut est 'NaN'
• qty_percent(series int/float) Définit le pourcentage de placement en bourse ((0-100) ◦ dont la priorité est inférieure à la priorité du paramètre 'qty'). Optionnel. La valeur par défaut est 100
• profit(series int/float) paramètre optionnel. Objectif de profit (indiqué en points) Si spécifié, sortie de la position sur ordre de plafonnement lorsque le montant de profit indiqué (en points) est atteint. La valeur par défaut est <unk>NaN<unk>
• limit(series int/float) paramètre facultatif ◦ objectif de profit ◦ prix spécifié ◦ sortie du marché à un prix spécifié ◦ ou mieux ◦ priorité du paramètre 'limit' supérieure à la priorité du paramètre 'profit' ◦ si la valeur n'est pas 'NaN', 'limit' remplace 'profit') ◦ valeur par défaut est <unk>NaN<unk> ◦
• loss(series int/float) paramètre optionnel ≠ Stop loss (indiqué en points) ≠ Si spécifié, sortie du marché avec un stop loss (indiqué en points) ≠ Si la valeur par défaut est <unk>NaN<unk>
• stop(series int/float) paramètre facultatif ≠ Stop loss (prix à spécifier) ≠ Exit position de marché à prix spécifié (ou moins) si spécifié ≠ Priorité de paramètre 'stop loss' supérieure à la priorité de paramètre 'loss' (si valeur n'est pas 'NaN', alors 'stop loss' au lieu de 'loss') ≠ valeur par défaut est <unk>NaN<unk>
• trail_price(series int/float) paramètres optionnels. Tracking stop activation level ((prix à spécifier)) Si spécifié, le stop est placé lorsque le prix spécifié est atteint. Dans le paramètre de la colonne trail_offset, le décalage est spécifié pour déterminer le prix initial de la colonne tracking stop ((en points): X points en dessous du niveau d'activation pour quitter le multiple; X points au-dessus du niveau d'activation pour quitter le vide. La valeur par défaut est NaN<unk>.
• trail_points(series int/float) paramètres optionnels. Tracking Stop Loss Activation Level (indiqué en points pour les bénéfices). Si spécifié, placement d'un Stop Loss Tracking Order (indiqué en points pour les bénéfices) lorsque le niveau de prix calculé est atteint.
• trail_offset(series int/float) paramètres optionnels. Tracking stop activation level ((exprimé en points). Le décalage en points est utilisé pour déterminer le prix initial d'un stop tracking: X points en dessous de 'trail_price' ou 'trail_points' pour quitter le multi-titres; X points en haut de 'trail_price' ou 'trail_points' pour quitter le vide.
• oca_name(series string) Paramètre sélectionnable. Nom du groupe OCA (oca_type = strategy.oca.reduce) Objectif de profit, stop loss/tracking stop loss. Si le nom n'est pas spécifié, il sera généré automatiquement.Remarque: FMZ ne prend pas en charge ce paramètre.
• comment(series string) Paramètres à choisir. Les autres détails de la commande.
• when(series bool) Paramètre facultatif。 État de la commande。 Si "true", la commande est placée。 Si "false", rien ne se passe ((une commande avec le même ID placée précédemment n'est pas annulée)。 La valeur par défaut est "true"。
• alert_message(series string) Un paramètre à choisir lorsque le symbole {{strategy.order.alert_message}} est utilisé dans le champ de message d'alerte de la boîte de dialogue de création d'une alerte.

strategy.cancel

Il s'agit d'une commande qui utilise le nom de référence pour annuler / désactiver toutes les listes prédéfinies et qui est générée par les fonctions suivantes: strategy.order, strategy.entry et strategy.exit.

            
            
            
strategy.cancel(id, when) 

Exemple

            pine
            
            
strategy(title = "simple order cancellation example")
conditionForBuy = open > high[1]
strategy.entry("long", strategy.long, 1, limit = low, when = conditionForBuy) // enter long using limit order at low price of current bar if conditionForBuy is true
strategy.cancel("long", when = not conditionForBuy) // cancel the entry order with name "long" if conditionForBuy is false

paramètre

• id(series string) Paramètre à sélectionner. Identification de la commande. Positionner cette identification pour annuler une commande.
• when(series bool) Paramètre optionnel. Annuler une commande en fonction de l'ID. Si elle est "true", l'ordre est annulé. La valeur par défaut est "true".

strategy.cancel_all

Il s'agit d'une commande d'annulation/déclenchement de toutes les commandes de liste pré-enregistrée, générée par les fonctions suivantes: strategy.order, strategy.entry et strategy.exit.

            
            
            
strategy.cancel_all(when) 

Exemple

            pine
            
            
strategy(title = "simple all orders cancellation example")
conditionForBuy1 = open > high[1]
strategy.entry("long entry 1", strategy.long, 1, limit = low, when = conditionForBuy1) // enter long by limit if conditionForBuy1 is true
conditionForBuy2 = conditionForBuy1 and open[1] > high[2]
strategy.entry("long entry 2", strategy.long, 1, limit = ta.lowest(low, 2), when = conditionForBuy2) // enter long by limit if conditionForBuy2 is true
conditionForStopTrading = open < ta.lowest(low, 2)
strategy.cancel_all(conditionForStopTrading) // cancel both limit orders if the conditon conditionForStopTrading is true

paramètre

• when(series bool) Paramètre optionnel ≠ annuler les conditions de toutes les commandes ≠ annuler toutes les commandes actives si la condition est vraie ≠ la valeur par défaut est <unk>true<unk>

strategy.order

Il s'agit d'une commande de la commande suivante. Si une commande avec le même ID est déjà en suspens, la commande peut être modifiée. Si aucune commande avec le même ID n'est spécifiée, une nouvelle commande est émise.

            
            
            
strategy.order(id, direction, qty, limit, stop, oca_name, oca_type, comment, when, alert_message)

Exemple

            
            
            
strategy(title = "simple strategy order example")
strategy.order("buy", strategy.long, 1, when = open > high[1]) // buy by market if current open great then previous high
strategy.order("sell", strategy.short, 1, when = open < low[1]) // sell by market if current open less then previous low

paramètre

• id(series string) Paramètre requis。 Identificateur de commande。 Les commandes peuvent être annulées ou modifiées en se référant à leur identifiant。
• direction(strategy_direction) Un paramètre nécessaire. Direction de la commande: 'strategy.long' pour acheter et 'strategy.short' pour vendre
• qty(series int/float) Paramètres à choisir. Nombre de contrats/actions/heures/unités négociés. La valeur par défaut est 'NaN'
• limit(series int/float) Paramètre facultatif。 le prix limite de la commande。 le type de commande est "limit" ou "stop-limit" si spécifié。 les autres types de commande sont "NaN"。
• stop(series int/float) Paramètre facultatif. Le type d'ordre est "stop" ou "stop-limit" si spécifié. Les autres types d'ordres sont "NaN".
• oca_name(series string) Paramètre facultatif. La commande appartient au nom du groupe OCA. Si la commande n'appartient à aucun groupe OCA, il devrait y avoir un caractère blanc.Remarque: FMZ ne prend pas en charge ce paramètre.
• oca_type(input string) Paramètres optionnels. Type de groupe d'ordres OCA. Les valeurs autorisées sont: strategy.oca.none - l'ordre ne doit pas appartenir à un groupe OCA spécifique; strategy.oca.cancel - l'ordre doit appartenir à un groupe OCA, et une fois que l'ordre est passé, tous les autres ordres du même groupe seront annulés; strategy.oca.reduce - l'ordre doit appartenir à un groupe OCA, et si X nombre de contrats d'ordres ont été placés, le nombre d'autres contrats d'ordres du même groupe OCA est réduit par X.Remarque: FMZ ne prend pas en charge ce paramètre.
• comment(series string) Paramètres à choisir. Les autres détails de la commande.
• when(series bool) Paramètre facultatif。 État de la commande。 Si "true", la commande est placée。 Si "false", rien ne se passe ((une commande avec le même ID placée précédemment n'est pas annulée)。 La valeur par défaut est "true"。
• alert_message(series string) Un paramètre à choisir lorsque le symbole {{strategy.order.alert_message}} est utilisé dans le champ de message d'alerte de la boîte de dialogue de création d'une alerte.

strategy.opentrades.entry_bar_index

Le bar_index qui renvoie à une entrée en bourse non liquidée.

            
            
            
strategy.opentrades.entry_bar_index(trade_num)

Attendre 10 lignes K et faire le plein.

Exemple

            pine
            
            
strategy("`strategy.opentrades.entry_bar_index` Example")

barsSinceLastEntry() =>
    strategy.opentrades > 0 ? bar_index - strategy.opentrades.entry_bar_index(strategy.opentrades - 1) : na

// Enter a long position if there are no open positions.
if strategy.opentrades == 0
    strategy.entry("Long",  strategy.long)

// Close the long position after 10 bars. 
if barsSinceLastEntry() >= 10
    strategy.close("Long")

paramètre

• trade_num(series int) Numéro de transaction de la transaction non liquidée 。 Le numéro de la première transaction est zéro 。

Voir aussi
strategy.closedtrades.entry_bar_index strategy.closedtrades.exit_bar_index

strategy.opentrades.entry_id

L'ID de l'opérateur qui a effectué l'ouverture d'une transaction non liquidée.

            
            
            
strategy.opentrades.entry_id(trade_num)

Exemple

            pine
            
            
strategy("`strategy.opentrades.entry_id` Example", overlay = true)

// We enter a long position when 14 period sma crosses over 28 period sma.
// We enter a short position when 14 period sma crosses under 28 period sma.
longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))

// Strategy calls to enter a long or short position when the corresponding condition is met.
if longCondition
    strategy.entry("Long entry at bar #" + str.tostring(bar_index), strategy.long)
if shortCondition
    strategy.entry("Short entry at bar #" + str.tostring(bar_index), strategy.short)

// Display ID of the latest open position.
if barstate.islastconfirmedhistory
    runtime.log("Last opened position is " + strategy.opentrades.entry_id(strategy.opentrades - 1))

Retourne une valeur
L'ID de l'opérateur qui a effectué l'ouverture d'une transaction non liquidée.

paramètre

• trade_num(series int) Numéro de transaction de la transaction non liquidée 。 Le numéro de la première transaction est zéro 。

À noter
Si trade_num n'est pas dans la fourchette, la fonction renvoie na:0 à strategy.opentrades-1。

Voir aussi
strategy.opentrades.entry_bar_index strategy.opentrades.entry_time

strategy.opentrades.entry_price

Le prix d'entrée de la transaction non liquidée.

            
            
            
strategy.opentrades.entry_price(trade_num)

Exemple

            pine
            
            
strategy("strategy.closedtrades.entry_price Example 1")

// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.
if bar_index % 15 == 0
    strategy.entry("Long", strategy.long)
if bar_index % 20 == 0
    strategy.close("Long")

// Return the entry price for the latest closed trade.
entryPrice = strategy.closedtrades.entry_price(strategy.closedtrades - 1)

plot(entryPrice, "Long entry price")

Calculer le prix moyen d'une position non liquidée

Exemple

            pine
            
            
strategy("strategy.opentrades.entry_price Example 2", pyramiding = 2)

// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.
if bar_index % 15 == 0
    strategy.entry("Long", strategy.long)
if bar_index % 20 == 0
    strategy.close("Long")

// Calculate average open position price.
avgOpenPositionPrice() =>
    sumOpenPositionPrice = 0.0
    for tradeNo = 0 to strategy.opentrades - 1
        sumOpenPositionPrice += strategy.opentrades.entry_price(tradeNo) * strategy.opentrades.size(tradeNo) / strategy.position_size
    result = nz(sumOpenPositionPrice / strategy.opentrades)

plot(avgOpenPositionPrice())

paramètre

• trade_num(series int) Numéro de transaction de la transaction non liquidée 。 Le numéro de la première transaction est zéro 。

Voir aussi
strategy.closedtrades.exit_price

strategy.opentrades.entry_time

Retour à l'heure UNIX de l'entrée en bourse sans avoir encore réglé la position.

            
            
            
strategy.opentrades.entry_time(trade_num)

Exemple

            pine
            
            
strategy("strategy.opentrades.entry_time Example")

// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.
if bar_index % 15 == 0
    strategy.entry("Long", strategy.long)
if bar_index % 20 == 0
    strategy.close("Long")

// Calculates duration in milliseconds since the last position was opened.
timeSinceLastEntry()=>
    strategy.opentrades > 0 ? (time - strategy.opentrades.entry_time(strategy.opentrades - 1)) : na

plot(timeSinceLastEntry() / 1000 * 60 * 60 * 24, "Days since last entry")

paramètre

• trade_num(series int) Numéro de transaction de la transaction non liquidée 。 Le numéro de la première transaction est zéro 。

Voir aussi
strategy.closedtrades.entry_time strategy.closedtrades.exit_time

strategy.opentrades.profit

Les pertes de retour sur les transactions non liquidées. Les pertes sont exprimées en valeur négative.

            
            
            
strategy.opentrades.profit(trade_num)

Retour sur les bénéfices de la dernière transaction ouverte

Exemple

            pine
            
            
strategy("`strategy.opentrades.profit` Example 1", commission_type = strategy.commission.percent, commission_value = 0.1)

// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.
if bar_index % 15 == 0
    strategy.entry("Long", strategy.long)
if bar_index % 20 == 0
    strategy.close("Long")

plot(strategy.opentrades.profit(strategy.opentrades - 1), "Profit of the latest open trade")

Calculer le bénéfice de toutes les transactions non liquidées

Exemple

            pine
            
            
strategy("`strategy.opentrades.profit` Example 2", pyramiding = 5)

// Strategy calls to enter 5 long positions every 2 bars.
if bar_index % 2 == 0
    strategy.entry("Long", strategy.long, qty = 5)

// Calculate open profit or loss for the open positions.
tradeOpenPL() =>
    sumProfit = 0.0
    for tradeNo = 0 to strategy.opentrades - 1
        sumProfit += strategy.opentrades.profit(tradeNo)
    result = sumProfit
    
plot(tradeOpenPL(), "Profit of all open trades")

paramètre

• trade_num(series int) Numéro de transaction de la transaction non liquidée 。 Le numéro de la première transaction est zéro 。

Voir aussi
strategy.closedtrades.profit strategy.openprofit strategy.netprofit strategy.grossprofit

strategy.opentrades.size

Retourne la direction de la transaction et le nombre de contrats dans une transaction en cours. Si cette valeur est supérieure à 0, la position du marché est en tête. Si cette valeur est inférieure à 0, la position du marché est vide.

            
            
            
strategy.opentrades.size(trade_num)

Exemple

            pine
            
            
strategy("`strategy.opentrades.size` Example 1")

// We calculate the max amt of shares we can buy.
amtShares = math.floor(strategy.equity / close)
// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars
if bar_index % 15 == 0
    strategy.entry("Long", strategy.long, qty = amtShares)
if bar_index % 20 == 0
    strategy.close("Long")

// Plot the number of contracts in the latest open trade.
plot(strategy.opentrades.size(strategy.opentrades - 1), "Amount of contracts in latest open trade")

Pourcentage de bénéfices moyens sur les transactions non liquidées

Exemple

            pine
            
            
strategy("`strategy.opentrades.size` Example 2")

// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.
if bar_index % 15 == 0
    strategy.entry("Long", strategy.long)
if bar_index % 20 == 0
    strategy.close("Long")

// Calculate profit for all open trades.
profitPct = 0.0
for tradeNo = 0 to strategy.opentrades - 1
    entryP = strategy.opentrades.entry_price(tradeNo)
    exitP = close
    profitPct += (exitP - entryP) / entryP * strategy.opentrades.size(tradeNo) * 100
    
// Calculate average profit percent for all open trades.
avgProfitPct = nz(profitPct / strategy.opentrades)

paramètre

• trade_num(series int) Numéro de transaction de la transaction non liquidée 。 Le numéro de la première transaction est zéro 。

Voir aussi
strategy.closedtrades.size strategy.position_size strategy.opentrades strategy.closedtrades

strategy.closedtrades.entry_bar_index

Il retourne le bar_index de l'entrée de la transaction qui a été liquidée.

            
            
            
strategy.closedtrades.entry_bar_index(trade_num)

Exemple

            pine
            
            
strategy("strategy.closedtrades.entry_bar_index Example")
// Enter long trades on three rising bars; exit on two falling bars.
if ta.rising(close, 3)
    strategy.entry("Long", strategy.long)
if ta.falling(close, 2)
    strategy.close("Long")
// Function that calculates the average amount of bars in a trade.
avgBarsPerTrade() =>
    sumBarsPerTrade = 0
    for tradeNo = 0 to strategy.closedtrades - 1
        // Loop through all closed trades, starting with the oldest.
        sumBarsPerTrade += strategy.closedtrades.exit_bar_index(tradeNo) - strategy.closedtrades.entry_bar_index(tradeNo) + 1
    result = nz(sumBarsPerTrade / strategy.closedtrades)
plot(avgBarsPerTrade())

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi
strategy.closedtrades.exit_bar_index strategy.opentrades.entry_bar_index

strategy.closedtrades.exit_price

Retour au prix de départ d'une transaction qui a été liquidée.

            
            
            
strategy.closedtrades.exit_price(trade_num)

Exemple

            pine
            
            
strategy("strategy.closedtrades.exit_price Example 1")

// We are creating a long trade every 5 bars
if bar_index % 5 == 0
    strategy.entry("Long",  strategy.long)
strategy.close("Long")

// Return the exit price from the latest closed trade.
exitPrice = strategy.closedtrades.exit_price(strategy.closedtrades - 1)

plot(exitPrice, "Long exit price")

Calculer le pourcentage de bénéfices moyens sur toutes les transactions qui ont été liquidées

Exemple

            pine
            
            
strategy("strategy.closedtrades.exit_price Example 2")

// Strategy calls to create single short and long trades.
if bar_index == last_bar_index - 15
    strategy.entry("Long Entry",  strategy.long)
else if bar_index == last_bar_index - 10
    strategy.close("Long Entry")
    strategy.entry("Short", strategy.short)
else if bar_index == last_bar_index - 5
    strategy.close("Short")

// Calculate profit for both closed trades.
profitPct = 0.0
for tradeNo = 0 to strategy.closedtrades - 1
    entryP = strategy.closedtrades.entry_price(tradeNo)
    exitP = strategy.closedtrades.exit_price(tradeNo)
    profitPct += (exitP - entryP) / entryP * strategy.closedtrades.size(tradeNo) * 100
    
// Calculate average profit percent for both closed trades.
avgProfitPct = nz(profitPct / strategy.closedtrades)

plot(avgProfitPct)

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi
strategy.closedtrades.entry_price

strategy.closedtrades.exit_bar_index

Le retour de bar_index de sortie d'une transaction qui a été clôturée

            
            
            
strategy.closedtrades.exit_bar_index(trade_num)

Exemple

            pine
            
            
strategy("strategy.closedtrades.exit_bar_index Example 1")

// Strategy calls to place a single short trade. We enter the trade at the first bar and exit the trade at 10 bars before the last chart bar.
if bar_index == 0
    strategy.entry("Short",  strategy.short)
if bar_index == last_bar_index - 10
    strategy.close("Short")

// Calculate the amount of bars since the last closed trade.
barsSinceClosed = strategy.closedtrades > 0 ? bar_index - strategy.closedtrades.exit_bar_index(strategy.closedtrades - 1) : na

plot(barsSinceClosed, "Bars since last closed trade")

Calculer le nombre moyen de lignes K pour chaque transaction.

Exemple

            pine
            
            
strategy("strategy.closedtrades.exit_bar_index Example 2")

// Enter long trades on three rising bars; exit on two falling bars.
if ta.rising(close, 3)
    strategy.entry("Long", strategy.long)
if ta.falling(close, 2)
    strategy.close("Long")

// Function that calculates the average amount of bars per trade.
avgBarsPerTrade() =>
    sumBarsPerTrade = 0
    for tradeNo = 0 to strategy.closedtrades - 1
        // Loop through all closed trades, starting with the oldest.
        sumBarsPerTrade += strategy.closedtrades.exit_bar_index(tradeNo) - strategy.closedtrades.entry_bar_index(tradeNo) + 1
    result = nz(sumBarsPerTrade / strategy.closedtrades)

plot(avgBarsPerTrade())

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi
bar_index

strategy.closedtrades.entry_id

L'id de l'entrée qui a été renvoyée pour la transaction qui a été liquidée.

            
            
            
strategy.closedtrades.entry_id(trade_num)

Exemple

            pine
            
            
strategy("strategy.closedtrades.entry_id Example", overlay = true)
var isOpen = false 
var openIndex = -1
// Enter a short position and close at the previous to last bar.
if not barstate.ishistory and not isOpen
    strategy.entry("Short at bar #" + str.tostring(bar_index), strategy.short)
    isOpen := true
    openIndex := bar_index
if openIndex != -1 and bar_index > openIndex + 100
    strategy.close_all()
    
// Display ID of the last entry position.
if barstate.islastconfirmedhistory
    runtime.log("Last Entry ID is: " + strategy.closedtrades.entry_id(strategy.closedtrades - 1))

Retourne une valeur
L'id de l'entrée qui a été renvoyée pour la transaction qui a été liquidée.

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

À noter
Si trade_num n'est pas dans la fourchette, la fonction renvoie na:0 à strategy.closedtrades-1。

Voir aussi
strategy.closedtrades.entry_bar_index strategy.closedtrades.entry_time

strategy.closedtrades.entry_price

Retour au prix d'entrée de la transaction qui a été liquidée.

            
            
            
strategy.closedtrades.entry_price(trade_num)

Exemple

            pine
            
            
strategy("strategy.closedtrades.entry_price Example 1")

// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.
if bar_index % 15 == 0
    strategy.entry("Long", strategy.long)
if bar_index % 20 == 0
    strategy.close("Long")

// Return the entry price for the latest  entry.
entryPrice = strategy.closedtrades.entry_price(strategy.closedtrades - 1)

plot(entryPrice, "Long entry price")

Calculer le pourcentage de bénéfices moyens sur toutes les transactions qui ont été liquidées

Exemple

            pine
            
            
strategy("strategy.closedtrades.entry_price Example 2")

// Strategy calls to create single short and long trades
if bar_index == last_bar_index - 15
    strategy.entry("Long Entry",  strategy.long)
else if bar_index == last_bar_index - 10
    strategy.close("Long Entry")
    strategy.entry("Short", strategy.short)
else if bar_index == last_bar_index - 5
    strategy.close("Short")

// Calculate profit for both closed trades.
profitPct = 0.0
for tradeNo = 0 to strategy.closedtrades - 1
    entryP = strategy.closedtrades.entry_price(tradeNo)
    exitP = strategy.closedtrades.exit_price(tradeNo)
    profitPct += (exitP - entryP) / entryP * strategy.closedtrades.size(tradeNo) * 100
    
// Calculate average profit percent for both closed trades.
avgProfitPct = nz(profitPct / strategy.closedtrades)

plot(avgProfitPct)

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi
strategy.closedtrades.exit_price strategy.closedtrades.size strategy.closedtrades

strategy.closedtrades.entry_time

Retour à l'heure UNIX de la clôture de la transaction.

            
            
            
strategy.closedtrades.entry_time(trade_num)

Exemple

            pine
            
            
strategy("strategy.closedtrades.entry_time Example", overlay = true)

// Enter long trades on three rising bars; exit on two falling bars.
if ta.rising(close, 3)
    strategy.entry("Long", strategy.long)
if ta.falling(close, 2)
    strategy.close("Long")

// Calculate the average trade duration 
avgTradeDuration() =>
    sumTradeDuration = 0
    for i = 0 to strategy.closedtrades - 1
        sumTradeDuration += strategy.closedtrades.exit_time(i) - strategy.closedtrades.entry_time(i)
    result = nz(sumTradeDuration / strategy.closedtrades)

// Display average duration converted to seconds and formatted using 2 decimal points
if barstate.islastconfirmedhistory
    runtime.log(str.tostring(avgTradeDuration() / 1000, "#.##") + " seconds")

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi
strategy.opentrades.entry_time strategy.closedtrades.exit_time time

strategy.closedtrades.profit

Les pertes sont exprimées en valeur négative.

            
            
            
strategy.closedtrades.profit(trade_num)

Exemple

            pine
            
            
strategy("`strategy.closedtrades.profit` Example")

// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.
if bar_index % 15 == 0
    strategy.entry("Long", strategy.long)
if bar_index % 20 == 0
    strategy.close("Long")

// Calculate average gross profit by adding the difference between gross profit and commission.
avgGrossProfit() =>
    sumGrossProfit = 0.0
    for tradeNo = 0 to strategy.closedtrades - 1
        sumGrossProfit += strategy.closedtrades.profit(tradeNo) - strategy.closedtrades.commission(tradeNo)
    result = nz(sumGrossProfit / strategy.closedtrades)
    
plot(avgGrossProfit(), "Average gross profit")

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi
strategy.opentrades.profit strategy.closedtrades.commission

strategy.closedtrades.size

Retourne la direction de la transaction et le nombre de contrats dans une transaction qui a été liquidée. Si cette valeur est supérieure à 0, la position du marché est en tête. Si cette valeur est inférieure à 0, la position du marché est vide.

            
            
            
strategy.closedtrades.size(trade_num)

Exemple

            pine
            
            
strategy("`strategy.closedtrades.size` Example 1")

// We calculate the max amt of shares we can buy.
amtShares = math.floor(strategy.equity / close)
// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars
if bar_index % 15 == 0
    strategy.entry("Long", strategy.long, qty = amtShares)
if bar_index % 20 == 0
    strategy.close("Long")

// Plot the number of contracts traded in the last closed trade.     
plot(strategy.closedtrades.size(strategy.closedtrades - 1), "Number of contracts traded")

Calcul du pourcentage de bénéfice moyen sur les transactions en position de marché.

Exemple

            pine
            
            
strategy("`strategy.closedtrades.size` Example 2")

// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.
if bar_index % 15 == 0
    strategy.entry("Long", strategy.long)
if bar_index % 20 == 0
    strategy.close("Long")


// Calculate profit for both closed trades.
profitPct = 0.0
for tradeNo = 0 to strategy.closedtrades - 1
    entryP = strategy.closedtrades.entry_price(tradeNo)
    exitP = strategy.closedtrades.exit_price(tradeNo)
    profitPct += (exitP - entryP) / entryP * strategy.closedtrades.size(tradeNo) * 100
    
// Calculate average profit percent for both closed trades.
avgProfitPct = nz(profitPct / strategy.closedtrades)

plot(avgProfitPct)

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi
strategy.opentrades.size strategy.position_size strategy.closedtrades strategy.opentrades

strategy.closedtrades.exit_time

Retour à l'heure UNIX de sortie d'une transaction qui a été réglée.

            
            
            
strategy.closedtrades.exit_time(trade_num)

Exemple

            pine
            
            
strategy("strategy.closedtrades.exit_time Example 1")

// Enter long trades on three rising bars; exit on two falling bars.
if ta.rising(close, 3)
    strategy.entry("Long", strategy.long)
if ta.falling(close, 2)
    strategy.close("Long")

// Calculate the average trade duration. 
avgTradeDuration() =>
    sumTradeDuration = 0
    for i = 0 to strategy.closedtrades - 1
        sumTradeDuration += strategy.closedtrades.exit_time(i) - strategy.closedtrades.entry_time(i)
    result = nz(sumTradeDuration / strategy.closedtrades)

// Display average duration converted to seconds and formatted using 2 decimal points.
if barstate.islastconfirmedhistory
    label.new(bar_index, high, str.tostring(avgTradeDuration() / 1000, "#.##") + " seconds")

X secondes pour réouvrir une transaction qui a été réglée

Exemple

            
            
            
strategy("strategy.closedtrades.exit_time Example 2")

// Strategy calls to emulate a single long trade at the first bar.
if bar_index == 0
    strategy.entry("Long", strategy.long)

reopenPositionAfter(timeSec) =>
    if strategy.closedtrades > 0
        if time - strategy.closedtrades.exit_time(strategy.closedtrades - 1) >= timeSec * 1000
            strategy.entry("Long", strategy.long)

// Reopen last closed position after 120 sec.                
reopenPositionAfter(120)

if ta.change(strategy.opentrades)
    strategy.exit("Long", stop = low * 0.9, profit = high * 2.5)

paramètre

• trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. Le numéro de la première transaction est 0

Voir aussi
strategy.closedtrades.entry_time

strategy.risk.allow_entry_in

Cette fonction peut être utilisée pour spécifier la direction dans laquelle la fonction strategy.entry permet d'ouvrir une position sur un marché.

            
            
            
strategy.risk.allow_entry_in(value)

Exemple

            pine
            
            
strategy("strategy.risk.allow_entry_in")

strategy.risk.allow_entry_in(strategy.direction.long)
strategy.entry("Long", strategy.long, when = open > close)
// Instead of opening a short position with 10 contracts, this command will close long entries.
strategy.entry("Short", strategy.short, when = open < close, qty = 10)

paramètre

• value(simple string) Direction autorisée ≠ valeur possible:strategy.direction.all、strategy.direction.long、strategy.direction.short

strategy.risk.max_position_size

Le but de cette règle est de déterminer la valeur maximale d'une position sur le marché. La règle affecte les fonctions suivantes:strategy.entryLe nombre d'entrées peut être réduit (si nécessaire) au nombre de contrats/actions/mains/unités, de sorte que le montant total de la position ne dépasse pas la valeur indiquée dans 'strategy.risk.max_position_size'. Si le nombre minimum est toujours en violation de la règle, aucune commande ne sera placée.

            
            
            
strategy.risk.max_position_size(contracts)

Exemple

            pine
            
            
strategy("risk.max_position_size Demo", default_qty_value = 100)
strategy.risk.max_position_size(10)
strategy.entry("buy", strategy.long, when = open > close)
plot(strategy.position_size)  // max plot value will be 10

paramètre

• contracts(simple int/float) Paramètre requis. Le nombre maximal de contrats/actions/mains/unités pour une position.

math

math.abs

Si seulement.number >= 0，numberLa valeur absolue est numberou pour -number。

            
            
            
math.abs(number) 

Retourne une valeur
numberLes valeurs absolues de

math.acos

La fonction acos renvoie le résidu inverse du nombre ((exprimé en arcs), comme cos ((acos ((y)) = y dans la plage y.[-1, 1]。

            
            
            
math.acos(angle)

Retourne une valeur
La résonance inverse. Si y est hors de portée[-1,1], l'angle de retour est[0,Pi] ou dans une plage de na.

math.random

Retourne une valeur pseudo-aléatoire. Cette fonction génère une séquence de valeurs différente pour chaque script exécuté. Utiliser la même valeur pour les paramètres sélectifs de semence génère une séquence répétable.

            
            
            
math.random(min, max, seed)

Retourne une valeur
Une valeur aléatoire.

paramètre

• min(series int/float) Limite inférieure d'une plage de valeurs aléatoires。 Cette valeur n'est pas incluse dans la plage。 La valeur par défaut est 0。
• max(series int/float) Limite supérieure de la plage de valeurs aléatoires。 Cette valeur n'est pas incluse dans la plage。 La valeur par défaut est 1。
• seed(input int) Paramètre facultatif. Lorsque la même graine est utilisée, il est permis d'appeler la fonction de manière continue pour produire un ensemble de valeurs répétables.

math.asin

La fonction asin renvoie la résine inverse du nombre ((exprimée en arcs), la résine ((asin ((y)) = y dans la plage y[-1, 1]。

            
            
            
math.asin(angle) 

Retourne une valeur
La résonance. Si y est hors de portée[-1,1], l'angle de retour est[-Pi / 2, Pi / 2] ou dans une plage de na.

math.atan

La fonction atan renvoie la coupe inverse du nombre ((exprimé en arcs), tan (((atan ((y)) = y dans n'importe quel y.

            
            
            
math.atan(angle) 

Retourne une valeur
La valeur de coupe inverse; angle de retour dans[-Pi / 2, dans le domaine de Pi / 2].

math.ceil

La fonction d'intégration vers le haut renvoie le plus petit nombre entier (le plus proche de l'infini négatif) supérieur ou égal à l'arithmétique.

            
            
            
math.ceil(number)

Retourne une valeur
Le plus petit entier inférieur ou égal à un nombre donné.

Voir aussi
math.floor math.round

math.cos

La fonction cos renvoie l'axe du triangle à l'angle.

            
            
            
math.cos(angle) 

Retourne une valeur
Les cordes triangulaires des coins.

paramètre

• angle(series int/float) angle, avec une courbure

math.exp

numberLa fonction exp de e est numberla puissance, où e est le nombre d'our.

            
            
            
math.exp(number) 

Retourne une valeur
Une représentation de la valeur de e, c'est numberJe suis désolé.

Voir aussi
math.pow

math.floor

            
            
            
math.floor(number) 

Retourne une valeur
Le plus grand entier inférieur ou égal à un nombre donné.

Voir aussi
math.ceil math.round

math.log

N'importe quoi.numberL'arithmétique naturelle de > 0 est la seule y, de sorte que e^y = number。

            
            
            
math.log(number)

Retourne une valeur
numberL'arithmétique naturelle de .

Voir aussi
math.log10

math.log10

numberL'arithmétique courante (ou basée sur 10) est celle où l'on doit augmenter 10 pour obtenirnumber。10^y = number。

            
            
            
math.log10(number)

Retourne une valeur
numberL'arithmétique de base 10 de .

Voir aussi
math.log

math.pow

Fonctions de la matrice mathématique

            
            
            
math.pow(base, exponent)

Exemple

            pine
            
            
// math.pow
plot(math.pow(close, 2))

Retourne une valeur
baseAugmentéexponentSi vous avezbaseC'est une série, elle est calculée par élément.

paramètre

• base(series int/float) spécifie la base à utiliser.
• exponent(series int/float) Indicateur spécifié。

Voir aussi
math.sqrt math.exp

math.sign

Si le nombre de pions est égal à zéro, le symbole (signum) du nombre de pions est égal à zéro, si le nombre de pions est supérieur à zéro, il est égal à 1, et si le nombre de pions est inférieur à zéro, il est égal à -1,0.

            
            
            
math.sign(number)

Retourne une valeur
Le symbole du paramètre.

math.sin

La fonction cosine renvoie la cosine d'un angle.

            
            
            
math.sin(angle)

Retourne une valeur
Syntonie triangulaire des angles

paramètre

• angle(series int/float) angle, avec une courbure

math.sqrt

N'importe quoi.numberLa racine carrée de plus de zéro est la seule chose pour laquelle y est égal à zéro et y est égal à zéro.number。

            
            
            
math.sqrt(number)

Retourne une valeur
numberLa racine carrée de

Voir aussi
math.pow

math.tan

Le triangle dans lequel la fonction tan renvoie l'angle est orthogonal.

            
            
            
math.tan(angle)

Retourne une valeur
Le triangle des coins est rectangle.

paramètre

• angle(series int/float) angle, avec une courbure

math.round

Le retour.numberSi l'on utilise le nombre de points, on peut utiliser le nombre de points, le nombre de points, le nombre de points, le nombre de points, le nombre de points.precisionLe paramètre retourne une valeur de flochette de quatre chiffres à cinq chiffres.

            
            
            
math.round(number) 

            
            
            
math.round(number, precision) 

Retourne une valeur
numberLes valeurs de l'équivalent sont approximées à l'entier le plus proche, ou selon la précision.

paramètre

• number(series int/float) La valeur à entourer de 5 est ≠
• precision(series int) est un paramètre sélectif.numberLes nombres décimaux seront arrondis au carré sans paramètres, et arrondis au carré au plus proche entier.

À noter
Notez que pour une valeur 'na', la fonction renvoie 'na'。

Voir aussi
math.ceil math.floor

math.max

Renvoie la plus grande des valeurs.

            
            
            
math.max(number0, number1, ...) 

Exemple

            pine
            
            
// math.max
plot(math.max(close, open))
plot(math.max(close, math.max(open, 42)))

Retourne une valeur
La plus grande des valeurs données.

Voir aussi
math.min

math.min

Retourne la plus petite des valeurs.

            
            
            
math.min(number0, number1, ...) 

Exemple

            pine
            
            
// math.min
plot(math.min(close, open))
plot(math.min(close, math.min(open, 42)))

Retourne une valeur
La plus petite valeur parmi plusieurs valeurs données.

Voir aussi
math.max

math.avg

Calculer la moyenne de toutes les séries ((éléments correspondants))

            
            
            
math.avg(number0, number1, ...)

Retourne une valeur
Moyenne

Voir aussi
math.sum ta.cum ta.sma

math.round_to_mintick

Retourne la valeur de mintick qui est ronde sur le produit, c'est-à-dire que la valeur de mintick peut être divisée par la valeur la plus proche de syminfo.mintick, sans résidu, et arrondie vers le haut.

            
            
            
math.round_to_mintick(number) 

Retourne une valeur
numberIl a fait quatre tours et cinq entrées pour être précis jusqu'à tick.

paramètre

• number(series int/float) La valeur à entourer de 5 est ≠

Voir aussi
math.ceil math.floor

math.sum

La fonction sum renvoie le résultat de la synthèse glissante de la dernière valeur y de x.

            
            
            
math.sum(source, length)

Retourne une valeur
lengthLa ligne K est retournéesourceRésumé

paramètre

• source(series int/float) Valeur de série à exécuter。
• length(series int) K nombre de lignes (longueur).

Voir aussi
ta.cum for

math.todegrees

De l'angle en unité d'arc, retournez à l'angle approximativement équivalent en unité de degré.

            
            
            
math.todegrees(radians) 

Retourne une valeur
La valeur d'angle est mesurée en unités.

paramètre

• radians(series int/float) Angle représenté par l'arc.

math.toradians

De l'angle en unités de mesure, retournez l'angle approximativement équivalent en unités d'arcade.

            
            
            
math.toradians(degrees) 

Retourne une valeur
La valeur angulaire en unités d'arc.

paramètre

• degrees(series int/float) L'angle est mesuré en unités.

others

fixnan

Pour une série donnée, remplacez la valeur NaN par la précédente valeur non-NaN。

            
            
            
fixnan(source) 

Retourne une valeur
Une série sans interruption

paramètre

• source (series int/float/bool/color)

Voir aussi
na nz

nz

Remplacez la valeur NaN par zéro (ou un nombre spécifié) dans la série.

            
            
            
nz(source, replacement) 

            
            
            
nz(source)

Exemple

            pine
            
            
// nz
plot(nz(ta.sma(close, 100)))

Retourne une valeur
sourceLa valeur, si elle n'est pasnaSisourceest égal ànaSi vous utilisez 1, retourne 0, si vous utilisez 1.replacementParamètres

paramètre

• source(series int/float/bool/color) La valeur de la série à exécuter
• replacement(series int/float/bool/color) remplace les valeurs de tous les thresholds de la série de thresholds de la source de la colonne.

Voir aussi
na fixnan

na

Si c'est NaN, la valeur de test est ∂.

            
            
            
na(x)

Retourne une valeur
Si x n'est pas un nombre valide, alors c'est vrai ((x est NaN), sinon c'est faux.

Voir aussi
fixnan nz

int

Convertir na ou couper la valeur de float en int ≠

            
            
            
int(x) 

Retourne une valeur
Convertissez la valeur de l'argument après int.

Voir aussi
float bool color string

float

Réglez na à flottant.

            
            
            
float(x) 

Retourne une valeur
La conversion en valeur de paramètre après float

Voir aussi
int bool color string

alert

Trigger des événements d'alerte lors de l'appel pendant la ligne K en temps réel et créer des alertes basées sur les événements de la fonction d'alerte comme indicateur ou stratégie précédemment créée via la boîte de dialogue Créer une fenêtre d'alerte.

            
            
            
alert(message, freq)

Exemple

            pine
            
            
// alert() example
ma = ta.sma(close, 14)
xUp = ta.crossover(close, ma)
if xUp
    // Trigger the alert the first time a cross occurs during the real-time bar.
    alert("Price (" + str.tostring(close) + ") crossed over MA (" + str.tostring(ma) +  ").", alert.freq_once_per_bar)
plot(ma)
plotchar(xUp, "xUp", "▲", location.top, size = size.tiny)

paramètre

• message(series string) Le message envoyé lors du déclenchement de l'alerte.
• freq(input string) Trigger frequency. Les valeurs possibles sont: alert.freq_all, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar

À noter
Le centre d'aide explique comment créer une alerte de ce type.
Contrairement à la condition d'alert, l'appel d'alert n'est pas considéré comme un dessin supplémentaire.
Les appels de fonctions peuvent être globaux ou locaux.
L'appel de la fonction n'affiche rien sur le graphique
Le paramètre <unk>freq<unk> n'affecte que la fréquence de déclenchement utilisée pour cette fonction.

Voir aussi
alertcondition

alertcondition

Créer une condition d'alerte est disponible dans la boîte de dialogue Créer une condition d'alerte. Veuillez noter que la condition d'alert ne crée pas d'alerte, mais vous offre plus d'options dans la boîte de dialogue Créer une condition d'alert. De plus, l'effet de la condition d'alert n'est pas visible sur le graphique.

            
            
            
alertcondition(condition, title, message)

Exemple

            pine
            
            
// alertcondition
alertcondition(close >= open, title='Alert on Green Bar', message='Green Bar!')

paramètre

• condition(series bool) La série de valeurs bool utilisée pour une alerte. True signifie que l'alerte a été déclenchée et false signifie qu'il n'y a pas d'alerte. Paramètre requis.
• title(const string) Titre de la condition d'alerte. Paramètres à choisir.
• message(const string) Afficher un message lorsque l'alerte est déclenchée.

À noter
Veuillez noter que dans Pine v4, les appels de conditions d'alerte génèrent un graphique supplémentaire. Tous ces appels sont pris en compte lorsque nous calculons le nombre de séries de sorties pour chaque script.

Voir aussi
alert

indicator

Pour la compatibilitéTrading ViewLe code de stratégie n'a pas besoin d'être appelé.

Voir aussi
strategy

time

La fonction time renvoie l'heure UNIX de la ligne K actuelle de la plage de temps et du moment de la transaction, et NaN si le moment n'est pas dans le moment de la transaction. Remarque: FMZ n'est pas pris en chargesessionParamètres

time(timeframe, session, timezone)

time(timeframe, session)

            
            
            
time(timeframe)

Exemple

            pine
            
            
timeinrange(res, sess) => not na(time(res, sess, "America/New_York")) ? 1 : 0
plot(timeinrange("1", "1300-1400"), color=color.red)

// This plots 1.0 at every start of 10 minute bar on a 1 minute chart:
newbar(res) => ta.change(time(res)) == 0 ? 0 : 1
plot(newbar("10"))

Lorsque vous configurez une session, vous pouvez spécifier non seulement l'heure et la minute, mais aussi le jour de la semaine.
Si aucune date n'est spécifiée, on considère que la période de négociation est définie comme étant du dimanche (1) au samedi (7), c'est-à-dire 1100-2000<unk> est identique à 1100-1200:1234567<unk>.
Vous pouvez le modifier en spécifiant une date. Par exemple, pour les produits qui sont échangés 7 jours par semaine et 24 heures par jour, le script suivant ne sera pas coloré pour les samedis et dimanches:

Exemple

            pine
            
            
// Time
t1 = time(timeframe.period, "0000-0000:23456")
bgcolor(t1 ? color.new(color.blue, 90) : na)

Une seule.sessionLes paramètres peuvent contenir plusieurs périodes de transaction différentes, séparées par des virgules. Par exemple, le script suivant mettra en évidence le diagramme K de 10h00 à 11h00 et de 14h00 à 15h00 (jours ouvrables uniquement):

Exemple

            pine
            
            
// Time
t1 = time(timeframe.period, "1000-1100,1400-1500:23456")
bgcolor(t1 ? color.new(color.blue, 90) : na)

Retourne une valeur
Temps Unix

paramètre

• timeframe(simple string) Période de temps。 La chaîne vide est interprétée comme la période de temps actuelle de la figure。
• session(simple string) Spécification de la période de transaction. Paramètre optionnel, par défaut, utilisation de la période de transaction des marchandises. La chaîne vide est interprétée comme la période de transaction des marchandises.
• timezone (simple string) sessionLe paramètre de fuseau horaire。 ne peut être utilisé que si le fuseau de session de la souris a été spécifié。 est facultatif。 par défaut, syminfo.timezone。 peut être spécifié avec l'expression GMT ((par exemple, fuseau GMT-5)) ou le nom de la base de données du fuseau horaire IANA ((par exemple, fuseau America/New_York)).

À noter
L'heure UNIX est le nombre de millisecondes qui se sont écoulées depuis le 1er janvier 1970 à 00:00:00 UTC.

year

            
            
            
year(time)

            
            
            
year(time, timezone)

Retourne une valeur
L'année de mise à disposition de l'heure UNIX ((zones horaires d'échange)) [2].

paramètre

• time(series int) Le temps Unix en millisecondes.
• timezone(series string) Paramètre sélectionnable ◦ fuseau horaire ◦

À noter
L'heure UNIX est le nombre de millisecondes depuis le 1er janvier 1970 UTC 00:00:00. Par défaut, le fuseau horaire est syminfo.timezone. Vous pouvez utiliser le timestamp pour vérifier les valeurs possibles.
Notez que cette fonction renvoie l'année en fonction de l'heure d'ouverture de la ligne K. Pour les heures de négociation du soir (par exemple, les heures de négociation du lundi de l'EURUSD commencent le dimanche à 17h00 UTC-4), cette valeur peut être inférieure à l'année du jour de négociation.

Voir aussi
year time month dayofmonth dayofweek hour minute second

month

            
            
            
month(time)

            
            
            
month(time, timezone)

Retourne une valeur
Les mois qui fournissent l'heure UNIX ((zones horaires d'échange))

paramètre

• time(series int) Le temps Unix en millisecondes.
• timezone(series string) Paramètre sélectionnable ◦ fuseau horaire ◦

À noter
L'heure UNIX est le nombre de millisecondes depuis le 1er janvier 1970 UTC 00:00:00. Par défaut, le fuseau horaire est syminfo.timezone. Vous pouvez utiliser le timestamp pour vérifier les valeurs possibles.
Notez que cette fonction renvoie le mois en fonction de l'heure d'ouverture de la ligne K. Pour les heures de négociation du soir (par exemple, les heures de négociation du lundi de l'EURUSD commencent le dimanche à 17h00 UTC-4), la valeur peut être inférieure à 1 par rapport au mois du jour de négociation.

Voir aussi
month time year dayofmonth dayofweek hour minute second

hour

            
            
            
hour(time)

            
            
            
hour(time, timezone)

Retourne une valeur
Les heures de l'heure UNIX sont fournies dans les fuseaux horaires d'échange.

paramètre

• time(series int) Le temps Unix en millisecondes.
• timezone(series string) Paramètre sélectionnable ◦ fuseau horaire ◦

À noter
L'heure UNIX est le nombre de millisecondes depuis le 1er janvier 1970 UTC 00:00:00. Par défaut, le fuseau horaire est syminfo.timezone. Vous pouvez utiliser le timestamp pour vérifier les valeurs possibles.

Voir aussi
hour time year month dayofmonth dayofweek minute second

minute

            
            
            
minute(time)

            
            
            
minute(time, timezone)

Retourne une valeur
Minutes de temps fournies par UNIX (en échangeant les fuseaux horaires).

paramètre

• time(series int) Le temps Unix en millisecondes.
• timezone(series string) Paramètre sélectionnable ◦ fuseau horaire ◦

À noter
L'heure UNIX est le nombre de millisecondes depuis le 1er janvier 1970 UTC 00:00:00. Par défaut, le fuseau horaire est syminfo.timezone. Vous pouvez utiliser le timestamp pour vérifier les valeurs possibles.

Voir aussi
minute time year month dayofmonth dayofweek hour second

second

            
            
            
second(time)

            
            
            
second(time, timezone)

Retourne une valeur
Il fournit le nombre de secondes de temps UNIX ((zones d'échange de temps) }}.

paramètre

• time(series int) Le temps Unix en millisecondes.
• timezone(series string) Paramètre sélectionnable ◦ fuseau horaire ◦

À noter
L'heure UNIX est le nombre de millisecondes depuis le 1er janvier 1970 UTC 00:00:00. Par défaut, le fuseau horaire est syminfo.timezone. Vous pouvez utiliser le timestamp pour vérifier les valeurs possibles.

Voir aussi
second time year month dayofmonth dayofweek hour minute

weekofyear

            
            
            
weekofyear(time)

            
            
            
weekofyear(time, timezone)

Retourne une valeur
La période qui fournit l'heure UNIX (en échangeant le fuseau horaire) <unk>.

paramètre

• time(series int) Le temps Unix en millisecondes.
• timezone(series string) Paramètre sélectionnable ◦ fuseau horaire ◦

À noter
L'heure UNIX est le nombre de millisecondes depuis le 1er janvier 1970 UTC 00:00:00. Par défaut, le fuseau horaire est syminfo.timezone. Vous pouvez utiliser le timestamp pour vérifier les valeurs possibles.
Notez que la fonction retourne la semaine en fonction de l'heure d'ouverture de la ligne K. Pour les heures de transaction du jour au lendemain (par exemple EURUSD, dont les heures de transaction du lundi commencent à 17h00 le dimanche), cette valeur peut être inférieure à la semaine du jour de transaction.

Voir aussi
weekofyear time year month dayofmonth dayofweek hour minute second

dayofweek

            
            
            
dayofweek(time)

            
            
            
dayofweek(time, timezone)

Retourne une valeur
Date de la semaine qui fournit l'heure UNIX ((zones horaires d'échange) }}.

paramètre

• time(series int) Le temps Unix en millisecondes.
• timezone(series string) Paramètre sélectionnable ◦ fuseau horaire ◦

À noter
Notez que cette fonction renvoie la date en fonction de l'heure d'ouverture de la ligne K. Pour les heures de transaction du soir (par exemple, les heures de transaction du lundi de l'EURUSD commencent à 17h00 le dimanche), cette valeur peut être inférieure à la date du jour de la transaction.
L'heure UNIX est le nombre de millisecondes depuis le 1er janvier 1970 UTC 00:00:00. Par défaut, le fuseau horaire est syminfo.timezone. Vous pouvez utiliser le timestamp pour vérifier les valeurs possibles.

Voir aussi
time dayofmonth

dayofmonth

            
            
            
dayofmonth(time)

            
            
            
dayofmonth(time, timezone)

Retourne une valeur
Date de chaque mois qui fournit l'heure UNIX ((zone horaire d'échange)).

paramètre

• time(series int) Le temps Unix en millisecondes.
• timezone(series string) Paramètre sélectionnable ◦ fuseau horaire ◦

À noter
L'heure UNIX est le nombre de millisecondes depuis le 1er janvier 1970 UTC 00:00:00. Par défaut, le fuseau horaire est syminfo.timezone. Vous pouvez utiliser le timestamp pour vérifier les valeurs possibles.
Notez que cette fonction renvoie la date en fonction de l'heure d'ouverture de la ligne K. Pour les heures de transaction du jour au lendemain (par exemple, les heures de transaction du lundi de l'EURUSD commencent le dimanche à 17h00 UTC-4), cette valeur peut être inférieure à la date du jour de la transaction.

Voir aussi
time dayofweek

timestamp

La fonction de balise de temps renvoie la date et l'heure spécifiées de l'heure UNIX.

            
            
            
timestamp(dateString)

            
            
            
timestamp(year, month, day, hour, minute, second)

            
            
            
timestamp(timezone, year, month, day, hour, minute, second)

Exemple

            pine
            
            
// timestamp
plot(timestamp(2016, 01, 19, 09, 30), linewidth=3, color=color.green)
plot(timestamp(syminfo.timezone, 2016, 01, 19, 09, 30), color=color.blue)
plot(timestamp(2016, 01, 19, 09, 30), color=color.yellow)
plot(timestamp("GMT+6", 2016, 01, 19, 09, 30))
plot(timestamp(2019, 06, 19, 09, 30, 15), color=color.lime)
plot(timestamp("GMT+3", 2019, 06, 19, 09, 30, 15), color=color.fuchsia)
plot(timestamp("Feb 01 2020 22:10:05"))
plot(timestamp("2011-10-10T14:48:00"))
plot(timestamp("04 Dec 1995 00:12:00 GMT+5"))

Retourne une valeur
Temps Unix

paramètre

• timezone(series string) fuseau horaire。 est optionnel。 la valeur par défaut est syminfo.timezone。 peut être spécifiée avec l'expression GMT ((par exemple, <unk>GMT-5<unk>) ou le nom de la base de données de fuseau horaire IANA ((par exemple, <unk>America/New_York<unk>)).
• year(series int) année
• month(series int) mois
• dayDate de la série int.
• hour(series int) (paramètres optionnels) heure. La valeur par défaut est 0
• minute(series int) (paramètre à choisir) minutes. La valeur par défaut est 0
• second(series int) (paramètre à choisir) Second。 par défaut 0。
• dateString(const string) Une chaîne de caractères qui contient une date et une heure et un fuseau horaire au choix. Son format doit être conforme aux normes IETF RFC 2822 ou ISO 8601 ((<unk>DD MMM YYYY hh:mm:ss±hhmm<unk> ou<unk>YYYYY-MM-DDThh:mm:ss±hh:mm<unk>, donc<unk>20 Feb 2020<unk> ou<unk>2020-02-20<unk>) ‬. Si la date n'est pas fournie, alors <unk>00:00<unk>‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬<unk>‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬<unk>‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬

À noter
L'heure UNIX est le nombre de millisecondes qui se sont écoulées depuis le 1er janvier 1970 à 00:00:00 UTC.

Voir aussi
time timenow syminfo.timezone

fill

Utilisez les couleurs fournies pour remplir le fond entre deux dessins ou des lignes.

            
            
            
fill(hline1, hline2, color, title, editable, fillgaps, display)

            
            
            
fill(plot1, plot2, color, title, editable, show_last, fillgaps, display)

Exemple

            pine
            
            
h1 = hline(20)
h2 = hline(10)
fill(h1, h2, color=color.new(color.blue, 90))

p1 = plot(open)
p2 = plot(close)
fill(p1, p2, color=color.new(color.green, 90))

paramètre

• hline1(hline) Le premier objet de hline. Paramètre requis.
• hline2(hline) Deuxième objet de la ligne. Paramètres requis.
• plot1(plot) Le premier objet de tracé. Paramètre requis.
• plot2(plot) Deuxième objet de tracé 。 Paramètres requis 。
• color(series color) Couleur de la série. Vous pouvez utiliser des constantes telles que "color = red" ou "color =#ff001a" et des expressions complexes telles que "color = close >= open ? green: red". Paramètres optionnels.
• title(const string) a créé le titre de remplissage de l'objet.
• editable(const bool) Si true, le style de remplissage est modifiable dans la boîte de dialogue format. La valeur par défaut est true.
• show_last(input int) Définit le nombre de lignes k qui remplissent le graphique (( retourne au passé à partir de la dernière ligne k) [2].
• fillgaps(const bool) Contrôle le remplissage continu de l'espace, c'est-à-dire que lorsque l'une des appels de la plot ((() renvoie une valeur na. S'il est défini sur true, le dernier remplissage continuera à remplir l'espace.
• display(plot_display) Contrôle de la position d'affichage du remplissage. Les valeurs possibles sont: display.none, display.all.

Voir aussi
plot barcolor bgcolor hline

hline

La ligne horizontale est représentée à un niveau de prix fixe donné.

            
            
            
hline(price, title, color, linestyle, linewidth, editable, display)

Exemple

            pine
            
            
// input.hline
hline(3.14, title='Pi', color=color.blue, linestyle=hline.style_dotted, linewidth=2)

// You may fill the background between any two hlines with a fill() function:
h1 = hline(20)
h2 = hline(10)
fill(h1, h2, color=color.new(color.green, 90))

Retourne une valeur
Les objets hline pouvant être utilisés pour le remplissage:

paramètre

• priceLa valeur que l'objet (input int/float) affichera est la valeur de la valeur que vous devez afficher.
• titleTitre de l'objet (string constant)
• color(input color) Couleur de la ligne de rendu. Doit être une constante (non expressible). Paramètres optionnels.
• linestyle(hline_style) Style de la ligne de rendu。 Les valeurs possibles sont: solid, dotted, dotted。 Les paramètres sont optionnels。
• linewidth(input int) La largeur de la ligne de rendu。 par défaut est de 1。
• editable(const bool) Si true, le style hline peut être modifié dans la boîte de dialogue format. La valeur par défaut est true.
• display(plot_display) La position de l'affichage de la ligne de commande. Les valeurs possibles sont: display.none, display.all.
• overlay(const bool) Paramètre de l'extension de la plate-forme FMZ, utilisé pour définir la fonction actuelle sur le diagramme principal (true) ou sur le diagramme secondaire (faux). La valeur par défaut est false. Sans spécifier ce paramètre, on obtientstrategyouindicatorDansoverlayParamètres définisstrategyouindicatorAucun réglageoverlayLes paramètres sont traités comme des paramètres par défaut.

bgcolor

Remplissez le fond de la ligne K avec la couleur spécifiée.

            
            
            
bgcolor(color, offset, editable, show_last, title, display, overlay)

Exemple

            pine
            
            
// bgcolor example
bgcolor(close < open ? color.new(color.red,70) : color.new(color.green, 70))

paramètre

• color(series color) Couleur de remplissage du fond. Vous pouvez utiliser des constantes telles que <unk>red<unk> ou <unk>#ff001a<unk>, ainsi que des expressions complexes telles que 'close >= open ? green: red'. Paramètres nécessaires.
• offset(series int) Séquence de couleurs qui se déplace vers la gauche ou vers la droite sur un nombre donné de lignes k. La valeur par défaut est 0
• editable(const bool) Si true, le style bgcolor peut être modifié dans la boîte de dialogue format. La valeur par défaut est true.
• show_last(input int) Définit le nombre de lignes k qui remplissent le graphique (( retourne au passé à partir de la dernière ligne k) [2].
• title(const string) titre de bgcolor。 paramètres sélectifs。
• display(plot_display) Contrôle l'emplacement de l'affichage de la couleur bg. Les valeurs possibles sont: display.none, display.all. La valeur par défaut est display.all.
• overlay(const bool) Paramètre de l'extension de la plate-forme FMZ, utilisé pour définir la fonction actuelle sur le diagramme principal (true) ou sur le diagramme secondaire (faux). La valeur par défaut est false. Sans spécifier ce paramètre, on obtientstrategyouindicatorDansoverlayParamètres définisstrategyouindicatorAucun réglageoverlayLes paramètres sont traités comme des paramètres par défaut.

Voir aussi
plot

barcolor

Réglez la couleur de la ligne K

            
            
            
barcolor(color, offset, editable, show_last, title, display)

Exemple

            pine
            
            
barcolor(close < open ? color.black : color.white)

paramètre

• color(series color) Couleur de la ligne K。 Vous pouvez utiliser des constantes telles que <unk>red<unk> ou <unk>#ff001a<unk>, ainsi que des expressions complexes telles que 'close >= open ? green : red‛。 Paramètres nécessaires。
• offset(series int) Séquence de couleurs qui se déplace vers la gauche ou vers la droite sur un nombre donné de lignes k. La valeur par défaut est 0
• editable(const bool) Si true, le style barcolor peut être modifié dans la boîte de dialogue format. La valeur par défaut est true.
• show_last(input int) Définit le nombre de lignes k qui remplissent le graphique (( retourne au passé à partir de la dernière ligne k) [2].
• title(const string) Titre de la barre de couleurs. Paramètres optionnels.
• display(plot_display) Contrôle la position de l'affichage de la couleur de la ligne K. Les valeurs possibles sont: display.none, display.all.

Voir aussi
bgcolor plot fill

error

La version compatible avec PINE v4errorFonctionnalités etruntime.errorUn accord.

Variables intégrées

order

order.ascending

Déterminer l'ordre de tri de la plus petite à la plus grande matrice.

taper
sort_order

Voir aussi
array.new_float array.sort

order.descending

Déterminer l'ordre de tri de la plus grande à la plus petite.

taper
sort_order

Voir aussi
array.new_float array.sort

timeframe

timeframe.isdaily

Si la résolution actuelle est la résolution quotidienne, retourne true, sinon retourne false.

taper
simple bool

Voir aussi
timeframe.isdwm timeframe.isintraday timeframe.isminutes timeframe.isseconds timeframe.isweekly timeframe.ismonthly

timeframe.isdwm

Si la résolution actuelle est une résolution quotidienne, hebdomadaire ou mensuelle, retourne true, sinon retourne false.

taper
simple bool

Voir aussi
timeframe.isintraday timeframe.isminutes timeframe.isseconds timeframe.isdaily timeframe.isweekly timeframe.ismonthly

timeframe.isintraday

Retourne true si la période actuelle est une période de jours (minutes ou secondes), sinon false.

taper
simple bool

Voir aussi
timeframe.isminutes timeframe.isseconds timeframe.isdwm timeframe.isdaily timeframe.isweekly timeframe.ismonthly

timeframe.isminutes

Retourne true si la période actuelle est une période de minutes, sinon false.

taper
simple bool

Voir aussi
timeframe.isdwm timeframe.isintraday timeframe.isseconds timeframe.isdaily timeframe.isweekly timeframe.ismonthly

timeframe.ismonthly

Si la résolution actuelle est la résolution mensuelle, retourne true, sinon retourne false.

taper
simple bool

Voir aussi
timeframe.isdwm timeframe.isintraday timeframe.isminutes timeframe.isseconds timeframe.isdaily timeframe.isweekly

timeframe.isseconds

Retourne true si la période actuelle est en secondes, et false si elle n'est pas.

taper
simple bool

Voir aussi
timeframe.isdwm timeframe.isintraday timeframe.isminutes timeframe.isdaily timeframe.isweekly timeframe.ismonthly

timeframe.isweekly

Si la résolution actuelle est la résolution hebdomadaire, retourne true, sinon retourne false.

taper
simple bool

Voir aussi
timeframe.isdwm timeframe.isintraday timeframe.isminutes timeframe.isseconds timeframe.isdaily timeframe.ismonthly

timeframe.multiplier

Les périodes de temps sont multipliées par des nombres, par exemple '60' - 60, 'D' - 1, '5D' - 5, '12M' - 12 <unk>.

taper
simple int

Voir aussi
syminfo.ticker syminfo.tickerid timeframe.period

timeframe.period

Les périodes de temps sont des périodes de 60 minutes, de 60 jours, de 60 semaines, de 5 mois, de 5 jours, de 12 mois, de 1 an, de 3 mois, de 1 trimestre.

taper
simple string

Voir aussi
syminfo.ticker syminfo.tickerid timeframe.multiplier

display

display.none

Une constante de nommage qui indique l'emplacement d'affichage du dessin. Affichage nulle part. Utilisable dans le message du modèle d'alerte.

taper
plot_display

Voir aussi
plot plotshape plotchar

display.all

Une constante de nommage qui indique la position à afficher sur la carte. Afficher n'importe quelle position.

taper
plot_display

Voir aussi
plot plotshape plotchar plotarrow plotbar plotcandle

shape

shape.xcross

Le style de forme de la fonction plotshape.

taper
const string

Voir aussi
plotshape

shape.cross

Le style de forme de la fonction plotshape.

taper
const string

Voir aussi
plotshape

shape.triangleup

Le style de forme de la fonction plotshape.

taper
const string

Voir aussi
plotshape

shape.triangledown

Le style de forme de la fonction plotshape.

taper
const string

Voir aussi
plotshape

shape.flag

Le style de forme de la fonction plotshape.

taper
const string

Voir aussi
plotshape

shape.circle

Le style de forme de la fonction plotshape.

taper
const string

Voir aussi
plotshape

shape.arrowup

Le style de forme de la fonction plotshape.

taper
const string

Voir aussi
plotshape

shape.arrowdown

Le style de forme de la fonction plotshape.

taper
const string

Voir aussi
plotshape

shape.labelup

Le style de forme de la fonction plotshape.

taper
const string

Voir aussi
plotshape

shape.labeldown

Le style de forme de la fonction plotshape.

taper
const string

Voir aussi
plotshape

shape.square

Le style de forme de la fonction plotshape.

taper
const string

Voir aussi
plotshape

shape.diamond

Le style de forme de la fonction plotshape.

taper
const string

Voir aussi
plotshape

color

color.aqua

est la constante de nommage de la couleur #00BCD4.

taper
const color

color.black

est la constante de nommage de la couleur #363A45.

taper
const color

color.blue

est la constante de nommage de la couleur #2962ff。

taper
const color

color.fuchsia

est la constante nominale de la couleur #E040FB.

taper
const color

color.gray

est la constante nominale de la couleur #787B86.

taper
const color

color.green

est la constante de nommage de la couleur #4CAF50.

taper
const color

color.lime

est la constante de dénomination de la couleur #00E676

taper
const color

color.maroon

La constante de dénomination de la couleur #880E4F.

taper
const color

color.navy

est la constante de nommage de la couleur #311B92.

taper
const color

color.olive

est la constante de nommage de la couleur #808000。

taper
const color

color.orange

est la constante de nommage de la couleur #FF9800。

taper
const color

color.purple

est la constante de nommage de la couleur #9C27B0

taper
const color

color.red

est la constante nominale de la couleur #FF5252.

taper
const color

color.silver

Nom de la constante de couleur #B2B5BE.

taper
const color

color.teal

color.teal

est la constante nominale de la couleur #00897B.

taper
const color

color.white

est la constante nominale de la couleur #FFFFFF.

taper
const color

color.yellow

est la constante nominale de la couleur #FFEB3B.

taper
const color

plot

plot.style_line

Constantes de nommage de type 'Line', utilisées dans la fonction plotstyleParamètres de la définition.

taper
plot_style

Voir aussi
plot plot.style_linebr plot.style_stepline plot.style_stepline_diamond plot.style_histogram plot.style_cross plot.style_area plot.style_areabr plot.style_columns plot.style_circles

plot.style_linebr

Les constantes de nommage de type 'Line With Breaks' sont utilisées dans la fonction plotstyleLes paramètres des paramètres sont similaires à ceux de plot.style_line, sauf que les espaces vides dans les données ne sont pas remplis.

taper
plot_style

Voir aussi
plot plot.style_line plot.style_stepline plot.style_stepline_diamond plot.style_histogram plot.style_cross plot.style_area plot.style_areabr plot.style_columns plot.style_circles

plot.style_histogram

Constantes de nommage de type histogramme, utilisées dans la fonction plotstyleParamètres de la définition.

taper
plot_style

Voir aussi
plot plot.style_line plot.style_linebr plot.style_stepline plot.style_stepline_diamond plot.style_cross plot.style_area plot.style_areabr plot.style_columns plot.style_circles

plot.style_columns

Les constantes de dénomination de type 'Columns' utilisées dans la fonction plotstyleParamètres de la définition.

taper
plot_style

Voir aussi
plot plot.style_line plot.style_linebr plot.style_stepline plot.style_stepline_diamond plot.style_histogram plot.style_cross plot.style_area plot.style_areabr plot.style_circles

plot.style_circles

Les constantes de dénomination de type 'Circles' utilisées dans la fonction plotstyleParamètres de la définition.

taper
plot_style

Voir aussi
plot plot.style_line plot.style_linebr plot.style_stepline plot.style_stepline_diamond plot.style_histogram plot.style_cross plot.style_area plot.style_areabr plot.style_columns

plot.style_area

Constantes de nommage de type 'Area', utilisées dans la fonction plotstyleParamètres de la définition.

taper
plot_style

Voir aussi
plot plot.style_line plot.style_linebr plot.style_stepline plot.style_stepline_diamond plot.style_histogram plot.style_areabr plot.style_cross plot.style_columns plot.style_circles

plot.style_areabr

Une constante de dénomination de type 'Area With Breaks' utilisée dans une fonction de plotstyleLes paramètres des paramètres ≠ sont similaires à ceux de plot.style_area, sauf que les espaces vides dans les données ne sont pas remplis ≠

taper
plot_style

Voir aussi
plot plot.style_line plot.style_linebr plot.style_stepline plot.style_stepline_diamond plot.style_histogram plot.style_cross plot.style_area plot.style_columns plot.style_circles

plot.style_cross

Constantes de dénomination de type 'Cross', utilisées dans les fonctions de plotstyleParamètres de la définition.

taper
plot_style

Voir aussi
plot plot.style_line plot.style_linebr plot.style_stepline plot.style_stepline_diamond plot.style_histogram plot.style_area plot.style_areabr plot.style_columns plot.style_circles

plot.style_stepline

La constante de nommage de type 'Step Line' est utilisée dans la fonction plotstyleParamètres de la définition.

taper
plot_style

Voir aussi
plot plot.style_stepline_diamond plot.style_linebr plot.style_histogram plot.style_cross plot.style_area plot.style_areabr plot.style_columns plot.style_circles

plot.style_stepline_diamond

Constantes de nommage de type 'Step Line With Diamonds', utilisées dans la fonction plotstyleLes paramètres des paramètres 。 sont similaires à ceux de plot.style_stepline, sauf que les changements de données sont également marqués en coniques 。

taper
plot_style

Voir aussi
plot plot.style_line plot.style_linebr plot.style_histogram plot.style_cross plot.style_area plot.style_areabr plot.style_columns plot.style_circles

location

location.abovebar

location.abovebar

Plotshape, valeur de positionnement de la fonction plotchar. Les formes sont tracées au-dessus de la ligne de la série principale k.

taper
const string

Voir aussi
plotshape plotchar location.belowbar location.top location.bottom location.absolute

location.belowbar

Plotshape, la valeur de position de la fonction plotchar。 La forme est tracée en dessous de la ligne de la série principale k。

taper
const string

Voir aussi
plotshape plotchar location.abovebar location.top location.bottom location.absolute

location.top

Plotshape, la valeur de position de la fonction plotchar. La forme est dessinée près du bord de la carte en haut.

taper
const string

Voir aussi
plotshape plotchar location.abovebar location.belowbar location.bottom location.absolute

location.bottom

Plotshape, la valeur de position de la fonction plotchar. Les formes sont dessinées près du bord inférieur du graphique.

taper
const string

Voir aussi
plotshape plotchar location.abovebar location.belowbar location.top location.absolute

location.absolute

Plotshape, valeur de positionnement de la fonction plotchar. La forme est tracée sur le graphique, en utilisant la valeur de l'indicateur comme coordonnée de prix.

taper
const string

Voir aussi
plotshape plotchar location.abovebar location.belowbar location.top location.bottom

size

size.auto

size.auto

La taille de la forme s'adapte automatiquement à la taille de la ligne k.

taper
const string

Voir aussi
plotshape plotchar size.tiny size.small size.normal size.large size.huge

size.tiny

La taille de la fonction plotshape, plotchar. La taille de la forme est minuscule.

taper
const string

Voir aussi
plotshape plotchar size.auto size.small size.normal size.large size.huge

size.small

La taille de la fonction plotshape, plotchar.

taper
const string

Voir aussi
plotshape plotchar size.auto size.tiny size.normal size.large size.huge

size.normal

La taille de la fonction plotshape, plotchar. La taille de la forme est normale.

taper
const string

Voir aussi
plotshape plotchar size.auto size.tiny size.small size.large size.huge

size.large

La taille de la fonction plotshape, plotchar.

taper
const string

Voir aussi
plotshape plotchar size.auto size.tiny size.small size.normal size.huge

size.huge

La taille de la fonction plotshape, plotchar. La taille de la forme est grande.

taper
const string

Voir aussi
plotshape plotchar size.auto size.tiny size.small size.normal size.large

alert

alert.freq_once_per_bar

Constante de nommage utilisée avec le paramètre 'freq' de la fonction alert().
Le premier appel de la ligne K déclenche l'alarme.

taper
const string

Voir aussi
alert

alert.freq_all

Constante de nommage utilisée avec le paramètre 'freq' de la fonction alert().
Tous les appels de fonctions déclenchent une alerte.

taper
const string

Voir aussi
alert

alert.freq_once_per_bar_close

Constante de nommage utilisée avec le paramètre 'freq' de la fonction alert().
L'appel de cette fonction ne se produit que lors de l'incrémentation du dernier script de la ligne K en temps réel et déclenche une alerte lors de la fermeture.

taper
const string

Voir aussi
alert

format

format.inherit

est une constante nominale.

taper
const string

Voir aussi
format.price format.volume

format.price

est une constante nominale.

taper
const string

À noter
Si format est format.price, la valeur de précision est définie par défaut. Vous pouvez utiliser les paramètres de précision de la fonction de pointage pour modifier la valeur de précision.

Voir aussi
format.inherit format.volume

format.volume

est une constante nominale.

taper
const string

Voir aussi
format.inherit format.price

syminfo

syminfo.ticker

Codes de produits sans préfixe de bourse, par exemple 'MSFT'。

taper
simple string

Voir aussi
syminfo.tickerid timeframe.period timeframe.multiplier

syminfo.tickerid

Le code de la marchandise avec le préfixe de l'échange, par exemple BATS: MSFT, NASDAQ: MSFT.

taper
simple string

Voir aussi
syminfo.ticker timeframe.period timeframe.multiplier

syminfo.basecurrency

La devise de base de la marchandise. Pour le code de la marchandise, remplacez BTCUSD par BTC.

taper
simple string

Voir aussi
syminfo.currency syminfo.ticker

syminfo.currency

La devise de la marchandise en cours. Le code de devise de retour: <unk> USD <unk> EUR <unk> etc.

taper
simple string

Voir aussi
syminfo.basecurrency syminfo.ticker

syminfo.type

Le type de code de la marchandise actuelle. Les valeurs possibles sont stock, futures, index, forex, crypto, fund, dr.

taper
simple string

Voir aussi
syminfo.ticker

syminfo.mintick

La valeur de mesure minimale de la variété actuelle. Paramètres du modèle dans la bibliothèque de classes de transaction de langue Pine sur FMZ, sur l'interface disque/récapitulateurPrécision de la devise de tarificationCette valeur peut être contrôlée.Précision de la devise de tarificationLa régulation 2 indique que le prix est précis à la seconde décimale au moment de la transaction, et que la plus petite unité de variation du prix est 0.01 ◦syminfo.mintick, soit 0.01 ◦.

taper
simple float

Voir aussi
syminfo.pointvalue

syminfo.pointvalue

Valeur de point de la marchandise actuelle

taper
simple float

Voir aussi
syminfo.mintick

syminfo.timezone

Les fuseaux horaires de l'échange de la série principale des graphiques. Les valeurs possibles sont indiquées dans le timestamp.

taper
simple string

Voir aussi
timestamp

barstate

barstate.islastconfirmedhistory

Si le script est exécuté sur la dernière ligne K de l'ensemble de données à la clôture du marché, ou si le script est exécuté sur la ligne K précédant la ligne K en temps réel, retourne true‬ si le marché est ouvert‬ ou false‬.

taper
series bool

À noter
Le code PineScript de cette variable permet de calculer différemment les données historiques et les données en temps réel.
Veuillez noter que l'utilisation de cette variable/fonction peut entraîner une redéfinition de l'indicateur.

Voir aussi
barstate.isfirst barstate.islast barstate.ishistory barstate.isrealtime barstate.isnew

barstate.isnew

Si le script est actuellement calculé sur la nouvelle ligne k, retourne true, sinon retourne false.

taper
series bool

À noter
Le code PineScript de cette variable permet de calculer différemment les données historiques et les données en temps réel.
Veuillez noter que l'utilisation de cette variable/fonction peut entraîner une redéfinition de l'indicateur.

Voir aussi
barstate.isfirst barstate.islast barstate.ishistory barstate.isrealtime barstate.isconfirmed barstate.islastconfirmedhistory

barstate.isfirst

Retourne true si la ligne k actuelle est la première ligne k du groupe de lignes k, et false sinon.

taper
series bool

À noter
Le code PineScript de cette variable permet de calculer différemment les données historiques et les données en temps réel.
Veuillez noter que l'utilisation de cette variable/fonction peut entraîner une redéfinition de l'indicateur.

Voir aussi
barstate.islast barstate.ishistory barstate.isrealtime barstate.isnew barstate.isconfirmed barstate.islastconfirmedhistory

barstate.islast

Retourne true si la ligne k actuelle est la dernière ligne k du groupe de lignes k, et false sinon.

taper
series bool

À noter
Le code PineScript de cette variable permet de calculer différemment les données historiques et les données en temps réel.
Veuillez noter que l'utilisation de cette variable/fonction peut entraîner une redéfinition de l'indicateur.

Voir aussi
barstate.isfirst barstate.ishistory barstate.isrealtime barstate.isnew barstate.isconfirmed barstate.islastconfirmedhistory

barstate.ishistory

Si la ligne k actuelle est la ligne k historique, retourne true, sinon retourne false.

taper
series bool

À noter
Le code PineScript de cette variable permet de calculer différemment les données historiques et les données en temps réel.
Veuillez noter que l'utilisation de cette variable/fonction peut entraîner une redéfinition de l'indicateur.

Voir aussi
barstate.isfirst barstate.islast barstate.isrealtime barstate.isnew barstate.isconfirmed barstate.islastconfirmedhistory

barstate.isconfirmed

Si le script est en train de calculer la dernière mise à jour de la ligne k actuelle, il retourne true. Le script suivant sera calculé sur la nouvelle ligne K.

taper
series bool

À noter
Le code PineScript de cette variable permet de calculer différemment les données historiques et les données en temps réel.
Il n'est pas recommandé d'utiliser barstate.isconfirmed dans une expression request.security. La valeur de la requête est imprévisible depuis request.security.
Veuillez noter que l'utilisation de cette variable/fonction peut entraîner une redéfinition de l'indicateur.

Voir aussi
barstate.isfirst barstate.islast barstate.ishistory barstate.isrealtime barstate.isnew barstate.islastconfirmedhistory

barstate.isrealtime

Retourne true si la ligne k actuelle est la ligne k en temps réel, sinon false.

taper
series bool

À noter
Le code PineScript de cette variable permet de calculer différemment les données historiques et les données en temps réel.
Veuillez noter que l'utilisation de cette variable/fonction peut entraîner une redéfinition de l'indicateur.

Voir aussi
barstate.isfirst barstate.islast barstate.ishistory barstate.isnew barstate.isconfirmed barstate.islastconfirmedhistory

barstate.time

Pas encore

ta

ta.accdist

Indice de cumulation / répartition

taper
series float

ta.iii

L'indice de résistance du disque.

taper
series float

Exemple

            pine
            
            
// Intraday Intensity Index
plot(ta.iii, color=color.yellow)

// the same on pine
f_iii() =>
    (2 * close - high - low) / ((high - low) * volume)

plot(f_iii())

ta.nvi

Indicateur de masse négative.

taper
series float

Exemple

            pine
            
            
// Negative Volume Index

plot(ta.nvi, color=color.yellow)

// the same on pine
f_nvi() =>
    float ta_nvi = 1.0
    float prevNvi = (nz(ta_nvi[1], 0.0) == 0.0)  ? 1.0: ta_nvi[1]
    if nz(close, 0.0) == 0.0 or nz(close[1], 0.0) == 0.0
        ta_nvi := prevNvi
    else
        ta_nvi := (volume < nz(volume[1], 0.0)) ? prevNvi + ((close - close[1]) / close[1]) * prevNvi : prevNvi
    result = ta_nvi

plot(f_nvi())

ta.pvi

Indicateur de masse.

taper
series float

Exemple

            pine
            
            
// Positive Volume Index

plot(ta.pvi, color=color.yellow)

// the same on pine
f_pvi() =>
    float ta_pvi = 1.0
    float prevPvi = (nz(ta_pvi[1], 0.0) == 0.0)  ? 1.0: ta_pvi[1]
    if nz(close, 0.0) == 0.0 or nz(close[1], 0.0) == 0.0
        ta_pvi := prevPvi
    else
        ta_pvi := (volume > nz(volume[1], 0.0)) ? prevPvi + ((close - close[1]) / close[1]) * prevPvi : prevPvi
    result = ta_pvi

plot(f_pvi())

ta.obv

Indicateur de la marée énergétique.

taper
series float

Exemple

            pine
            
            
// On Balance Volume
plot(ta.obv, color=color.yellow)

// the same on pine
f_obv() =>
    ta.cum(math.sign(ta.change(close)) * volume)

plot(f_obv())

ta.pvt

Indicateur de la tendance des prix.

taper
series float

Exemple

            pine
            
            
// Price-Volume Trend
plot(ta.pvt, color=color.yellow)

// the same on pine
f_pvt() =>
    ta.cum((ta.change(close) / close[1]) * volume)

plot(f_pvt())

ta.wad

La ligne de force aérienne de William Dorsey.

taper
series float

Exemple

            pine
            
            
// Williams Accumulation/Distribution
plot(ta.wad, color=color.yellow)

// the same on pine
f_wad() =>
    trueHigh = math.max(high, close[1])
    trueLow = math.min(low, close[1])
    mom = ta.change(close)
    gain = (mom > 0) ? close - trueLow : (mom < 0) ? close - trueHigh : 0
    ta.cum(gain)

plot(f_wad())

ta.wvad

La dispersion de la variation de William

taper
series float

Exemple

            pine
            
            
// Williams Variable Accumulation/Distribution
plot(ta.wvad, color=color.yellow)

// the same on pine
f_wvad() =>
    (close - open) / (high - low) * volume

plot(f_wvad())

math

math.e

est la constante nominale du nombre d'Euros. Elle est égale à 2,7182818284590452.

taper
const float

Voir aussi
math.phi math.pi math.rphi

math.phi

est la constante nominale de la division en or ≠ 1.6180339887498948 ≠

taper
const float

Voir aussi
math.e math.pi math.rphi

math.pi

est la constante nominale de la constante d'Archimède ≠ 3.1415926535897932 ≠

taper
const float

Voir aussi
math.e math.phi math.rphi

math.rphi

est la constante nominale du taux de fractionnement en or. Elle est égale à 0,6180339887498948.

taper
const float

Voir aussi
math.e math.pi math.phi

strategy

strategy.equity

Les droits et intérêts actuels (strategy.initial_capital + strategy.netprofit + strategy.openprofit)

taper
series float

Voir aussi
strategy.netprofit strategy.openprofit strategy.position_size

strategy.position_size

La direction et l'ampleur de la position actuelle sur le marché. Si la valeur est > 0, la position est plus longue. Si la valeur est < 0, la position est plus courte. La valeur absolue est le nombre de contrats / actions / mains / unités dans la transaction (la taille de la position).

taper
series float

Voir aussi
strategy.position_avg_price

strategy.position_avg_price

Si la position du marché est lisse, l'aluminium NaN se retirera.

illustrer
Le prix moyen dans FMZ PINE Script est le prix incluant les frais de traitement. Par exemple: le prix de commande est de 8000, la direction de vente, la quantité de 1 main ((un, une feuille), le prix moyen après la transaction n'est pas de 8000, moins de 8000 ((le coût comprend les frais de traitement).

taper
series float

Voir aussi
strategy.position_size

strategy.long

Plusieurs directions

taper
strategy_direction

Voir aussi
strategy.entry strategy.exit

strategy.short

Direction de la tête vide.

taper
strategy_direction

Voir aussi
strategy.entry strategy.exit

strategy.closedtrades

Le nombre de transactions clôturées sur l'ensemble de l'intervalle de négociation.

taper
series int

Voir aussi
strategy.position_size strategy.opentrades

strategy.opentrades

Nombre de transactions non fermées ou en cours de détention. Si non, 0 est affiché.

taper
series int

Voir aussi
strategy.position_size

strategy.netprofit

La valeur monétaire totale de toutes les transactions effectuées.

taper
series float

Voir aussi
strategy.openprofit strategy.position_size strategy.grossprofit

strategy.grossprofit

La valeur monétaire totale de toutes les transactions gagnantes qui ont été réalisées.

taper
series float

Voir aussi
strategy.netprofit

strategy.openprofit

Les pertes non réalisées sur les positions non clôturées en cours.

taper
series float

Voir aussi
strategy.netprofit strategy.position_size

strategy.direction.long

Une stratégie qui peut faire plus

taper
const string

Voir aussi
strategy.risk.allow_entry_in

strategy.direction.short

Une stratégie qui n'est qu'un échec

taper
const string

Voir aussi
strategy.risk.allow_entry_in

strategy.direction.all

Les stratégies permettant à la fois de faire plus et de faire moins

taper
const string

Voir aussi
strategy.risk.allow_entry_in

dayofweek

dayofweek

La semaine de l'heure actuelle de la ligne k du fuseau horaire.

taper
series int

À noter
Notez que cette variable renvoie le jour en fonction de l'heure d'ouverture de la ligne K. Pour les heures de négociation du jour au lendemain (par exemple EURUSD, dont les heures de négociation du lundi commencent à 17h00 le dimanche), cette valeur peut être inférieure à la journée du jour de négociation.
Vous pouvez utiliser les variables dayofweek.sunday, dayofweek.monday, dayofweek.tuesday, dayofweek.wednesday, dayofweek.thursday, dayofweek.friday et dayofweek.saturday pour effectuer une comparaison.

Voir aussi
time dayofmonth

dayofweek.sunday

est la constante nominale de la valeur de retour de la fonction dayofweek et de la valeur de la variable dayofweek.

taper
const int

Voir aussi
dayofweek.monday dayofweek.tuesday dayofweek.wednesday dayofweek.thursday dayofweek.friday dayofweek.saturday

dayofweek.monday

est la constante nominale de la valeur de retour de la fonction dayofweek et de la valeur de la variable dayofweek.

taper
const int

Voir aussi
dayofweek.sunday dayofweek.tuesday dayofweek.wednesday dayofweek.thursday dayofweek.friday dayofweek.saturday

dayofweek.tuesday

est la constante nominale de la valeur de retour de la fonction dayofweek et de la valeur de la variable dayofweek.

taper
const int

Voir aussi
dayofweek.sunday dayofweek.monday dayofweek.wednesday dayofweek.thursday dayofweek.friday dayofweek.saturday

dayofweek.wednesday

est la constante nominale de la valeur de retour de la fonction dayofweek et de la valeur de la variable dayofweek.

taper
const int

Voir aussi
dayofweek.sunday dayofweek.monday dayofweek.tuesday dayofweek.thursday dayofweek.friday dayofweek.saturday

dayofweek.thursday

est la constante nominale de la valeur de retour de la fonction dayofweek et de la valeur de la variable dayofweek.

taper
const int

Voir aussi
dayofweek.sunday dayofweek.monday dayofweek.tuesday dayofweek.wednesday dayofweek.friday dayofweek.saturday

dayofweek.friday

est la constante nominale de la valeur de retour de la fonction dayofweek et de la valeur de la variable dayofweek.

taper
const int

Voir aussi
dayofweek.sunday dayofweek.monday dayofweek.tuesday dayofweek.wednesday dayofweek.thursday dayofweek.saturday

dayofweek.saturday

est la constante nominale de la valeur de retour de la fonction dayofweek et de la valeur de la variable dayofweek.

taper
const int

Voir aussi
dayofweek.sunday dayofweek.monday dayofweek.tuesday dayofweek.wednesday dayofweek.thursday dayofweek.friday

hline

hline.style_dashed

est la constante de dénomination de Hline.

taper
hline_style

Voir aussi
hline.style_solid hline.style_dotted

hline.style_dotted

hline.style_dotted

est la constante de dénomination de la fonction Hline de la forme ponctuelle.

taper
hline_style

Voir aussi
hline.style_solid hline.style_dashed

hline.style_solid

est la constante de nommage de la fonction Hline de la forme linéaire du centre.

taper
hline_style

Voir aussi
hline.style_dotted hline.style_dashed

barmerge

barmerge.gaps_on

Donner la stratégie de fusion des données demandées. Les données sont fusionnées avec les écarts possibles (valeur na).

taper
barmerge_gaps

Voir aussi
request.security barmerge.gaps_off

barmerge.gaps_off

Stratégie de fusion des données demandées. Les données sont fusionnées sans interruption, toutes les lacunes étant remplies par les valeurs existantes les plus récentes.

taper
barmerge_gaps

Voir aussi
request.security barmerge.gaps_on

barmerge.lookahead_on

Stratégie pour la localisation des données demandées par la fusion. La carte à barres demandée est fusionnée avec la carte à barres actuelle en fonction du temps d'ouverture de la ligne k. Cette stratégie de fusion peut avoir un impact négatif sur le calcul de l'historique de l'extraction des données de l'axe futur.

taper
barmerge_lookahead

Voir aussi
request.security barmerge.lookahead_off

barmerge.lookahead_off

Politique de localisation des données demandées par la fusion. La bande dessinée demandée est fusionnée avec la bande dessinée actuelle en fonction du temps de clôture de la ligne k. Cette stratégie de fusion interdit l'impact de l'historique de calcul de l'obtention de données de la future ligne.

taper
barmerge_lookahead

Voir aussi
request.security barmerge.lookahead_on

others

hl2

C'est le plus bas prix plus le plus haut prix plus le plus bas prix.

taper
series float

Voir aussi
open high low close volume time hlc3 hlcc4 ohlc4

hlc3

C'est la clé rapide de [le prix le plus élevé + le prix le plus bas + le prix de clôture]/3

taper
series float

Voir aussi
open high low close volume time hl2 hlcc4 ohlc4

hlcc4

C'est la touche de raccourcissement de [haute + basse + basse + basse + basse + basse]/4.

taper
series float

Voir aussi
open high low close volume time hl2 hlc3 ohlc4

ohlc4

c'est la clé de commande de [prix d'ouverture + prix le plus élevé + prix le plus bas + prix de clôture]/4

taper
series float

Voir aussi
open high low close volume time hl2 hlc3 hlcc4

na

Double. La valeur de NaN est (non numérique) [2].

taper
simple na

Exemple

            pine
            
            
// na
plot(bar_index < 10 ? na : close)    // CORRECT
plot(close == na ? close[1] : close)    // INCORRECT!
plot(na(close) ? close[1] : close)    // CORRECT

À noter
Ne tentez pas de le comparer ! Si vous voulez vérifier si une certaine valeur est NaN, utilisez la fonction intégrée na。

Voir aussi
na

bar_index

L'indice des barres de prix actuel 〇 est numéroté à partir de zéro, la première ligne étant indiquée par 0 〇.

taper
series int

Exemple

            pine
            
            
// bar_index
plot(bar_index)
plot(bar_index > 5000 ? close : 0)

À noter
Veuillez noter que bar_index a remplacé la variable n de la version 4.
Veuillez noter que l'index K est calculé à partir de la première ligne historique K comme étant 0 <unk> .
Veuillez noter que l'utilisation de cette variable/fonction peut entraîner une redéfinition de l'indicateur.

Voir aussi
barstate.isfirst barstate.islast barstate.isrealtime

last_bar_index

L'index de la dernière ligne K de la figure ≠ K. L'index K commence par la première ligne K à zéro ≠ K.

taper
series int

Exemple

            
            
            
strategy("Mark Last X Bars For Backtesting", overlay = true, calc_on_every_tick = true)
lastBarsFilterInput = input.int(100, "Bars Count:")
// Here, we store the 'last_bar_index' value that is known from the beginning of the script's calculation.
// The 'last_bar_index' will change when new real-time bars appear, so we declare 'lastbar' with the 'var' keyword.
var lastbar = last_bar_index
// Check if the current bar_index is 'lastBarsFilterInput' removed from the last bar on the chart, or the chart is traded in real-time.
allowedToTrade = (lastbar - bar_index <= lastBarsFilterInput) or barstate.isrealtime
bgcolor(allowedToTrade ? color.new(color.green, 80) : na)

Retourne une valeur
Indice K historique final de la clôture ou indice K en temps réel de l'ouverture.

À noter
Veuillez noter que l'utilisation de cette variable peut entraîner un redessin de l'indicateur.

Voir aussi
bar_index last_bar_time barstate.ishistory barstate.isrealtime

time

L'heure actuelle en ligne k dans le format UNIX. C'est le nombre de millisecondes depuis le 1er janvier 1970 à 00:00:00 UTC.

timenow

L'heure actuelle au format UNIX <unk> est le nombre de millisecondes depuis le 1er janvier 1970 à 00:00:00 UTC <unk>.

taper
series int

À noter
Veuillez noter que l'utilisation de cette variable/fonction peut entraîner une redéfinition de l'indicateur.

Voir aussi
timestamp time dayofmonth dayofweek

taper
series int

À noter
Notez que cette variable renvoie une heure par rapport à l'heure d'ouverture de la ligne K. Par conséquent, pour une période de négociation du jour au lendemain (par exemple, EURUSD, dont la période du lundi commence à 17h00 le dimanche), cette variable peut renvoyer l'heure avant la date de la journée de négociation. Par exemple, sur EURUSD, la variable dayofmonth (par exemple, time) peut être inférieure à la date de la journée de négociation, car la ligne K de la date actuelle est en fait ouverte la veille.

Voir aussi
time dayofmonth dayofweek

year

Ligne k de l'année en cours dans le fuseau horaire de changement.

taper
series int

À noter
Notez que cette variable renvoie l'année en fonction de l'heure d'ouverture de la ligne K. Pour les heures de négociation de nuit (par exemple EURUSD, dont les heures de négociation du lundi commencent à 17h00 le dimanche), cette valeur peut être inférieure à l'année du jour de négociation.

Voir aussi
year time month weekofyear dayofmonth dayofweek hour minute second

month

La ligne de la lune k actuelle dans le fuseau horaire de la bourse.

taper
series int

À noter
Notez que cette variable renvoie le mois en fonction de l'heure d'ouverture de la ligne K. Pour les heures de négociation du soir (par exemple EURUSD, dont les heures de négociation du lundi commencent à 17h00 le dimanche), la valeur peut être inférieure à 1 par rapport au mois du jour de négociation.

Voir aussi
month time year weekofyear dayofmonth dayofweek hour minute second

hour

L'heure actuelle du fuseau horaire de l'échange est la ligne k.

taper
series int

Voir aussi
hour time year month weekofyear dayofmonth dayofweek minute second

minute

L'heure actuelle du fuseau horaire de l'échange est la ligne k.

taper
series int

Voir aussi
minute time year month weekofyear dayofmonth dayofweek hour second

second

Ligne de seconde k actuelle du fuseau horaire de l'échange.

taper
series int

Voir aussi
second time year month weekofyear dayofmonth dayofweek hour minute

open

Le prix d'ouverture.

taper
series float

À noter
L'opérateur de parenthèses carrées est disponible.[] pour accéder à la valeur précédente, par exemple ≠ open[1]，open[2]。

Voir aussi
high low close volume time hl2 hlc3 hlcc4 ohlc4

high

Le prix le plus élevé actuellement.

taper
series float

À noter
L'opérateur de parenthèses carrées est disponible.[] pour accéder à une valeur antérieure, par exemple ≠ high[1]，high[2]。

Voir aussi
open low close volume time hl2 hlc3 hlcc4 ohlc4

low

Le prix le plus bas actuellement.

taper
series float

À noter
L'opérateur de parenthèses carrées est disponible.[] pour accéder à une valeur antérieure, par exemple ≠ low[1]，low[2]。

Voir aussi
open high close volume time hl2 hlc3 hlcc4 ohlc4

close

Le prix de clôture de la ligne K en cours ou le prix de la dernière transaction de la ligne K en temps réel qui n'a pas encore été terminée.

taper
series float

À noter
L'opérateur de parenthèses carrées est disponible.[] pour accéder à une valeur antérieure, par exemple <unk> close[1]，close[2]。

Voir aussi
open high low volume time hl2 hlc3 hlcc4 ohlc4

volume

Le trafic de la ligne K actuel.

taper
series float

À noter
L'opérateur de parenthèses carrées est disponible.[] pour accéder à des valeurs précédentes, par exemple ◦ volume[1]，volume[2]。

Voir aussi
open high low close time hl2 hlc3 hlcc4 ohlc4

weekofyear

Le nombre de semaines dans la partie de la ligne k actuelle du fuseau horaire de changement.

taper
series int

À noter
Veuillez noter que cette variable retourne la semaine en fonction de l'heure d'ouverture de la ligne K. Pour les heures de négociation du soir (par exemple, EURUSD, dont les heures de négociation du lundi commencent à 17h00 le dimanche), cette valeur peut être inférieure à la semaine du jour de négociation.

Voir aussi
weekofyear time year month dayofmonth dayofweek hour minute second

dayofmonth

Date de l'heure actuelle de la ligne k du fuseau horaire de l'échange.

taper
series int

À noter
Notez que cette variable renvoie le jour en fonction de l'heure d'ouverture de la ligne K. Pour les heures de négociation du jour au lendemain (par exemple EURUSD, dont les heures de négociation du lundi commencent à 17h00 le dimanche), cette valeur peut être inférieure à la journée du jour de négociation.

Voir aussi
time dayofweek