ido no pertenece a ningún grupo OCA, debe haber un carácter en blanco.Nota: FMZ no admite este parámetro. - oca_type(input string) Parámetros opcionales ❚ Tipo de grupo de órdenes OCA ❚ Valores permitidos: strategy.oca.none - el pedido no debe pertenecer a ningún grupo de OCA específico; strategy.oca.cancel - el pedido debe pertenecer al grupo OCA, una vez que el pedido es entregado, todos los demás pedidos en el mismo grupo serán cancelados; strategy.oca.reduce - el pedido debe pertenecer al grupo OCA, si se ha colocado un número X de contratos de pedidos, el número de otros contratos de pedidos en el mismo grupo OCA disminuye X ❚Nota: FMZ no admite este parámetro. - comment(series string) Parámetros opcionales。 Otras instrucciones del pedido。 - when(series bool) Parámetros opcionales。 el estado del pedido。 si es “true”, el pedido se coloca。 si es “false”, no ocurre nada ((el pedido con el mismo ID colocado anteriormente no se revocó)。 el valor predeterminado es “true”。 - alert_message(series string) Un parámetro opcional cuando se utiliza el símbolo {{strategy.order.alert_message}} en el campo de la barra de mensajes de la barra de mensajes de la barra de diálogo de creación de la barra de alarmas.

strategy.close

Se trata de una orden de salida con un ID designado. Si hay varias órdenes de entrada con el mismo ID, todas se retirarán al mismo tiempo. Si no hay una orden de apertura con un ID designado al activar la orden, la orden no tendrá efecto.

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

Ejemplo

strategy("closeEntry Demo", overlay=false)
strategy.entry("buy", strategy.long, when = open > close)
strategy.close("buy", when = open < close, qty_percent = 50, comment = "close buy entry for 50%")
plot(strategy.position_size)

parámetro

• id(series string) Parámetros requeridos。 Identificador del pedido。 Se puede cerrar el pedido haciendo referencia a su identificación。
• when(series bool) Parámetros seleccionables ◦ Condiciones del comando ◦
• qty(series int/float) Parámetros seleccionables. Número de contratos/acciones/horas/unidades de salida de la operación. El valor predeterminado es ‘NaN’
• qty_percent(series int/float) define el porcentaje de posición en la línea de paridad entre ((0-100) ◦ que tiene una prioridad inferior a la prioridad del parámetro ‘qty’ ◦ opcional ◦ el valor por defecto es 100 ◦
• comment(series string) Parámetros opcionales。 Otras instrucciones del pedido。
• alert_message(series string) Un parámetro opcional cuando se utiliza el símbolo {{strategy.order.alert_message}} en el campo de la barra de mensajes de la barra de mensajes de la barra de diálogo de creación de la barra de alarmas.

strategy.close_all

La salida de la posición actual del mercado para mantenerla estable.

strategy.close_all(when, comment, alert_message) 

Ejemplo

strategy("closeAll Demo", overlay=false)
strategy.entry("buy", strategy.long, when = open > close)
strategy.close_all(when = open < close, comment = "close all entries")
plot(strategy.position_size)

parámetro

• when(series bool) Parámetros seleccionables ◦ Condiciones del comando ◦
• comment(series string) Parámetros opcionales。 Otras instrucciones del pedido。
• alert_message(series string) Un parámetro opcional cuando se utiliza el símbolo {{strategy.order.alert_message}} en el campo de la barra de mensajes de la barra de mensajes de la barra de diálogo de creación de la barra de alarmas.

strategy.exit

Esta es una orden de salida de una posición de entrada o de todo el mercado. Si una orden de entrada con el mismo ID ya está en suspenso, puede modificarse. Si una orden de entrada no se negocia, pero aparece una orden de salida, la orden de salida se mantendrá en suspenso hasta que la orden de salida pueda ser colocada por la parte posterior a la orden de entrada. Para suspender una orden de salida, se debe usar la orden estrategia. cancelar o estrategia. cancelar_todo. Si la función estrategia.exit se invoca una vez, solo se retirará una vez.

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

Ejemplo

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"

parámetro

• id(series string) Parámetros requeridos。 Identificador de pedido。 Se puede cancelar o modificar un pedido haciendo referencia a su identificación。
• from_entry(series string) Parámetros opcionales ❚ Exit para especificar el identificador de instrucciones de entrada ❚ Exit para todas las posiciones, debe utilizar una cadena en blanco ❚ El valor predeterminado es una cadena en blanco ❚
• qty(series int/float) Parámetros seleccionables. Número de contratos/acciones/horas/unidades de salida de la operación. El valor predeterminado es ‘NaN’
• qty_percent(series int/float) define el porcentaje de posición en la línea de paridad entre ((0-100) ◦ que tiene una prioridad inferior a la prioridad del parámetro ‘qty’ ◦ opcional ◦ el valor por defecto es 100 ◦
• profit(series int/float) Parámetros opcionales ◦ Objetivo de ganancias (indicado en puntos) ◦ Si se ha especificado, salga de la posición en el mercado con una orden de precio límite cuando se alcance el monto de ganancias especificado (en puntos) ◦ El valor predeterminado es NaN
• limit(series int/float) Parámetros opcionales. Objetivo de ganancias (se requiere especificar el precio). Si se ha especificado, se retira de la posición del mercado con el precio especificado (o mejor). El parámetro ‘limit’ tiene prioridad superior a la prioridad del parámetro ‘profit’ (si el valor no es ‘NaN’, entonces ‘limit’ reemplaza ‘profit’).
• loss(series int/float) parámetros opcionales Stop loss (indicado en puntos) Si se ha especificado, cuando se alcanza el monto de pérdidas especificado (puntos), se retira de la posición de mercado con una sola parada de pérdidas El valor predeterminado es NaN
• stop(series int/float) parámetros opcionales ≠ stop loss (precisa precio) ≠ si se ha especificado, se saldrá de la posición en el mercado al precio especificado (o peor) ≠ si el parámetro ‘stop loss’ tiene prioridad superior a la del parámetro ‘loss’ (si el valor no es ‘NaN’, entonces ‘stop loss’ sustituye a ‘loss’) ≠ el valor predeterminado es NaN
• trail_price(series int/float) Parámetros opcionales ◦ seguimiento del nivel de activación del stop loss ◦ precio especificado ◦ si se especifica, se colocará el stop loss de seguimiento cuando se alcance el nivel de precio especificado ◦ desviación especificada en el parámetro de la barra trail_offset para determinar el precio inicial del stop loss de seguimiento ◦ en puntos: X puntos por debajo del nivel de activación para salir de la multitud; X puntos por encima del nivel de activación para salir de la nada ◦ el valor predeterminado es ◦ NaN ◦
• trail_points(series int/float) Parámetros opcionales ❚ seguimiento del nivel de activación de la parada de pérdidas ◦ ganancias expresadas en puntos ◦ si se especifica, se colocará una orden de parada de seguimiento cuando se alcance el nivel de precio calculado ◦ cantidad de ganancias especificadas ◦ desviación especificada en el parámetro de la barra de trail_offset para determinar el movimiento del precio inicial de la barra de pérdidas ◦ en puntos: X puntos por debajo del nivel de activación para salir de la multitud; X puntos por encima del nivel de activación para salir de la nube ◦ el valor predeterminado es NaN
• trail_offset(series int/float) parámetros opcionales ❚ seguimiento de nivel de activación de stop loss (… en puntos) ❚ desviación en puntos utilizada para determinar el precio inicial de seguimiento de stop loss: X puntos por debajo de ‘trail_price’ o ‘trail_points’ para salir de la multitud; X puntos por encima de ‘trail_price’ o ‘trail_points’ para salir de la caída ❚ el valor predeterminado es NaN。
• oca_name(series string) Parámetros opcionales. Nombre del grupo OCA (oca_type = strategy.oca.reduce) Objetivo de ganancias, stop loss / tracking stop loss. Si no se especifica el nombre, se generará automáticamente.Nota: FMZ no admite este parámetro.
• comment(series string) Parámetros opcionales。 Otras instrucciones del pedido。
• when(series bool) Parámetros opcionales。 el estado del pedido。 si es “true”, el pedido se coloca。 si es “false”, no ocurre nada ((el pedido con el mismo ID colocado anteriormente no se revocó)。 el valor predeterminado es “true”。
• alert_message(series string) Un parámetro opcional cuando se utiliza el símbolo {{strategy.order.alert_message}} en el campo de la barra de mensajes de la barra de mensajes de la barra de diálogo de creación de la barra de alarmas.

strategy.cancel

Se trata de un comando que utiliza el nombre para cancelar/desactivar todas las listas de preinstalación, generado por las siguientes funciones: strategy.order, strategy.entry y strategy.exit。

strategy.cancel(id, when) 

Ejemplo

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

parámetro

• id(series string) Parámetros obligatorios。 identificación de la orden。 ubicación de la identificación para revocar una orden。
• when(series bool) Parámetros opcionales. Cancelar una orden según el ID. Si es “true”, la orden será cancelada. El valor predeterminado es “true”.

strategy.cancel_all

Se trata de cancelar/desactivar todos los comandos de la lista de preinstalación, generados por las siguientes funciones: strategy.order, strategy.entry y strategy.exit.

strategy.cancel_all(when) 

Ejemplo

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

parámetro

• when(series bool) Parámetros opcionales ◦ cancelar todas las órdenes de condiciones ◦ cancelar todas las órdenes de actividad si la condición es verdadera ◦ el valor por defecto es true

strategy.order

Esta es la orden de la siguiente orden. Si una orden con el mismo ID ya está pendiente, se puede modificar la orden. Si no hay una orden con el ID especificado, se emitirá una nueva orden. Para detener la orden, se debe usar la orden strategy.cancel o strategy.cancel_all. En comparación con la función strategy.entry, la función strategy.order no se ve afectada por la forma de la pirámide.

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

Ejemplo

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

parámetro

• id(series string) Parámetros requeridos。 Identificador de pedido。 Se puede cancelar o modificar un pedido haciendo referencia a su identificación。
• direction(strategy_direction) Un parámetro necesario. Dirección de la orden: ‘strategy.long’ para comprar, ‘strategy.short’ para vender
• qty(series int/float) Parámetros seleccionables  Número de contratos/acciones/horas/unidades negociadas  Valor predeterminado ‘NaN’ 
• limit(series int/float) Parámetros opcionales. El precio límite de la orden. Si se especifica, el tipo de orden es “limit” o “stop-limit”. Otros tipos de orden son “NaN”.
• stop(series int/float) Parámetros opcionales. El precio de parada de la orden. Si se ha especificado, el tipo de orden es “stop” o “stop-limit”. Otros tipos de orden son “NaN”.
• oca_name(series string) Parámetros opcionales. El pedido pertenece al nombre del grupo OCA. Si el pedido no pertenece a ningún grupo OCA, debe haber un carácter en blanco.Nota: FMZ no admite este parámetro.
• oca_type(input string) Parámetros opcionales ❚ Tipo de grupo de órdenes OCA ❚ Valores permitidos: strategy.oca.none - el pedido no debe pertenecer a ningún grupo de OCA específico; strategy.oca.cancel - el pedido debe pertenecer al grupo OCA, una vez que el pedido es entregado, todos los demás pedidos en el mismo grupo serán cancelados; strategy.oca.reduce - el pedido debe pertenecer al grupo OCA, si se ha colocado un número X de contratos de pedidos, el número de otros contratos de pedidos en el mismo grupo OCA disminuye X ❚Nota: FMZ no admite este parámetro.
• comment(series string) Parámetros opcionales。 Otras instrucciones del pedido。
• when(series bool) Parámetros opcionales。 el estado del pedido。 si es “true”, el pedido se coloca。 si es “false”, no ocurre nada ((el pedido con el mismo ID colocado anteriormente no se revocó)。 el valor predeterminado es “true”。
• alert_message(series string) Un parámetro opcional cuando se utiliza el símbolo {{strategy.order.alert_message}} en el campo de la barra de mensajes de la barra de mensajes de la barra de diálogo de creación de la barra de alarmas.

strategy.opentrades.entry_bar_index

Regresa el bar_index de la entrada en una posición no equilibrada.

strategy.opentrades.entry_bar_index(trade_num)

Esperar 10 líneas K y cerrar la posición.

Ejemplo

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

parámetro

• trade_num(series int) Número de transacción de la operación sin liquidar 。 Número de la primera operación es cero 。

Véase también strategy.closedtrades.entry_bar_index strategy.closedtrades.exit_bar_index

strategy.opentrades.entry_id

ID de la entrada que regresa a la operación sin liquidar.

strategy.opentrades.entry_id(trade_num)

Ejemplo

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

Devuelve el valor ID de la entrada que regresa a la operación sin liquidar.

parámetro

• trade_num(series int) Número de transacción de la operación sin liquidar 。 Número de la primera operación es cero 。

Las notas Si trade_num no está dentro del rango, la función devuelve na:0 a strategy.opentrades-1。

Véase también strategy.opentrades.entry_bar_index strategy.opentrades.entry_time

strategy.opentrades.entry_price

El precio de entrada de las operaciones de devolución de posiciones no liquidadas.

strategy.opentrades.entry_price(trade_num)

Ejemplo

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

Cálculo del precio promedio de las posiciones sin liquidar

Ejemplo

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

parámetro

• trade_num(series int) Número de transacción de la operación sin liquidar 。 Número de la primera operación es cero 。

Véase también strategy.closedtrades.exit_price

strategy.opentrades.entry_time

Regresar a la hora UNIX de entrada en una operación sin liquidar.

strategy.opentrades.entry_time(trade_num)

Ejemplo

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

parámetro

• trade_num(series int) Número de transacción de la operación sin liquidar 。 Número de la primera operación es cero 。

Véase también strategy.closedtrades.entry_time strategy.closedtrades.exit_time

strategy.opentrades.profit

Las pérdidas que se devuelven a las operaciones sin liquidar. Las pérdidas se expresan como negativas.

strategy.opentrades.profit(trade_num)

Regreso a las ganancias de la última posición abierta

Ejemplo

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

Cálculo de las ganancias de todas las operaciones no liquidadas

Ejemplo

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

parámetro

• trade_num(series int) Número de transacción de la operación sin liquidar 。 Número de la primera operación es cero 。

Véase también strategy.closedtrades.profit strategy.openprofit strategy.netprofit strategy.grossprofit

strategy.opentrades.size

Devuelve la dirección de la operación y el número de contratos en la operación de posición no liquidada. Si este valor es > 0, la posición de mercado es de más cabeza. Si este valor es < 0, la posición de mercado es de cabeza vacía.

strategy.opentrades.size(trade_num)

Ejemplo

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

Cálculo del porcentaje de ganancias promedio de las operaciones sin liquidar

Ejemplo

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)

parámetro

• trade_num(series int) Número de transacción de la operación sin liquidar 。 Número de la primera operación es cero 。

Véase también strategy.closedtrades.size strategy.position_size strategy.opentrades strategy.closedtrades

strategy.closedtrades.entry_bar_index

Regresa el bar_index de la entrada en una operación que se ha liquidado.

strategy.closedtrades.entry_bar_index(trade_num)

Ejemplo

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

parámetro

• trade_num(series int) Número de transacción de la operación que se ha liquidado. El número de la primera transacción es cero.

Véase también strategy.closedtrades.exit_bar_index strategy.opentrades.entry_bar_index

strategy.closedtrades.exit_price

Regresar al precio de salida de una operación que se haya liquidado.

strategy.closedtrades.exit_price(trade_num)

Ejemplo

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

Calcula el porcentaje de ganancias promedio de todas las transacciones liquidadas

Ejemplo

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)

parámetro

• trade_num(series int) Número de transacción de la operación que se ha liquidado. El número de la primera transacción es cero.

Véase también strategy.closedtrades.entry_price

strategy.closedtrades.exit_bar_index

Regresa el bar_index de la salida de la operación que ha sido liquidada.

strategy.closedtrades.exit_bar_index(trade_num)

Ejemplo

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

Calcula el número promedio de líneas K por transacción.

Ejemplo

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

parámetro

• trade_num(series int) Número de transacción de la operación que se ha liquidado. El número de la primera transacción es cero.

Véase también bar_index

strategy.closedtrades.entry_id

El id de la entrada que devuelve la operación que ha sido liquidada.

strategy.closedtrades.entry_id(trade_num)

Ejemplo

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

Devuelve el valor El id de la entrada que devuelve la operación que ha sido liquidada.

parámetro

• trade_num(series int) Número de transacción de la operación que se ha liquidado. El número de la primera transacción es cero.

Las notas Si trade_num no está en el rango, la función devuelve na:0 a strategy.closedtrades-1。

Véase también strategy.closedtrades.entry_bar_index strategy.closedtrades.entry_time

strategy.closedtrades.entry_price

El precio de entrada de las operaciones que han sido liquidadas.

strategy.closedtrades.entry_price(trade_num)

Ejemplo

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

Calcula el porcentaje de ganancias promedio de todas las transacciones liquidadas

Ejemplo

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)

parámetro

• trade_num(series int) Número de transacción de la operación que se ha liquidado. El número de la primera transacción es cero.

Véase también strategy.closedtrades.exit_price strategy.closedtrades.size strategy.closedtrades

strategy.closedtrades.entry_time

Regresar a la hora de entrada de UNIX en el que se ha liquidado la posición.

strategy.closedtrades.entry_time(trade_num)

Ejemplo

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

parámetro

• trade_num(series int) Número de transacción de la operación que se ha liquidado. El número de la primera transacción es cero.

Véase también strategy.opentrades.entry_time strategy.closedtrades.exit_time time

strategy.closedtrades.profit

Las pérdidas que se devuelven a las operaciones que se han liquidado. Las pérdidas se expresan como negativas.

strategy.closedtrades.profit(trade_num)

Ejemplo

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

parámetro

• trade_num(series int) Número de transacción de la operación que se ha liquidado. El número de la primera transacción es cero.

Véase también strategy.opentrades.profit strategy.closedtrades.commission

strategy.closedtrades.size

Devuelve la dirección de la operación y el número de contratos en la operación que se ha liquidado. Si este valor es > 0, la posición de mercado es de más cabeza. Si este valor es < 0, la posición de mercado es de cabeza vacía.

strategy.closedtrades.size(trade_num)

Ejemplo

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

Cálculo del porcentaje de ganancias promedio de las operaciones en posición cerrada

Ejemplo

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)

parámetro

• trade_num(series int) Número de transacción de la operación que se ha liquidado. El número de la primera transacción es cero.

Véase también strategy.opentrades.size strategy.position_size strategy.closedtrades strategy.opentrades

strategy.closedtrades.exit_time

Regreso a la hora UNIX de salida de la operación de liquidación.

strategy.closedtrades.exit_time(trade_num)

Ejemplo

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

Reabrir una posición cerrada después de X segundos

Ejemplo

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)

parámetro

• trade_num(series int) Número de transacción de la operación que se ha liquidado. El número de la primera transacción es cero.

Véase también strategy.closedtrades.entry_time

strategy.risk.allow_entry_in

Esta función se puede usar para especificar en qué dirección de mercado la función strategy.entry permite abrir posiciones.

strategy.risk.allow_entry_in(value)

Ejemplo

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)

parámetro

• value(simple string) Dirección permitida ≠ los valores posibles:strategy.direction.all、strategy.direction.long、strategy.direction.short

strategy.risk.max_position_size

El objetivo de esta regla es determinar el valor máximo de una posición en el mercado. La regla afecta a las siguientes funciones:strategy.entryEl número de entradas puede reducirse (si es necesario) a contratos/acciones/mano/unidad, por lo que el valor total de la posición no excede el valor indicado en ‘strategy.risk.max_position_size’. Si la cantidad mínima sigue siendo una violación de la regla, no se colocarán órdenes.

strategy.risk.max_position_size(contracts)

Ejemplo

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

parámetro

• contracts(simple int/float) Parámetros requeridos ◦ Número máximo de contratos/acciones/manos/unidades de posición ◦

math

math.abs

¿Cuál es el problema?number >= 0，numberEl valor absoluto es numberSi no es así,number。

math.abs(number) 

Devuelve el valor numberEl valor absoluto de .

math.acos

La función acos devuelve el eje inverso de la cifra ((en forma de arco), tal como cos ((acos ((y)) = y en el rango de y[-1, 1]。

math.acos(angle)

Devuelve el valor El valor de la contra-resonancia. Si y está fuera del alcance[-1,1], el ángulo de retorno está en[En el rango de 0, Pi] o na.

math.random

Devuelve un valor pseudoaleatorio. Esta función generará una secuencia de valores diferente para cada ejecución de un script. El uso del mismo valor para los parámetros de semilla elegibles generará una secuencia de valores repetible.

math.random(min, max, seed)

Devuelve el valor Un valor aleatorio.

parámetro

• min(series int/float) El límite inferior de un rango de valores aleatorios. El valor no está incluido en el rango. El valor predeterminado es 0
• max(series int/float) Limite superior de un rango de valores aleatorios. El valor no está incluido en el rango. El valor predeterminado es 1
• seed(input int) Parámetros seleccionables. Cuando se usa la misma semilla, se permite la invocación consecutiva de la función para generar un conjunto de valores repetibles.

math.asin

La función asin devuelve el antinuclear de la cifra ((en arco), sincronía ((asin ((y)) = y en el rango y[-1, 1]。

math.asin(angle) 

Devuelve el valor El valor de la antitronsonalidad. Si y está fuera del alcance[-1,1], el ángulo de retorno está en[-Pi / 2, Pi / 2] o en el rango de na.

math.atan

La función atan devuelve el recto inverso de la cifra ((expresado en arco), tan (((atan ((y)) = cualquier y de y。

math.atan(angle) 

Devuelve el valor El valor de corte inverso; el ángulo de retorno está en[-Pi / 2, en el rango de Pi / 2].

math.ceil

La función de toma de enteros hacia arriba devuelve el número entero más pequeño (el más cercano a la infinidad negativa) mayor o igual al número entero de los argumentos.

math.ceil(number)

Devuelve el valor Menos o igual al número entero más pequeño de un número dado

Véase también math.floor math.round

math.cos

La función cos retorna el ángulo de la arista del triángulo.

math.cos(angle) 

Devuelve el valor Las cuerdas triangulares de los cuernos.

parámetro

• angle(series int/float) ángulo, en arco

math.exp

numberLa función exp de e es numberEl segundo lado, donde e es el número de Euler.

math.exp(number) 

Devuelve el valor Una de las representaciones de e, que es number¿Qué es esto?

Véase también math.pow

math.floor

math.floor(number) 

Devuelve el valor Menos o igual al mayor número entero de un número dado.

Véase también math.ceil math.round

math.log

¿Cuál es el problema?numberEl logaritmo natural de > 0 es el único y que hace que e^y = number。

math.log(number)

Devuelve el valor numberEl número natural de .

Véase también math.log10

math.log10

numberEl uso común (o el de base 10) de la logaritmos es que hay que elevar el 10 para obtener el cubo.number。10^y = number。

math.log10(number)

Devuelve el valor numberEl logaritmo de base 10 de .

Véase también math.log

math.pow

Funciones de la barra de matemáticas

math.pow(base, exponent)

Ejemplo

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

Devuelve el valor baseSe elevó aexponent¿Cuál es el problema?baseEs una serie que se calcula por elementos.

parámetro

• base(series int/float) Especifica la base que se quiere usar.
• exponent(series int/float) Especifica el índice.

Véase también math.sqrt math.exp

math.sign

Si el número de pilas es cero, el símbolo (signum) del número de pilas es cero, si el número de pilas es mayor que 0, es 1.0, si el número de pilas es menor que 0, es -1.0。

math.sign(number)

Devuelve el valor El símbolo de los parámetros.

math.sin

La función cosine devuelve la cosine de un ángulo del triángulo.

math.sin(angle)

Devuelve el valor La síntesis triangular de los ángulos.

parámetro

• angle(series int/float) ángulo, en arco

math.sqrt

Cualquiera.numberLa raíz cuadrada de >=0 es la única vez que y >=0 hace que y al cuadrado sea igual a y.number。

math.sqrt(number)

Devuelve el valor numberLa raíz cuadrada de

Véase también math.pow

math.tan

El triángulo cuyo ángulo de retorno es tan es el diagonal.

math.tan(angle)

Devuelve el valor El triángulo de las esquinas es rectangular.

parámetro

• angle(series int/float) ángulo, en arco

math.round

El regreso.numberSi se utiliza el número de enteros, se recorta hasta el número entero más cercano y se completa hacia arriba.precisionEl parámetro, a su vez, devuelve un cuadriculado de cinco dígitos en el punto flotante.

math.round(number) 

math.round(number, precision) 

Devuelve el valor numberLos valores de los cuadrados de cinco en el número entero más cercano, o según la precisión.

parámetro

• number(series int/float) Se debe rodear el valor de la línea de flotación.
• precision(series int) Es opcional.numberLos dígitos pequeños que se cuadraran. Cuando no se proporcionan los parámetros, se cuadraran al número entero más cercano.

Las notas Tenga en cuenta que para el valor ‘na’, la función devuelve ‘na’ .

Véase también math.ceil math.floor

math.max

Devuelve el mayor de varios valores.

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

Ejemplo

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

Devuelve el valor El mayor de varios valores dados.

Véase también math.min

math.min

Devuelve el menor de varios valores.

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

Ejemplo

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

Devuelve el valor El valor más pequeño entre varios valores dados.

Véase también math.max

math.avg

Calcula el promedio de todas las series ((elementos correspondientes)

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

Devuelve el valor El promedio

Véase también math.sum ta.cum ta.sma

math.round_to_mintick

Devuelve el valor de mintick cuadrados en el producto, es decir, se puede dividir por el valor más cercano de syminfo.mintick, sin restes, y redondear hacia arriba.

math.round_to_mintick(number) 

Devuelve el valor numberEl juego se ha hecho de cuatro cuartos y cinco entradas para llegar a tick.

parámetro

• number(series int/float) Se debe rodear el valor de la línea de flotación.

Véase también math.ceil math.floor

math.sum

La función sum devuelve el resumen deslizante de la última y de x.

math.sum(source, length)

Devuelve el valor lengthLa línea K regresó.sourceResumen:

parámetro

• source(series int/float) Valor de la serie a ejecutar
• length(series int) K número de líneas (la longitud).

Véase también ta.cum for

math.todegrees

Desde el ángulo en unidades de arco, regresa el ángulo equivalente aproximado en unidades de grado.

math.todegrees(radians) 

Devuelve el valor Se mide en unidades de ángulo.

parámetro

• radians(series int/float) el ángulo en unidades de arco.

math.toradians

Desde el ángulo en unidades de medida, regresa el ángulo de aproximación equivalente en unidades de arco.

math.toradians(degrees) 

Devuelve el valor El ángulo en unidades de arco.

parámetro

• degrees(series int/float) es el ángulo medido en unidades de medida.

others

fixnan

Para la serie dada, sustituye el valor NaN por el valor no NaN anterior.

fixnan(source) 

Devuelve el valor Una serie sin interrupciones.

parámetro

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

Véase también na nz

nz

Sustituya el valor NaN por cero (o número especificado) en la serie.

nz(source, replacement) 

nz(source)

Ejemplo

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

Devuelve el valor sourceEl valor de si no esnaSi es así.sourceEl valor denaSi se utiliza 1, se devuelve 0.replacementParámetros

parámetro

• source(series int/float/bool/color) Valor de la serie a ejecutar
• replacement(series int/float/bool/color) sustituye el valor de todos los valores de la barra de la fuente de la barra.

Véase también na fixnan

na

Si es NaN, entonces el valor de prueba es .

na(x)

Devuelve el valor Si x no es un número válido, entonces es verdadero (x es NaN), y si no es cierto, es falso.

Véase también fixnan nz

int

Convierta na o corte el valor de float por int。

int(x) 

Devuelve el valor Convierte el valor de los parámetros después de int.

Véase también float bool color string

float

Si el valor de na es variable, entonces el valor de na es variable.

float(x) 

Devuelve el valor Convierte el valor del parámetro en float

Véase también int bool color string

alert

Trigger alertas de eventos cuando se llaman durante la línea K en tiempo real, y anteriormente se crearon alertas basadas en eventos de la función de alerta como indicadores o estrategias mediante el cuadro de diálogo Crear cuadro de alertas.

alert(message, freq)

Ejemplo

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

parámetro

• message(series string) El mensaje que se envía cuando se activa la alarma.
• freq(input string) Trigger frequency。 los valores posibles son: alert.freq_all (todas las funciones se llaman para activar la alerta), alert.freq_once_per_bar (la primera función en la línea K se llama para activar la alerta), alert.freq_once_per_bar_close (la función se llama sólo durante la última secuencia de comandos de la línea K en tiempo real y se activa la alerta al cerrar) el valor predeterminado es alert.freq_once_per_bar。

Las notas El Centro de ayuda explica cómo crear una alerta de este tipo. En contraste con alertcondition, la llamada alert no se considera como un dibujo adicional. Las llamadas de funciones pueden ser tanto globales como locales. Las llamadas a funciones no muestran nada en el gráfico. El parámetro freq solo afecta la frecuencia de activación en la que se utiliza esta función.

Véase también alertcondition

alertcondition

Creación de condiciones de alerta, en el cuadro de diálogo Creación de alertas. Tenga en cuenta que alertcondition no crea alertas, sólo le da más opciones en el cuadro de diálogo Creación de alertas. Además, el efecto alertcondition no se ve en el gráfico.

alertcondition(condition, title, message)

Ejemplo

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

parámetro

• condition(series bool) Es el valor de una serie de boole para una alerta. El valor de True representa el disparo de la alerta, y el de False, no hay alerta.
• title(const string) Título de la condición de la alerta. Parámetros opcionales.
• message(const string) Mostrar el mensaje cuando se activa la alarma.

Las notas Tenga en cuenta que en Pine v4 la invocación de la condición de alerta genera un gráfico adicional. Todas estas invocaciones se tienen en cuenta cuando se calcula el número de series de salida de cada script.

Véase también alert

indicator

Para la compatibilidad.Trading ViewEl código de la estrategia, que en realidad no necesita ser invocado.

Véase también strategy

time

La función time devuelve la hora de UNIX de la línea K actual de un rango de tiempo especificado y el momento de la transacción, y devuelve NaN si el punto de tiempo no está en el momento de la transacción. Nota: No es compatible con FMZsessionParámetros

time(timeframe, session, timezone)

time(timeframe, session)

time(timeframe)

Ejemplo

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

Al configurar una sesión, puede especificar no solo la hora y el minuto, sino también el dí