[TOC] Je vous en prie.

Introduction aux mots clés, à la grammaire et aux paramètres

Structure du code

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

<version>
<declaration_statement>
<code>

Nom de l'entreprise

Les symboles des notes supportés par la langue Pine de la FMZ: notes en une seule ligne//, notes à plusieurs lignes/* */, comme la méthode des notes dans l'exemple suivant:

[macdLine, signalLine, histLine] = ta.macd(close, 12, 26, 9)  // calculate the MACD indicator

/*
The plot function draws the indicator line on the chart
*/
plot(macdLine, color = color.blue, title='macdLine')
plot(signalLine, color = color.orange, title='signalLine')
plot(histLine, color = color.red, title='histLine')

La version

Une instruction de compilateur de la forme suivante indique au compilateur quelle version de Pine le script a été écrit avec:

//@version=5

La version par défaut est V5, qui peut être omis du code//@version=5.

Déclaration de déclaration

• indicator()
• strategy()

L'instruction de déclaration détermine le type de script, qui à son tour détermine ce qui y est autorisé, et comment il est utilisé et exécuté. Définir les propriétés clés du script, telles que son nom, où il apparaîtra lorsqu'il est ajouté au graphique, la précision et le format des valeurs numériques qu'il affiche, et certaines valeurs numériques qui régissent son comportement en temps d'exécution, par exemple, le nombre maximal d'objets de dessin à afficher dans le graphique. Pour les stratégies, les attributs comprennent des arguments qui contrôlent le backtesting, tels que le capital initial, les commissions, le glissement, etc.indicator()oustrategy()la déclaration doit être incluse dans un code de stratégie en pin de la ZFM.

Le code

Les lignes d'un script qui ne sont pas des commentaires ou des instructions du compilateur, qui sont des instructions, qui mettent en œuvre l'algorithme du script.

• Déclaration variable
• Réattribution des variables
• Déclaration de fonction
• Appels de fonction intégrés, appels de fonction définis par l'utilisateur
• if, for, whileouswitchet autres constructions

Les déclarations peuvent être organisées de différentes manières.

• Certaines instructions peuvent être exprimées en une seule ligne, comme la plupart des déclarations de variables, les lignes contenant un seul appel de fonction ou les déclarations de fonction en une seule ligne.
• Les instructions dans la portée globale d'un script (c'est-à-dire les parties qui ne font pas partie d'un bloc local) ne peuvent pas commencer par unspaceoutabLes lignes qui commencent à la première position d'une ligne font par définition partie de la portée globale du script.
• Unlocal blockest toujours nécessaire pour les déclarations de structure ou de fonction multilignes. Un bloc local doit être indenté par un onglet ou quatre espaces (sinon, il sera analysé comme le code concaténé de la ligne précédente, qui est déterminé comme le contenu continu de la ligne précédente de code), et chaque bloc local définit une portée locale différente.
• Plusieurs énoncés d'une seule ligne peuvent être concaténés sur une seule ligne en utilisant des virgules (,) comme délimiteurs.
• Une ligne peut contenir des commentaires ou seulement des commentaires.
• Les lignes peuvent également être enroulées (continuées sur plusieurs lignes).

Par exemple, inclure trois blocs locaux, un dans la déclaration de fonction personnalisée et deux dans la déclaration de variable en utilisant la structure if, comme suit:

indicator("", "", true)             // Declaration statement (global scope), can be omitted

barIsUp() =>                        // Function declaration (global scope)
    close > open                    // Local block (local scope)

plotColor = if barIsUp()            // Variable declaration (global scope)
    color.green                     // Local block (local scope)
else
    color.red                       // Local block (local scope)

runtime.log("color", color = plotColor)  // Call a built-in function to output the log (global scope)

Code de nouvelle ligne

Les lignes longues peuvent être divisées en plusieurs lignes, ou enveloppées. Une ligne enveloppée doit être indentée par n'importe quelle quantité d'espace blanc, tant qu'elle n'est pas un multiple de 4 (ces limites sont utilisées pour indenter des blocs locaux).

a = open + high + low + close

Il peut être emballé comme suit (notez que le nombre d'espaces en retrait par ligne n'est pas un multiple de 4):

a = open +
      high +
          low +
             close

Un appel long peut être décrit comme suit:

close1 = request.security(syminfo.tickerid, "D", close)      // closing price data series of syminfo.tickerid daily level of the current trading pair
close2 = request.security(syminfo.tickerid, "240", close)    // closing price data series of syminfo.tickerid 240-minute level of the current trading pair
plot(ta.correlation(close, open, 100),                       // Line-long plot() calls can be wrapped
   color = color.new(color.purple, 40),
   style = plot.style_area,
   trackprice = true)

Les déclarations dans les déclarations de fonctions définies par l'utilisateur peuvent également être enveloppées. Cependant, comme un bloc local doit syntaxiquement commencer par un tiret (4 espaces ou 1 onglet), lors de sa division sur la ligne suivante, la continuation d'une déclaration doit commencer par plus d'un tiret (pas égal à 4 multiples d'espaces).

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érie temporelle

La série temporelle n'est pas un type ou un format de données, mais plutôt un concept de structure de base dans le langage PINE. Utilisé pour stocker des valeurs qui changent continuellement dans le temps, chaque valeur correspond à un point dans le temps.

Prenez la variable intégréeopenPar exemple, leopenla variable intégrée enregistre le prix d'ouverture de chaque représentation int BAR, si cetteopenest une période de représentation int de 5 minutes.openla variable enregistre le prix d'ouverture de chaque représentation int de 5 minutes BAR (bar).openPour faire référence aux valeurs précédentes (valeurs passées) dans la série temporelle, nous utilisons le[]Lorsque la stratégie est exécutée sur une certaine représentation int BAR,open[1]Le sens est de se référer au prix d'ouverture de la précédente représentation int BAR de la représentation int actuelle BAR.

Bien que...séries temporellesest très similaire à la structure de données array, bien que le langage PINE ait également un type de tableau.

Les séries chronologiques conçues dans le langage du pin peuvent facilement calculer la valeur cumulée du prix de clôture dans le code de stratégie, et il n'y a pas besoin d'utiliser des structures de boucle telles que pour, seulement la fonction intégréeta.cum(close)Pour un autre exemple, nous devons calculer la valeur moyenne de la différence entre le prix le plus élevé et le prix le plus bas des 14 dernières BAR de représentation int (c'est-à-dire les 14 BAR de représentation int les plus proches du moment actuel où le code est exécuté), qui peut être écrite comme suit:ta.sma(high - low, 14)

Le résultat de l'appel d'une fonction sur une série temporelle laissera également une trace sur la série temporelle, encore une fois nous utilisons le[]Par exemple, lorsque nous testons si le prix de clôture de la représentation int actuelle BAR dépasse la valeur maximale du prix le plus élevé de la dernière représentation int 10 BAR (à l'exclusion de la représentation int actuelle BAR).breach = close > ta.highest(close, 10)[1]On peut aussi écrirebreach = close > ta.highest(close[1], 10)Alors...ta.highest(close, 10)[1]etta.highest(close[1], 10)sont équivalentes.

Ceci peut être vérifié par le code suivant:

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)

Le code de test ci-dessus fournira les valeurs de a et b sur chaque BAR dans la série temporelle correspondante.

Arguments de modèle de la bibliothèque de classe de commerce de la langue du pin

Instructions pour définir les arguments du modèle intégré Pine Language Trade Class Library de la stratégie PINE.

Paramètres de négociation

• Mode d'exécution Modèle de prix de clôture: le modèle n'est exécuté qu'après la fin du BAR en cours et la transaction est exécutée au début du BAR suivant. Modèle de prix en temps réel: Le modèle est exécuté à chaque fois que le prix bouge, et il y a un signal pour exécuter la transaction immédiatement.
• Taille par défaut du lot ouvert: si l'ordre de transaction ne spécifie pas le montant de la transaction, la transaction sera exécutée selon le montant fixé.
• Quantité maximale de commande pour une seule transaction: Déterminer le montant maximal de chaque commande afin d'éviter d'avoir une incidence sur le marché en fonction du marché réel et de ce cadre d'argumentation.
• Points de glissement: déterminer le glissement lors de la passation d'une commande selon lesPricing Currency PrecisionPar exemple, la précision de la devise de prix est réglée sur 2, ce qui est précis à la seconde décimale, précis à 0,01. Ensuite, chaque point de glissement représente 0,01 unité de prix. À ce moment-là, le point de glissement est réglé sur 5, et le glissement lors de la passation d'un ordre est de 0,05 (le glissement fait référence à la partie du prix qui déborde lors de la passation d'un ordre pour un meilleur et un ordre de handicap).
• Le plus long nombre de période de la variable: affecte le nombre de lignes K BAR dans le graphique.SetMaxBarLendans lejavascript srategy.

Options sur contrats à terme

• Code de variété: code du contrat, il n'est nécessaire de le définir que lorsque l'objet d'échange est un objet d'échange non ponctuel.
• La taille minimale du contrat: le volume de négociation minimum du contrat lors de la passation d'un ordre.

Options de négociation en direct

• Progressus de récupération automatique: récupère automatiquement l'état avant le dernier arrêt de stratégie.
• Si l'ordre n'est pas rempli, l'ordre sera annulé et l'ordre sera remplacé pour tenter de négocier.
• Intervalle de sondage réseau (millièmes de seconde): valable uniquement pour le protocole REST, il contrôle l'intervalle de demande réseau pour empêcher les demandes d'être trop fréquentes et de dépasser la limite d'échange.
• Temps de synchronisation du compte (secondes): la période de synchronisation des données du compte.
• Temps de synchronisation de position après ouverture d'une position (millièmes de seconde): Seulement pour les positions répétées causées par des retards de données dans certains échanges, la définition d'un temps de synchronisation plus long peut atténuer de tels problèmes.
• Multiple d'effet de levier: définit le multiple d'effet de levier.

Commerce au comptant, autres réglages

• Volume de négociation d'un lot: le volume de négociation par défaut d'un lot, qui n'est valable que pour le spot.
• Volume minimum des échanges: Le volume minimum des échanges.
• Precision de la devise de prix: la précision du prix, c'est-à-dire le nombre de décimales dans le prix.
• Précision de la variété de négociation: la précision de la quantité de commande, c'est-à-dire le nombre de décimales de la quantité de commande.
• Frais de traitement: calculer certaines données selon ce paramètre, 0,002 signifie 2/1000.
• Intervalle des statistiques des profits et pertes: Il est uniquement utilisé pour afficher les statistiques des profits et pertes sur le marché réel.
• Réessayer avec échec (ms): intervalle de réessayer lorsque la requête réseau échoue.
• Utiliser un proxy: valable uniquement pour le protocole REST.
• Masquer les erreurs courantes du réseau: Masquer les journaux d'erreurs courantes dans la zone du journal.
• Adresse de base du commutateur: valable uniquement pour le protocole REST.
• Notifications push: envoyer des messages push dans les boîtes aux lettres, etc.

Commerce des commandes

Position ouverte

strategy(title = "open long example", pyramiding = 3)                                // The number of orders placed in the same direction allowed by pyramiding
strategy.entry("long1", strategy.long, 0.01)                                         // Open a long position at the market price, specify the group label as long1
strategy.entry("long2", strategy.long, 0.02, when = close > ta.ema(close, 10))       // The condition is triggered, the order is executed, and the market price opens a long position
strategy.entry("long3", strategy.long, 0.03, limit = 30000)                          // Specify the (lower) price, plan to place a buy order, wait for a deal to open a position, and open a position at a limit price

Position fermée

strategy(title = "close long example", pyramiding = 2)                              // The number of orders placed in the same direction allowed by pyramiding
strategy.entry("long1", strategy.long, 0.1)                                         // Open a long position at the market price, specify the group label as long1
strategy.entry("long2", strategy.long, 0.1)                                         // Open a long position at the market price, specify the group label as long2
strategy.close("long1", when = strategy.position_size > 0.1, qty_percent = 50, comment = "close buy entry for 50%")   // To close a position, specify to close 50% of the positions whose group label is long1
strategy.close("long2", when = strategy.position_size > 0.1, qty_percent = 80, comment = "close buy entry for 80%")   // To close a position, specify to close 80% of the positions whose group label is long2

Mécanisme commercial

Le mécanisme de position du langage PINE est similaire à la position unidirectionnelle. Par exemple, lors de la tenue d'une position dans la direction longue (position longue), s'il y a un ordre d'opération de vente, un ordre planifié, etc. (dans la direction opposée à la position), l'exécution sera déclenchée, et la position dans la direction longue sera fermée en premier. (Fermer toutes les positions longues), puis exécuter l'ordre déclenché (dans la direction opposée par rapport à la position avant la fermeture).

L'ordre prévu

Lorsque vous passez un ordre à l'aide de la commande de placement d'ordre, si aucun prix n'est spécifié, l'ordre par défaut est un ordre de marché. En plus de l'ordre de marché, vous pouvez également passer un ordre via un ordre planifié, qui n'opère pas immédiatement pour passer un ordre. L'ordre planifié existe dans la file d'attente d'ordre planifiée du programme lorsqu'il n'est pas déclenché, et peut être vu dans l'onglet Planifié Order du tableau des informations d'état (c'est-à-dire la barre d'état lorsque la stratégie est en cours d'exécution) pendant la mise en marche.commande réelle/test de retour. Le système ne passera un ordre que lorsque le prix du marché en temps réel répond aux conditions pour déclencher ces ordres planifiés. Par conséquent, il est normal que ces ordres présentent un léger écart dans le prix du commerce.strategy.entryfonction pour passer une commande, nous pouvons spécifier lelimit, stop arguments.

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    

• ordre de limite

  Lorsque l'ordre est un ordre d'achat (c'est-à-dire que le prix de l'ordre est supérieur à la valeur de l'ordre).directionL'argument eststrategy.long), l'ordre ne sera déclenché que lorsque le prix actuel du marché est inférieur à ce prix. Lorsque l'ordre est un ordre de vente (c'est-à-directionL'argument eststrategy.short), l'ordre ne sera déclenché que si le prix actuel du marché est supérieur à ce prix.

• ordre d'arrêt

  Lorsque l'ordre est un ordre d'achat, l'ordre ne sera déclenché que lorsque le prix actuel du marché est supérieur à ce prix. Lorsqu'un ordre est un ordre de vente, l'ordre ne sera déclenché que si le prix actuel du marché est inférieur à ce prix.

• ordre stop-limit

  Lelimitetstoples arguments peuvent être définis en même temps, et l'ordre sera déclenché au prix qui remplit les conditions en premier.

Pourcentage des capitaux propres

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

// Simple moving average crossover strategy
longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))  

// If the moving average crossover condition is met, buy or sell
if (longCondition)
    strategy.entry("Long", strategy.long)  

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

Après avoir précisédefault_qty_type=strategy.percent_of_equity, réglédefault_qty_valueLe montant de la commande est calculé en fonction du montant de la devise libellée sur le compte. Par exemple: si le compte courant a 10 000 USDT, la mise en place d'une commande de 1% signifie placer une commande avec une échelle de 100 USDT (calculée sur la base du prix courant lors de la vente).

Déclaration, structure logique mots clés

- Je ne sais pas.

var est un mot clé utilisé pour l'attribution et l'initialisation ponctuelle de variables. En général, la grammaire de l'attribution des variables qui ne contient pas le mot clé var provoque la valeur de la variable s à être écrasée à chaque fois que les données sont mises à jour.

var variable_name = expression

Expliquer:

• variable_name- Tout nom d'une variable utilisateur autorisé dans Pine Script (il peut contenir des lettres majuscules et minuscules en latin, des chiffres et des soulignements (_), mais il ne peut pas commencer par un nombre).
• expression- Toute expression arithmétique, comme pour définir une variable régulière.

Exemple

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

La variable a contient le prix de clôture de la première barre de chaque barre de la série. La variable b contient le prix de clôture de la première barre de prix verde de la série. La variable c détient le prix de clôture de la dixième barre verde de la série.

Sur FMZ, il est divisé en modèle de prix en temps réel et modèle de prix de clôture.varetvarip.

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

// Test var varip
var i = 0
varip ii = 0

// Print the i and ii changed in each round of the strategy logic on the graph
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)

// Each round of logic execution increments i and ii by 1
if true
    i := i + 1
    ii := ii + 1

• Modèle de prix en temps réel Le code de test ci-dessus est exécuté en deux phases: 1. phase de représentation int historique. 2. phase de représentation int temps réel. Dans le modèle de prix en temps réel, phase de représentation int historique, les variables i et ii déclarées parvar, varipsont exécutés progressivement à chaque ronde d'exécution du code de stratégie (parce queif truePar conséquent, on peut voir que les nombres affichés sur la représentation int BAR du résultat du backtest sont augmentés de 1 un par un. Lorsque la phase de représentation int historique se termine, la phase de représentation int en temps réel commence.var, varipComme il s'agit d'un modèle de prix en temps réel, le code de stratégie sera exécuté une fois pour chaque variation de prix dans une représentation int BAR,i := i + 1etii := ii + 1La différence est que ii est modifié à chaque fois. Bien que i soit également modifié à chaque fois, la valeur précédente sera restaurée lorsque la logique de stratégie est exécutée dans le tour suivant, et la valeur de i ne sera pas mise à jour jusqu'à ce que la représentation int actuelle BAR soit terminée (c'est-à-dire que la valeur précédente ne sera pas restaurée lorsque la logique de stratégie est exécutée dans le tour suivant). On peut donc voir que la variable i est toujours augmentée de 1 pour chaque BAR. Mais la variable ii est accumulée plusieurs fois pour chaque BAR.

• Modèle de prix de clôture Puisque le modèle de prix de clôture exécute la logique de stratégie une seule fois par représentation int BAR disparu.varetvaripDans l'exemple ci-dessus, le modèle de prix de clôture se comporte exactement de la même manière, à la fois dans la phase de représentation int historique et dans la phase de représentation int en temps réel, en augmentant de 1 par représentation int BAR.

variété

varip (var intrabar persist) est un mot-clé utilisé pour l'affectation et l'initialisation ponctuelle de variables.

varip variable_name = expression

Expliquer:

• variable_name- Tout nom d'une variable utilisateur autorisé dans un script Pine (il peut contenir des lettres majuscules et minuscules, des chiffres et des soulignements (_), mais il ne peut pas commencer par un nombre).
• expression- Toute expression arithmétique, comme le temps définissant les variables régulières.

Exemple

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

Avec varip, le même comportement se produit sur les barres historiques, mais sur les barres en direct, le graphique renvoie une valeur qui augmente d'un pour chaque tick.

Les commentairesIl ne peut être utilisé qu'avec des types simples tels que float, int, bool, string et des tableaux de ces types.

vrai

Il représente la valeur d'une variable bool, ou une valeur qui peut être calculée quand une expression utilise unla comparaisonoulogique operator.

Les commentairesVeuillez consulter les descriptions deComparaisonLes opérateurs etC' est logique. Operators.

Voir aussi bool

faux

Il représente la valeur d'une variable bool et le résultat des opérations de comparaison et des opérations logiques.

Les commentairesVeuillez consulter les descriptions deComparaisonLes opérateurs etC' est logique. Operators.

Voir aussi bool

si

Une instruction If définit un bloc d'instructions qui doit être exécuté lorsque la condition d'une expression est remplie.

Code universel 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

Les commentaires var_declarationX- Cette variable obtient la valeur de l'instruction ifcondition- Si la condition est vraie, la logique dans le bloc de l'instructionthenest utilisé (var_decl_then0, var_decl_then1Si la condition est fausse, la logique dans le bloc d'instructionelse ifouelseest utilisé (var_decl_else0, var_decl_else1, etc.).return_expression_thenetreturn_expression_else- La dernière expression du module ou l'expression du bloc else renvoie la valeur finale de l'instruction.

Le type de la valeur de retour de l'instruction if dépend du type dereturn_expression_thenetreturn_expression_else. Lors de l'exécution sur TradingView, leurs types doivent correspondre: lorsque vous avez une valeur de chaîne dans le bloc else, il n'est pas possible de retourner une valeur entière du bloc. Lors de l'exécution sur le FMZ, l'exemple suivant ne signalera pas d'erreur. Lorsque la valeur y est open, la valeur du graphique lors du dessin est n/a.

Exemple

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

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

LeelseDans ce cas, si la condition est false, la variable var_declarationX est attribuée une valeur empty (na, false, ou ):

Exemple

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

Les blocs de then, else if, else sont déplacés quatre espaces:

Exemple

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

La valeur résultante de laifIl peut être utile si vous avez besoin d'effets secondaires d'expressions, par exemple dans le trading de stratégie:

Exemple

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

Si les instructions peuvent se contenir mutuellement:

Exemple

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

pour

La construction for permet d'exécuter plusieurs instructions à 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 facultative qui sera attribuée comme la valeur de l'expression return_expression de la boucle.counter- Une variable qui détient la valeur du compteur de boucle, augmentant/décrémant de 1 ou la valeur step_num à chaque itération de la boucle.from_num- La valeur de départ du compteur. série int/float sont autorisées.to_num- La valeur finale du compteur. La boucle s'interrompt lorsque le compteur est supérieur à to_num (ou inférieur à to_num dans le cas de from_num > to_num). series int/float valeurs/expressions sont autorisées, mais elles ne sont évaluées que lors de la première itération de la boucle.step_num- La valeur d'incrémentation/décrémentation du compteur. Elle est facultative. La valeur par défaut est +1 ou -1, selon la plus grande des valeurs de from_num ou to_num. Lors de l'utilisation de valeurs, le compteur est également augmenté/décrémenté selon la plus grande des valeurs de from_num ou to_num, de sorte que le signe +/- de step_num est facultatif.statements | continue | break- N'importe quel nombre de phrases, ou les mots clés continue ou break, indentés par 4 espaces ou un seul onglet.return_expression- La valeur de retour de la boucle, si elle est présente, est attribuée à la variable dans var_declaration. Si la boucle sort en raison des mots clés continue ou break, la valeur de retour de la boucle est la valeur de retour de la dernière variable à laquelle une valeur a été attribuée avant la sortie de la boucle.continue- Un mot clé qui ne peut être utilisé que dans les boucles, il provoque l'exécution de la prochaine itération de la boucle.break- Le mot clé pour sortir de la boucle.

Exemple

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

Voir aussi for...in while

Pour... dans

Lefor...inconstruct permet de répéter plusieurs instructions pour chaque élément du tableau.array_element, ou avec deux arguments:[index, array_element]La deuxième forme n'affecte pas la fonction de la boucle. Elle garde une trace de l'indice de l'itération en cours dans la première variable de la tuple.

[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 facultative à laquelle sera attribuée la valeur des bouclesreturn_expression. index- Une variable optionnelle qui suit l'indice d'itération en cours. L'indice commence à 0. Les variables sont immuables dans le corps de la boucle. Lorsqu'il est utilisé, il doit être contenu dans une tuple qui contient égalementarray_element. array_element- Une variable contenant chaque élément de matrice consécutif à traiter dans la boucle.array_id- L'identifiant du tableau de l'itération.statements | continue | break- N'importe quel nombre de phrases, ou les mots clés continue ou break, indentés par 4 espaces ou un seul onglet.return_expression- La valeur de retour de la boucle est attribuée à la variablevar_declarationSi la boucle s'éteint en raison des mots clés continue ou break, la valeur de retour de la boucle est la variable qui a été attribuée pour la dernière fois avant la sortie de la boucle.continue- Un mot clé qui ne peut être utilisé que dans les boucles, il provoque l'exécution de la prochaine itération de la boucle.break- Le mot clé pour sortir de la boucle.

Permet de modifier les éléments d'un tableau ou leur taille dans une boucle. Ici, nous utilisons la forme d'un seul argument defor...inpour déterminer, pour chaque barre, combien de barres ont une valeur OHLC supérieure à la SMA de la valeur close:

Exemple

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

Ici, nous utilisons la forme à deux arguments de for...in pour définir les valeurs de notreisPosle tableau àtrueLorsque leurs valeurs correspondantes dans notrevaluesArrayles nombres de la matrice sont positifs:

Exemple

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

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

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

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

pendant que

Lewhilel'instruction permet l'itération conditionnelle des blocs de code natifs.

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

Expliquer:variable_declaration- Déclaration facultative des variables.return expressionpeut fournir une valeur d'initialisation pour cette variable.boolean_expression- Si tel est le cas, exécuter le bloc local duwhileSi la déclaration est fausse, l'exécution du script se poursuit après lawhile statement. continue- Lecontinuemot clé provoque la boucle à la branche à l'itération suivante.break- LebreakL'exécution du script reprend après lewhile statement. return_expression- ligne facultative indiquant la valeur de retour de l'indicateurwhile statement.

Exemple

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

plot(factorial)

Les commentairesLe bloc de code natif après le premierwhileLa ligne doit être entrecoupée de quatre espaces ou d'un onglet.whileboucle, l'expression booléenne suivantewhiledoit éventuellement devenir fausse, oubreakdoit être exécuté.

échangeur

L'opérateur de commutation transfère le contrôle à l'une de plusieurs instructions 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

commutateur avec expression:

Exemple

// Switch using an expression

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

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

plot(ma)

commutateur sans expression:

Exemple

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

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

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

RetoursLa valeur de la dernière expression dans le bloc d'instructions locales exécuté.

Les commentairesSeulement un deslocal_blockcas oudefault_local_blockpeut être exécuté.default_local_blockest introduit uniquement avec le=>Le code de la base de données est un code de la base de données, et est exécuté uniquement si le bloc précédent n'est pas exécuté.switchl'instruction est attribuée à une variable etdefault_local_blockn'est pas spécifié, la déclaration renvoienasilocal_blockLorsque l'on attribue le résultat d'unswitchdéclaration à une variable, touteslocal_blockles instances doivent renvoyer une valeur du même type.

Voir aussi if ?:

séries

La série est un mot-clé qui indique le type de série de données.series keyword.

Opérateur

=

Utilisé pour attribuer des valeurs aux variables, mais uniquement lorsque la variable est déclarée (la première fois utilisée).

:=

L'opérateur d'attribution attribue une valeur à la variable de gauche. Utilisé pour attribuer des valeurs à des variables déclarées précédemment.

!=

Applicable à toutes les expressions.

expr1 != expr2

RetoursValeur booléenne, ou une séquence de valeurs booléennes.

%

Modulo (résidu entier), applicable aux expressions numériques.

expr1 % expr2

RetoursValeur entière ou flottante, ou série de valeurs.

Les commentairesDans Pine Script, lorsque le reste entier est calculé, le quotient est tronqué, c'est-à-dire arrondi vers la valeur absolue la plus basse.

Exemple: -1 % 9 = -1 - 9 * tronqué ((-1/9) = -1 - 9 * tronqué ((-0,111) = -1 - 9 * 0 = -1.

%=

Applicable aux expressions numériques.

expr1 %= expr2

Exemple

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

RetoursValeur entière ou flottante, ou série de valeurs.

*

Assignation de multiplication, applicable aux expressions numériques.

expr1 * expr2

RetoursValeur entière ou flottante, ou série de valeurs.

*=

Assignation de multiplication, applicable aux expressions numériques.

expr1 *= expr2

Exemple

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

RetoursValeur entière ou flottante, ou série de valeurs.

+

Addition ou unary plus. Applicable aux expressions numériques ou aux chaînes.

expr1 + expr2

+ expr

RetoursLe binaire+de la chaîne renvoie la combinaison de expr1 et expr2 Numéro renvoie une valeur entière ou à virgule flottante, ou une séquence de valeurs: Le binaire + renvoie expr1 plus expr2. Unary + renvoie expr (rien n'est ajouté à la symétrie de l'opérateur unary).

Les commentairesVous pouvez utiliser des opérateurs arithmétiques avec des nombres ainsi qu'avec des variables de série.

+=

Applique aux expressions numériques ou aux chaînes.

expr1 += expr2

Exemple

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

RetoursPour les chaînes, renvoie la concaténation d'expr1 et expr2. Pour les nombres, renvoie une valeur entière ou flottante, ou une série de valeurs.

Les commentairesVous pouvez utiliser des opérateurs arithmétiques avec des nombres ainsi qu'avec des variables de série.

-

Soustraction ou moins unitaire, applicable aux expressions numériques.

expr1 - expr2

- expr

RetoursRenvoie une valeur entière ou à virgule flottante, ou une série de valeurs: Le binaire + renvoie expr1 moins expr2. Unary-renvoie la négation de expr.

Les commentairesVous pouvez utiliser des opérateurs arithmétiques avec des nombres ainsi qu'avec des variables de série.

-=

Assignation de soustraction applicable aux expressions numériques.

expr1 -= expr2

Exemple

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

RetoursValeur entière ou flottante, ou série de valeurs.

/

Assignation de division, applicable aux expressions numériques.

expr1 / expr2

RetoursValeur entière ou flottante, ou série de valeurs.

/=

Assignation de division, applicable aux expressions numériques.

expr1 /= expr2

Exemple

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

RetoursValeur entière ou flottante, ou série de valeurs.

<

Applicable aux expressions numériques.

expr1 < expr2

RetoursValeur booléenne, ou série de valeurs booléennes.

<=

Moins ou égal à. Applicable aux expressions numériques.

expr1 <= expr2

RetoursValeur booléenne, ou série de valeurs booléennes.

==

Applicable aux expressions de tout type.

expr1 == expr2

RetoursValeur booléenne, ou série de valeurs booléennes.

=>

L'opérateur => est utilisé dans les déclarations de fonctions définies par l'utilisateurswitch statements.

La grammaire de la déclaration de fonction est la suivante:

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

Un<local_block>est zéro ou plus d'instructions Pine Script.<function_result>est une variable, une expression ou une tuple.

Exemple

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

Les référencesVous pouvez en apprendre davantage sur les fonctions définies par l'utilisateur dans les pages du manuel de l'utilisateur sur les fonctions de déclaration et les bibliothèques de scripts.

>

Applicable aux expressions numériques.

expr1 > expr2

RetoursValeur booléenne, ou série de valeurs booléennes.

>=

Plus grand que ou égal à, applicable aux expressions numériques.

expr1 >= expr2

RetoursValeur booléenne, ou série de valeurs booléennes.

?:

L'opérateur conditionnel ternaire.

expr1 ? expr2 : expr3

Exemple

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

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

Retoursexpr2 si expr1 est évalué comme vrai, expr3 autrement. La valeur zéro (0 et aussi NaN, +Infinity, -Infinity) est considérée comme fausse, toute autre valeur est vraie.

Les commentairesUtilisez na pour else branche si vous n'en avez pas besoin. Vous pouvez combiner deux ou plusieurs opérateurs?: pour obtenir l'équivalent d'une instruction de type switch (voir les exemples ci-dessus). Vous pouvez utiliser des opérateurs arithmétiques avec des nombres ainsi qu'avec des variables de série.

Voir aussi na

[]

Le sous-script de la série donne accès aux valeurs précédentes de la série expr1. expr2 est le nombre de barres dans le passé, et il doit être numérique.

expr1[expr2]

Exemple

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

RetoursUne série de valeurs.

Voir aussi math.floor

et

Logique et applicable aux expressions booléennes.

expr1 and expr2

RetoursValeur booléenne, ou série de valeurs booléennes.

ou

Logique OR, applicable aux expressions booléennes.

expr1 or expr2

RetoursValeur booléenne, ou série de valeurs booléennes.

Je ne sais pas.

Négation logique (NOT) applicable aux expressions booléennes.

not expr1

RetoursValeur booléenne, ou série de valeurs booléennes.

Mots clés de type de données

Boole

Mots clés utilisés pour déclarer explicitement le type bool (booléen) d'une variable ou d'un argument. Les variables Bool peuvent avoir des valeurs: true, false ou na.

Exemple

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

Les commentairesMentionner explicitement le type dans une déclaration de variable est facultatif, sauf lorsqu'il est initialisé avec na. En savoir plus sur les types de script Pine dans la page du manuel de l'utilisateur sur le système de types.

Voir aussi var varip int float color string true false

int

Mot clé utilisé pour déclarer explicitement le type int (entier) d'une variable ou d'un argument.

Exemple

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

Les commentairesMentionner explicitement le type dans une déclaration de variable est facultatif, sauf lorsqu'il est initialisé avec na. En savoir plus sur les types de script Pine dans la page du manuel de l'utilisateur sur le système de types.

Voir aussi var varip float bool color string

flottant

Mots clés utilisés pour déclarer explicitement le type float (pointe flottante) d'une variable ou d'un argument.

Exemple

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

Les commentairesLa mention explicite du type dans une déclaration de variable est facultative, sauf lorsqu'elle est initialisée par na.

Voir aussi var varip int bool color string

une chaîne

Mot clé utilisé pour déclarer explicitement le type string d'une variable ou d'un argument.

Exemple

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

Les commentairesMentionner explicitement le type dans une déclaration de variable est facultatif, sauf lorsqu'il est initialisé avec na. En savoir plus sur les types de script Pine dans la page du manuel de l'utilisateur sur le système de types.

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

couleur

Mot clé utilisé pour déclarer explicitement le type color d'une variable ou d'un argument.

Exemple

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

Les commentairesLes paires de lettres représentent des valeurs hexadécimales de 00 à FF (0 à 255 en décimal) où les paires RR, GG et BB sont les valeurs des composantes rouge, verte et bleue des couleurs. AA est une valeur optionnelle pour la transparence des couleurs (ou composante alpha) où 00 est invisible et FF opaque.

Mentionner explicitement le type dans une déclaration de variable est facultatif, sauf lorsqu'il est initialisé avec na. En savoir plus sur les types de script Pine dans la page du manuel de l'utilisateur sur le système de types.

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

séquence

Mots clés utilisés pour déclarer explicitement le type array d'une variable ou d'un argument.array.new<type>, array.from function.

Exemple

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

Les commentairesLes objets de matrice sont toujours de forme série.

Voir aussi var array.new array.from

Objets

Les objets dans le langage PINE sont des instances de types définis par l'utilisateur (UDT), qui peuvent être compris comme des classes sans méthode qui permettent aux utilisateurs de créer des types personnalisés dans des stratégies pour organiser différentes valeurs dans une entité.

Définition des types

Définissons un type de commande pour stocker les informations de commande:

type order
    float price
    float amount
    string symbol

• Les types sont déclarés à l'aide detype keyword.
• Le mot clé type est suivi du nom de type.
• Le type de première ligne définit le nom du type, les quatre espaces indentés et définit les champs contenus dans le type.
• Chaque champ doit déclarer son type de données, tel que int, float, string.

Création d'objets

En utilisant le type déclaré, appeler lenew()fonction pour créer un objet:

order1 = order.new()

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

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

Vous pouvez aussi créer des objets vides:

order order1 = na

Considérons un exemple pratique:

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)   // Output {"data":{"price":46002.8,"amount":1,"symbol":"swap"},"_meta":0,"_type":"order"}

Dans cet exemple:

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

On peut aussi l'écrire comme:

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

Type d'objet pour l'utilisation du mot clé var

//@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")

Lorsque vous utilisez le mot clé var pour déclarer une variable affectée à un objet de type défini par l'utilisateur, le mot clé s'applique automatiquement à tous les champs de l'objet.

• L'objet firstBar est déclaré en utilisant le mot clé var, de sorte que ses champs (index, prix, volume) conserveront leurs valeurs à chaque itération, à partir de la première entrée et se terminant par la dernière entrée.
• L'objet currentBar n'est pas déclaré avec le mot clé var, donc ses champs seront réinitialisés à chaque entrée et vous aurez un nouvel objet à chaque itération.

En traçant les champs d'index des deux objets, vous pouvez comparer les différences entre eux. firstBar.index maintiendra la valeur définie précédemment dans chaque itération, tandis que currentBar.index sera réinitialisé dans chaque itération à la valeur bar_index de l'entrée actuelle.

Types d'objets pour l'utilisation du mot clé varip

//@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, le mot-clé varip est utilisé pour indiquer que les champs d'un objet persistent tout au long de l'exécution du script et ne retournent pas sur les barres non confirmées. Dans la déclaration du type Counter, le champ bars n'utilise pas le mot-clé varip, il retourne donc sur chaque barre non confirmée. L'objet de compteur est déclaré en utilisant le mot clé var, il persiste donc tout au long de l'exécution du script. Dans chaque itération, le champ des barres et le champ des tiques sont augmentés de 1. Enfin, en traçant les champs counter.bars et counter.ticks, vous pouvez comparer la différence entre eux. La valeur de counter.bars retourne à chaque barre non confirmée, tandis que la valeur de counter.ticks continue d'augmenter jusqu'à la fin de l'exécution du script.

Plus de