s, trail_offset, oca_name, comment, when, alert_message)

**Beispiel**

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

Parameter

• id(series string) Notwendige Parameter。 Auftragsbezeichner。 Der Auftrag kann durch Verweis auf seine Bezeichnungen storniert oder geändert werden。
• from_entry(series string) Optionale Parameter ≠ Exit mit dem angegebenen Eingangsbefehlsmarker ≠ Exit mit allen Positionen ≠ Leerzeichen ≠ Leerzeichen als Standard.
• qty(series int/float) Optionale Parameter. Anzahl der ausgehenden Verträge/Aktien/Uhrzahlen/Einheiten. Standardwert ist ‘NaN’.
• qty_percent(series int/float) definiert den Prozentsatz der Flachposition als ((0-100) ◦, dessen Priorität unter der Priorität des ‘qty’-Parameters liegt. Optional. Der Standardwert ist 100 ◦
• profit(series int/float) Optionale Parameter. Gewinnziel (in Punkten angegeben). Wenn angegeben, wird die Position bei Erreichen der angegebenen Gewinnmenge (in Punkten) mit einem Limit-Order beendet.
• limit(series int/float) Optionale Parameter. Gewinnziel ([Präsistenzpreis] angegeben werden muss). Wenn angegeben, dann zum angegebenen Preis ([Präsistenzpreis] oder besser). Ausstieg aus dem Markt. Das Parameter ‘limit’ hat eine höhere Priorität als das Parameter ‘profit’ (wenn der Wert nicht ‘NaN’ ist, ersetzt ‘limit’ ‘profit’).
• loss(series int/float) Optionale Parameter. Stop loss (in Punkten angegeben). Wenn angegeben, wird die Position mit einem Stop Loss beendet, wenn der angegebene Verlust (in Punkten angegeben) erreicht wird.
• stop(series int/float) Optionale Parameter  Stop loss ([Präis anzugeben ist erforderlich])  Wenn angegeben, wird der Marktausstieg mit dem angegebenen Preis ([Präis] oder schlechter) durchgeführt  Der Parameter Stop loss hat eine höhere Priorität als der Parameter Loss ([Präis] wenn der Wert nicht ‘NaN’ ist, wird ‘Stop Loss’ anstelle von ‘Loss’)  Der Standardwert ist NaN
• trail_price(series int/float) Optionale Parameter: Tracking Stop Loss Activation Level (Preis muss angegeben werden). Wenn angegeben, wird ein Tracking Stop bei Erreichen des angegebenen Preisniveaus platziert. In der Tracking Trail_offset Parameter wird die Abweichung angegeben, um den anfänglichen Preis eines Tracking Stop Losses zu bestimmen (in Punkten): X-Punkte unterhalb des Aktivierungsniveaus, um aus der Mehrzahl auszusteigen; X-Punkte über dem Aktivierungsniveau, um aus der Leerheit auszusteigen.
• trail_points(series int/float) Optionale Parameter: Tracking Stop-Loss-Aktivierungsniveau (siehe Gewinn in Punkten). Wenn angegeben, wird ein Tracking-Stop-Bill platziert, wenn der berechnete Preisniveau (siehe Gewinnbetrag in Punkten) erreicht wird. In der Trailing-Trail-Offset-Parameter wird die Verlagerung des Startpreises des Tracking-Stop-Bills (siehe Punkte) angegeben: X Punkte unter dem Aktivierungsniveau, um aus der Mehrzahl auszusteigen; X Punkte über dem Aktivierungsniveau, um aus dem Leerstand auszusteigen.
• trail_offset(series int/float) Optionale Parameter. Tracking-Stop-Aktivierungsniveau (in Punkten angegeben). Die Abweichung in Punkten wird verwendet, um den Anfangspreis für Tracking-Stop-Billings zu bestimmen: X Punkte niedriger als ‘trail_price’ oder ‘trail_points’ für den Ausstieg aus dem Mehrwert; X Punkte höher als ‘trail_price’ oder ‘trail_points’ für den Ausstieg aus dem Leerwert.
• oca_name(series string) Optionale Parameter. Name der OCA-Gruppe (oca_type = strategy.oca.reduce) Gewinnziel, Stop-Loss / Tracking-Stop-Loss. Wenn kein Name angegeben ist, wird dieser automatisch generiert.Hinweis: FMZ unterstützt dieses Parameter nicht.
• comment(series string) Optionale Parameter。 weitere Hinweise auf Bestellungen。
• when(series bool) Optionale Parameter  Status der Bestellung  Wenn “true” ist, wird die Bestellung platziert  Wenn “false” ist, passiert nichts  keine Bestellung mit derselben ID, die zuvor platziert wurde, wurde widerrufen  Der Standardwert ist “true” 
• alert_message(series string) Eine Option, wenn Sie das Positionszeichen {{strategy.order.alert_message}} in der Eingabe-Nachricht-Eingabe-Feld des Dialogfelds “Erstellen Sie eine Eingabe-Nachricht” verwenden.

strategy.cancel

Das ist ein Befehl, der den Namen der Angabe anspricht, um alle vorgefertigten Listen abzubrechen/auszuschalten, erzeugt durch die folgenden Funktionen: strategy.order, strategy.entry und strategy.exit。

strategy.cancel(id, when) 

Beispiel

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) Pflichtparameter。 Auftragsmarke。 Position der Marke, um einen Auftrag zu widerrufen。
• when(series bool) Optionale Parameter. Anhand der ID einen Auftrag stornieren. Wenn es “true” ist, wird der Auftrag storniert.

strategy.cancel_all

Dies ist die Annullierung/Deaktivierung aller Vorladen-Befehle, die durch die folgenden Funktionen erzeugt werden: strategy.order, strategy.entry und strategy.exit.

strategy.cancel_all(when) 

Beispiel

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 ◦ die Bedingungen für alle Bestellungen stornieren ◦ alle aktiven Bestellungen werden storniert, wenn die Bedingung wahr ist ◦ der Standardwert ist ◦ true ◦

strategy.order

Das ist der Befehl für die nächste Bestellung. Wenn ein Auftrag mit der gleichen ID bereits aufgehängt ist, kann der Auftrag geändert werden. Wenn kein Auftrag mit der angegebenen ID ausgeführt wird, wird ein neuer Auftrag ausgegeben. Um den Auftrag zu beenden, sollte der Befehl strategy.cancel oder strategy.cancel_all verwendet werden.

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

Beispiel

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。 Auftragsbezeichner。 Der Auftrag kann durch Verweis auf seine Bezeichnungen storniert oder geändert werden。
• direction(strategy_direction) Ein notwendiger Parameter. Order-Richtung: “strategy.long” für Kauf und “strategy.short” für Verkauf.
• qty(series int/float) Optionale Parameter. Anzahl der getätigten Verträge/Aktien/Stunden/Einheiten. Die Voreinstellung lautet ‘NaN’.
• limit(series int/float) Optionale Parameter ◦ Auftragsbegrenzung ◦ Auftragsart “limit” oder “stop-limit” ◦ Auftragsart “NaN” ◦
• stop(series int/float) Optionale Parameter. Der Stop-Loss-Preis des Auftrages. Wenn angegeben, ist der Auftragstyp “stop” oder “stop-limit”. Andere Auftragstypen sind “NaN”.
• oca_name(series string) Optionale Parameter. Der Auftrag gehört zu einer OCA-Gruppenbezeichnung. Wenn der Auftrag nicht zu einer OCA-Gruppe gehört, sollte ein leeres Zeichen vorhanden sein.Hinweis: FMZ unterstützt dieses Parameter nicht.
• oca_type(input string) Optionale Parameter。 OCA-Bestellgruppen-Typ。 Die erlaubten Werte sind: strategy.oca.none - Der Auftrag sollte nicht zu einer bestimmten OCA-Gruppe gehören; strategy.oca.cancel - Der Auftrag sollte zu einer OCA-Gruppe gehören, sobald der Auftrag abgeschlossen ist, werden alle anderen Aufträge in derselben Gruppe storniert; strategy.oca.reduce - Der Auftrag sollte zu einer OCA-Gruppe gehören, wenn X Anzahl von Auftragsverträgen platziert wurde, reduziert sich die Anzahl der anderen Auftragsverträge in derselben OCA-Gruppe um X。Hinweis: FMZ unterstützt dieses Parameter nicht.
• comment(series string) Optionale Parameter。 weitere Hinweise auf Bestellungen。
• when(series bool) Optionale Parameter  Status der Bestellung  Wenn “true” ist, wird die Bestellung platziert  Wenn “false” ist, passiert nichts  keine Bestellung mit derselben ID, die zuvor platziert wurde, wurde widerrufen  Der Standardwert ist “true” 
• alert_message(series string) Eine Option, wenn Sie das Positionszeichen {{strategy.order.alert_message}} in der Eingabe-Nachricht-Eingabe-Feld des Dialogfelds “Erstellen Sie eine Eingabe-Nachricht” verwenden.

strategy.opentrades.entry_bar_index

Bar_index, der einen noch nicht ausgeglichenen Börsengang zurückgibt.

strategy.opentrades.entry_bar_index(trade_num)

Warte auf 10 K-Linien und mach die Position klar.

Beispiel

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) Die Transaktionsnummer für den nicht ausgeglichenen Handel. Die Nummer für den ersten Handel ist null.

Siehe auch strategy.closedtrades.entry_bar_index strategy.closedtrades.exit_bar_index

strategy.opentrades.entry_id

ID für die Rückgabe eines Eingangs in einen ungeklärten Handel.

strategy.opentrades.entry_id(trade_num)

Beispiel

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ückgabewert ID für die Rückgabe eines Eingangs in einen ungeklärten Handel.

Parameter

• trade_num(series int) Die Transaktionsnummer für den nicht ausgeglichenen Handel. Die Nummer für den ersten Handel ist null.

Anmerkung Wenn trade_num nicht im Bereich ist, gibt die Funktion na:0 zurück zu strategy.opentrades-1。

Siehe auch strategy.opentrades.entry_bar_index strategy.opentrades.entry_time

strategy.opentrades.entry_price

Eintrittspreise für die Rückgabe von ungeklärten Positionen.

strategy.opentrades.entry_price(trade_num)

Beispiel

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 ungeklärten Kurses

Beispiel

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) Die Transaktionsnummer für den nicht ausgeglichenen Handel. Die Nummer für den ersten Handel ist null.

Siehe auch strategy.closedtrades.exit_price

strategy.opentrades.entry_time

Zurück zu UNIX-Zeit für den Eintritt in eine noch nicht ausgeglichene Position.

strategy.opentrades.entry_time(trade_num)

Beispiel

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) Die Transaktionsnummer für den nicht ausgeglichenen Handel. Die Nummer für den ersten Handel ist null.

Siehe auch strategy.closedtrades.entry_time strategy.closedtrades.exit_time

strategy.opentrades.profit

Verluste, die auf ungeklärte Geschäfte zurückgehen. Verluste werden als negative Werte dargestellt.

strategy.opentrades.profit(trade_num)

Rückkehr zu den Gewinnen aus dem letzten Börsengang

Beispiel

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

Berechnung des Gewinns aus allen ungeklärten Positionen

Beispiel

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) Die Transaktionsnummer für den nicht ausgeglichenen Handel. Die Nummer für den ersten Handel ist null.

Siehe auch strategy.closedtrades.profit strategy.openprofit strategy.netprofit strategy.grossprofit

strategy.opentrades.size

Gibt die Richtung und die Anzahl der Geschäfte in einem ungeklärten Handel zurück. Wenn dieser Wert > 0 ist, ist die Marktposition mehrköpfig. Wenn dieser Wert < 0 ist, ist die Marktposition leer.

strategy.opentrades.size(trade_num)

Beispiel

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 der durchschnittlichen Gewinne aus ungeklärten Positionen

Beispiel

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) Die Transaktionsnummer für den nicht ausgeglichenen Handel. Die Nummer für den ersten Handel ist null.

Siehe auch strategy.closedtrades.size strategy.position_size strategy.opentrades strategy.closedtrades

strategy.closedtrades.entry_bar_index

Bar_index, der einen ausgeglichenen Eintrag zurückgibt.

strategy.closedtrades.entry_bar_index(trade_num)

Beispiel

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 Nummer des Transaktions, der mit der Auszahlung begann. Die Nummer des ersten Transaktions ist null.

Siehe auch strategy.closedtrades.exit_bar_index strategy.opentrades.entry_bar_index

strategy.closedtrades.exit_price

Rückkehr zum Ausgangspreis für einen ausgeglichenen Handel.

strategy.closedtrades.exit_price(trade_num)

Beispiel

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 den Prozentsatz der durchschnittlichen Gewinne für alle ausgeglichenen Geschäfte

Beispiel

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 Nummer des Transaktions, der mit der Auszahlung begann. Die Nummer des ersten Transaktions ist null.

Siehe auch strategy.closedtrades.entry_price

strategy.closedtrades.exit_bar_index

Bar_index, der den ausgeglichenen Handel zurückgibt.

strategy.closedtrades.exit_bar_index(trade_num)

Beispiel

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 K-Linie pro Transaktion.

Beispiel

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 Nummer des Transaktions, der mit der Auszahlung begann. Die Nummer des ersten Transaktions ist null.

Siehe auch bar_index

strategy.closedtrades.entry_id

Die Eintritts-ID für einen ausgeglichenen Handel wird zurückgegeben.

strategy.closedtrades.entry_id(trade_num)

Beispiel

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ückgabewert Die Eintritts-ID für einen ausgeglichenen Handel wird zurückgegeben.

Parameter

• trade_num(series int) Die Nummer des Transaktions, der mit der Auszahlung begann. Die Nummer des ersten Transaktions ist null.

Anmerkung Wenn trade_num nicht im Bereich ist, gibt die Funktion na:0 zurück zu strategy.closedtrades-1。

Siehe auch strategy.closedtrades.entry_bar_index strategy.closedtrades.entry_time

strategy.closedtrades.entry_price

Eintrittspreise für die Rückgabe eines ausgeglichenen Deals.

strategy.closedtrades.entry_price(trade_num)

Beispiel

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 den Prozentsatz der durchschnittlichen Gewinne für alle ausgeglichenen Geschäfte

Beispiel

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 Nummer des Transaktions, der mit der Auszahlung begann. Die Nummer des ersten Transaktions ist null.

Siehe auch strategy.closedtrades.exit_price strategy.closedtrades.size strategy.closedtrades

strategy.closedtrades.entry_time

Zurück zur UNIX-Zeit, in der der Handel ausgeglichen wurde.

strategy.closedtrades.entry_time(trade_num)

Beispiel

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 Nummer des Transaktions, der mit der Auszahlung begann. Die Nummer des ersten Transaktions ist null.

Siehe auch strategy.opentrades.entry_time strategy.closedtrades.exit_time time

strategy.closedtrades.profit

Verluste, die auf einen ausgeglichenen Handel zurückkehren. Verluste werden als negative Werte dargestellt.

strategy.closedtrades.profit(trade_num)

Beispiel

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 Nummer des Transaktions, der mit der Auszahlung begann. Die Nummer des ersten Transaktions ist null.

Siehe auch strategy.opentrades.profit strategy.closedtrades.commission

strategy.closedtrades.size

Gibt die Richtung und die Anzahl der Geschäfte in einem ausgeglichenen Handel zurück. Wenn dieser Wert > 0 ist, ist die Marktposition mehrköpfig. Wenn dieser Wert < 0 ist, ist die Marktposition leer.

strategy.closedtrades.size(trade_num)

Beispiel

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 aus den Off-Position-Transaktionen

Beispiel

strategy("`strategy.closedtrades.size` Example 2")

// Strategy calls to enter long trades every 15 bars and exit long trades every 20 bars.
if bar_index % 15 == 0
    strategy.entry("Long", strategy.long)
if bar_index % 20 == 0
    strategy.close("Long")


// Calculate profit for both closed trades.
profitPct = 0.0
for tradeNo = 0 to strategy.closedtrades - 1
    entryP = strategy.closedtrades.entry_price(tradeNo)
    exitP = strategy.closedtrades.exit_price(tradeNo)
    profitPct += (exitP - entryP) / entryP * strategy.closedtrades.size(tradeNo) * 100
    
// Calculate average profit percent for both closed trades.
avgProfitPct = nz(profitPct / strategy.closedtrades)

plot(avgProfitPct)

Parameter

• trade_num(series int) Die Nummer des Transaktions, der mit der Auszahlung begann. Die Nummer des ersten Transaktions ist null.

Siehe auch strategy.opentrades.size strategy.position_size strategy.closedtrades strategy.opentrades

strategy.closedtrades.exit_time

Zurück zum UNIX-Zeitpunkt, zu dem der ausgeglichene Handel beendet wurde.

strategy.closedtrades.exit_time(trade_num)

Beispiel

strategy("strategy.closedtrades.exit_time Example 1")

// Enter long trades on three rising bars; exit on two falling bars.
if ta.rising(close, 3)
    strategy.entry("Long", strategy.long)
if ta.falling(close, 2)
    strategy.close("Long")

// Calculate the average trade duration. 
avgTradeDuration() =>
    sumTradeDuration = 0
    for i = 0 to strategy.closedtrades - 1
        sumTradeDuration += strategy.closedtrades.exit_time(i) - strategy.closedtrades.entry_time(i)
    result = nz(sumTradeDuration / strategy.closedtrades)

// Display average duration converted to seconds and formatted using 2 decimal points.
if barstate.islastconfirmedhistory
    label.new(bar_index, high, str.tostring(avgTradeDuration() / 1000, "#.##") + " seconds")

Nach X Sekunden wird der ausgeschlossene Handel wieder geöffnet.

Beispiel

strategy("strategy.closedtrades.exit_time Example 2")

// Strategy calls to emulate a single long trade at the first bar.
if bar_index == 0
    strategy.entry("Long", strategy.long)

reopenPositionAfter(timeSec) =>
    if strategy.closedtrades > 0
        if time - strategy.closedtrades.exit_time(strategy.closedtrades - 1) >= timeSec * 1000
            strategy.entry("Long", strategy.long)

// Reopen last closed position after 120 sec.                
reopenPositionAfter(120)

if ta.change(strategy.opentrades)
    strategy.exit("Long", stop = low * 0.9, profit = high * 2.5)

Parameter

• trade_num(series int) Die Nummer des Transaktions, der mit der Auszahlung begann. Die Nummer des ersten Transaktions ist null.

Siehe auch strategy.closedtrades.entry_time

strategy.risk.allow_entry_in

Diese Funktion kann verwendet werden, um zu bestimmen, in welcher Richtung die Strategy.entry-Funktion zulässt.

strategy.risk.allow_entry_in(value)

Beispiel

strategy("strategy.risk.allow_entry_in")

strategy.risk.allow_entry_in(strategy.direction.long)
strategy.entry("Long", strategy.long, when = open > close)
// Instead of opening a short position with 10 contracts, this command will close long entries.
strategy.entry("Short", strategy.short, when = open < close, qty = 10)

Parameter

• value(simple string) Erlaubte Richtungen. Mögliche Werte:strategy.direction.all、strategy.direction.long、strategy.direction.short

strategy.risk.max_position_size

Der Zweck dieser Regel ist es, den maximalen Wert einer Marktposition zu bestimmen. Die Regel wirkt sich auf folgende Funktionen aus:strategy.entryDie Anzahl der Eintrittskanonen kann reduziert werden (wenn erforderlich) auf die Anzahl der Kontrakte/Aktien/Hände/Einheiten, so dass der Gesamtwert der Position nicht über den in ‘strategy.risk.max_position_size’ angegebenen Wert hinausgeht. Wenn die Mindestanzahl dennoch gegen die Regeln verstößt, wird kein Auftrag platziert.

strategy.risk.max_position_size(contracts)

Beispiel

strategy("risk.max_position_size Demo", default_qty_value = 100)
strategy.risk.max_position_size(10)
strategy.entry("buy", strategy.long, when = open > close)
plot(strategy.position_size)  // max plot value will be 10

Parameter

• contracts(simple int/float) Notwendige Parameter. Höchste Anzahl an Verträgen/Aktien/Händlern/Einheiten der Position.

math

math.abs

Was ist?number >= 0，numberDer absolute Wert ist numberoder -number。

math.abs(number) 

Rückgabewert numberAbsolute Werte für

math.acos

Die acos-Funktion gibt die negative Eckung der Zahl ((in einem Bogen) zurück, z. B. cos ((acos ((y)) = y im Bereich y.[-1, 1]。

math.acos(angle)

Rückgabewert Reverse-Effekt. Wenn y außerhalb des Bereichs ist[-1,1], der Rückwinkel ist in[In der Reichweite von 0, Pi] oder na.

math.random

Gibt einen pseudo-randomisierten Wert zurück. Die Funktion erzeugt eine unterschiedliche Reihe von Werten für jedes Skript, das ausgeführt wird. Die Verwendung der gleichen Werte für die auswählbaren Seed-Parameter erzeugt eine wiederholbare Reihe.

math.random(min, max, seed)

Rückgabewert Ein zufälliger Wert.

Parameter

• min(series int/float) Untere Grenze des Randomwertbereichs。 Der Wert ist nicht im Bereich enthalten。 Der Standardwert ist 0。
• max(series int/float) Obergrenze für den Bereich der zufälligen Werte. Der Wert ist nicht im Bereich enthalten. Der Standardwert ist 1
• seed(input int) Optionale Parameter. Es ist erlaubt, diese Funktion in Folge aufzurufen, um eine Reihe von wiederholbaren Werten zu erzeugen, wenn derselbe Seed verwendet wird.

math.asin

Die asin-Funktion gibt die Gegen-Synthese der Zahlen zurück ((in einem Bogen), wobei die Synthese ((asin ((y)) = y in einem Bereich von y[-1, 1]。

math.asin(angle) 

Rückgabewert Die Antitronschall-Werte. Wenn y außerhalb des Bereichs ist[-1,1], der Rückwinkel ist in[-Pi / 2, Pi / 2] oder in der Reichweite von na.

math.atan

Die atan-Funktion gibt die linke Schnittstelle der Zahlen zurück ((in einem Bogen), so dass tan ((atan ((y)) = y in jedem y.

math.atan(angle) 

Rückgabewert Die Rückwärtswinkel ist in[-Pi / 2, Pi / 2] im Bereich der

math.ceil

Die oberwärtsgeführte Integer-Funktion gibt die kleinste (und damit am wenigsten negative) ganze Zahl zurück, die größer oder gleich dem Argument ist.

math.ceil(number)

Rückgabewert Mindeste ganze Zahl kleiner oder gleich einer gegebenen Zahl

Siehe auch math.floor math.round

math.cos

Die cos-Funktion gibt einen Dreiecksschleife zurück.

math.cos(angle) 

Rückgabewert Die Dreiecksschlinge der Ecke.

Parameter

• angle(series int/float) Winkel, in der Breite

math.exp

numberDie exp-Funktion von e ist numberDie Quadratur, wobei e die Eulerzahl ist.

math.exp(number) 

Rückgabewert Eines der Werte für e, das istnumberDas ist eine gute Idee.

Siehe auch math.pow

math.floor

math.floor(number) 

Rückgabewert größtmögliche ganze Zahl kleiner oder gleich der angegebenen Zahl.

Siehe auch math.ceil math.round

math.log

Was auch immer.numberDie natürliche Logarithmik von > 0 ist die einzige y, so dass e^y = number。

math.log(number)

Rückgabewert numberDie natürlichen Argumente der .

Siehe auch math.log10

math.log10

numberDie übliche Argumentation ist, dass man den Wert 10 erhöhen muss, um den Wert 10 zu erhalten.number。10^y = number。

math.log10(number)

Rückgabewert numberDie logarithmische Basis von 10

Siehe auch math.log

math.pow

Mathematische Funktionen

math.pow(base, exponent)

Beispiel

// math.pow
plot(math.pow(close, 2))

Rückgabewert baseErhöhung aufexponentWennbaseEs ist eine Reihe, die nach Elementen berechnet wird.

Parameter

• base(series int/float) Gibt die Basis an, die verwendet werden soll.
• exponent(series int/float) Der angegebene Index.

Siehe auch math.sqrt math.exp

math.sign

Wenn die Quadratzahl 0 ist, ist das Signal der Quadratzahl 0; wenn die Quadratzahl größer als 0 ist, ist es 1,0; wenn die Quadratzahl kleiner als 0 ist, ist es -1,0.

math.sign(number)

Rückgabewert Das Logo der Parameter.

math.sin

Die Synthesefunktion gibt die Synthese eines Winkels zurück.

math.sin(angle)

Rückgabewert Die Dreiecks-Synthese der Ecken.

Parameter

• angle(series int/float) Winkel, in der Breite

math.sqrt

Was auch immernumberDie Quadratwurzel von >=0 ist die einzige Sache, bei der y >=0 so groß ist, dass y^2 = number。

math.sqrt(number)

Rückgabewert numberDie Quadratwurzel.

Siehe auch math.pow

math.tan

Der Dreiecksschnitt, in dem die Tan-Funktion den Winkel zurückgibt.

math.tan(angle)

Rückgabewert Die Ecken des Dreiecks sind gerade.

Parameter

• angle(series int/float) Winkel, in der Breite

math.round

Zurück.numberWenn der Wert von {\displaystyle } verwendet wird, wird der Wert von {\displaystyle } auf die nächstgelegene ganze Zahl verteilt und nach oben ausgeglichen.precisionDer Parameter gibt einen Floating-Point-Wert zurück, der in eine Vier- oder Fünf-Zahl-Zahl eingegeben wird.

math.round(number) 

math.round(number, precision) 

Rückgabewert numberDie Werte der Werte werden in die nächste ganze Zahl oder entsprechend der Genauigkeit eingeteilt.

Parameter

• number(series int/float) Umkreist werden soll.
• precision(series int) Optionale ParameternumberDie geringe Zahl, die mit einer Viertelzahl versehen wird. Wenn keine Parameter angegeben sind, wird die Viertelzahl mit einer Viertelzahl an die nächste ganze Zahl versehen.

Anmerkung Bitte beachten Sie, dass die Funktion ‘na’ für ‘na’ zurückgibt.

Siehe auch math.ceil math.floor

math.max

Gibt den größten von mehreren Werten zurück.

math.max(number0, number1, ...) 

Beispiel

// math.max
plot(math.max(close, open))
plot(math.max(close, math.max(open, 42)))

Rückgabewert Die größte von mehreren gegebenen Werten.

Siehe auch math.min

math.min

Gibt die kleinste von mehreren Werten zurück.

math.min(number0, number1, ...) 

Beispiel

// math.min
plot(math.min(close, open))
plot(math.min(close, math.min(open, 42)))

Rückgabewert Minimaler Wert unter mehreren gegebenen Werten.

Siehe auch math.max

math.avg

Berechnen Sie den Mittelwert aller Reihen ((entsprechende Elemente) .

math.avg(number0, number1, ...)

Rückgabewert Durchschnitt

Siehe auch math.sum ta.cum ta.sma

math.round_to_mintick

Gibt die Mintick-Werte zurück, die in die Ware eingezählt wurden, d.h. die können ohne Rest durch die nächstgelegenen Werte von syminfo.mintick dividiert und nach oben eingezählt werden.

math.round_to_mintick(number) 

Rückgabewert numberVier Runden und fünf Eingänge bis zum Tick.

Parameter

• number(series int/float) Umkreist werden soll.

Siehe auch math.ceil math.floor

math.sum

Die sum-Funktion gibt die Schiebe-Synthese der letzten y-Werte von x zurück.

math.sum(source, length)

Rückgabewert lengthK-Strecke zurückgegebensourceZusammengefasst

Parameter

• source(series int/float) Die auszuführenden Serienwerte.
• length(series int) Anzahl der K-Zeilen (länge).

Siehe auch ta.cum for

math.todegrees

Von einem Winkel in der Einheit der Bogenlänge wird der nahezu äquivalente Winkel in der Einheit der Grade zurückgegeben.

math.todegrees(radians) 

Rückgabewert Winkelwert in Einheiten gemessen.

Parameter

• radians(series int/float) Der Winkel in Einheiten des Bogen.

math.toradians

Von einem Winkel in Einheiten der Größe wird der nahezu äquivalente Winkel in Einheiten der Bogenlänge zurückgegeben.

math.toradians(degrees) 

Rückgabewert Winkelwert in Einheiten der Bogenlänge.

Parameter

• degrees(series int/float) Der Winkel in Einheiten.

others

fixnan

NaN-Werte werden für die angegebene Reihe durch vorherige Nicht-NaN-Werte ersetzt.

fixnan(source) 

Rückgabewert Eine Serie ohne Na-Lücke.

Parameter

• source (series int/float/bool/color)

Siehe auch na nz

nz

NaN-Werte durch Null (oder eine bestimmte Zahl in der Reihe) ersetzen.

nz(source, replacement) 

nz(source)

Beispiel

// nz
plot(nz(ta.sma(close, 100)))

Rückgabewert sourceWenn es nicht so istnaWennsourceDie Werte fürnaWird 0 zurückgegeben, wird 1 zurückgegeben.replacementParameter

Parameter

• source(series int/float/bool/color) Die Serie, die ausgeführt werden soll.
• replacement(series int/float/bool/color) ersetzt die Werte aller na-Thresholds in der source-Serie.

Siehe auch na fixnan

na

Wenn NaN, dann Testwert

na(x)

Rückgabewert Wenn x keine gültige Zahl ist, dann ist es wahr (x ist NaN), andernfalls ist es falsch.

Siehe auch fixnan nz

int

Umwandlung in na oder Trennung der Float-Werte in int。

int(x) 

Rückgabewert Umwandlung in die Parameterwerte nach int。

Siehe auch float bool color string

float

Setzen Sie na auf Floating.

float(x) 

Rückgabewert Umwandlung in die Parameterwerte nach float。

Siehe auch int bool color string

alert

Alarmereignisse werden ausgelöst, wenn sie während der K-Linie in Echtzeit aufgerufen werden, und Alarmereignisse werden zuvor als Kennzeichen oder als Strategie erstellt, die auf den Ereignissen der Alarmfunktion basieren.

alert(message, freq)

Beispiel

// alert() example
ma = ta.sma(close, 14)
xUp = ta.crossover(close, ma)
if xUp
    // Trigger the alert the first time a cross occurs during the real-time bar.
    alert("Price (" + str.tostring(close) + ") crossed over MA (" + str.tostring(ma) +  ").", alert.freq_once_per_bar)
plot(ma)
plotchar(xUp, "xUp", "▲", location.top, size = size.tiny)

Parameter

• message(series string) Die Nachricht, die beim Auslösen des Alarms gesendet wird.
• freq(input string) Triggerfrequenz. Die möglichen Werte sind: alert.freq_all, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.freq_once_per_bar, alert.alert.freq_once_per_bar, alert.alert.freq_once_per_bar, alert.freq_once_per_per_bar, alert

Anmerkung Die Hilfszentrale zeigt Ihnen, wie Sie solche Warnungen erstellen können. Im Gegensatz zu alertcondition zählt der alert-Aufruf nicht als zusätzliche Grafik. Funktionsaufrufe können sowohl global als auch lokal eingesetzt werden. Der Funktionsaufruf zeigt nichts auf der Grafik. Der Parameter freq wirkt sich nur auf die Triggerfrequenz aus, bei der diese Funktion aufgerufen wird.

Siehe auch alertcondition

alertcondition

Alarmbedingungen erstellen können Sie im Dialogfeld “Alarmbedingungen erstellen”. Bitte beachten Sie, dass der alertcondition-Effekt keinen Alarm erstellt, sondern Ihnen nur weitere Optionen im Dialogfeld “Alarmbedingungen erstellen” bietet. Außerdem ist der Effekt des alertcondition-Effekts in der Grafik nicht sichtbar.

alertcondition(condition, title, message)

Beispiel

// alertcondition
alertcondition(close >= open, title='Alert on Green Bar', message='Green Bar!')

Parameter

• condition(series bool) Eine Reihe von Boole-Werten, die für Alarme verwendet werden. True bedeutet Alarm ausgelöst, false bedeutet keine Alarm.
• title(const string) Der Titel der Alarmbedingung. Optionale Parameter.
• message(const string) Anzeige einer Nachricht, wenn der Alarm ausgelöst wird. Optional.

Anmerkung Bitte beachten Sie, dass in Pine v4 der Aufruf der Alarmbedingung eine zusätzliche Grafik erzeugt. Alle diese Aufrufe werden berücksichtigt, wenn wir die Anzahl der Ausgabefolgen für jedes Skript berechnen.

Siehe auch alert

indicator

Für die KompatibilitätTrading ViewStrategiecode, der eigentlich nicht aufgerufen werden muss.

Siehe auch strategy

time

Die time-Funktion gibt die UNIX-Zeit der aktuellen K-Zeile für den angegebenen Zeitbereich und die Transaktionszeit zurück. Wenn die Zeitpunkte nicht in der Transaktionszeit liegen, wird NaN zurückgegeben.sessionParameter

time(timeframe, session, timezone)

time(timeframe, session)

time(timeframe)

Beispiel

timeinrange(res, sess) => not na(time(res, sess, "America/New_York")) ? 1 : 0
plot(timeinrange("1", "1300-1400"), color=color.red)

// This plots 1.0 at every start of 10 minute bar on a 1 minute chart:
newbar(res) => ta.change(time(res)) == 0 ? 0 : 1
plot(newbar("10"))

Wenn Sie eine Sitzung einrichten, können Sie nicht nur die Uhrzeit und die Minuten, sondern auch den Tag in der Woche angeben. Wenn kein Datum angegeben ist, wird angenommen, dass die Handelszeit von Sonntag (1) bis Samstag (7) eingestellt ist, d. h. 1100-2000 RON ist identisch mit 1100-1200 RON: 1234567 RON. Sie können dies ändern, indem Sie den Tag angeben. Zum Beispiel, für Waren, die 7 Tage in der Woche gehandelt werden und 24-Stunden-Handelszeiten haben, wird das folgende Skript nicht für Samstag und Sonntag gefärbt:

Beispiel

// Time
t1 = time(timeframe.period, "0000-0000:23456")
bgcolor(t1 ? color.new(color.blue, 90) : na)

Eine.sessionDie Parameter können mehrere verschiedene Transaktionszeiten enthalten, die durch Kommas getrennt sind. So wird beispielsweise in folgenden Skripten ein K-Linienbild von 10:00 bis 11:00 und von 14:00 bis 15:00 (nur an Werktagen) hervorgehoben:

Beispiel

// Time
t1 = time(timeframe.period, "1000-1100,1400-1500:23456")
bgcolor(t1 ? color.new(color.blue, 90) : na)

Rückgabewert Unix-Zeit

Parameter

• timeframe(simple string) Zeitspanne. Die leere Zeichenfolge wird als die aktuelle Zeitspanne des Diagramms interpretiert.
• session(simple string) Handelszeitspezifikationen。 Optionale Parameter, Standard ist Handelszeiten。 Leere Strings werden als Handelszeiten für Waren interpretiert。 FMZ wird nicht unterstützt。
• timezone (simple string) sessionDer Parameter-Zeitzone。 kann nur verwendet werden, wenn die Sitzungszone der Antenne angegeben ist。 ist optional。 Der Standardwert ist syminfo.timezone。 kann mit der GMT-Ausdrucksweise ((z. B. GMT-5) oder dem IANA-Zeitzonendatenbanknamen ((z. B. America/New_York)) angegeben werden。

Anmerkung UNIX-Zeit ist die Anzahl der Millisekunden, die seit dem 1. Januar 1970 (UTC 00:00:00) vergangen sind.

year

year(time)

year(time, timezone)

Rückgabewert Das Jahr, in dem die UNIX-Zeit verfügbar ist (eine Wechselzeitzone).

Parameter

• time(series int) ist die Unix-Zeit in Millisekunden.
• timezone(series string) Optionale Parameter ◦ Zeitzone ◦

Anmerkung UNIX-Zeit ist die Anzahl der Millisekunden seit dem 1. Januar 1970 UTC 00:00:00 Uhr. Die Standardzeitzone ist syminfo.timezone. Sie können die möglichen Werte mit einem Zeitstempel überprüfen. Bitte beachten Sie, dass diese Funktion das Jahr anhand der Öffnungszeit der K-Linie zurückgibt. Für die Übernacht-Handelszeit (z. B. EURUSD-Mondtags-Handelszeit, die am Sonntag um 17:00 UTC-4 beginnt) kann dieser Wert 1 niedriger sein als das Jahr des Handelstages.

Siehe auch year time month dayofmonth dayofweek hour minute second

month

month(time)

month(time, timezone)

Rückgabewert Monat, in dem die UNIX-Zeit verfügbar ist (eingeschaltete Zeitzone).

Parameter

• time(series int) ist die Unix-Zeit in Millisekunden.
• timezone(series string) Optionale Parameter ◦ Zeitzone ◦

Anmerkung UNIX-Zeit ist die Anzahl der Millisekunden seit dem 1. Januar 1970 UTC 00:00:00 Uhr. Die Standardzeitzone ist syminfo.timezone. Sie können die möglichen Werte mit einem Zeitstempel überprüfen. Bitte beachten Sie, dass diese Funktion den Monat anhand der Öffnungszeit der K-Linie zurückgibt. Für die Übernacht-Handelszeit (z. B. EURUSD-Handelszeit am Montag beginnt am Sonntag um 17:00 UTC-4) kann dieser Wert 1 niedriger sein als der Monat des Handelstages.

Siehe auch month time year dayofmonth dayofweek hour minute second

hour

hour(time)

hour(time, timezone)

Rückgabewert UNIX-Zeit (eingeschaltete Zeitzone) [2].

Parameter

• time(series int) ist die Unix-Zeit in Millisekunden.
• timezone(series string) Optionale Parameter ◦ Zeitzone ◦

Anmerkung UNIX-Zeit ist die Anzahl der Millisekunden seit dem 1. Januar 1970 UTC 00:00:00 Uhr. Die Standardzeitzone ist syminfo.timezone. Sie können die möglichen Werte mit einem Zeitstempel überprüfen.

Siehe auch hour time year month dayofmonth dayofweek minute second

minute

minute(time)

minute(time, timezone)

Rückgabewert Minuten für die Bereitstellung von UNIX-Zeit ((Swap-Zeitzonen)) [2].

Parameter

• time(series int) ist die Unix-Zeit in Millisekunden.
• timezone(series string) Optionale Parameter ◦ Zeitzone ◦

Anmerkung UNIX-Zeit ist die Anzahl der Millisekunden seit dem 1. Januar 1970 UTC 00:00:00 Uhr. Die Standardzeitzone ist syminfo.timezone. Sie können die möglichen Werte mit einem Zeitstempel überprüfen.

Siehe auch minute time year month dayofmonth dayofweek hour second

second

second(time)

second(time, timezone)

Rückgabewert Die Anzahl der Sekunden, die für die UNIX-Zeit vorgesehen sind (eingeschaltete Zeitzonen).

Parameter

• time(series int) ist die Unix-Zeit in Millisekunden.
• timezone(series string) Optionale Parameter ◦ Zeitzone ◦

Anmerkung UNIX-Zeit ist die Anzahl der Millisekunden seit dem 1. Januar 1970 UTC 00:00:00 Uhr. Die Standardzeitzone ist syminfo.ti