FMZ PINE Script est un fichier

Retourne la valeurLe nombre moyen d'éléments d'une matrice.

Paramètres - id(int[]/float[]) Objets de l'arrayé.

À bientôt

### array.mode

该函数返回阵列元素的模式。如果有多个具有相同频率的值，则返回最小值。

Le code de l'appareil est:

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

Retourne la valeurLe modèle des éléments d'une matrice.

Paramètres - id(int[]/float[]) Objets de l'arrayé.

À bientôt

### array.percentile_linear_interpolation

返回数组值的指定百分比（百分位数）小于或等于它的值，使用线性插值。

Le nombre de fois où les données sont utilisées est le nombre de fois où les données sont utilisées.

**参数**
- ```id``` (int[]/float[]) 阵列对象。
- ```percentage``` (series int/float) 必须等于或小于返回值的值的百分比。

**备注**
在统计数据中，百分位是出现在某个分数或低于某个分数的排名项目的百分比。此测量显示低于您测量的百分等级的标准频率分布中的分数百分比。线性插值估计两个排名之间的值。

**另见**
```array.new_float``` ```array.insert``` ```array.slice``` ```array.reverse``` ```order.ascending``` ```order.descending```

### array.percentile_nearest_rank

使用最近秩方法返回指定百分比的数组值（百分位数）小于或等于它的值。

Le nombre d'annonces est calculé en fonction de l'indicateur de référence.

**参数**
- ```id``` (int[]/float[]) 阵列对象。
- ```percentage``` (series int/float) 必须等于或小于返回值的值的百分比。

**备注**
在统计数据中，百分位是出现在某个分数或低于某个分数的排名项目的百分比。 此测量显示低于您正在测量的百分排名的标准频率分布中的分数百分比。

**另见**
```array.new_float``` ```array.insert``` ```array.slice``` ```array.reverse``` ```order.ascending``` ```order.descending```

### array.percentrank

返回阵列中值的百分位排名。

Le nombre d'établissements d'établissement d'accueil

**参数**
- ```id``` (int[]/float[]) 阵列对象。
- ```index``` (series int) 计算其百分排名的值。

**备注**
百分位排名是数组中有多少元素小于或等于参考值的百分比。

**另见**
```array.new_float``` ```array.insert``` ```array.slice``` ```array.reverse``` ```order.ascending``` ```order.descending```

### array.range

该函数返回给定数组的最小值和最大值之间的差。

Résultats de l'analyse

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

Retourne la valeurDifférence entre la valeur minimale et la valeur maximale d'un ensemble.

Paramètres - id(int[]/float[]) Objets de l'arrayé.

À bientôt

### array.remove

该函数通过删除具有指定索引的元素来更改阵列的内容。

```array.remove(id, index)```

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

Retourne la valeurLa valeur de l'élément est supprimée.

Paramètres - id(any array type) Objet de la matrice. - Je ne sais pas.index(series int) l'index des éléments à supprimer.

À bientôt

### array.reverse

此函数反转阵列。第一个阵列元素变成最后一个，最后一个阵列元素变成第一个。

Le code de l'appareil est le suivant:

**例子**
```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ètres - id(any array type) Objet de l'array.

À bientôt

### array.from

该函数采用以下类型之一的可变数量的参数：int、float、bool、string、line、color、linefill，并返回相应类型的阵列。

L'expérience de l'expérience de l'expérience de l'expérience de l'expérience de l'expérience

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

Retourne la valeurLa valeur de l'élément d'une matrice.

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

array.new

Cette fonction crée un nouveau<type>L'élément est un objet de l'arithmétique.

array.new(size, initial_value)

Exemples

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

Exemples

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

Exemples

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

Exemples

// 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 la valeurL'ID d'un objet d'une matrice peut être utilisée avec d'autres matrices.

Paramètres - sizeLa taille initiale de la séquence (series int) ⇒ est facultative ⇒ est la valeur par défaut ⇒ 0. - Je ne sais pas.initial_value(series <type>) est la valeur initiale de tous les éléments de la série.

Nom de l'auteurL'index de la matrice commence à 0. Si vous souhaitez initialement initialer une matrice et spécifier tous ses éléments en même temps, utilisez la fonction array.from.

À bientôt

### array.new_bool

此函数创建一个由bool类型的元素组成的新阵列对象。

Le code de l'appareil est le code de l'appareil.

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

Retourne la valeurL'ID d'un objet d'une matrice peut être utilisée avec d'autres matrices.

Paramètres - sizeLa taille initiale de la séquence (series int) ⇒ est facultative ⇒ est la valeur par défaut ⇒ 0. - Je ne sais pas.initial_value(series bool) La valeur initiale de tous les éléments de la série↑ Optionnelle↑ La valeur par défaut est na↑

Nom de l'auteurL'index d'une matrice commence à zéro.

À bientôt

### array.new_float

此函数创建一个新的浮点型元素阵列对象。

Le nombre de fois où le nombre de fois où le nombre de fois où le nombre de fois où le nombre de fois

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

Retourne la valeurL'ID d'un objet d'une matrice peut être utilisée avec d'autres matrices.

Paramètres - sizeLa taille initiale de la séquence (series int) ⇒ est facultative ⇒ est la valeur par défaut ⇒ 0. - Je ne sais pas.initial_value(series int/float) La valeur initiale de tous les éléments de la série. Optionnelle. La valeur par défaut est na.

Nom de l'auteurL'index d'une matrice commence à zéro.

À bientôt

### array.new_int

该函数创建一个由int类型的元素组成的新阵列对象。

Le nombre de fois où le nombre de fois où le nombre de fois où le nombre de fois où le nombre de fois

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

Retourne la valeurL'ID d'un objet d'une matrice peut être utilisée avec d'autres matrices.

Paramètres - sizeLa taille initiale de la séquence (series int) ⇒ est facultative ⇒ est la valeur par défaut ⇒ 0. - Je ne sais pas.initial_value(series int) La valeur initiale de tous les éléments de la série↑ est optionnelle↑ la valeur par défaut est na↑

Nom de l'auteurL'index d'une matrice commence à zéro.

À bientôt

### array.new_string

该函数创建一个字符串类型元素的新阵列对象。

Arrêtez de faire des erreurs.

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

Retourne la valeurL'ID d'un objet d'une matrice peut être utilisée avec d'autres matrices.

Paramètres - sizeLa taille initiale de la séquence (series int) ⇒ est facultative ⇒ est la valeur par défaut ⇒ 0. - Je ne sais pas.initial_value(series string) La valeur initiale de tous les éléments de la série↑ est optionnelle↑ la valeur par défaut est na↑

Nom de l'auteurL'index d'une matrice commence à zéro.

À bientôt

### array.get

该函数返回指定索引处元素的值。

```array.get(id, index)```

**例子**
```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 la valeurLa valeur de l'élément d'une matrice.

Paramètres - id(any array type) Objet de la matrice. - Je ne sais pas.index(series int) est l'index de l'élément dont la valeur doit être renvoyée.

À bientôt

### array.push

该函数将一个值附加到阵列。

Arrêtez de faire des erreurs.

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

Paramètres - id(any array type) Objet de la matrice. - Je ne sais pas.value (series <type of the array's elements>) est ajoutée à la valeur de l'élément à la fin de l'arrangement.

À bientôt

### array.set

该函数将元素的值设置为指定的索引。

Le nombre de points de référence est le nombre de points de référence.

**例子**
```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ètres - id(any array type) Objet de la matrice. - Je ne sais pas.index(series int) pour modifier l'index de l'élément. - Je ne sais pas.value (series <type of the array's elements>) nouvelle valeur à définir.

À bientôt

### array.sum

该函数返回阵列元素的总和。

Réglage de la valeur de l'élément

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

Retourne la valeurLa somme des éléments d'une matrice.

Paramètres - id(int[]/float[]) Objets de l'arrayé.

À bientôt

### array.avg

该函数返回阵列元素的均值。

Le code de l'appareil

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

Retourne la valeurLes valeurs moyennes des éléments d'une matrice.

Paramètres - id(int[]/float[]) Objets de l'arrayé.

À bientôt

### array.indexof

此函数返回值首次出现的索引。如果找不到该值，则返回 -1。

Le nombre d'éléments d'un tableau est le nombre d'éléments d'un tableau.

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

Retourne la valeurL'index de l'élément.

Paramètres - id(any array type) Objet de la matrice. - Je ne sais pas.value (series <type of the array's elements>La valeur à rechercher dans l'array.

À bientôt

## strategy

在```strategy```相关的内置函数中，止损点数、止盈点数定义为价格一跳的倍数。例如```strategy.exit```函数的```profit```、```loss```参数以点表示止损、止盈，参数```profit```设置为10，即价格一跳乘以10作为止盈价差，价格一跳即内置变量```syminfo.mintick```。

### strategy

该函数设置了多个策略属性。
注意，传参仅支持```title```，```shorttitle```，```overlay```，```pyramiding```，```default_qty_type```，```default_qty_value```参数，其它参数可以通过PINE语言策略的界面参数设置。

stratégie ((titre, titre abrégé, superposition, format, précision, échelle, pyramide, calc_on_order_fills, calc_on_every_tick, max_bars_back, backtest_fill_limits_assumption, default_qty_type, default_qty_value, initial_capital, devise, glissement, 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)

**例子**
```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ètres - title(const string) Le titre de l'indicateur que vous voyez dans le plugin indicateur/politique. Paramètres requis. - Je ne sais pas.shorttitle(const string) Le titre court de l'indicateur que vous voyez dans l'exemple du graphique. - Je ne sais pas.overlay(const bool) Si true, le paramètre est ajouté comme superposition de la série principale. Si false - il est ajouté dans une fenêtre de graphique séparée. - Je ne sais pas.format(const string) Le type de valeur possible d'un indicateur formaté sur l'axe de prix est format.inherit、format.price、format.volume、par défaut format.inherit。 - Je ne sais pas.precision(const int) Le chiffre après le nombre de virgules de la valeur d'un indicateur sur l'axe des prix. Il doit être un entier non négatif et ne pas être supérieur à 16. S'il est omis, le format de la série mère est utilisé. Si format est format.inherit et que ce paramètre est défini, format devient format.price. - Je ne sais pas.scale(scale_type) L'indicateur doit suivre les coordonnées de prix. Les valeurs possibles sont: scale.right, scale.left, scale.none. - Je ne sais pas.pyramiding(const int) Nombre maximal d'entrées autorisé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. - Je ne sais pas.calc_on_order_fills(const bool) calcul d'une commande intrabar supplémentaire. Si le paramètre est défini sur la commande true, la stratégie recalculera une fois que la ligne K est remplie après l'ordre (pas seulement à la fermeture de la ligne k). - Je ne sais pas.calc_on_every_tick(const bool) calcul de la stratégie intrabar supplémentaire. Si le paramètre est true, la stratégie calculera en temps réel chaque degré sans fermer la ligne k. Cette paramètre n'affecte pas le calcul de la stratégie des données historiques. - Je ne sais pas.max_bars_back(const int) Le nombre maximal de barres pouvant être utilisé pour la politique de référence historique. Si le code du script cite les données historiques de la variable (en utilisant l'opérateur de const[]), ce paramètre s'applique à chaque variable intégrée ou à chaque variable utilisateur du script. La taille de la zone de sauvegarde variable dans le script pine est généralement détectée automatiquement. Cependant, dans certains cas, cela est impossible, ce qui explique pourquoi le paramètre permet à l'utilisateur de définir manuellement la valeur inférieure. - Je ne sais pas.backtest_fill_limits_assumption(const int) L'hypothèse de l'exécution de l'offre limitée. L'offre limitée n'est traitée à l'intrabar que lorsque le prix du marché dépasse le nombre de ticks indiqué au niveau de l'offre limitée. - Je ne sais pas.default_qty_type(const string) est défini pourqtyLa valeur du paramètre est indiquée dans la fonction strategy.entry ou strategy.order. Les valeurs possibles sont: strategy.fixed indique le nombre de contrats/actions/manches, strategy.cash indique le montant de la monnaie, ou strategy.percent_of_equity indique le pourcentage d'intérêts disponibles. - Je ne sais pas.default_qty_value(const int/float) Le nombre de transactions par défaut des fonctions strategy.entry ou strategy.order, dont l'unité est déterminée par l'option utilisée avec l'option default_qty_type, lorsque leur paramètre qty n'est pas défini. - Je ne sais pas.currency(const string) La monnaie de compte de cette stratégie. Optionnelle. La valeur par défaut est la monnaie du produit 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. - Je ne sais pas.slippage(const int) avec tick comme point de glissement de l'unité de soumission, est augmenté/sous-estimé par rapport au prix de transaction de l'ordre de vente/achat ou de l'ordre de stop-loss. Si mintick = 0.01 et le point de glissement = 5, le total des points de glissement sera de 5 * 0.01 = 0.05. - Je ne sais pas.commission_type(const string) Type de commission pour chaque commande. Les valeurs autorisées sont: stratégie.commission.percent (pourcentage de la quantité de cash de l'ordre), stratégie.commission.cash_per_contract (pour chaque contrat, le montant est indiqué dans la monnaie du compte), stratégie.commission.cash_per_order (pour chaque commande, le montant est indiqué dans la monnaie du compte). - Je ne sais pas.commission_value(const int/float) valeur de la commission de l'ordre; selon le type choisi (commission type) inclure le pourcentage ou le montant; - Je ne sais pas.process_orders_on_close(const bool) est réglé sur la barre de configuration pour générer d'autres tentatives d'exécution des ordres après la clôture du schéma et la fin du calcul de la stratégie. Si les ordres sont des ordres au prix du marché, l'imprimante de courtage les exécute avant l'ouverture du prochain schéma. Si les ordres sont des prix limités, les ordres ne sont exécutés que lorsque les conditions de prix sont remplies. - Je ne sais pas.close_entries_rule(const string) Définit l'ordre de clôture de l'ordre. La valeur autorisée est: FIFO ou ANY. FIFO signifie que la première transaction doit être fermée lorsque plusieurs transactions sont ouvertes. Cette règle s'applique aux actions, aux contrats à terme et aux devises américaines (règles de conformité NFA 2-43b). - Je ne sais pas.max_lines_count(const int) affiche le nombre de lignes de caractères récentes. La valeur par défaut est 50, la valeur maximale autorisée est 500. - Je ne sais pas.max_labels_count(const int) affiche le nombre de tableaux de balises récents. La valeur par défaut est 50, la valeur maximale autorisée est 500. - Je ne sais pas.max_boxes_count(const int) Le nombre de tableaux de la dernière boîte affichée. La valeur par défaut est 50, la valeur maximale autorisée est 500. - Je ne sais pas.margin_long(const int/float) Le taux de couverture multi-tête est le pourcentage du prix d'achat d'un titre dont la position multi-tête doit être couverte par de l'argent liquide ou des garanties. - Je ne sais pas.margin_short(const int/float) Le taux de change est le pourcentage du prix d'achat d'un titre qui doit être couvert par de l'argent ou des garanties. Il doit être non négatif. - Je ne sais pas.explicit_plot_zorder(const bool) spécifie l'ordre de représentation des traits, des charges et des lignes horizontales des indicateurs. Si true, les traits sont traités selon l'ordre dans lequel ils apparaissent dans le code des indicateurs, chaque nouveau graphique étant dessiné au-dessus du précédent. Ceci s'applique uniquement aux fonctions plot * (), fill et hline. - Je ne sais pas.initial_capital(const int/float) Le montant d'argent utilisé pour la transaction stratégique est initialement indiqué par la devise définie dans la barre de devises de l'émetteur. Optionnel. La valeur par défaut est 1000000. - Je ne sais pas.risk_free_rate(const int/float) Le taux de rendement sans risque est la variation annuelle en pourcentage de la valeur d'un investissement au risque minimal ou nul, utilisée pour calculer les ratios Sharpe et Sortino.

Nom de l'auteurChaque script de stratégie doit avoir une stratégie appelée. Le code PineScript qui utilise le paramètre calc_on_every_tick = true peut effectuer des calculs différents sur les enregistrements historiques et les données en temps réel. Lorsque vous utilisez un graphique de type non standard comme base de stratégie, vous devez savoir que les résultats seront différents. Les commandes seront exécutées au prix de ce tableau (par exemple, pour Heikin Ashi, le prix de Heikin Ashi sera utilisé (la moyenne n'est pas le vrai prix du marché). Nous vous recommandons donc fortement d'utiliser le type de graphique standard dans votre stratégie.

À bientôt

### strategy.entry

这是进入市场的命令。 如果具有相同ID的订单已经挂起，则可修改订单。 如果没有指定ID的订单，则会发出新的订单。 要停用进场指令，应使用命令strategy.cancel或strategy.cancel_all。 与函数strategy.order相比，strategy.entry功能受金字塔影响，可以正确反转市场位置。 如果“Limit”和“stop”参数均为“NaN”，则订单类型为市场订单。

stratégie.entrée ((id, direction, qty, limite, arrêt, oca_nom, oca_type, commentaire, quand, alerte_message)

**例子**
```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ètres - id(series string) Paramètres requis. L'identifiant de la commande. On peut annuler ou modifier une commande en citant son identifiant. - Je ne sais pas.direction(strategy_direction) Un paramètre nécessaire. Direction de l'acquisition du marché: stratégie.long est multi-tête, stratégie.short est vide. - Je ne sais pas.qty(series int/float) paramètres sélectifs↑ nombre de contrats/actions/points de vente/unités négociés↑ valeur par défaut: NaN↑ - Je ne sais pas.limit(series int/float) paramètre sélectionnable. Prix limite de l'ordre. Si le type d'ordre est spécifié, il s'agit de l'ordre de limite de série ou de l'ordre de limite de série. - Je ne sais pas.stop(series int/float) paramètre sélectionnable↑ prix de stop-loss de l'ordre↑ type d'ordre s'il est spécifié, c'est le stop-stop ou le stop-limit; les autres types d'ordres sont le NaN-NaNaNa. - Je ne sais pas.oca_name(series string) Optionnelle. Cette commande appartient au nom du groupe OCA. Si l'ordre ne appartient à aucun groupe OCA, il devrait y avoir un caractère vide.Attention: FMZ ne prend pas en charge ce paramètre. - oca_type(input string) Optionnelle; type de groupe d'ordres OCA. La valeur autorisée est: strategy.oca.none - l'ordre ne doit pas appartenir à un groupe OCA spécifique; strategy.oca.cancel - l'ordre doit appartenir au groupe OCA et tous les autres ordres du même groupe seront annulés une fois que l'ordre est passé; strategy.oca.reduce - l'ordre doit appartenir au groupe OCA, si X de contrats d'ordres ont été placés, le nombre d'autres ordres du même groupe OCA diminue X.Attention: FMZ ne prend pas en charge ce paramètre. - comment(series string) Paramètres sélectifs. - Je ne sais pas.when(series bool) Optionnelle. Paramètres. État de l'ordre. Si le lien est true, l'ordre est placé. Si le lien est false, rien ne se passe. - Je ne sais pas.alert_message(series string) Un paramètre optionnel utilisé pour remplacer le caractère {{strategy.order.alert_message}} dans le champ de message de la chaîne de dialogue de la chaîne d'alarme.

strategy.close

Il s'agit d'une commande pour un ordre d'exit avec un ID spécifié. Si plusieurs ordres d'entrée ont le même ID, ils s'excluent tous en même temps. Si un ordre ouvert n'a pas d'ID spécifié au moment du déclenchement de la commande, la commande n'est pas exécutée.

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

Exemples

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ètres - id(series string) Paramètres requis. L'identifiant de l'ordre. L'ordre peut être fermé en citant son identifiant. - Je ne sais pas.when(series bool) Paramètres sélectifs. Conditions de la commande. - Je ne sais pas.qty(series int/float) Optionnelle. Paramètre de sortie. Nombre de contrats/nombre d'actions/nombre de pièces/unités. - Je ne sais pas.qty_percent(series int/float) Définit le pourcentage de l'équilibre ((0-100)). Sa priorité est inférieure à celle de l'option qty. Optionnelle. La valeur par défaut est 100. - Je ne sais pas.comment(series string) Paramètres sélectifs. - Je ne sais pas.alert_message(series string) Un paramètre optionnel utilisé pour remplacer le caractère {{strategy.order.alert_message}} dans le champ de message de la chaîne de dialogue de la chaîne d'alarme.

stratégie.close_all

Le gouvernement a décidé de retirer ses positions actuelles du marché pour les maintenir à plat.

strategy.close_all(when, comment, alert_message) 

Exemples

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ètres - when(series bool) Paramètres sélectifs. Conditions de la commande. - Je ne sais pas.comment(series string) Paramètres sélectifs. - Je ne sais pas.alert_message(series string) Un paramètre optionnel utilisé pour remplacer le caractère {{strategy.order.alert_message}} dans le champ de message de la chaîne de dialogue de la chaîne d'alarme.

strategy.exit

Il s'agit d'une commande de retrait qui spécifie une entrée ou une position de marché complète. Une commande peut être modifiée si des ordres avec le même ID sont déjà suspendus. Si une commande d'entrée n'est pas passée, mais qu'une commande de retrait est passée, l'ordre de retrait est suspendu jusqu'à ce que l'ordre de retrait puisse être placé après la transaction de l'ordre d'entrée. Pour annuler une commande de retrait, vous devez utiliser la commande strategy.cancel ou strategy.cancel_all. Si la fonction strategy.exit est appelée une seule fois, elle ne sera retirée qu'une seule fois.

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

Exemples

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ètres - id(series string) Paramètres requis. L'identifiant de la commande. On peut annuler ou modifier une commande en citant son identifiant. - Je ne sais pas.from_entry(series string) Paramètre sélectionnable↑ pour spécifier l'identifiant d'entrée d'instruction Exit↑ pour exiter tous les positions, une chaîne vide doit être utilisée↑ par défaut une chaîne vide↑ - Je ne sais pas.qty(series int/float) Optionnelle. Paramètre de sortie. Nombre de contrats/nombre d'actions/nombre de pièces/unités. - Je ne sais pas.qty_percent(series int/float) Définit le pourcentage de l'équilibre ((0-100)). Sa priorité est inférieure à celle de l'option qty. Optionnelle. La valeur par défaut est 100. - Je ne sais pas.profit(series int/float) paramètre sélectionnable.  Objectif de profit (indiqué par un point).  Si cela est spécifié, l'ordre de sortie du marché est donné à un prix limité lorsque le point de profit spécifié est atteint.  La valeur par défaut est NaN. - Je ne sais pas.limit(series int/float) paramètre sélectionnable. Objectif de profit (prix à spécifier). Si c'est le cas, sortez du marché au prix (ou mieux) indiqué. La priorité du paramètre est supérieure à celle du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre du paramètre. - Je ne sais pas.loss(series int/float) paramètre sélectionnable↑ Stop-loss (indiqué par un point)↑ S'il est spécifié, quittez le marché en un seul stop-loss lorsque le point de perte spécifié est atteint↑ La valeur par défaut est NaN↑ - Je ne sais pas.stop(series int/float) Paramètres choisis. Arrêt de perte (prix à spécifier). Si c'est le cas, vous quittez le marché au prix indiqué (ou pire). La priorité du paramètre arrêt de perte est supérieure à la priorité du paramètre arrêt de perte. - Je ne sais pas.trail_price(series int/float) Optionnelle. Paramètre: ∞ niveau d'activation de la trace d'arrêt de perte ∞ prix à spécifier ∞ si elle est spécifiée, la trace d'arrêt de perte sera placée lorsque le niveau de prix spécifié est atteint ∞ dans le paramètre ∞ trace d'arrêt de perte ∞ décalage utilisé pour déterminer le prix initial de la trace d'arrêt de perte ∞ en points ∞: X point inférieur au niveau d'activation pour une sortie à plusieurs niveaux; X point supérieur au niveau d'activation pour une sortie à plusieurs niveaux ∞ valeur par défaut ∞ NaN ∞). - Je ne sais pas.trail_points(series int/float) Optionnelle par paramètre ─ suivi de niveau d'activation de stop-loss (indiqué par des points de profit) ─ si elle est spécifiée, la ligne de stop-loss est placée lorsque le niveau de prix calculé (indiqué par un montant de profit) est atteint. Dans le paramètre de la ligne de stop-loss (indiqué par des points de décalage) dans le paramètre de la ligne de stop-loss (indiqué par le paramètre de la ligne de stop-loss): X point inférieur au niveau d'activation pour une sortie à plusieurs têtes; X point supérieur au niveau d'activation pour une sortie à vide. - Je ne sais pas.trail_offset(series int/float) Optionnelle. Le niveau d'activation des stops est indiqué en points. Le décalage en points est utilisé pour déterminer le prix initial de la liste de stops suivie: X point inférieur à la barre de prix ou à la barre de points pour quitter plusieurs points; X point supérieur à la barre de prix ou à la barre de points pour quitter des espaces. - Je ne sais pas.oca_name(series string) Paramètres optionnels. Nom du groupe OCA (oca_type = strategy.oca.reduce) Objectif de gain, stop/track stop. Si aucun nom n'est spécifié, ce nom est généré automatiquement.Attention: FMZ ne prend pas en charge ce paramètre. - comment(series string) Paramètres sélectifs. - Je ne sais pas.when(series bool) Optionnelle. Paramètres. État de l'ordre. Si le lien est true, l'ordre est placé. Si le lien est false, rien ne se passe. - Je ne sais pas.alert_message(series string) Un paramètre optionnel utilisé pour remplacer le caractère {{strategy.order.alert_message}} dans le champ de message de la chaîne de dialogue de la chaîne d'alarme.

strategy.cancel

Il s'agit d'une commande de renonciation/dépannage de toutes les listes de pré-annonces, générée par les fonctions suivantes: strategy.order, strategy.entry et strategy.exit.

strategy.cancel(id, when) 

Exemples

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ètres - id(series string) Paramètres à sélectionner.  Marque d'ordre.  Localiser cette marque pour annuler une commande. - Je ne sais pas.when(series bool) Paramètre sélectionnable↑ annuler une commande en fonction de l'ID↑ annuler l'ordre si elle est en mode true↑ par défaut true↑

stratégie.annuler_tout

这是取消/停用所有预挂单命令，由以下功能生成：strategy.order，strategy.entry和strategy.exit。

strategy.cancel_all(when) 

Exemples

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ètres - when(series bool) Optionnelle ⇒ annuler toutes les commandes ⇒ annuler toutes les commandes actives si la condition est vraie ⇒ valeur par défaut ⇒ true ⇒

strategy.order

C'est la commande de la commande suivante. Si une commande avec le même ID est déjà accrochée, vous pouvez modifier l'ordre. Si une commande sans ID est spécifiée, une nouvelle commande est envoyée. Pour arrêter l'ordre, vous devez utiliser la commande stratégie.cancel ou stratégie.cancel_all. Contrairement à la fonction stratégie.entry, la fonction stratégie.order n'est pas affectée par la forme de la pyramide.

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

Exemples

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ètres - id(series string) Paramètres requis. L'identifiant de la commande. On peut annuler ou modifier une commande en citant son identifiant. - Je ne sais pas.direction(strategy_direction) Un paramètre nécessaire. La direction de l'ordre: stratégie.long est pour acheter, stratégie.short est pour vendre. - Je ne sais pas.qty(series int/float) paramètres sélectifs↑ nombre de contrats/actions/points de vente/unités négociés↑ valeur par défaut: NaN↑ - Je ne sais pas.limit(series int/float) paramètre sélectionnable. Prix limite de l'ordre. Si le type d'ordre est spécifié, il s'agit de l'ordre de limite de série ou de l'ordre de limite de série. - Je ne sais pas.stop(series int/float) paramètre sélectionnable↑ prix de stop-loss de l'ordre↑ type d'ordre s'il est spécifié, c'est le stop-stop ou le stop-limit; les autres types d'ordres sont le NaN-NaNaNa. - Je ne sais pas.oca_name(series string) Optionnelle. Cette commande appartient au nom du groupe OCA. Si l'ordre ne appartient à aucun groupe OCA, il devrait y avoir un caractère vide.Attention: FMZ ne prend pas en charge ce paramètre. - oca_type(input string) Optionnelle; type de groupe d'ordres OCA. La valeur autorisée est: strategy.oca.none - l'ordre ne doit pas appartenir à un groupe OCA spécifique; strategy.oca.cancel - l'ordre doit appartenir au groupe OCA et tous les autres ordres du même groupe seront annulés une fois que l'ordre est passé; strategy.oca.reduce - l'ordre doit appartenir au groupe OCA, si X de contrats d'ordres ont été placés, le nombre d'autres ordres du même groupe OCA diminue X.Attention: FMZ ne prend pas en charge ce paramètre. - comment(series string) Paramètres sélectifs. - Je ne sais pas.when(series bool) Optionnelle. Paramètres. État de l'ordre. Si le lien est true, l'ordre est placé. Si le lien est false, rien ne se passe. - Je ne sais pas.alert_message(series string) Un paramètre optionnel utilisé pour remplacer le caractère {{strategy.order.alert_message}} dans le champ de message de la chaîne de dialogue de la chaîne d'alarme.

La stratégie.ouverture des marchés.entrée_bar_index

Retourne le bar_index pour une entrée de transaction qui n'a pas été levée.

strategy.opentrades.entry_bar_index(trade_num)

Attendre 10 lignes K et les aligner

Exemples

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ètres - trade_num(series int) Numéro de transaction de la transaction qui n'est pas en liquidation.

À bientôt

### strategy.opentrades.entry_id

返回未平仓交易的入场的ID。

stratégie.opentrades.entry_id (numéro de transaction)

**例子**
```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 la valeurRetournez l'ID de l'entrée pour les transactions qui ne sont pas liquidées.

Paramètres - trade_num(series int) Numéro de transaction de la transaction qui n'est pas en liquidation.

Nom de l'auteurSi trade_num n'est pas dans la plage, la fonction renvoie na:0 à strategy.opentrades−1.

À bientôt

### strategy.opentrades.entry_price

返回未平仓交易的入场价格。

stratégie.opentrades.entry_price (numéro de transaction)

**例子**
```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 non équilibré

Exemples

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ètres - trade_num(series int) Numéro de transaction de la transaction qui n'est pas en liquidation.

À bientôt

### strategy.opentrades.entry_time

返回未平仓交易入场的UNIX时间。

stratégie.ouverture des transactions.heure d'entrée (numéro de transaction)

**例子**
```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ètres - trade_num(series int) Numéro de transaction de la transaction qui n'est pas en liquidation.

À bientôt

### strategy.opentrades.profit

返回未平仓交易的盈亏。损失表示为负值。

La stratégie est ouverte, le profit est ouvert.

返回最后开仓交易的利润

**例子**
```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 les bénéfices de toutes les transactions qui n'ont pas été liquidées

Exemples

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ètres - trade_num(series int) Numéro de transaction de la transaction qui n'est pas en liquidation.

À bientôt

### strategy.opentrades.size

返回未平仓交易中的交易方向和合约数量。如果该值>0，则市场仓位为多头。如果该值<0，则市场仓位为空头。

stratégie.opentrades.size (numéro de négociation)

**例子**
```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")

Calculer le pourcentage de bénéfices moyens sur les transactions non liquidées

Exemples

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ètres - trade_num(series int) Numéro de transaction de la transaction qui n'est pas en liquidation.

À bientôt

### strategy.closedtrades.entry_bar_index

返回已平仓交易入场的bar_index。

Stratégie.transactions clôturées.entrée_bar_index (numéro de transaction)

**例子**
```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ètres - trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. La première transaction est numérotée avec 0.

À bientôt

### strategy.closedtrades.exit_price

返回已平仓交易的出场价格。

Stratégie.transactions clôturées.prix de sortie (numéro de transaction)

**例子**
```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

Exemples

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ètres - trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. La première transaction est numérotée avec 0.

À bientôt

### strategy.closedtrades.exit_bar_index

返回已平仓交易退出的bar_index。

Stratégie.transactions clôturées.index de sortie (numéro de transaction)

**例子**
```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")

Calcule le nombre moyen de lignes K par transaction.

Exemples

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ètres - trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. La première transaction est numérotée avec 0.

À bientôt

### strategy.closedtrades.entry_id

返回已平仓交易的入场的id。

Stratégie.transactions clôturées.entrée_id (numéro de transaction)

**例子**
```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 la valeurRetourne l'id de l'entrée pour une transaction qui a été liquidée.

Paramètres - trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. La première transaction est numérotée avec 0.

Nom de l'auteurSi trade_num n'est pas dans la plage, la fonction renvoie na:0 à strategy.closedtrades−1.

À bientôt

### strategy.closedtrades.entry_price

返回已平仓交易的入场价格。

Stratégie.transactions clôturées.prix d'entrée (numéro de transaction)

**例子**
```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

Exemples

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ètres - trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. La première transaction est numérotée avec 0.

À bientôt

### strategy.closedtrades.entry_time

返回已平仓交易入场的UNIX时间。

Stratégie.trades fermés.heure d'entrée (numéro de transaction)

**例子**
```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ètres - trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. La première transaction est numérotée avec 0.

À bientôt

### strategy.closedtrades.profit

返回已平仓交易的盈亏。损失表示为负值。

stratégie.trades fermés.profit (numéro de transaction)

**例子**
```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ètres - trade_num(series int) Numéro de transaction de la transaction qui a été liquidée. La première transaction est numérotée avec 0.

À bientôt

### strategy.closedtrades.size

返回已平仓交易中的交易方向和合约数量。如果该值>0，则市场仓位为多头。 如果该值<0，则市场仓位为空头。

Stratégie.transactions fermées.taille (numéro de transaction)

**例子**
```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")

Calculer le pourcentage de profit moyen sur les transactions en liquide

Exemples “pine strategy("stratégie.transactions clôturées.taille ≠ Exemple 2)

// La stratégie exige d'entrer dans les longs commerces tous les 15 bars et de sortir des longs commerces tous les 20 bars. si bar_index % 15 est égal à 0 stratégie.entrée ((Long, stratégie.long) si bar_index % 20 est égal à 0 La stratégie.close ((Long)

// Calculer le bénéfice pour les deux transactions fermées. profitPct = 0,0 pour les transactionsNo = 0 à la stratégie.transactions clôturées - 1 EntréeP = stratégie.transaction fermée

En savoir plus