FMZ PINE Script Dokumentation

Rückgabe von WertenDie Mittelzahl der Array-Elemente.

Parameter - id(int[]/float[]) Arrayobjekte.

Bis dann

### array.mode

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

Die Datenbank ist nicht mehr verfügbar.

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

Rückgabe von WertenDas Modell der Array-Elemente.

Parameter - id(int[]/float[]) Arrayobjekte.

Bis dann

### array.percentile_linear_interpolation

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

Anschluss an die Datenbank

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

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

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

### array.percentile_nearest_rank

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

Anschluss an die Datenbank

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

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

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

### array.percentrank

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

Anschluss an die Datenbank

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

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

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

### array.range

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

Anschluss an die Datenbank

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

Rückgabe von WertenDie Differenz zwischen dem Minimum und dem Maximum der Arrays.

Parameter - id(int[]/float[]) Arrayobjekte.

Bis dann

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

Rückgabe von WertenDer Wert des entfernten Elements.

Parameter - id(any array type) Array-Objekte. - Was ist los?index(series int) Index der zu löschenden Elemente.

Bis dann

### array.reverse

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

Array.reverse ((id))

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

Parameter - id(any array type) Array-Objekte.

Bis dann

### array.from

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

Hier sind die folgenden Daten:

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

Rückgabe von WertenDie Werte der Elemente der Array.

Parameter - arg0, arg1, ...(series int/float/bool/color/string/line/linefill) Arrayparameter;

array.new

Die Funktion erstellt eine neue<type>Elementar-Array-Objekte.

array.new(size, initial_value)

Beispiele

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

Beispiele

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

Beispiele

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

Beispiele

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

Rückgabe von WertenDie ID der Array-Objekte, die zusammen mit anderen Arrays verwendet werden können.

Parameter - sizeDie anfängliche Größe der (series int) Serie↑ Optional↑ Default 0↑ - Was ist los?initial_value(series <type>) Der Anfangswert für alle Sequenzelemente↑ Optional↑ Der Standardwert ist na↑

AnmerkungenDie Arrayindex beginnen bei 0. Wenn Sie ein Array einlösen und alle Elemente gleichzeitig angeben möchten, verwenden Sie die Funktion array.from.

Bis dann

### array.new_bool

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

Das ist nicht der Fall.

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

Rückgabe von WertenDie ID der Array-Objekte, die zusammen mit anderen Arrays verwendet werden können.

Parameter - sizeDie anfängliche Größe der (series int) Serie↑ Optional↑ Default 0↑ - Was ist los?initial_value(series bool) Der Anfangswert aller Sequenzelemente↑ Optional↑ Der Standardwert ist na↑

AnmerkungenDie Arrayindex beginnen bei 0.

Bis dann

### array.new_float

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

Array.new_float (Größe, Anfangswert)

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

Rückgabe von WertenDie ID der Array-Objekte, die zusammen mit anderen Arrays verwendet werden können.

Parameter - sizeDie anfängliche Größe der (series int) Serie↑ Optional↑ Default 0↑ - Was ist los?initial_value(series int/float) Der Anfangswert für alle Sequenzelemente. Optional. Der Standardwert ist na.

AnmerkungenDie Arrayindex beginnen bei 0.

Bis dann

### array.new_int

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

Das System wird von einem anderen System ausgerüstet.

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

Rückgabe von WertenDie ID der Array-Objekte, die zusammen mit anderen Arrays verwendet werden können.

Parameter - sizeDie anfängliche Größe der (series int) Serie↑ Optional↑ Default 0↑ - Was ist los?initial_value(series int) Der Anfangswert aller Sequenzelemente↑ Optional↑ Der Standardwert ist na↑

AnmerkungenDie Arrayindex beginnen bei 0.

Bis dann

### array.new_string

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

Das ist nicht der Fall.

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

Rückgabe von WertenDie ID der Array-Objekte, die zusammen mit anderen Arrays verwendet werden können.

Parameter - sizeDie anfängliche Größe der (series int) Serie↑ Optional↑ Default 0↑ - Was ist los?initial_value(series string) Der Anfangswert aller Sequenzelemente↑ Optional↑ Der Standardwert ist na↑

AnmerkungenDie Arrayindex beginnen bei 0.

Bis dann

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

Rückgabe von WertenDie Werte der Elemente der Array.

Parameter - id(any array type) Array-Objekte. - Was ist los?index(series int) ist ein Index für ein Element, dessen Wert zurückgegeben werden soll.

Bis dann

### array.push

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

- Das ist nicht der Fall. - Das ist der Fall.

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

Parameter - id(any array type) Array-Objekte. - Was ist los?value (series <type of the array's elements>) wird dem Elementwert am Ende des Arrays hinzugefügt.

Bis dann

### array.set

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

Array.set ((id, Index, Wert)

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

Parameter - id(any array type) Array-Objekte. - Was ist los?index(series int) Das Index eines Elements, das geändert werden soll. - Was ist los?value (series <type of the array's elements>) neue Werte zu setzen.

Bis dann

### array.sum

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

Die Datenbank ist nicht mehr verfügbar.

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

Rückgabe von WertenDie Summe der Elemente eines Arrays.

Parameter - id(int[]/float[]) Arrayobjekte.

Bis dann

### array.avg

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

Anschluss an die Datenbank

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

Rückgabe von WertenDie Mittelwerte der Array-Elemente.

Parameter - id(int[]/float[]) Arrayobjekte.

Bis dann

### array.indexof

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

Anschluss an die Datenbank

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

Rückgabe von WertenDas ist der Index eines Elements.

Parameter - id(any array type) Array-Objekte. - Was ist los?value (series <type of the array's elements>) ist der Wert, nach dem man in einem Array suchen soll.

Bis dann

## strategy

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

### strategy

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

Strategie ((Titel, Kurztitel, Überlagerung, Format, Präzision, Skala, Pyramidenbildung, calc_on_order_fills, calc_on_every_tick, max_bars_back, backtest_fill_limits_assumption, default_qty_type, default_qty_value, initial_capital, Währung, Schlupf, Provision_type, Provision_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)

Parameter - title(const string) wird die Kennzeichen-Titel, die in der Kennzahl/Strategie-Plugin gesehen wird. - Was ist los?shorttitle(const string) Die Kurzüberschrift der Indikatoren, die in den Diagrammbeispielen zu sehen sind. - Was ist los?overlay(const bool) Wenn true, wird der Indikator als Überlagerung der Hauptreihe hinzugefügt. Wenn false - er wird in eine separate Grafikfenzeile hinzugefügt. - Was ist los?format(const string) Der Typ eines Format-Indikatorwerts auf der Preisleiste ist möglich: format.inherit、format.price、format.volume、default format.inherit。 - Was ist los?precision(const int) Die Ziffer nach der Zahl der Schwellpunkte der Indikatorenwerte auf der Preisachse. Die Ziffer muss eine nicht-negative ganze Zahl sein und darf nicht größer als 16 sein. Wenn sie ausgelassen wird, wird das Format der Stammreihe verwendet. Wenn format format.inherit ist und dieser Parameter eingestellt ist, wird format format.price. - Was ist los?scale(scale_type) Der Indikator sollte der Preiskoordinate folgen. Die möglichen Werte sind scale.right, scale.left, scale.none. - Was ist los?pyramiding(const int) Maximale Anzahl zulässiger Eintrittsbestellungen in die gleiche Richtung. Wenn dieser Wert 0 ist, kann nur eine Eintrittsbestellung in die gleiche Richtung eröffnet werden, und alle anderen Eintrittsbestellungen werden abgelehnt. - Was ist los?calc_on_order_fills(const bool) Berechnung zusätzlicher Intrabar-Bestellungen. Wenn die Parameter auf true gesetzt sind, wird die Strategie neu berechnet, sobald die K-Zeile nach dem Befehl gefüllt ist (nicht nur beim Schließen der k-Zeile). - Was ist los?calc_on_every_tick(const bool) Zusätzliche Intrabar-Politikberechnung. Wenn die Parameter true sind, berechnet die Strategie in Echtzeit jede Zeitspanne, ohne die K-Zeile zu schließen. Die Parameter beeinflussen nicht die Politikberechnung der historischen Daten. - Was ist los?max_bars_back(const int) Die maximale Anzahl von Bars, die für die Historie-Referenzpolitik verwendet werden kann. Wenn in dem Skriptcode auf die Historie der Variablen Bezug genommen wird, wird dieser Parameter für jede eingebaute Variable oder Benutzervariable im Skript angewendet. Die Größe der variablen Bufferzone in einem Pine-Skript wird normalerweise automatisch erkannt. In einigen Fällen ist dies jedoch nicht möglich, weshalb der Parameter es dem Benutzer erlaubt, diesen Wert manuell zu setzen. - Was ist los?backtest_fill_limits_assumption(const int) Einschränkungsausschreibung Ausführungsansprüche. Eine Einschränkungsausschreibung wird nur dann in der Intrabar gehandelt, wenn der Marktpreis die angegebene Anzahl von Ticks überschreitet. - Was ist los?default_qty_type(const string) wird fürqtyDer Wert der Parameter ist der Inhalt, der in der Funktion strategy.entry oder strategy.order angegeben wird. Die möglichen Werte sind: strategy.fixed steht für Vertrag/Aktie/Handzahl, strategy.cash steht für Geldbetrag oder strategy.percent_of_equity steht für das Prozentsatz der verfügbaren Vermögenswerte. - Was ist los?default_qty_value(const int/float) Die Anzahl der Standardtransaktionen der Funktionen strategy.entry oder strategy.order, deren Einheit durch die Parameter bestimmt wird, die zusammen mit der Parameter default_qty_type verwendet werden, wenn ihre qty-Parameter nicht definiert sind. - Was ist los?currency(const string) Die Kontowährung dieser Strategie. Optional. Der Standardwert ist die Währung der Waren auf dem Diagramm. Die möglichen Werte sind: 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. - Was ist los?slippage(const int) mit tick als Einheit des Angebots, wird von der Transaktionspreis des Kauf/Verkauf- oder Stop-Loss-Auftritts erhöht/abgezogen. Wenn mintick = 0.01 und tick = 5, dann wird der Gesamtslip 5 * 0.01 = 0.05 sein. - Was ist los?commission_type(const string) Die Art der Provisionen für jeden Auftrag. Die zulässigen Werte sind: strategy.commission.percent (Prozentsatz des Auftragsbetrags), strategy.commission.cash_per_contract (Betrag in der Kontowährung pro Auftrag) und strategy.commission.cash_per_order (Betrag in der Kontowährung pro Auftrag). - Was ist los?commission_value(const int/float) Kommissionswert des Auftrags. Je nach gewählter Art (Kommissionsart) wird ein Prozentsatz oder ein Betrag enthalten. - Was ist los?process_orders_on_close(const bool) wird eingestellt, um weitere Versuche der Ausführung zu generieren, nachdem das Diagramm geschlossen ist und die Strategieberechnung abgeschlossen ist. Wenn die Bestellungen Marktpreise sind, wird der Broker-Simulator sie vor der Eröffnung des nächsten Diagramms ausführen. Wenn die Bestellung ein Limitpreis ist, wird die Bestellung nur ausgeführt, wenn die Preisbedingungen erfüllt sind. - Was ist los?close_entries_rule(const string) Bestimmt die Reihenfolge, in der der Auftrag geschlossen wird. Der zulässige Wert lautet: FIFO oder ANY. FIFO (First-in, First-out) bedeutet, dass der erste Handel geschlossen werden muss, wenn mehrere Trades geöffnet sind. Diese Regel gilt für Aktien, Futures und US-Forex (NFA-konforme Regel 2-43b). - Was ist los?max_lines_count(const int) zeigt die Anzahl der letzten Strichbilder an. Der Standardwert ist 50, der maximal zulässige Wert ist 500. - Was ist los?max_labels_count(const int) Zeigt die Anzahl der letzten Markierungen an. Der Standardwert ist 50, der maximal zulässige Wert ist 500. - Was ist los?max_boxes_count(const int) Anzahl der letzten Box-Drawings, die angezeigt werden. Der Standardwert ist 50, der maximal zulässige Wert ist 500. - Was ist los?margin_long(const int/float) Multiplatform ist das Prozentsatz des Kaufpreises einer Wertpapierposition, die mit Bargeld oder Pfand gedeckt sein muss. - Was ist los?margin_short(const int/float) Die Leerverbindung ist das Prozentsatz des Kaufpreises einer Leerposition, die mit Bargeld oder Pfand gedeckt sein muss. - Was ist los?explicit_plot_zorder(const bool) Gibt die Reihenfolge der Darstellung von Plots, Füllungen und Horizontalen an. Wenn true, wird das Diagramm in der Reihenfolge dargestellt, in der es im Indexcode erscheint. Jedes neuere Diagramm wird auf dem vorherigen Diagramm dargestellt. Dies gilt nur für die Plot* (() Funktion, Fill und Hline. - Was ist los?initial_capital(const int/float) Das ursprünglich für den Strategiehandel verfügbare Geldvolumen wird mit einer Währung angegeben, die in der Währungskette definiert wird. - Was ist los?risk_free_rate(const int/float) Die risikofreie Rendite ist die jährliche prozentuale Veränderung des Wertes einer Investition, bei der der Risiko minimal oder null ist. Sie wird für die Berechnung des Sharpe- und Sortino-Rates verwendet.

AnmerkungenJedes Strategie-Skript muss einen Strategie-Aufruf haben. PineScript-Code, der den Parameter calc_on_every_tick = true verwendet, kann unterschiedliche Berechnungen für historische Aufzeichnungen und Echtzeitdaten durchführen. Wenn Sie ein Diagramm mit einem nicht-standardischen Charttyp als Basis für Ihre Strategie verwenden, müssen Sie wissen, dass die Ergebnisse unterschiedlich sein können. Die Bestellung wird zum Preis der Tabelle ausgeführt (z. B. für Heikin Ashi wird der Preis von Heikin Ashi verwendet (durchschnittlich) ist nicht der tatsächliche Marktpreis). Daher empfehlen wir Ihnen dringend, den Standard-Charttyp in Ihrer Strategie zu verwenden.

Bis dann

### strategy.entry

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

Strategie.Eintrag ((id, Richtung, qty, Grenze, Stopp, oca_name, oca_type, Kommentar, wann, Alarm_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

Parameter - id(Series string) Notwendige Parameter. Auftrags-Identifikator. - Was ist los?direction(strategy_direction) Ein notwendiger Parameter. Markthaltungsrichtung: strategy.long für mehrere Köpfe, strategy.short für leere Köpfe. - Was ist los?qty(series int/float) Optionable Parameter↑ Vertrag/Anzahl der Aktien/Handzahlen/Einheitszahl der Transaktionen↑ Voreinstellung von NaN NaN↑↑ - Was ist los?limit(series int/float) Optionale Parameter. Der Limitpreis der Bestellung. Wenn angegeben, ist der Bestelltyp limit oder stop-limit. Andere Bestelltypen sind NaN. - Was ist los?stop(series int/float) Optionable Parameter. Stop-Loss-Preis der Bestellung. - Was ist los?oca_name(series string) Optionale Parameter. Der Auftrag gehört zu einem OCA-Gruppennamen. Wenn der Auftrag nicht zu einer OCA-Gruppe gehört, sollte er einen leeren Charakter haben.Hinweis: FMZ unterstützt diesen Parameter nicht. - oca_type(input string) Optionsparameter.  OCA-Ordergruppe-Typ.  Der zulässige Wert lautet: strategy.oca.none - der Auftrag darf nicht zu einer bestimmten OCA-Gruppe gehören; strategy.oca.cancel - der Auftrag sollte zu einer OCA-Gruppe gehören, sodass alle anderen Aufträge in derselben Gruppe abgeschafft werden, sobald der Auftrag ausgeführt wurde; strategy.oca.reduce - der Auftrag sollte zu einer OCA-Gruppe gehören, so dass die Anzahl der anderen Aufträge in derselben OCA-Gruppe X reduziert, wenn die Anzahl der Aufträge X platziert wurde.Hinweis: FMZ unterstützt diesen Parameter nicht. - comment(series string) Optionale Parameter. - Was ist los?when(series bool) Optionale Parameter. Status der Bestellung. Wenn sie als true geläufig ist, wird die Bestellung platziert. Wenn sie als false geläufig ist, geschieht nichts. - Was ist los?alert_message(series string) Ein Optionsparameter, wenn Sie die {{strategy.order.alert_Message}}-Zeichen in der Strategie-Nachricht-Zeichen-Feld im Dialogfeld Alarm-Zeichen erstellen.

strategy.close

Es handelt sich um einen Befehl für einen Ausstiegs-Auftrag mit einer angegebenen ID. Wenn mehrere Eintritts-Aufträge mit derselben ID vorhanden sind, werden sie alle gleichzeitig ausgeschlossen. Der Befehl wird nicht ausgeführt, wenn keine offene Order mit einer angegebenen ID beim Auslösen des Befehls vorhanden ist. Der Befehl verwendet Marktordern. Jeder Eintritt wird von einem separaten Marktordern geschlossen.

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

Beispiele

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)

Parameter - id(series string) Notwendige Parameter. "Order-Identifier". - Was ist los?when(series bool) Optionale Parameter. - Was ist los?qty(series int/float) Optionale Parameter↑ Anzahl der ausgehenden Verträge/Anzahl der Aktien/Anzahl der Hände/Anzahl der Einheiten。 Default ist NaN。 - Was ist los?qty_percent(series int/float) definiert das Prozent des Ausgleichs ((0-100) ). Seine Priorität ist niedriger als die Priorität des Parameters qty. Optional. Der Standardwert ist 100. - Was ist los?comment(series string) Optionale Parameter. - Was ist los?alert_message(series string) Ein Optionsparameter, wenn Sie die {{strategy.order.alert_Message}}-Zeichen in der Strategie-Nachricht-Zeichen-Feld im Dialogfeld Alarm-Zeichen erstellen.

Strategie.schließen_alle

Der Markt wird in den kommenden Monaten wieder stabilisiert, wenn die derzeitigen Marktpositionen ausgeschlossen werden.

strategy.close_all(when, comment, alert_message) 

Beispiele

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)

Parameter - when(series bool) Optionale Parameter. - Was ist los?comment(series string) Optionale Parameter. - Was ist los?alert_message(series string) Ein Optionsparameter, wenn Sie die {{strategy.order.alert_Message}}-Zeichen in der Strategie-Nachricht-Zeichen-Feld im Dialogfeld Alarm-Zeichen erstellen.

strategy.exit

Dies ist ein Ausstiegsbefehl, der einen bestimmten Eintritt oder die gesamte Marktposition angibt. Eine Änderung der Bestellung ist möglich, wenn eine Bestellung mit derselben ID bereits aufgehängt ist. Wenn eine Eintrittsbestellung nicht abgewickelt wurde, aber ein Ausstiegsbefehl auftritt, wird der Ausstiegsbefehl aufbewahrt, bis der Ausstiegsbefehl hinter der Eintrittsbestellung platziert wird. Um einen Ausstiegsbefehl zu beenden, sollte der Befehl strategy.cancel oder strategy.cancel_all verwendet werden. Wenn die Funktion strategy.exit einmal aufgerufen wird, wird nur ein Ausstieg durchgeführt.

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

Beispiele

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"

Parameter - id(Series string) Notwendige Parameter. Auftrags-Identifikator. - Was ist los?from_entry(series string) Einstellbarer Parameter. ==================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================== - Was ist los?qty(series int/float) Optionale Parameter↑ Anzahl der ausgehenden Verträge/Anzahl der Aktien/Anzahl der Hände/Anzahl der Einheiten。 Default ist NaN。 - Was ist los?qty_percent(series int/float) definiert das Prozent des Ausgleichs ((0-100) ). Seine Priorität ist niedriger als die Priorität des Parameters qty. Optional. Der Standardwert ist 100. - Was ist los?profit(series int/float) Optionale Parameter <>. Wenn angegeben, bei Erreichen der angegebenen Gewinnmenge <> mit einem Limit-Order die Marktposition verlassen <>. - Was ist los?limit(series int/float) Optionale Parameter. Profitziel (Preis erforderlich) Wenn angegeben, bei angegebener Preis (oder besser) aus der Marktposition aussteigen. Der Vorrang des Parameter-Limit-Tipps ist höher als der des Parameter-Limit-Profit-Tipps. - Was ist los?loss(series int/float) Optionale Parameter──Stoppverlust (doppelt angegeben)── Wenn angegeben, bei Erreichen der angegebenen Verlustmenge (doppelt angegeben) mit einem Stoppverlust aus der Marktposition aussteigen. - Was ist los?stop(series int/float) Optionale Parameter................................... - Was ist los?trail_price(series int/float) Optionale Parameter: ◦ Tracking Stop-Loss-Aktivierungs-Level (Preis muss angegeben werden) ◦ Wenn angegeben, wird die Tracking Stop-Loss-Liste platziert, wenn die angegebene Preis-Level erreicht wird. ◦ In den Parametern der Tracking-Strail_offset-Liste wird die Abweichung angegeben, um den Anfangspreis der Tracking-Stop-List zu bestimmen (punktisch): X-Punkte unter dem Aktivierungs-Level für einen Multi-Head-Austritt; X-Punkte über dem Aktivierungs-Level für einen Leerlauf-Austritt. ◦ Der Standardwert ist NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-NaN-Na-Na-Na-Na-Na - Was ist los?trail_points(series int/float) Optionale Parameter: ◦ Tracking Stop-Loss-Aktivierungs-Level (Nutzen in Punkten angegeben) ◦ Wenn angegeben, wird die Tracking Stop-Loss-Liste platziert, wenn das berechnete Preisniveau (Nutzen in Punkten angegeben) erreicht wird. ◦ In den Parametern der Tracking-Strail_offset-Liste wird die Abweichung angegeben, um den Anfangspreis der Tracking-Stop-Loss-Liste zu bestimmen (Punkte): ◦ X-Punkte unter dem Aktivierungs-Level für einen Multi-Head-Austritt; ◦ X-Punkte über dem Aktivierungs-Level für einen Blank-Head-Austritt. ◦ Der Standardwert ist ◦ NaN. - Was ist los?trail_offset(series int/float) Optionale Parameter.Strack Stop-Loss-Aktivierungs-Level (punktisch angegeben).Die Punktmesser-Abweichung wird verwendet, um den Anfangspreis der Track Stop-Loss-Liste zu bestimmen: X-Punkte unter dem trail_price or trail_points für mehrere Ausgänge; X-Punkte über dem trail_price or trail_points für Ausgänge. Der Standardwert ist NaN. - Was ist los?oca_name(series string) Optionale Parameter. Name der OCA-Gruppe (oca_type = strategy.oca.reduce) Gewinnziel, Stop/Track Stop. Wenn kein Name angegeben ist, wird dieser automatisch generiert.Hinweis: FMZ unterstützt diesen Parameter nicht. - comment(series string) Optionale Parameter. - Was ist los?when(series bool) Optionale Parameter. Status der Bestellung. Wenn sie als true geläufig ist, wird die Bestellung platziert. Wenn sie als false geläufig ist, geschieht nichts. - Was ist los?alert_message(series string) Ein Optionsparameter, wenn Sie die {{strategy.order.alert_Message}}-Zeichen in der Strategie-Nachricht-Zeichen-Feld im Dialogfeld Alarm-Zeichen erstellen.

strategy.cancel

Dies ist ein Name-Referenz-Befehl, um alle Vorhanglisten zu deaktivieren/auszuschalten, der von den folgenden Funktionen erzeugt wird: strategy.order, strategy.entry und strategy.exit.

strategy.cancel(id, when) 

Beispiele

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

Parameter - id(series string) Mussparameter↑ Bestellzeichen↑ Lokalisieren dieses Zeichen, um eine Bestellung zu widerrufen↑ - Was ist los?when(series bool) Optionale Parameter. Eine Bestellung aufgrund der ID zu stornieren. Die Bestellung wird storniert, wenn sie als true gelistet ist.

Strategie.abbrechen_alle

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

strategy.cancel_all(when) 

Beispiele

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

Parameter - when(series bool) Optionale Parameter↑ Bedingungen für alle Bestellungen stornieren↑ Wenn die Bedingung wahr ist, werden alle aktiven Bestellungen storniert↑ Der Standardwert ist true↑

strategy.order

Das ist der Befehl, der die Bestellung aufhebt. Wenn eine Bestellung mit derselben ID bereits aufgehängt ist, kann der Befehl geändert werden. Wenn keine Bestellung mit derselben ID angegeben ist, wird eine neue Bestellung ausgegeben. Um die Bestellung zu beenden, sollte der Befehl strategy.cancel oder strategy.cancel_all verwendet werden. Im Gegensatz zu der Funktion strategy.entry ist die Funktion strategy.order nicht von der Form der Pyramide beeinflusst.

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

Beispiele

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

Parameter - id(Series string) Notwendige Parameter. Auftrags-Identifikator. - Was ist los?direction(strategy_direction) Ein notwendiger Parameter. Auftragsrichtung: strategy.long Kauf, strategy.short Verkauf. - Was ist los?qty(series int/float) Optionable Parameter↑ Vertrag/Anzahl der Aktien/Handzahlen/Einheitszahl der Transaktionen↑ Voreinstellung von NaN NaN↑↑ - Was ist los?limit(series int/float) Optionale Parameter. Der Limitpreis der Bestellung. Wenn angegeben, ist der Bestelltyp limit oder stop-limit. Andere Bestelltypen sind NaN. - Was ist los?stop(series int/float) Optionable Parameter. Stop-Loss-Preis der Bestellung. - Was ist los?oca_name(series string) Optionale Parameter. Der Auftrag gehört zu einem OCA-Gruppennamen. Wenn der Auftrag nicht zu einer OCA-Gruppe gehört, sollte er einen leeren Charakter haben.Hinweis: FMZ unterstützt diesen Parameter nicht. - oca_type(input string) Optionsparameter.  OCA-Ordergruppe-Typ.  Der zulässige Wert lautet: strategy.oca.none - der Auftrag darf nicht zu einer bestimmten OCA-Gruppe gehören; strategy.oca.cancel - der Auftrag sollte zu einer OCA-Gruppe gehören, sodass alle anderen Aufträge in derselben Gruppe abgeschafft werden, sobald der Auftrag ausgeführt wurde; strategy.oca.reduce - der Auftrag sollte zu einer OCA-Gruppe gehören, so dass die Anzahl der anderen Aufträge in derselben OCA-Gruppe X reduziert, wenn die Anzahl der Aufträge X platziert wurde.Hinweis: FMZ unterstützt diesen Parameter nicht. - comment(series string) Optionale Parameter. - Was ist los?when(series bool) Optionale Parameter. Status der Bestellung. Wenn sie als true geläufig ist, wird die Bestellung platziert. Wenn sie als false geläufig ist, geschieht nichts. - Was ist los?alert_message(series string) Ein Optionsparameter, wenn Sie die {{strategy.order.alert_Message}}-Zeichen in der Strategie-Nachricht-Zeichen-Feld im Dialogfeld Alarm-Zeichen erstellen.

Strategie.Oppentrades.Entry_bar_index

Gibt den Bar_index zurück, der nicht in den Handel eingegangen ist.

strategy.opentrades.entry_bar_index(trade_num)

Warten Sie auf 10 K-Linien und brechen Sie

Beispiele

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

Parameter - trade_num(series int) Transaktionsnummer der nicht in Ausgleich stehenden Transaktionen.

Bis dann

### strategy.opentrades.entry_id

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

Strategie.Offentrades.Eintrag_id(Handel_Nummer)

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

Rückgabe von WertenDie Anmeldedaten für ungelöste Transaktionen werden zurückgegeben.

Parameter - trade_num(series int) Transaktionsnummer der nicht in Ausgleich stehenden Transaktionen.

AnmerkungenWenn trade_num nicht im Bereich liegt, gibt die Funktion na:0 an strategy.opentrades-1 zurück.

Bis dann

### strategy.opentrades.entry_price

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

Strategie.Offentrading.Eintrittspreis ((Handel_Nummer)

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

Berechnung des durchschnittlichen ungleichgewichtigten Preises

Beispiele

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

Parameter - trade_num(series int) Transaktionsnummer der nicht in Ausgleich stehenden Transaktionen.

Bis dann

### strategy.opentrades.entry_time

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

Strategie.Offentrades.Eintrittszeit (Handelsnummer)

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

Parameter - trade_num(series int) Transaktionsnummer der nicht in Ausgleich stehenden Transaktionen.

Bis dann

### strategy.opentrades.profit

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

Strategie.Offentrades.Gewinn (Trade_num)

返回最后开仓交易的利润

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

Berechnen Sie die Gewinne für alle nicht ausgeglichenen Geschäfte

Beispiele

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

Parameter - trade_num(series int) Transaktionsnummer der nicht in Ausgleich stehenden Transaktionen.

Bis dann

### strategy.opentrades.size

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

Strategie.Oppentrades.Größe ((Handel_Nummer)

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

Berechnung des Prozentsatzes des durchschnittlichen Gewinns von nicht gebundenen Geschäften

Beispiele

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)

Parameter - trade_num(series int) Transaktionsnummer der nicht in Ausgleich stehenden Transaktionen.

Bis dann

### strategy.closedtrades.entry_bar_index

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

Strategie.geschlossene Geschäfte.Eintrag_Bar_Index ((Handel_Nummer)

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

Parameter - trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

Bis dann

### strategy.closedtrades.exit_price

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

Strategie.abgeschlossener Handel.Ausgangspreis (Trade_number)

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

Berechnen Sie die Prozentsätze der durchschnittlichen Gewinne aller ausgeglichenen Geschäfte

Beispiele

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)

Parameter - trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

Bis dann

### strategy.closedtrades.exit_bar_index

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

Strategie.geschlossene Geschäfte.Exit_bar_index ((Handel_Nummer)

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

Berechnen Sie die durchschnittliche Anzahl von K-Linien pro Transaktion.

Beispiele

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

Parameter - trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

Bis dann

### strategy.closedtrades.entry_id

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

Strategie.abgeschlossener Handel.Eintrag_id ((Handel_Nummer)

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

Rückgabe von WertenDie Anmeldedaten für die bereits ausgeglichenen Transaktionen werden zurückgegeben.

Parameter - trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

AnmerkungenWenn trade_num nicht im Bereich liegt, gibt die Funktion na:0 an strategy.closedtrades-1 zurück.

Bis dann

### strategy.closedtrades.entry_price

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

Strategie.abgeschlossener Handel.Eintrittspreis (Nummer des Handels)

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

Berechnen Sie die Prozentsätze der durchschnittlichen Gewinne aller ausgeglichenen Geschäfte

Beispiele

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)

Parameter - trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

Bis dann

### strategy.closedtrades.entry_time

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

Strategie.abgeschlossener Handel.Eintrittszeit (Nummer des Handels)

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

Parameter - trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

Bis dann

### strategy.closedtrades.profit

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

Strategie.Gesperrte Geschäfte.Gewinn ((Handel_Nummer)

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

Parameter - trade_num(series int) Die Transaktionsnummer, bei der die Transaktion abgewickelt wurde. Die Nummer der ersten Transaktion ist null.

Bis dann

### strategy.closedtrades.size

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

Strategie.abgeschlossener Handel.Größe (Nummer des Handels)

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

Berechnung des Prozentsatzes der durchschnittlichen Gewinne bei einem Aktienhandel

Beispiele “pine strategy("Strategie.Gesperrte Geschäfte.Größe ≠ Beispiel 2)

Die Strategie sieht vor, alle 15 Bars Long Trades einzugeben und alle 20 Bars Long Trades zu verlassen. wenn bar_index % 15 == 0 Strategie.Eintrag ((Long, Strategie.lang) wenn Bar_index % 20 == 0 Strategie.Schließen ((Long)

// Profit für beide geschlossenen Trades berechnen. GewinnPct = 0,0 für den Handel Nr. = 0 zu Strategie.geschlossene Geschäfte - 1 Eintrag P = Strategie.abgeschlossener Handel

Weitere Informationen