优宽 PINE Script 文档

`` array.variance array.min

array.percentile_linear_interpolation

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

array.percentile_linear_interpolation(id, percentage) 

参数

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

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

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

array.percentile_nearest_rank

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

array.percentile_nearest_rank(id, percentage) 

参数

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

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

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

array.percentrank

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

array.percentrank(id, index) 

参数

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

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

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

array.range

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

array.range(id) 

例子

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

返回值 数组中最小值和最大值之间的差。

参数

• id (int[]/float[]) 阵列对象。

另见 array.new_float array.min array.max array.sum

array.remove

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

array.remove(id, index)

例子

// array.remove example
a = array.new_float(5,high)
removedEl = array.remove(a, 0)
plot(array.size(a))
plot(removedEl)

返回值 被删除元素的值。

参数

• id (any array type) 阵列对象。
• index (series int) 要删除的元素索引。

另见 array.new_float array.set array.push array.insert array.pop array.shift

array.reverse

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

array.reverse(id)

例子

// array.reverse example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i])
plot(array.get(a, 0))
array.reverse(a)
plot(array.get(a, 0))

参数

• id (any array type) 阵列对象。

另见 array.new_float array.sort array.push array.set array.avg

array.from

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

array.from(arg0, arg1, ...)

例子

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

返回值 阵列元素的值。

参数

• arg0, arg1, ... (series int/float/bool/color/string/line/linefill) 数组参数。

array.new

该函数创建一个新的<type>元素数组对象。

array.new(size, initial_value)

例子

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

例子

// array.new<color> example
a = array.new<color>()
array.push(a, color.red)
array.push(a, color.green)
plot(close, color = array.get(a, close > open ? 1 : 0))

例子

// array.new<float> example
length = 5
var a = array.new<float>(length, close)
if array.size(a) == length
    array.remove(a, 0)
    array.push(a, close)
plot(array.sum(a) / length, "SMA")

例子

// array.new<line> example
// draw last 15 lines
var a = array.new<line>()
array.push(a, line.new(bar_index - 1, close[1], bar_index, close))
if array.size(a) > 15
    ln = array.shift(a)
    line.delete(ln)

返回值 可与其他阵列一起使用的阵列对象的ID。*（）函数。

参数

• size (series int) 序列的初始大小。可选。默认值为0。
• initial_value (series <type>) 所有序列元素的初始值。可选。默认值为“na”。

备注 阵列索引从0开始。 如果要初始化一个阵列并同时指定其所有元素，请使用函数array.from。

另见 array.from array.push array.get array.size array.remove array.shift array.sum

array.new_bool

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

array.new_bool(size, initial_value)

例子

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

返回值 可与其他阵列一起使用的阵列对象的ID。*（）函数。

参数

• size (series int) 序列的初始大小。可选。默认值为0。
• initial_value (series bool) 所有序列元素的初始值。可选。默认值为“na”。

备注 阵列索引从0开始。

另见 array.new_float array.get array.slice array.sort

array.new_float

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

array.new_float(size, initial_value)

例子

// array.new_float example
length = 5
a = array.new_float(length, close)
plot(array.sum(a) / length)

返回值 可与其他阵列一起使用的阵列对象的ID。*（）函数。

参数

• size (series int) 序列的初始大小。可选。默认值为0。
• initial_value (series int/float) 所有序列元素的初始值。可选。默认值为“na”。

备注 阵列索引从0开始。

另见 array.new_bool array.get array.slice array.sort

array.new_int

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

array.new_int(size, initial_value)

例子

// array.new_int example
length = 5
a = array.new_int(length, int(close))
plot(array.sum(a) / length)

返回值 可与其他阵列一起使用的阵列对象的ID。*（）函数。

参数

• size (series int) 序列的初始大小。可选。默认值为0。
• initial_value (series int) 所有序列元素的初始值。可选。默认值为“na”。

备注 阵列索引从0开始。

另见 array.new_float array.get array.slice array.sort

array.new_string

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

array.new_string(size, initial_value)

例子

// array.new_string example
length = 5
a = array.new_string(length, "text")
runtime.log(array.get(a, 0))

返回值 可与其他阵列一起使用的阵列对象的ID。*（）函数。

参数

• size (series int) 序列的初始大小。可选。默认值为0。
• initial_value (series string) 所有序列元素的初始值。可选。默认值为“na”。

备注 阵列索引从0开始。

另见 array.new_float array.get array.slice

array.get

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

array.get(id, index)

例子

// array.get example
a = array.new_float(0)
for i = 0 to 9
    array.push(a, close[i] - open[i])
plot(array.get(a, 9))

返回值 阵列元素的值。

参数

• id (any array type) 阵列对象。
• index (series int) 要返回其值的元素的索引。

另见 array.new_float array.set array.slice array.sort

array.push

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

array.push(id, value)

例子

// array.push example
a = array.new_float(5, 0)
array.push(a, open)
plot(array.get(a, 5))

参数

• id (any array type) 阵列对象。
• value (series <type of the array's elements>) 添加到阵列末尾的元素值。

另见 array.new_float array.set array.insert array.remove array.pop array.unshift

array.set

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

array.set(id, index, value) 

例子

// array.set example
a = array.new_float(10)
for i = 0 to 9
    array.set(a, i, close[i])
plot(array.sum(a) / 10)

参数

• id (any array type) 阵列对象。
• index (series int) 要修改元素的索引。
• value (series <type of the array's elements>) 要设置的新值。

另见 array.new_float array.get array.slice

array.sum

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

array.sum(id) 

例子

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

返回值 阵列元素的总和。

参数

• id (int[]/float[]) 阵列对象。

另见 array.new_float array.max array.min

array.avg

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

array.avg(id)

例子

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

返回值 阵列元素的均值。

参数

• id (int[]/float[]) 阵列对象。

另见 array.new_float array.max array.min array.stdev

array.indexof

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

array.indexof(id, value)

例子

// array.indexof example
a = array.new_float(5,high)
index = array.indexof(a, high)
plot(index)

返回值 元素的索引。

参数

• id (any array type) 阵列对象。
• value (series <type of the array's elements>) 要在阵列中搜索的值。

另见 array.lastindexof array.get array.lastindexof array.remove array.insert

strategy

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

strategy

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

strategy(title, shorttitle, overlay, format, precision, scale, pyramiding, calc_on_order_fills, calc_on_every_tick, max_bars_back, backtest_fill_limits_assumption, default_qty_type, default_qty_value, initial_capital, currency, slippage, commission_type, commission_value, process_orders_on_close, close_entries_rule, margin_long, margin_short, explicit_plot_zorder, max_lines_count, max_labels_count, max_boxes_count, risk_free_rate) 

例子

strategy("Strategy", overlay = true)

// Enter long by market if current open is greater than previous high.
strategy.entry("Long", strategy.long, 1, when = open > high[1])
// Generate a full exit bracket (profit 10 points, loss 5 points per contract) from the entry named "Long".
strategy.exit("Exit", "Long", profit = 10, loss = 5)

参数

• title (const string) 将在指标/策略插件中看到的指标标题。参数是必需的。
• shorttitle (const string) 将在图表图例中看到的指标短标题。参数是可选的。
• overlay (const bool) 如果为true，则该指标将被添加为主要系列的叠加层。如果为false - 它将被添加到单独的图表窗格中。默认为false。
• format (const string) 价格轴上格式化指标值的类型可能的值为：format.inherit、format.price、format.volume。默认为format.inherit。
• precision (const int) 价格轴上指标值的浮点数后的位数。必须是非负整数且不大于16。如果省略，则使用父系列的格式。如果format为format.inherit并且设置了此参数，则format变为format.price。
• scale (scale_type) 指标应跟随价格坐标。可能的值为：scale.right，scale.left,scale.none。值scale.none只能只能与’overlay=true’设置结合使用。
• pyramiding (const int) 同一方向允许的最大数量。如果该值为0，则只能打开同一方向的一个入场订单，任何其他入场订单将被拒绝。默认值为0。
• calc_on_order_fills (const bool) 额外的intrabar订单计算。如果参数被设置为“true”，那么一旦K线内在订单后填满，策略就会重新计算(不仅仅在关闭k线之时)。默认值为“false”。
• calc_on_every_tick (const bool) 额外的intrabar策略计算。如果参数为“true”，策略将实时计算每个刻度，而不关闭k线。该参数不影响历史数据的策略计算。默认值为“false”。
• max_bars_back (const int) 可用于历史参考策略的最大蜡烛数。 如果在脚本代码中引用了变量的历史数据（使用了’[]'运算符），则此参数将应用于脚本中的每个内置变量或用户变量。 Pine脚本中的可变缓冲区大小通常是自动检测的。 然而，在某些情况下这是不可能的，这就是参数允许用户手动设置该值的下限的原因。 注意：使用max_bars_back函数而不是参数是最佳的，因为它仅适用于一个变量。
• backtest_fill_limits_assumption (const int) 限价单执行假设。只有当市价超过限价单水平指定的tick数时，限价单才会在intrabar成交。
• default_qty_type (const string) 确定用于 qty 参数的值在strategy.entry或strategy.order函数中表示的内容。可能的值是：strategy.fixed表示合约/股票/手数，strategy.cash表示货币金额，或strategy.percent_of_equity表示可用权益的百分比。
• default_qty_value (const int/float) strategy.entry或strategy.order函数的默认交易数量，当它们的 ‘qty’ 参数未定义时，其单位由与 ‘default_qty_type’ 参数一起使用的参数确定。
• currency (const string) 此策略的帐户货币。可选。默认值是图表上商品的货币。可能的值： currency.NONE, currency.USD, currency.EUR, currency.AUD, currency.GBP, currency.NZD, currency.CAD, currency.CHF, currency.HKD, currency.JPY, currency.NOK, currency.SEK, currency.SGD, currency.TRY, currency.ZAR, currency.BTC, currency.ETH, currency.MYR, currency.KRW。
• slippage (const int) 以tick为报价单位的滑点，会从买/卖市价单或止损单的成交价格中增加/减去。如果mintick = 0.01并且滑点= 5，则总滑点将为5 * 0.01 = 0.05。
• commission_type (const string) 每个订单的佣金类型。 允许的值为：strategy.commission.percent(订单现金量的百分比)，strategy.commission.cash_per_contract(以每份合约的账户货币显示金额)，strategy.commission.cash_per_order (按每个订单的账户货币显示金额)。
• commission_value (const int/float) 订单佣金值。取决于所选择的类型 (佣金类型)包括百分比或金额。
• process_orders_on_close (const bool) 设置为“true”时，会在蜡烛图收盘并完成策略计算后生成执行订单的其他尝试。 如果订单是市价订单，则经纪商模拟器会在下一个蜡烛图开盘前执行它们。 如果订单是限价单，则只有在满足价格条件时才会执行订单。 如果要关闭当前蜡烛图的仓位，此选项很有用。 默认值为“false”。
• close_entries_rule (const string) 确定订单关闭的顺序。允许的值为：‘FIFO’ 或 ‘ANY’。FIFO（先入先出；First-In, First-Out）意味着当多个交易开放时，必须先关闭最早的交易。此规则适用于股票、期货和美国外汇（NFA合规规则2-43b）。 ‘ANY’ 意味着交易可以任何顺序关闭；这在非美国外汇交易中是允许的。默认值为 ‘FIFO’。
• max_lines_count (const int) 显示最近的线条图数量。默认值为50，最大允许值为500。
• max_labels_count (const int) 显示最近的标签图数量。默认值为50，最大允许值为500。
• max_boxes_count (const int) 显示的最后box绘图的数量。默认值为50，允许的最大值为500。
• margin_long (const int/float) 多头保证金是多头仓位必须以现金或抵押品覆盖的证券购买价格的百分比。必须是非负数。可选。默认值为100。
• margin_short (const int/float) 空头保证金是空头仓位必须以现金或抵押品覆盖的证券购买价格的百分比。必须是非负数。可选。默认值为100。
• explicit_plot_zorder (const bool) 指定指标的绘图、填充和水平线的呈现顺序。如果为true，将根据它们在指标代码中出现的顺序绘制图表，每个较新的图表都绘制在之前的图表之上。这仅适用于plot*()函数、fill和hline。可选。默认值为‘false’。
• initial_capital (const int/float) 最初可用于策略交易的资金量，以“货币”中定义的货币表示。可选。默认值为1000000。
• risk_free_rate (const int/float) 无风险收益率是风险最小或为零的投资价值的年度百分比变化，用于计算 Sharpe和Sortino比率。默认值为2。

备注 每个策略脚本必须有一个 strategy 调用。 使用参数calc_on_every_tick = true的PineScript代码可以对历史记录和实时数据进行不同的计算。 当使用非标准类型的图表作为策略基础时，你需要知道结果会有所不同。订单将在该表的价格执行（e.g.for Heikin Ashi将使用Heikin Ashi的价格（平均的）不是真正的市场价格）。因此，我们强烈建议您在您的策略中使用标准图表类型。

另见 indicator

strategy.entry

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

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

例子

strategy(title = "simple strategy entry example")
strategy.entry("enter long", strategy.long, 1, when = open > high[1]) // enter long by market if current open great then previous high
strategy.entry("enter short", strategy.short, 1, when = open < low[1]) // enter short by market if current open less then previous low

参数

• id (series string) 必要参数。 订单标识符。 可以通过引用其标识来取消或修改订单。
• direction (strategy_direction) 一个必需的参数。市场持仓方向：'strategy.long’为多头，'strategy.short’为空头。
• qty (series int/float) 可选参数。交易的合约/股数/手数/单位数量。预设值为’NaN’。
• limit (series int/float) 可选参数。订单的限价。若已指定，订单类型是"limit" 或"stop-limit"。其他订单类型为"NaN"。
• stop (series int/float) 可选参数。订单的止损价。如果已指定，订单类型为"stop"或"stop-limit"。其他订单类型则为"NaN"。
• oca_name (series string) 可选参数。 该订单属于OCA集团名。 如果订单不属于任何OCA集团，则应该有一个空字符。注意：优宽不支持此参数。
• oca_type (input string) 可选参数。 OCA订单组类型。 允许的值为：strategy.oca.none - 订单不应属于任何特定OCA组; strategy.oca.cancel - 订单应属于OCA组，一旦订单被成交，同一组的所有其他订单将被取消; strategy.oca.reduce - 订单应属于OCA组别，如果订单合同的X数量已被放置，则同一OCA组的其他订单合同数减少X。注意：优宽不支持此参数。
• comment (series string) 可选参数。订单的其他说明。
• when (series bool) 可选参数。订单的状况。若为"true"，订单被放置。若为"false"，则没有任何事情发生(之前放置的相同 ID 的订单没有被撤销)。默认值为"true"。
• alert_message (series string) 当在“创建警报”对话框的“消息”字段中使用{{strategy.order.alert_message}}占位符时，一个可选参数。

strategy.close

这是一个具有指定ID的退出订单的命令。 如果有多个具有相同ID的进场订单，则它们都将同一时间退出。 如果在触发命令时没有指定ID的开放订单，该命令则不会生效。 该命令使用市场订单。 每个进场都由分开的市场订单关闭。

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

例子

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)

参数

• id (series string) 必要参数。 订单标识符。可以通过引用其标识来关闭订单。
• when (series bool) 可选参数。命令的条件。
• qty (series int/float) 可选参数。退出交易的合约/股数/手数/单位的数量。默认值为’NaN’。
• qty_percent (series int/float) 定义平仓的百分比(0-100)。它的优先级低于 ‘qty’ 参数的优先级。可选。默认值为100。
• comment (series string) 可选参数。订单的其他说明。
• alert_message (series string) 当在“创建警报”对话框的“消息”字段中使用{{strategy.order.alert_message}}占位符时，一个可选参数。

strategy.close_all

退出当前市场仓位，使其持平。

strategy.close_all(when, comment, alert_message) 

例子

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)

参数

• when (series bool) 可选参数。命令的条件。
• comment (series string) 可选参数。订单的其他说明。
• alert_message (series string) 当在“创建警报”对话框的“消息”字段中使用{{strategy.order.alert_message}}占位符时，一个可选参数。

strategy.exit

这是一个退出指定进场或整个市场地位的命令。 如果具有相同ID的订单已经挂起，则可修改订单。 如果进场订单未成交，但是出现退场订单，该退场订单将暂待，直到进场订单成交后方可放置退场订单。 要停用退场订单，应使用命令strategy.cancel或strategy.cancel_all。 如果函数strategy.exit被调用一次，则只会退出一次。 如果要退出多次，应该多次调用命令strategy.exit。 如果您使用止损和追踪止损，其订单类型是“stop”，只有其中一个会被放置(会首先被成交)。 如果以下所有参数 ‘profit’, ‘limit’, ‘loss’, ‘stop’, ‘trail_points’, ‘trail_offset’ 皆为“NaN”，则命令将失败。 要使用市场订单离场，应使用命令strategy.close或strategy.close_all。

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

例子

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"

参数

• id (series string) 必要参数。 订单标识符。 可以通过引用其标识来取消或修改订单。
• from_entry (series string) 可选参数。以指定进场指令标识符退出。 要退出所有头寸，应使用空字符串。 默认值为空字符串。
• qty (series int/float) 可选参数。退出交易的合约/股数/手数/单位的数量。默认值为’NaN’。
• qty_percent (series int/float) 定义平仓的百分比(0-100)。它的优先级低于 ‘qty’ 参数的优先级。可选。默认值为100。
• profit (series int/float) 可选参数。 利润目标(以点表示)。 如果已指定，当达到指定的利润额(点)时，则以限价订单退出市场头寸。 默认值为“NaN”。
• limit (series int/float) 可选参数。 利润目标(需指定价格)。 若已指定，则以指定价格(或更好)退出市场头寸。 参数’limit’的优先级高于参数’profit’的优先级(若值非’NaN’，则’limit’取代’profit’)。 默认值为“NaN”。
• loss (series int/float) 可选参数。 止损(以点表示)。 如果已指定，当达到指定的亏损额(点)时，则以停损单退出市场头寸。 默认值为“NaN”。
• stop (series int/float) 可选参数。 止损(需指定价格)。 如果已指定，则将以指定价格(或更差)退出市场头寸。 参数’止损’的优先级高于参数’损失’的优先级(若值非’NaN’，则’止损’代替’损失’)。 默认值为“NaN”。
• trail_price (series int/float) 可选参数。跟踪止损激活水平(需指定价格)。如果已指定，当达到指定价格水平时，将放置跟踪止损单。在“trail_offset”参数中指定用于确定跟踪止损单初始价格的偏移量(以点计)：X 点低于激活水平以退出多头; X点高于激活水平以退出空头。默认值为“NaN”。
• trail_points (series int/float) 可选参数。跟踪止损激活水平(利润以点表示)。如果已指定，当达到已计算价格水平(指定利润金额)时，将放置跟踪止损单。在“trail_offset”参数中指定用于确定跟踪止损单初始价格的偏移量(以点计)：X 点低于激活水平以退出多头; X点高于激活水平以退出空头。默认值为“NaN”。
• trail_offset (series int/float) 可选参数。跟踪止损激活水平(以点表示)。以点计的偏移量用于确定跟踪止损单的初始价格：X 点低于’trail_price’ or 'trail_points’以退出多头; X点高于 ‘trail_price’ or 'trail_points’以退出空头。默认值为“NaN”。
• oca_name (series string) 可选参数。OCA group的名称 (oca_type = strategy.oca.reduce) 获利目标，止损/跟踪止损。如果未指定名称，将自动生成该名称。注意：优宽不支持此参数。
• comment (series string) 可选参数。订单的其他说明。
• when (series bool) 可选参数。订单的状况。若为"true"，订单被放置。若为"false"，则没有任何事情发生(之前放置的相同 ID 的订单没有被撤销)。默认值为"true"。
• alert_message (series string) 当在“创建警报”对话框的“消息”字段中使用{{strategy.order.alert_message}}占位符时，一个可选参数。

strategy.cancel

这是引用名称来取消/停用所有预挂单的命令，由以下功能生成：strategy.order, strategy.entry and strategy.exit。

strategy.cancel(id, when) 

例子

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

参数

• id (series string) 必选参数。订单标识。定位该标识以撤销一个订单。
• when (series bool) 可选参数。根据 ID 取消一个订单。若为"true"，该订单将被取消。默认值为"true"。

strategy.cancel_all

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

strategy.cancel_all(when) 

例子

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

参数

• when (series bool) 可选参数。取消所有订单的条件。如果条件为真，则所有活动订单将被取消。默认值为“true”。

strategy.order

这是下订单的命令。 如果具有相同ID的订单已经挂起，则可以修改订单。 如果没有指定ID的订单，则会发出新的订单。 要停止订单，应使用命令strategy.cancel或strategy.cancel_all。 与函数strategy.entry相比，函数strategy.order不受金字塔形式的影响。 如果“限制”和“止损”参数均为“NaN”，则订单类型为市场订单。

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

例子

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

参数

• id (series string) 必要参数。 订单标识符。 可以通过引用其标识来取消或修改订单。
• direction (strategy_direction) 一个必需的参数。订单方向：'strategy.long’为买入，'strategy.short’为卖出。
• qty (series int/float) 可选参数。交易的合约/股数/手数/单位数量。预设值为’NaN’。
• limit (series int/float) 可选参数。订单的限价。若已指定，订单类型是"limit" 或"stop-limit"。其他订单类型为"NaN"。
• stop (series int/float) 可选参数。订单的止损价。如果已指定，订单类型为"stop"或"stop-limit"。其他订单类型则为"NaN"。
• oca_name (series string) 可选参数。 该订单属于OCA集团名。 如果订单不属于任何OCA集团，则应该有一个空字符。注意：优宽不支持此参数。
• oca_type (input string) 可选参数。 OCA订单组类型。 允许的值为：strategy.oca.none - 订单不应属于任何特定OCA组; strategy.oca.cancel - 订单应属于OCA组，一旦订单被成交，同一组的所有其他订单将被取消; strategy.oca.reduce - 订单应属于OCA组别，如果订单合同的X数量已被放置，则同一OCA组的其他订单合同数减少X。注意：优宽不支持此参数。
• comment (series string) 可选参数。订单的其他说明。
• when (series bool) 可选参数。订单的状况。若为"true"，订单被放置。若为"false"，则没有任何事情发生(之前放置的相同 ID 的订单没有被撤销)。默认值为"true"。
• alert_message (series string) 当在“创建警报”对话框的“消息”字段中使用{{strategy.order.alert_message}}占位符时，一个可选参数。

strategy.opentrades.entry_bar_index

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

strategy.opentrades.entry_bar_index(trade_num)

等待10根K线并平仓

例子

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

参数

• trade_num (series int) 未平仓交易的交易编号。第一笔交易的编号为零。

另见 strategy.closedtrades.entry_bar_index strategy.closedtrades.exit_bar_index

strategy.opentrades.entry_id

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

strategy.opentrades.entry_id(trade_num)

例子

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

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

参数

• trade_num (series int) 未平仓交易的交易编号。第一笔交易的编号为零。

备注 如果 trade_num 不在范围内，则该函数返回 na：0 到 strategy.opentrades-1。

另见 strategy.opentrades.entry_bar_index strategy.opentrades.entry_time

strategy.opentrades.entry_price

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

strategy.opentrades.entry_price(trade_num)

例子

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

计算平均未平仓价格

例子

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

参数

• trade_num (series int) 未平仓交易的交易编号。第一笔交易的编号为零。

另见 strategy.closedtrades.exit_price

strategy.opentrades.entry_time

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

strategy.opentrades.entry_time(trade_num)

例子

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

参数

• trade_num (series int) 未平仓交易的交易编号。第一笔交易的编号为零。

另见 strategy.closedtrades.entry_time strategy.closedtrades.exit_time

strategy.opentrades.profit

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

strategy.opentrades.profit(trade_num)

返回最后开仓交易的利润

例子

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

计算所有未平仓交易的利润

例子

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

参数

• trade_num (series int) 未平仓交易的交易编号。第一笔交易的编号为零。

另见 strategy.closedtrades.profit strategy.openprofit strategy.netprofit strategy.grossprofit

strategy.opentrades.size

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

strategy.opentrades.size(trade_num)

例子

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

计算未平仓交易的平均利润百分比

例子

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)

参数

• trade_num (series int) 未平仓交易的交易编号。第一笔交易的编号为零。

另见 strategy.closedtrades.size strategy.position_size strategy.opentrades strategy.closedtrades

strategy.closedtrades.entry_bar_index

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

strategy.closedtrades.entry_bar_index(trade_num)

例子

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

参数

• trade_num (series int) 已平仓交易的交易编号。第一笔交易的编号为零。

另见 strategy.closedtrades.exit_bar_index strategy.opentrades.entry_bar_index

strategy.closedtrades.exit_price

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

strategy.closedtrades.exit_price(trade_num)

例子

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

计算所有已平仓交易的平均利润百分比

例子

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)

参数

• trade_num (series int) 已平仓交易的交易编号。第一笔交易的编号为零。

另见 strategy.closedtrades.entry_price

strategy.closedtrades.exit_bar_index

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

strategy.closedtrades.exit_bar_index(trade_num)

例子

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

计算每笔交易的平均K线数。

例子

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

参数

• trade_num (series int) 已平仓交易的交易编号。第一笔交易的编号为零。

另见 bar_index

strategy.closedtrades.entry_id

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

strategy.closedtrades.entry_id(trade_num)

例子

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

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

参数

• trade_num (series int) 已平仓交易的交易编号。第一笔交易的编号为零。

备注 如果 trade_num 不在范围内，则该函数返回 na：0 到 strategy.closedtrades-1。

另见 strategy.closedtrades.entry_bar_index strategy.closedtrades.entry_time

strategy.closedtrades.entry_price

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

strategy.closedtrades.entry_price(trade_num)

例子

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

计算所有已平仓交易的平均利润百分比

例子

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)

参数

• trade_num (series int) 已平仓交易的交易编号。第一笔交易的编号为零。

另见 strategy.closedtrades.exit_price strategy.closedtrades.size strategy.closedtrades

strategy.closedtrades.entry_time

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

strategy.closedtrades.entry_time(trade_num)

例子

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

参数

• trade_num (series int) 已平仓交易的交易编号。第一笔交易的编号为零。

另见 strategy.opentrades.entry_time strategy.closedtrades.exit_time time

strategy.closedtrades.profit

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

strategy.closedtrades.profit(trade_num)

例子

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

参数

• trade_num (series int) 已平仓交易的交易编号。第一笔交易的编号为零。

另见 strategy.opentrades.profit strategy.closedtrades.commission

strategy.closedtrades.size

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

strategy.closedtrades.size(trade_num)

例子

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

计算平仓交易的平均利润百分比

例子

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)

参数

• trade_num (series int) 已平仓交易的交易编号。第一笔交易的编号为零。

另见 strategy.opentrades.size strategy.position_size strategy.closedtrades strategy.opentrades

strate

更多内容