Die Ressourcen sind geladen. Beförderung...
  1. Foren
  2. Hilfe!
  3. FMZ PINE Skript Doc

FMZ PINE Skript Doc

Schriftsteller:Die Erfinder quantifizieren - Kleine Träume, Erstellt: 2022-04-28 16:05:05, aktualisiert: 2024-10-12 17:25:27

Der t-Wert ist NaN.

  • trail_price(series int/float) Ein optionales Argument. Trailing stop-Aktivierungsniveau (erfordert einen bestimmten Preis). Wenn dies angegeben ist, wird ein Trailing stop-Auftrag platziert, wenn das angegebene Preisniveau erreicht wird. Der Offset (in Ticks), um den Anfangspreis des Trailing stop-Auftrags zu bestimmen, wird im Argument trail_offset angegeben: X ticks niedriger als das Aktivierungsniveau, um aus der Long-Position auszugehen; X ticks höher als das Aktivierungsniveau, um aus der Short-Position auszugehen. Der Standardwert ist NaN.
  • trail_points(series int/float) Ein optionales Argument. Trailing stop Aktivierungsniveau (in Tick angegeben Gewinn). Wenn dies angegeben ist, wird ein Trailing stop-Order platziert, wenn das berechnete Preisniveau (gegebene Gewinnmenge) erreicht wird. Der Offset (in Tick) zur Bestimmung des Anfangspreises des Trailing stop-Orders wird im Argument trail_offset angegeben: X ticks niedriger als das Aktivierungsniveau, um aus der Long-Position auszugehen; X ticks höher als das Aktivierungsniveau, um aus der Short-Position auszugehen. Der Standardwert ist NaN.
  • trail_offset(serie int/float) Ein optionales Argument. Trailing-Stop-Preis (in Ticks angegeben). Der Offset in Ticks, um den Anfangspreis der Trailing-Stop-Order zu bestimmen: X tickt niedriger als trail_price oder trail_points, um eine Long-Position zu verlassen; X tickt höher als trail_price oder trail_points, um eine Short-Position zu verlassen. Der Standardwert ist NaN.
  • oca_name(Serienfolge) Ein optionales Argument. Name der OCA-Gruppe (oca_type = strategy.oca.reduce), zu der das Gewinnziel, der Stop-Loss / der Trailing-Stop-Order gehören. Wenn der Name nicht angegeben ist, wird er automatisch generiert.Beachten Sie, dass FMZ dieses Argument nicht unterstützt.
  • comment(Serienreihe) Ein optionales Argument. Zusätzliche Anweisungen für die Reihenfolge.
  • when(serie bool) Ein optionaler Argument. Bedingung der Bestellung. Die Bestellung wird platziert, wenn die Bedingung true ist. Wenn die Bedingung false ist, passiert nichts (die zuvor platzierte Bestellung mit der gleichen ID wird nicht storniert).
  • alert_message(Serienfolge) Ein optionales Argument, wenn der Platzhalter {{strategy.order.alert_message}} im Feld Message des Dialogfeldes Create Alert verwendet wird.

strategy.cancel

Es handelt sich um einen Befehl zur Stornierung/Deaktivierung von ausstehenden Aufträgen, indem auf deren Namen verwiesen wird, die durch die Funktionen: strategy.order, strategy.entry undstrategy.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

Argumente

  • id(Seriezeichenfolge) Ein erforderliches Argument. Die Bestellkennung. Es ist möglich, eine Bestellung zu stornieren, indem man auf ihre Kennung verweist.
  • when(series bool) Ein optionaler Argument. Bedingung zur Stornierung einer Bestellung mit angegebener ID. Wenn die Bedingung true ist, wird die Bestellung mit angegebener ID storniert. Standardwert ist true.

Strategie.abbrechen_alle

Es handelt sich um einen Befehl zur Stornierung/Deaktivierung aller ausstehenden Aufträge, die durch die Funktionen: strategy.order, strategy.entry undstrategy.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

Argumente

  • when(series bool) Ein optionaler Argument. Bedingung, alle Aufträge zu stornieren. Wenn die Bedingung wahr ist, werden alle aktiven Aufträge storniert. Der Standardwert ist true.

strategy.order

Es handelt sich um einen Befehl, um eine Bestellung zu platzieren. Wenn eine Bestellung mit der gleichen ID bereits aussteht, ist es möglich, die Bestellung zu ändern. Wenn keine Bestellung mit der angegebenen ID vorliegt, wird eine neue Bestellung platziert. Um die Bestellung zu deaktivieren, sollte der Befehl strategy.cancel oder strategy.cancel_all verwendet werden. Im Vergleich zur Funktion strategy.entry wird die Funktion strategy.order nicht durch Pyramiden beeinflusst. Wenn sowohl die limit als auch die stop Parameter NaN sind, ist der Bestelltyp Marktbestellung.

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

Argumente

  • id(Serie-String) Ein erforderlicher Parameter. Die Auftrags-Identifikator. Es ist möglich, eine Bestellung zu stornieren oder zu ändern, indem man sich auf ihre Identifikator.
  • direction(Strategie_Richtung) Ein erforderlicher Parameter. Orderrichtung: strategie.lang ist für Kauf, strategie.short ist für Verkauf.
  • qty(series int/float) Ein optioner Parameter. Anzahl der zu handelnden Verträge/Aktien/Lotten/Einheiten. Der Standardwert ist NaN.
  • limit(series int/float) Ein optioner Parameter. Grenzpreis der Bestellung. Wenn er angegeben ist, ist der Bestelltyp entweder limit oder stop-limit. NaN sollte für jeden anderen Bestelltyp angegeben werden.
  • stop(series int/float) Ein optionaler Parameter. Stop-Preis des Auftrags. Wenn er angegeben ist, ist der Auftragstyp entweder stop oder stop-limit. Für jeden anderen Auftragstyp sollte NaN angegeben werden.
  • oca_name(Serie-String) Ein optionaler Parameter. Name der OCA-Gruppe, zu der die Reihenfolge gehört. Sollte die Reihenfolge nicht zu einer bestimmten OCA-Gruppe gehören, sollte es eine leere Zeichenfolge geben.Beachten Sie, dass FMZ dieses Argument nicht unterstützt.
  • oca_type(Eingabezeichen) Ein optioner Parameter. Typ der OCA-Gruppe. Die zulässigen Werte sind: strategy.oca.none - der Auftrag sollte nicht zu einer bestimmten OCA-Gruppe gehören; strategy.oca.cancel - der Auftrag sollte einer OCA-Gruppe gehören, wobei alle anderen Aufträge derselben Gruppe storniert werden, sobald ein Auftrag ausgeführt wird; strategy.oca.reduce - der Auftrag sollte einer OCA-Gruppe gehören, wobei bei X Anzahl von Verträgen eines Auftrags die Anzahl der Verträge für jeden anderen Auftrag derselben OCA-Gruppe um X verringert wird.Beachten Sie, dass FMZ dieses Argument nicht unterstützt.
  • comment(Serienreihe) Ein optionale Parameter. Zusätzliche Hinweise zur Reihenfolge.
  • when(series bool) Ein optioner Parameter. Bedingung der Bestellung. Die Bestellung wird platziert, wenn die Bedingung true ist. Wenn die Bedingung false ist, geschieht nichts (die zuvor platzierte Bestellung mit der gleichen ID wird nicht storniert).
  • alert_message(Serienfolge) Ein optioner Parameter, der den Platzhalter {{strategy.order.alert_message}} ersetzt, wenn er im Dialogfeld Erstellen einer Warnung Nachricht verwendet wird.

Strategie.Oppentrades.Entry_bar_index

Gibt den Bar_index des Eintrags des offenen Handels zurück.

strategy.opentrades.entry_bar_index(trade_num)

Warten Sie auf 10 Bar und schließen Sie die Position.

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

Argumente

  • trade_num(Serie int) Die Handelsnummer des offenen Handels. Die Nummer des ersten Handels ist Null.

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

Strategie.Offentrades.Eintrag_id

Gibt die ID des Eintrags des offenen Handels zurück.

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ückkehrGibt die ID des Eintrags des offenen Handels zurück.

Argumente

  • trade_num(Serie int) Die Handelsnummer des offenen Handels. Die Nummer des ersten Handels ist Null.

AnmerkungenDie Funktion gibt na zurück, wenn trade_num nicht im Bereich liegt: 0 bis strategy.opentrades-1.

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

Strategie.Offener Handel.Eintrittspreis

Gibt den Preis des Eintrags des offenen Handels zurück.

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

Berechnen Sie den durchschnittlichen Preis der offenen Position.

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

Argumente

  • trade_num(Serie int) Die Handelsnummer des offenen Handels. Die Nummer des ersten Handels ist Null.

Siehe auch strategy.closedtrades.exit_price

Strategie.Offentrades.Eintrittszeit

Gibt die UNIX-Zeit des Eintrags des offenen Handels zurück.

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

Argumente

  • trade_num(Serie int) Die Handelsnummer des offenen Handels. Die Nummer des ersten Handels ist Null.

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

strategy.opentrades.profit

Er gibt den Gewinn/Verlust des offenen Handels an. Verluste werden als negative Werte ausgedrückt.

strategy.opentrades.profit(trade_num)

Rückgabe des Gewinns des letzten geöffneten Handels.

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

Berechnen Sie den Gewinn aller offenen 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")

Argumente

  • trade_num(Serie int) Die Handelsnummer des offenen Handels. Die Nummer des ersten Handels ist Null.

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

strategy.opentrades.size

Gibt die Richtung und die Anzahl der im offenen Handel gehandelten Verträge zurück. Wenn der Wert > 0 beträgt, war die Marktposition lang. Wenn der Wert < 0, war die Marktposition kurz.

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

Berechnen Sie den durchschnittlichen Gewinnanteil der offenen 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)

Argumente

  • trade_num(Serie int) Die Handelsnummer des offenen Handels. Die Nummer des ersten Handels ist Null.

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

Strategie.abgeschlossener Handel.Eintrag_Bar_Index

Gibt den Bar_Index des geschlossenen Handels zurück.

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

Argumente

  • trade_num(Serie int) Die Handelsnummer des geschlossenen Handels. Die Nummer des ersten Handels ist Null.

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

Strategie.abgeschlossener Handel.Ausgangspreis

Gibt den Ausgangspreis eines geschlossenen Handels zurück.

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 durchschnittlichen Gewinnprozentsatz für alle geschlossenen 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)

Argumente

  • trade_num(Serie int) Transaktionsnummer der abgeschlossenen Transaktion. Die Nummer der ersten Transaktion ist Null.

Siehe auch strategy.closedtrades.entry_price

Strategie.abgeschlossener Handel.Exit_bar_index

Gibt den Bar_index des geschlossenen Handelsausgangs zurück.

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 Anzahl von K-Linien 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())

Argumente

  • trade_num(Serie int) Die Handelsnummer des geschlossenen Handels. Die Nummer des ersten Handels ist Null.

Siehe auch bar_index

Strategie.abgeschlossener Handel.Eintrag_id

Gibt die ID des geschlossenen Handels-Eintrags zurück.

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ückkehrGibt die ID des geschlossenen Handels-Eintrags zurück.

Argumente

  • trade_num(Serie int) Die Handelsnummer des geschlossenen Handels. Die Nummer des ersten Handels ist Null.

AnmerkungenDie Funktion gibt na zurück, wenn trade_num nicht im Bereich liegt: 0 bis strategy.closedtrades-1.

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

Strategie.Abgeschlossener Handel.Eintrittspreis

Gibt den Preis für den geschlossenen Handel zurück.

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 durchschnittlichen Gewinnprozentsatz für alle geschlossenen 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)

Argumente

  • trade_num(Serie int) Die Handelsnummer des geschlossenen Handels. Die Nummer des ersten Handels ist Null.

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

Strategie.Abgeschlossener Handel.Eintrittszeit

Gibt die UNIX-Zeit des geschlossenen Handels-Eintrags zurück.

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

Argumente

  • trade_num(Serie int) Die Handelsnummer des geschlossenen Handels. Die Nummer des ersten Handels ist Null.

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

strategy.closedtrades.profit

Er gibt den Gewinn/Verlust des geschlossenen Handels zurück.

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

Argumente

  • trade_num(Serie int) Die Handelsnummer des geschlossenen Handels. Die Nummer des ersten Handels ist Null.

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

strategy.closedtrades.size

Gibt die Richtung und die Anzahl der im geschlossenen Handel gehandelten Verträge zurück. Wenn der Wert > 0 ist, war die Marktposition lang. Wenn der Wert < 0 ist, war die Marktposition kurz.

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

Berechnen Sie den durchschnittlichen Gewinnanteil bei geschlossenen Geschäften.

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)

Argumente

  • trade_num(Serie int) Die Handelsnummer des geschlossenen Handels. Die Nummer des ersten Handels ist Null.

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

Strategie.Abgeschlossener Handel.Ausgang_Zeit

Gibt die UNIX-Zeit des geschlossenen Handels zurück.

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 geschlossene Trades neu eröffnen.

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)

Argumente

  • trade_num(Serie int) Die Handelsnummer des geschlossenen Handels. Die Nummer des ersten Handels ist Null.

Siehe auch strategy.closedtrades.entry_time

Strategie.Risiko.Zulassung des Eintritts

Diese Funktion kann verwendet werden, um festzulegen, in welcher Marktrichtung die Strategie.Eintrittsfunktion Positionen eröffnen darf.

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)

Argumente

  • value(einfache Zeichenfolge) Die zulässige Richtung. Mögliche Werte:strategy.direction.all, strategy.direction.long, strategy.direction.short

Strategie.Risiko.max_position_size

Diese Regel dient der Bestimmung der Höchstgröße einer Marktposition und betrifft folgende Funktion:strategy.entry. Die Eintrittsmenge kann (falls erforderlich) auf eine bestimmte Anzahl von Verträgen/Aktien/Lotten/Einheiten reduziert werden, so dass die Gesamtpositionengröße den in strategy.risk.max_position_size angegebenen Wert nicht übersteigt. Verstößt die Mindestmenge immer noch gegen die Regel, wird der Auftrag nicht erteilt.

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

Argumente

  • contracts(simple int/float) Ein erforderlicher Parameter. Höchstzahl der Verträge/Aktien/Lotes/Einheiten in einer Position.

Mathematik

math.abs

Absoluter Wert vonnumberistnumberwennnumber>= 0, oder -number otherwise.

math.abs(number)

RückkehrDer absolute Wert vonnumber.

math.acos

Die Funktion acos gibt das Arccosinus (in Radianen) einer Zahl zurück, so dass cos ((acos(y)) = y für y im Bereich [-1, 1].

math.acos(angle)

RückkehrDer Bogenkosinus eines Wertes; der zurückgegebene Winkel liegt im Bereich [0, Pi] oder na, wenn y außerhalb des Bereichs [-1, 1] liegt.

math.random

Gibt einen pseudo-zufälligen Wert zurück. Die Funktion erzeugt eine andere Sequenz von Werten für jede Skriptdurchführung. Die Verwendung des gleichen Wertes für das optionale Seed-Argument erzeugt eine wiederholbare Sequenz.

math.random(min, max, seed)

RückkehrEin zufälliger Wert.

Argumente

  • min(series int/float) Die untere Grenze des Bereichs der zufälligen Werte. Der Wert ist nicht in den Bereich aufgenommen. Der Standardwert ist 0.
  • max(series int/float) Die obere Grenze des Bereichs der zufälligen Werte. Der Wert ist nicht im Bereich enthalten. Der Standardwert ist 1.
  • seed(Input int) Optional, wenn der gleiche Seed verwendet wird, ermöglicht es aufeinanderfolgenden Aufrufen der Funktion, einen wiederholbaren Wertsatz zu erzeugen.

math.asin

Die Asin-Funktion gibt das Arcsinus (in Radianen) einer Zahl zurück, so dass sin ((asin(y)) = y für y im Bereich [-1, 1].

math.asin(angle)

RückkehrDas Bogenzeichen eines Wertes; der zurückgegebene Winkel liegt im Bereich [-Pi/2, Pi/2] oder na, wenn y außerhalb des Bereichs [-1, 1] liegt.

math.atan

Die atan-Funktion gibt die Arctangente (in Radianen) einer Zahl zurück, so dass tan ((atan ((y)) = y für jedes y.

math.atan(angle)

RückkehrDie Bogentangente eines Wertes; der zurückgegebene Winkel liegt im Bereich [-Pi/2, Pi/2].

math.ceil

Die Ceiling-Funktion gibt die kleinste (negativ unendlichste) ganze Zahl zurück, die größer oder gleich dem Argument ist.

math.ceil(number)

RückkehrDie kleinste ganze Zahl kleiner oder gleich der angegebenen Zahl.

Siehe auch math.floor math.round

math.cos

Die Cos-Funktion gibt das trigonometrische Cosinus eines Winkels zurück.

math.cos(angle)

RückkehrDas trigonometrische Kosinus eines Winkels.

Argumente

  • angle(Serie int/float) Winkel in Radianen.

math.exp

Die Funktion exp vonnumberist erhoben zu der Macht dernumber, wo e die Euler-Zahl ist.

math.exp(number)

RückkehrEin Wert, der e auf die Potenz vonnumber.

Siehe auch math.pow

math.floor

math.floor(number)

RückkehrDie größte ganze Zahl kleiner oder gleich der angegebenen Zahl.

Siehe auch math.ceil math.round

math.log

Natürlicher Logarithmus einesnumber> 0 ist das einzigartige y, so dass e^y =number.

math.log(number)

RückkehrDer natürliche Logarithmus vonnumber.

Siehe auch math.log10

math.log10

Der gemeinsame (oder Basis 10) Logarithmus vonnumberist die Potenz, auf die 10 erhöht werden muss, um dienumber. 10 ^ y =number.

math.log10(number)

RückkehrDer Logarithmus in der Basis 10 vonnumber.

Siehe auch math.log

math.pow

Mathematische Leistungsfunktion.

math.pow(base, exponent)

Beispiel

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

Rückkehr baseErhöht zur Macht derexponentWenn.baseist eine Reihe, wird elementar berechnet.

Argumente

  • base(Serie int/float) Die zu verwendende Basis angeben.
  • exponent(Serie int/float) Geben Sie den Exponenten an.

Siehe auch math.sqrt math.exp

math.sign

Das Zeichen (signum) von number ist Null, wenn number Null ist, 1.0 wenn number größer als Null ist, -1.0 wenn number kleiner als Null ist.

math.sign(number)

RückkehrDas Zeichen des Streits.

math.sin

Die Sin-Funktion gibt den trigonometrischen Sinus eines Winkels zurück.

math.sin(angle)

RückkehrDer trigonometrische Sinus eines Winkels.

Argumente

  • angle(Serie int/float) Winkel in Radianen.

math.sqrt

Quadratwurzel von jedemnumber>= 0 ist das einzigartige y >= 0 so dass y^2 =number.

math.sqrt(number)

RückkehrDie Quadratwurzel vonnumber.

Siehe auch math.pow

math.tan

Die Tan-Funktion gibt die trigonometrische Tangente eines Winkels zurück.

math.tan(angle)

RückkehrDie trigonometrische Tangente eines Winkels.

Argumente

  • angle(Serie int/float) Winkel in Radianen.

math.round

Gibt den Wert vonnumberWenn die Anzahl der Zahlen auf die nächste ganze Zahl gerundet wird, werden die Zahlen auf die nächste ganze Zahl gerundet.precisionWenn ein Parameter verwendet wird, wird ein auf diese Anzahl von Dezimalstellen gerundeter Floatwert zurückgegeben.

math.round(number) 

math.round(number, precision)

RückkehrDer Wert vonnumberauf die nächstgelegene ganze Zahl gerundet oder nach Präzision.

Argumente

  • number(Serie int/float) Der zu abrundende Wert.
  • precision(Serie int) Optionales Argument.numberWenn kein Argument angegeben wird, wird auf die nächstgelegene ganze Zahl gerundet.

AnmerkungenBeachten Sie, dass für na-Werte die Funktion na zurückgibt.

Siehe auch math.ceil math.floor

math.max

Gibt den größten der mehrfachen Werte zurück.

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

Beispiel

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

RückkehrDer größte von mehreren gegebenen Werten.

Siehe auch math.min

math.min

Gibt den kleinsten von mehrfachen Werten zurück.

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

Beispiel

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

RückkehrDer kleinste von mehreren gegebenen Werten.

Siehe auch math.max

math.avg

Berechnet den Durchschnitt aller gegebenen Reihen (elementweise).

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

Rückkehr Average.

Siehe auch math.sum ta.cum ta.sma

Das ist ein sehr schwieriger Fall.

Gibt den auf das Mintick des Symbols abgerundeten Wert zurück, d. h. den nächstgelegenen Wert, der durch syminfo.mintick geteilt werden kann, ohne den Rest, wobei die Verbindungen nach oben abgerundet werden.

math.round_to_mintick(number)

RückkehrDienumberSie ist auf die Präzision des Ticks abgestimmt.

Argumente

  • number(Serie int/float) Der zu abrundende Wert.

Siehe auch math.ceil math.floor

math.sum

Die Summe-Funktion gibt die gleitende Summe der letzten y-Werte von x zurück.

math.sum(source, length)

RückkehrSumme vonsourcefürlengthZurück mit den Stangen.

Argumente

  • source(Serie int/float) Zu verarbeitende Werte.
  • length(Serie int) Anzahl der Balken (Länge).

Siehe auch ta.cum for

math.todegrees

Gibt einen etwa gleichwertigen Winkel in Grad von einem in Radianen gemessenen Winkel zurück.

math.todegrees(radians)

RückkehrDer Winkelwert in Grad.

Argumente

  • radians(Serie int/float) Winkel in Radianen.

math.toradians

Gibt einen in Grad gemessenen Winkel in Radianen zurück.

math.toradians(degrees)

RückkehrDer Winkelwert in Radianen.

Argumente

  • degrees(Serie int/float) Winkel in Grad.

andere

Festsetzen

Für eine bestimmte Reihe ersetzt NaN-Werte durch den vorherigen nächstgelegenen Nicht-NaN-Wert.

fixnan(source)

RückkehrEine Serie ohne Lücken.

Argumente

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

Siehe auch na nz

NZ

Ersetzt NaN-Werte durch Nullen (oder einen gegebenen Wert) in einer Reihe.

nz(source, replacement) 

nz(source)

Beispiel

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

RückkehrDer Wert vonsourcewenn nichtna. Wenn der Wert vonsourceistna, gibt Null zurück, oder diereplacementEin Argument, wenn man es benutzt.

Argumente

  • source(Serie int/float/bool/color) Zu verarbeitende Werte.
  • replacement(Serie int/float/bool/color) Wert, der alle na-Werte in dersource series.

Siehe auch na fixnan

nicht

Testwert, wenn es sich um einen NaN handelt.

na(x)

Rückkehrwahr, wenn x keine gültige Zahl ist (x ist NaN), andernfalls falsch.

Siehe auch fixnan nz

Inneres

Wirft den Flotwert auf int ein oder verkürzt ihn.

int(x)

RückkehrDer Wert des Arguments nach dem Casting in int.

Siehe auch float bool color string

Schwimmen

Das kann nicht schweben.

float(x)

RückkehrDer Wert des Arguments nach dem Einlegen in Float.

Siehe auch int bool color string

Warnung

Auslöst ein Warnereignis, wenn es während der Echtzeitleiste aufgerufen wird und eine Warnung basierend auf Warnfunktionsereignissen für den Indikator oder die Strategie durch das Dialogfeld Alert erstellen erstellt wurde.

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)

Argumente

  • messageNachricht gesendet, wenn der Alarm ausgelöst wird.
  • freq(Eingabezeile) Auslösfrequenz. Die möglichen Werte sind: alert.freq_all (alle Funktionsanrufe lösen die Warnung aus), alert.freq_once_per_bar (der erste Funktionsanruf während der Bar löst die Warnung aus), alert.freq_once_per_bar_close (der Funktionsanruf löst die Warnung nur aus, wenn er während der letzten Skript-Iteration der Echtzeitleiste auftritt, wenn sie geschlossen wird).

AnmerkungenDas Help Center erklärt, wie man solche Warnungen erstellt. Im Gegensatz zur Alarmbedingung zählen Alarmanrufe NICHT als zusätzliche Plot. Funktionsaufrufe können sowohl in globalen als auch in lokalen Bereichen angezeigt werden. Funktionsaufrufe zeigen nichts auf der Tabelle an. Das Argument freq beeinflusst nur die Auslösfrequenz des Funktionsanrufs, wenn es verwendet wird.

Siehe auch alertcondition

Alarmzustand

Erstellt Alarm-Bedingung, die im Alert-Dialog erhältlich ist. Bitte beachten Sie, dass die Alarm-Bedingung keine Alarm erstellt, sondern Ihnen nur mehr Optionen im Alert-Dialog eröffnet.

alertcondition(condition, title, message)

Beispiel

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

Argumente

  • condition(Serie bool) Reihe von Boolean-Werten, die für Alarm verwendet werden.
  • title(Const string) Titel der Alarmbedingung.
  • message(Const-String) Nachricht, die angezeigt werden soll, wenn Alarm ausgelöst wird.

AnmerkungenBitte beachten Sie, dass in Pine Script v4/v5 ein Alarmcondition-Aufruf ein zusätzliches Plot erzeugt. Alle solche Aufrufe werden berücksichtigt, wenn wir die Anzahl der Ausgabe-Reihen pro Skript berechnen.

Siehe auch alert

Indikator

Um mit demTrading ViewStrategie-Code, es ist nicht wirklich erforderlich, aufgerufen werden.

Siehe auch strategy

Zeit

Die Zeitfunktion gibt die UNIX-Zeit der aktuellen Leiste für den angegebenen Zeitrahmen und die Sitzung oder NaN zurück, wenn der Zeitpunkt außerhalb der Sitzung ist.session arguments.

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

Bei der Einrichtung einer Sitzung können Sie nicht nur die Stunden und Minuten, sondern auch die Tage der Woche angeben, die in diese Sitzung einbezogen werden. Wenn die Tage nicht angegeben sind, gilt die Sitzung als von Sonntag (1) bis Samstag (7) festgelegt, d. h. 1100-2000 ist gleich 1100-1200:1234567. Sie können dies ändern, indem Sie die Tage angeben. Zum Beispiel auf einem Symbol, das sieben Tage die Woche mit der 24-Stunden-Handelssitzung gehandelt wird, wird das folgende Skript Samstag und Sonntag nicht farben:

Beispiel

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

EinersessionDas Argument kann mehrere verschiedene Sitzungen umfassen, die durch Kommas getrennt sind. Zum Beispiel wird das folgende Skript die Balken von 10:00 bis 11:00 und von 14:00 bis 15:00 (nur an Werktagen) hervorheben:

Beispiel

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

RückkehrUNIX Zeit.

Argumente

  • timeframe(einfache Zeichenfolge) Zeitrahmen. Eine leere Zeichenfolge wird als der aktuelle Zeitrahmen des Diagramms interpretiert.
  • session(einfache Zeichenfolge) Sitzungsspezifikation. Optional argument, Sitzung des Symbols wird standardmäßig verwendet. Eine leere Zeichenfolge wird als Sitzung des Symbols interpretiert. FMZ unterstützt dies nicht.
  • timezone(einfache Zeichenfolge) Zeitzone dersessionDie Angabe von session ist optional. Die Standardfunktion ist syminfo.timezone. Kann in der GMT-Notierung (z. B. GMT-5) oder als IANA-Zeitzone-Datenbanknamen (z. B. America/New_York) angegeben werden.

AnmerkungenUNIX-Zeit ist die Anzahl der Millisekunden, die seit 00:00:00 UTC am 1. Januar 1970 vergangen sind.

Jahr

year(time)

year(time, timezone)

RückkehrJahr (in der Austauschzeitzone) für die angegebene UNIX-Zeit.

Argumente

  • time(Serie int) UNIX-Zeit in Millisekunden.
  • timezoneEin optionales Argument, Zeitzone.

AnmerkungenUNIX-Zeit ist die Anzahl der Millisekunden, die seit 00:00:00 UTC, 1. Januar 1970 vergangen sind. Beachten Sie, dass diese Funktion das Jahr zurückgibt, basierend auf der Zeit, zu der die Bar öffnet ist. Für Übernachtungsgespräche (z. B. EURUSD, bei denen die Montagssitzung am Sonntag, 17:00 UTC-4 beginnt) kann dieser Wert um 1 niedriger sein als das Jahr des Handelstages.

Siehe auch year time month dayofmonth dayofweek hour minute second

Monat

month(time)

month(time, timezone)

RückkehrMonat (in der Austauschzeitzone) für die angegebene UNIX-Zeit.

Argumente

  • time(Serie int) UNIX-Zeit in Millisekunden.
  • timezoneEin optionales Argument, Zeitzone.

AnmerkungenUNIX-Zeit ist die Anzahl der Millisekunden, die seit 00:00:00 UTC, 1. Januar 1970 vergangen sind. Beachten Sie, dass diese Funktion den Monat basierend auf der Zeit, in der die Bars geöffnet sind, zurückgibt. Für Übernachtungen (z. B. EURUSD, bei denen die Montagssitzung am Sonntag, 17:00 UTC-4 beginnt) kann dieser Wert um 1 niedriger sein als der Monat des Handelstages.

Siehe auch month time year dayofmonth dayofweek hour minute second

Stunde

hour(time)

hour(time, timezone)

RückkehrStunde (in der Zeitzone des Austauschs) für die angegebene UNIX-Zeit.

Argumente

  • time(Serie int) UNIX-Zeit in Millisekunden.
  • timezone(Serienstring) Ein optionales Parameter.

AnmerkungenUNIX-Zeit ist die Anzahl der Millisekunden, die seit 00:00:00 UTC, 1. Januar 1970 vergangen sind.

Siehe auch hour time year month dayofmonth dayofweek minute second

Minute

minute(time)

minute(time, timezone)

RückkehrMinute (in Austauschzeitzone) für die angegebene UNIX-Zeit.

Argumente

  • time(Serie int) UNIX-Zeit in Millisekunden.
  • timezoneEin optionales Argument, Zeitzone.

AnmerkungenUNIX-Zeit ist die Anzahl der Millisekunden, die seit 00:00:00 UTC, 1. Januar 1970 vergangen sind.

Siehe auch minute time year month dayofmonth dayofweek hour second

zweite

second(time)

second(time, timezone)

RückkehrSekunde (in Austauschzeitzone) für die angegebene UNIX-Zeit.

Argumente

  • time(Serie int) UNIX-Zeit in Millisekunden.
  • timezone(Serienstring) Ein optionales Parameter.

AnmerkungenUNIX-Zeit ist die Anzahl der Millisekunden, die seit 00:00:00 UTC, 1. Januar 1970 vergangen sind.

Siehe auch second time year month dayofmonth dayofweek hour minute

Woche pro Jahr

weekofyear(time)

weekofyear(time, timezone)

RückkehrWoche des Jahres (in der Austauschzeitzone) für die angegebene UNIX-Zeit.

Argumente

  • time(Serie int) UNIX-Zeit in Millisekunden.
  • timezone(Serienstring) Ein optionales Parameter.

AnmerkungenUNIX-Zeit ist die Anzahl der Millisekunden, die seit 00:00:00 UTC, 1. Januar 1970 vergangen sind. Beachten Sie, dass diese Funktion die Woche zurückgibt, die auf der Zeit der Öffnung der Bar basiert. Für Übernachtungsgespräche (z. B. EURUSD, bei der die Montagssitzung am Sonntag, 17:00 Uhr, beginnt) kann dieser Wert um 1 niedriger sein als die Woche des Handelstages.

Siehe auch weekofyear time year month dayofmonth dayofweek hour minute second

Tag-Woche

dayofweek(time)

dayofweek(time, timezone)

RückkehrTag der Woche (in der Austauschzeitzone) für die angegebene UNIX-Zeit.

Argumente

  • time(Serie int) UNIX-Zeit in Millisekunden.
  • timezone(Serienstring) Ein optionales Parameter.

AnmerkungenBeachten Sie, dass diese Funktion den Tag basierend auf der Öffnungszeit der Bar zurückgibt. Für Übernacht-Sitzungen (z. B. EURUSD, bei denen die Montagssitzung am Sonntag, 17:00 Uhr, beginnt) kann dieser Wert um 1 niedriger sein als der Tag des Handelstages. UNIX-Zeit ist die Anzahl der Millisekunden, die seit 00:00:00 UTC, 1. Januar 1970 vergangen sind.

Siehe auch time dayofmonth

Tag des Monats

dayofmonth(time)

dayofmonth(time, timezone)

RückkehrTag des Monats (in der Austauschzeitzone) für die angegebene UNIX-Zeit.

Argumente

  • time(Serie int) Unix-Zeit in Millisekunden.
  • timezone(Serienstring) Ein optionales Parameter.

AnmerkungenUNIX-Zeit ist die Anzahl der Millisekunden, die seit 00:00:00 UTC, 1. Januar 1970 vergangen sind. Beachten Sie, dass diese Funktion den Tag basierend auf der Uhrzeit der Öffnungszeiten zurückgibt. Für Übernacht-Sitzungen (z. B. EURUSD, bei denen die Montagssitzung am Sonntag, 17:00 UTC-4 beginnt) kann dieser Wert um 1 niedriger sein als der Tag des Handelstages.

Siehe auch time dayofweek

Zeitstempel

Die Funktion Timestamp gibt UNIX-Zeit des angegebenen Datums und der angegebenen Zeit zurück.

timestamp(dateString)

timestamp(year, month, day, hour, minute, second)

timestamp(timezone, year, month, day, hour, minute, second)

Beispiel

// timestamp
plot(timestamp(2016, 01, 19, 09, 30), linewidth=3, color=color.green)
plot(timestamp(syminfo.timezone, 2016, 01, 19, 09, 30), color=color.blue)
plot(timestamp(2016, 01, 19, 09, 30), color=color.yellow)
plot(timestamp("GMT+6", 2016, 01, 19, 09, 30))
plot(timestamp(2019, 06, 19, 09, 30, 15), color=color.lime)
plot(timestamp("GMT+3", 2019, 06, 19, 09, 30, 15), color=color.fuchsia)
plot(timestamp("Feb 01 2020 22:10:05"))
plot(timestamp("2011-10-10T14:48:00"))
Die nächste Seite Nächste Seite
Mehr

Die BettlerWarum kann die Strategie der Quadrat-Kopie die Strategie der Pine nicht realisieren?

Die Erfinder quantifizieren - Kleine TräumeDas ist eine sehr schlechte Idee.

Die BettlerDer Optimierte Trend-Tracker von Zhang Ziyi

Die Erfinder quantifizieren - Kleine TräumeHallo, was ist die Strategie?

2019 FMZ - Alle Rechte vorbehalten