Referencia de funciones
Todas las funciones, series y constantes integradas de LootScript: ta, math, str, color, input, dibujo, colecciones, estrategias y datos de order flow — con parámetros y valores por defecto.
Aquí está todo lo que viene integrado en LootScript: declaraciones del script, series de la barra, funciones por espacios de nombres, constantes y datos de order flow. La lista está tomada de la tabla de nombres integrados del propio compilador: lo que no está en esta página no existe en el lenguaje, y llamar a ese nombre dará error LS2002.
El manual no enseña el lenguaje: cómo funcionan los tipos, na, el historial x[1] y la nueva ejecución de la barra se explica en Sintaxis y tipos, y el dibujo y las opciones en Ajustes y renderizado.
Cómo leer este manual
Cada función está escrita en una línea: nombre, parámetros en el orden que acepta la llamada posicional y el tipo de resultado.
ta.stdev(source, length, biased = true) → float- Un parámetro sin
= …es obligatorio. Un parámetro con valor es opcional: si se omite, se usará el valor indicado. = naen un parámetro opcional significa “no establecido”: la función se comportará como se describe en la línea.- Los nombres de parámetros se pueden escribir explícitamente en la llamada:
ta.stdev(close, 20, biased = false). Los nombres son parte del lenguaje y no pueden abreviarse. - Un resultado
[float, float, float]son varios valores a la vez. Se desempaquetan en variables:[mid, up, dn] = ta.bb(close, 20, 2). - Un nombre sin paréntesis (
close,ta.obv,strategy.equity) es una serie o constante y se lee sin llamar. - El resultado
—significa que la función no devuelve nada y se escribe en una línea separada.
Declaración del script
La primera línea del script debe ser exactamente una declaración: indicator, strategy o library. Sus argumentos se leen antes de la primera barra, por lo que solo sirven literales y constantes.
| Declaración | Qué crea |
|---|---|
indicator(title, …) |
Un indicador en el gráfico |
strategy(title, …) |
Una estrategia para el probador: las mismas capacidades que un indicador, más las órdenes strategy.* |
library(title, version) |
Una biblioteca de funciones. Se importa con import Nombre/versión as alias. En una biblioteca no se puede dibujar ni declarar ajustes |
Parámetros de indicator
| Parámetro | Por defecto | Qué define |
|---|---|---|
title |
— | Nombre en la lista de indicadores y en la leyenda |
shortTitle |
na |
Título corto para la leyenda |
overlay |
false |
true — dibujar sobre las velas, false — en un área separada bajo el gráfico |
format, precision, scale |
na |
Aceptados por compatibilidad: la escala y el formato de números los controla el terminal |
maxBarsBack |
na |
Aceptado pero no efecto: la historia siempre se carga completa |
timeframe |
na |
Aceptado pero no efecto: el script se calcula en la temporalidad del gráfico; otra temporalidad da request.security |
maxLinesCount, maxLabelsCount, maxBoxesCount |
500 |
Cuántas líneas, etiquetas y rectángulos de un tipo viven simultáneamente. Si se supera, se elimina la más antigua |
maxPolylinesCount |
500 |
Reservado: el tipo polyline aún no existe en el lenguaje |
Constantes para format: format.inherit, format.price, format.volume, format.percent, format.mintick. Para scale: scale.right, scale.left, scale.none. Las cadenas format.* también las entiende str.tostring.
Parámetros de strategy
strategy tiene los mismos title, shortTitle, overlay y límites de objetos de dibujo que indicator, más parámetros del probador:
| Parámetro | Por defecto | Qué define |
|---|---|---|
initialCapital |
10000 |
Capital inicial |
currency |
"USD" |
Aceptado; no afecta al cálculo |
defaultQtyType |
strategy.qty.fixed |
Cómo interpretar el tamaño por defecto: strategy.qty.fixed — unidades, strategy.qty.cash — monto en moneda, strategy.qty.percent_of_equity — porcentaje del capital, strategy.qty.risk_percent — porcentaje de riesgo hasta el stop |
defaultQtyValue |
1 |
Tamaño de orden por defecto |
commissionType |
strategy.commission.percent |
Comisión en porcentaje, strategy.commission.cash_per_contract — por unidad, strategy.commission.cash_per_order — por orden |
commissionValue |
na |
Tamaño de la comisión. na — usar las tasas maker/taker del instrumento |
slippageTicks |
0 |
Deslizamiento en ticks |
pyramiding |
0 |
Cuántas entradas adicionales en la misma dirección se permiten |
positionModel |
strategy.model.netting |
Una posición global o separadas (strategy.model.hedging) |
calcOnEveryTick |
false |
Calcular órdenes en cada tick de la barra en vivo, no solo al cierre |
calcOnOrderFills |
false |
Aceptado; esta versión no lo usa |
processOrdersOnClose |
false |
Ejecutar órdenes al precio de cierre de la misma barra. El informe se marcará como no alcanzable en vivo |
marginLong, marginShort |
0 |
Margen inicial long y short en porcentaje de la posición. 0 — sin simulación de margen ni liquidaciones |
leverage |
1 |
Apalancamiento |
applyFunding |
true |
Incluir la tasa de financiación de futuros perpetuos en el resultado |
fillModel |
strategy.fill.conservative |
Camino del precio dentro de la barra. El modelo conservador asume que el precio primero fue en la peor dirección: si stop y take están ambos dentro de la barra, se ejecutará el stop. strategy.fill.optimistic — al revés |
Barra e instrumento
Series de la barra
| Nombre | Tipo | Qué contiene |
|---|---|---|
open, high, low, close, volume |
float |
Precios y volumen de la barra |
hl2, hlc3, ohlc4, hlcc4 |
float |
Precios medios de la barra: (H+L)/2, (H+L+C)/3, (O+H+L+C)/4, (H+L+2C)/4 |
time, time_close |
int |
Tiempo de apertura y cierre de la barra, milisegundos UTC |
bar_index |
int |
Número de la barra desde el inicio de la historia cargada, empezando en cero |
last_bar_index |
int |
Número de la última barra cargada |
timenow |
int |
Tiempo actual del terminal, en milisegundos UTC |
Estado de la barra: barstate
| Nombre | Es verdadero cuando |
|---|---|
barstate.isfirst |
Primera barra de la historia cargada |
barstate.islast |
Última barra cargada |
barstate.ishistory |
Barra de la historia, no en formación |
barstate.isrealtime |
Barra formándose en tiempo real |
barstate.isnew |
Primera pasada por una barra nueva |
barstate.isconfirmed |
La barra cerró — su valor ya no cambiará |
isrealtime, isnew y los valores dependientes de ellos difieren entre historia y en vivo — el compilador avisará si llegan al gráfico.
Instrumento: sym
| Nombre | Tipo | Qué contiene |
|---|---|---|
sym.ticker |
string |
Exchange e símbolo en la forma que acepta request.security |
sym.exchange |
string |
Código del exchange |
sym.base, sym.quote |
string |
Activo base y cotizado: BTC y USDT en BTCUSDT. na si no se pudo extraer la cotización |
sym.tick_size |
float |
Tick de precio |
sym.qty_step, sym.min_qty |
float |
Paso y mínimo de cantidad |
sym.maker_fee, sym.taker_fee |
float |
Comisiones maker y taker en fracción: 0.0002 es 0.02 % |
Temporalidad: tf
| Nombre | Tipo | Qué contiene |
|---|---|---|
tf.period |
string |
Temporalidad del gráfico como texto: "5", "60", "1D" |
tf.ms, tf.seconds |
int |
Longitud de la barra en milisegundos y segundos |
tf.isintraday, tf.isdaily |
bool |
Barra más corta que un día; barra exactamente de un día |
tf.in_ms(period) |
int |
Longitud de una temporalidad arbitraria en milisegundos; na si la cadena no se parsea |
tf.in_seconds(period = na) |
int |
Lo mismo en segundos; sin argumento — la temporalidad del gráfico |
Tiempo y calendario
Todas las funciones de calendario por defecto calculan en UTC, no en la zona horaria del equipo: así el indicador luce igual para todos.
| Función | Devuelve | Qué hace |
|---|---|---|
year, month, dayofmonth, weekofyear (timestamp = time, timezone = "UTC") |
int |
Año, mes, día, número de semana ISO |
dayofweek(timestamp = time, timezone = "UTC") |
int |
Día de la semana: domingo — 1, sábado — 7 |
hour, minute, second (timestamp = time, timezone = "UTC") |
int |
Hora, minuto, segundo |
time_of_day(timestamp = time, timezone = "UTC") |
int |
Milisegundos desde medianoche en la zona dada |
timestamp(year, month, day, hour = 0, minute = 0, second = 0, timezone = "UTC") |
int |
Marca de tiempo a partir de una fecha |
time_in_range(session, timezone = "UTC") |
bool |
Si la barra cae en un intervalo del tipo "0930-1600" |
session.ismarket, session.isfirstbar, session.islastbar |
bool |
Barra dentro de sesión, primera y última barra de sesión. En mercados 24/7 la sesión es el día UTC |
Las constantes de días coinciden con lo que devuelve dayofweek: dayofweek.sunday (1), dayofweek.monday, dayofweek.tuesday, dayofweek.wednesday, dayofweek.thursday, dayofweek.friday, dayofweek.saturday (7). La zona horaria se especifica con un identificador IANA, por ejemplo "Europe/Moscow".
ta — análisis técnico
Las funciones ta.* recuerdan su estado entre barras, por eso el compilador las calcula en cada barra aunque la llamada esté dentro de un if. En las primeras barras, hasta que la ventana se llena, las funciones devuelven na.
Medias móviles
| Función | Devuelve | Qué hace |
|---|---|---|
ta.sma(source, length) |
float |
Media simple de length barras |
ta.ema(source, length) |
float |
Media exponencial: peso del nuevo valor 2/(length+1) |
ta.rma(source, length) |
float |
Suavizado de Wilder, peso 1/length. Sobre esto se construyen RSI y ATR; no es lo mismo que ta.ema de la misma longitud |
ta.wma(source, length) |
float |
Media ponderada linealmente: barras recientes pesan más |
ta.vwma(source, length) |
float |
Media ponderada por volumen |
ta.hma(source, length) |
float |
Media de Hull: menos retardo en giros |
ta.swma(source) |
float |
Media simétricamente ponderada en cuatro barras |
ta.alma(source, length, offset = 0.85, sigma = 6) |
float |
Media con ventana gaussiana; offset desplaza el pico hacia barras recientes, sigma fija la anchura |
ta.linreg(source, length, offset = 0) |
float |
Punto sobre la recta de regresión de los últimos length valores |
Osciladores
| Función | Devuelve | Qué hace |
|---|---|---|
ta.rsi(source, length) |
float |
Índice de fuerza relativa, 0…100 |
ta.stoch(source, high, low, length) |
float |
Dónde está source dentro del rango high–low de length barras, 0…100 |
ta.cci(source, length) |
float |
Desviación de la media normalizada por la desviación absoluta media |
ta.mfi(source, length) |
float |
Índice de flujo monetario: RSI que incluye volumen |
ta.cmo(source, length) |
float |
Oscilador de Chande, −100…100 |
ta.roc(source, length) |
float |
Cambio en porcentaje respecto a length barras atrás |
ta.mom(source, length) |
float |
Diferencia con el valor de length barras atrás |
ta.tsi(source, shortLength, longLength) |
float |
Índice de fuerza verdadera: impulso doblemente suavizado sobre el módulo también suavizado |
ta.wpr(length) |
float |
Williams %R, −100…0 |
ta.bop(length = 1) |
float |
Balance of power: qué parte del rango ocupó el cuerpo, con suavizado |
ta.cog(source, length) |
float |
Centro de gravedad de la ventana |
Volatilidad y canales
| Función | Devuelve | Qué hace |
|---|---|---|
ta.tr(handle_na = true) |
float |
Rango verdadero de la barra |
ta.atr(length) |
float |
Average true range |
ta.natr(length) |
float |
ATR en porcentaje respecto al cierre |
ta.stdev(source, length, biased = true) |
float |
Desviación estándar. biased = false — muestral, divisor length−1 |
ta.variance(source, length, biased = true) |
float |
Varianza, con la misma elección de divisor |
ta.dev(source, length) |
float |
Desviación absoluta media respecto a la media |
ta.bb(source, length, mult) |
[float, float, float] |
Bandas de Bollinger: media, superior, inferior |
ta.bbw(source, length, mult) |
float |
Ancho de las bandas respecto a la media |
ta.kc(source, length, mult, useTrueRange = true) |
[float, float, float] |
Canal de Keltner: media, superior, inferior |
ta.kcw(source, length, mult, useTrueRange = true) |
float |
Ancho del canal de Keltner respecto a la media |
ta.range(length) |
float |
Altura de las últimas length barras: máximo high menos mínimo low |
Tendencia
| Función | Devuelve | Qué hace |
|---|---|---|
ta.macd(source, fastLength, slowLength, signalLength) |
[float, float, float] |
MACD: línea, señal, histograma |
ta.dmi(diLength, adxLength) |
[float, float, float] |
Índice direccional: +DI, −DI, ADX |
ta.adx(diLength, adxLength) |
float |
Solo ADX |
ta.supertrend(factor, atrLength) |
[float, int] |
Línea supertrend y dirección: 1 — tendencia alcista, −1 — bajista |
ta.sar(start = 0.02, increment = 0.02, maximum = 0.2) |
float |
Parabolic SAR |
ta.vortex(length) |
[float, float] |
Indicador vortex: VI+ y VI− |
ta.aroon(length) |
[float, float] |
Aroon up y down: cuántas barras desde el máximo y mínimo de la ventana, 0…100 |
Volumen
| Función | Devuelve | Qué hace |
|---|---|---|
ta.obv, ta.pvt, ta.nvi, ta.pvi, ta.ad |
float |
Series acumulativas sin paréntesis: On-balance volume, precio por volumen, índices de volumen negativo y positivo, acumulación/distribución |
ta.cmf(length) |
float |
Chaikin money flow |
ta.eom(length = 14, divisor = 10000) |
float |
Ease of movement: movimiento de precio por unidad de volumen |
ta.vwap(source = hlc3, anchor = session.isfirstbar) |
float |
VWAP desde la última barra en que anchor fue verdadera |
Estructura y eventos
| Función | Devuelve | Qué hace |
|---|---|---|
ta.highest(source, length), ta.lowest(source, length) |
float |
Máximo y mínimo de length barras |
ta.highestbars(source, length), ta.lowestbars(source, length) |
int |
Desplazamiento hasta la barra con máximo o mínimo: 0 — barra actual, valores negativos hacia atrás |
ta.crossover(a, b) |
bool |
a cruzó b de abajo hacia arriba en esta barra |
ta.crossunder(a, b) |
bool |
a cruzó b de arriba abajo |
ta.cross(a, b) |
bool |
Cualquiera de los dos cruces |
ta.change(source, length = 1) |
float |
Diferencia respecto al valor length barras atrás |
ta.rising(source, length), ta.falling(source, length) |
bool |
Valor creció (cayó) en cada una de las últimas length barras |
ta.barssince(condition) |
int |
Cuántas barras han pasado desde la última vez que la condición fue verdadera |
ta.valuewhen(condition, source, occurrence = 0) |
float |
Valor de source en la barra donde la condición fue verdadera; occurrence = 1 — en la anterior de ese tipo |
ta.pivothigh(source, leftBars, rightBars), ta.pivotlow(…) |
float |
Pico o valle confirmado. Aparece rightBars barras después del punto |
ta.percentrank(source, length) |
float |
Qué porcentaje de valores pasados de la ventana no son mayores que el actual |
ta.median(source, length), ta.mode(source, length) |
float |
Mediana y valor modal de la ventana |
ta.correlation(source1, source2, length) |
float |
Correlación entre dos series, −1…1 |
ta.sum(source, length) |
float |
Suma en length barras |
ta.cum(source) |
float |
Suma desde la primera barra cargada |
Ausencia de valor: na
| Función | Devuelve | Qué hace |
|---|---|---|
na(x) |
bool |
Verdadero si no hay valor. Funciona con cualquier tipo, incluidos objetos y colecciones |
nz(x, replacement = 0) |
float |
Reemplaza na por replacement |
fixnan(x) |
float |
Extiende el último valor existente a través de huecos |
La comparación x == na el compilador no la aceptará: siempre es falsa. Compruebe con na(x), y sustituya con el operador a ?? b.
math
| Función | Devuelve | Qué hace |
|---|---|---|
math.abs(x), math.sign(x) |
float |
Módulo y signo (−1, 0, 1). math.abs de entero sigue siendo entero |
math.round(x, precision = na) |
int o float |
Sin precision — al entero, resultado int. Con precision — a los decimales, resultado float |
math.floor(x), math.ceil(x), math.trunc(x) |
int |
Redondeo hacia abajo, arriba, truncamiento |
math.min(a, b, c = na, d = na), math.max(…) |
float |
Mínimo y máximo de 2–4 valores; na se ignora. De enteros — entero |
math.sum(a, b, c = na, d = na), math.avg(…) |
float |
Suma y promedio de 2–4 valores |
math.clamp(x, lower, upper) |
float |
Restringe el valor entre límites |
math.pow(base, exponent) |
float |
Potencia |
math.sqrt(x), math.cbrt(x) |
float |
Raíz cuadrada y cúbica |
math.exp(x), math.log(x), math.log10(x), math.log2(x) |
float |
Exponencial y logaritmos |
math.hypot(x, y) |
float |
Longitud de la hipotenusa |
math.gcd(a, b), math.lcm(a, b) |
int |
MCD y mcm |
math.approx(a, b, tolerance = 1e-9) |
bool |
Números iguales con precisión relativa tolerance |
math.random(min = 0, max = 1, seed = na) |
float |
Número aleatorio en [min, max). Cada llamada tiene su propia secuencia |
math.pi, math.e, math.phi, math.rphi, math.inf, math.epsilon |
float |
Constantes: π, e, sección áurea y su inversa, infinito, epsilon de máquina |
Trigonometría
| Función | Devuelve | Qué hace |
|---|---|---|
math.sin(x), math.cos(x), math.tan(x) |
float |
Seno, coseno, tangente; ángulo en radianes |
math.asin(x), math.acos(x), math.atan(x) |
float |
Funciones inversas |
math.atan2(y, x) |
float |
Ángulo del punto (x, y) considerando el cuadrante |
math.sinh(x), math.cosh(x), math.tanh(x) |
float |
Funciones hiperbólicas |
math.todegrees(radians), math.toradians(degrees) |
float |
Convertir radianes a grados y viceversa |
str — cadenas
| Función | Devuelve | Qué hace |
|---|---|---|
str.tostring(value, format = na) |
string |
Número a texto; format — format.* o patrón |
str.tonumber(text) |
float |
Texto a número; na si no se parsea |
str.format(pattern, arg0, arg1 = na, arg2 = na, arg3 = na) |
string |
Sustituye valores en un patrón tipo "RSI {0}, ATR {1}" |
str.format_time(timestamp, format = "yyyy-MM-dd HH:mm:ss", timezone = "UTC") |
string |
Marca de tiempo a texto |
str.length(text) |
int |
Longitud de la cadena |
str.substring(text, begin, end = na) |
string |
Subcadena; sin end — hasta el final |
str.pos(text, needle) |
int |
Posición de la primera aparición |
str.contains(text, needle), str.startswith(text, prefix), str.endswith(text, suffix) |
bool |
Comprobaciones de existencia, inicio y fin |
str.replace(text, target, replacement, occurrence = 0) |
string |
Reemplaza una aparición, por defecto la primera |
str.replace_all(text, target, replacement) |
string |
Reemplaza todas las apariciones |
str.split(text, separator) |
array<string> |
Divide la cadena en partes |
str.join(parts, separator = "") |
string |
Junta un array de cadenas |
str.upper(text), str.lower(text), str.trim(text) |
string |
Mayúsculas/minúsculas y recorte de espacios |
str.repeat(text, count, separator = "") |
string |
Repite text count veces |
str.match(text, pattern) |
string |
Primera coincidencia regex o na |
str.escape_regex(text) |
string |
Escapa caracteres especiales para búsqueda literal |
No se puede concatenar una cadena con un número usando + — convierta el número con str.tostring.
color — colores
| Función | Devuelve | Qué hace |
|---|---|---|
color.rgb(red, green, blue, alpha = 255) |
color |
Color por canales 0…255 |
color.new(base, alpha) |
color |
Mismo color con otra opacidad |
color.from_gradient(value, bottomValue, topValue, bottomColor, topColor) |
color |
Color intermedio según value en el rango |
color.r(c), color.g(c), color.b(c), color.t(c) |
int |
Canales rojo, verde, azul y alfa, 0…255 |
El alfa en LootScript es la opacidad: 255 — color sólido, 0 — totalmente transparente. Colores listos: color.red, color.green, color.blue, color.teal, color.orange, color.purple, color.yellow, color.white, color.black, color.gray, color.silver, color.maroon, color.navy, color.olive, color.lime, color.aqua, color.fuchsia. También se puede escribir un color literal: #FF9800 o #FF980080.
input — ajustes del script
Cada llamada input.* añade una línea en la ventana de ajustes del indicador. El valor es constante durante toda la ejecución, por eso vale para la longitud de ventana ta.*.
| Función | Devuelve | Línea de ajustes |
|---|---|---|
input.int(defval, title = na, minval = na, maxval = na, step = 1, tooltip = na, group = na, inline = na) |
int |
Entero |
input.float(defval, title = na, minval = na, maxval = na, step = 0.1, tooltip = na, group = na, inline = na) |
float |
Número decimal |
input.bool(defval, title = na, tooltip = na, group = na, inline = na) |
bool |
Checkbox |
input.string(defval, title = na, options = na, tooltip = na, group = na, inline = na) |
string |
Texto o lista de options |
input.color(defval, title = na, tooltip = na, group = na, inline = na) |
color |
Selector de color |
input.source(defval, title = na, tooltip = na, group = na, inline = na) |
float |
Selección de serie: close, hl2, volume, etc. |
input.enum(defval, title = na, tooltip = na, group = na, inline = na) |
tipo enumerado | Lista de miembros del enum |
input.symbol(defval, title = na, tooltip = na, group = na, inline = na) |
string |
Instrumento en formato "EXCHANGE:SYMBOL" |
input.timeframe(defval, title = na, options = na, tooltip = na, group = na, inline = na) |
string |
Temporalidad: "5", "60", "1D" |
group agrupa líneas bajo un encabezado común, inline coloca varias en la misma fila, tooltip muestra ayuda. El valor guardado está ligado al nombre de la variable: si renombras la variable, la opción vuelve a defval.
Salida en el gráfico
Estas funciones se escriben en una línea aparte. Un script puede tener hasta 64 salidas, pero el panel de gráficos solo dibuja las primeras tres series plot.
| Función | Qué dibuja |
|---|---|
plot(series, title = na, color = #2196F3, linewidth = na, style = plot.style_line, offset = 0, join = false, editable = true, show_last = na, display = display.all) |
Una serie de valores. na crea hueco en la línea. Sin linewidth se usa el grosor del panel |
plotshape(condition, title = na, style = shape.triangleup, location = location.belowbar, color = color.blue, text = na, size = size.small, offset = 0) |
Icono en las barras donde la condición es verdadera |
plotchar(condition, title = na, char = "▲", location = location.abovebar, color = color.blue, text = na, size = size.auto, offset = 0) |
Carácter en las barras donde la condición es verdadera |
hline(price, title = na, color = color.gray, linestyle = hline.style_dashed, linewidth = na) |
Línea horizontal. El precio es constante |
fill(plot1, plot2, color = na, title = na, top_value = na, bottom_value = na, top_color = na, bottom_color = na) |
Relleno entre dos plot o hline: color sólido o gradiente con los cuatro últimos parámetros |
bgcolor(color, offset = 0, title = na) |
Fondo de la barra; na — sin fondo |
barcolor(color, offset = 0, title = na) |
Color de la vela |
plot y hline devuelven una referencia que se pasa a fill: p1 = plot(a), luego fill(p1, p2, color = …).
Estilos plot: plot.style_line, plot.style_linebr, plot.style_stepline, plot.style_stepline_diamond, plot.style_histogram, plot.style_columns, plot.style_area, plot.style_areabr, plot.style_circles, plot.style_cross.
Estilos hline: hline.style_solid, hline.style_dashed, hline.style_dotted.
Iconos: shape.triangleup, shape.triangledown, shape.circle, shape.square, shape.diamond, shape.arrowup, shape.arrowdown, shape.cross, shape.xcross, shape.flag, shape.labelup, shape.labeldown.
Posición del icono: location.abovebar, location.belowbar, location.top, location.bottom, location.absolute.
Tamaño: size.auto, size.tiny, size.small, size.normal, size.large, size.huge.
Dónde mostrar la serie: display.all, display.pane, display.price_scale, display.status_line, display.data_window, display.none.
Objetos de dibujo
Líneas, rectángulos, etiquetas y tablas se crean con .new y viven hasta que se borren o los expulse el límite (por defecto 500 objetos de un tipo). .new devuelve una referencia con la que se modifica el objeto. Un setter a na no hace nada, por lo que el patrón “borrar y crear de nuevo” no requiere comprobaciones. Todos los objetos de un tipo están en arrays line.all, box.all, label.all, table.all.
La coordenada X por defecto es el número de barra (xloc.bar_index); con xloc.bar_time es el tiempo de la barra en ms. La coordenada Y es precio o valor de la escala del panel.
line
| Función | Devuelve | Qué hace |
|---|---|---|
line.new(x1, y1, x2, y2, xloc = xloc.bar_index, extend = extend.none, color = color.blue, style = line.style_solid, width = 1) |
line |
Segmento entre dos puntos |
line.set_x1(id, x), line.set_y1(id, y), line.set_x2(id, x), line.set_y2(id, y) |
— | Cambia un extremo |
line.set_xy1(id, x, y), line.set_xy2(id, x, y) |
— | Cambia el punto entero |
line.set_xloc(id, x1, x2, xloc) |
— | Cambia ambos X y la forma de leerlos |
line.set_extend(id, extend), line.set_color(id, color), line.set_style(id, style), line.set_width(id, width) |
— | Extensión, color, estilo, grosor |
line.get_x1(id), line.get_x2(id) |
int |
Coordenadas X de los extremos |
line.get_y1(id), line.get_y2(id) |
float |
Coordenadas Y de los extremos |
line.get_price(id, x) |
float |
Precio en la línea en el punto x |
line.copy(id) |
line |
Copia de la línea |
line.delete(id) |
— | Borra la línea |
Extensión: extend.none, extend.left, extend.right, extend.both. Estilos: line.style_solid, line.style_dotted, line.style_dashed, line.style_arrow_left, line.style_arrow_right, line.style_arrow_both.
label
| Función | Devuelve | Qué hace |
|---|---|---|
label.new(x, y, text = na, xloc = xloc.bar_index, yloc = yloc.price, color = color.blue, style = label.style_label_down, textcolor = color.white, size = size.normal, textalign = text.align_center, tooltip = na, text_font_family = font.family_default) |
label |
Etiqueta con texto |
label.set_x(id, x), label.set_y(id, y), label.set_xy(id, x, y) |
— | Posición |
label.set_text(id, text), label.set_tooltip(id, text) |
— | Texto y tooltip |
label.set_color(id, color), label.set_textcolor(id, color) |
— | Color de fondo y del texto |
label.set_style(id, style), label.set_size(id, size), label.set_textalign(id, align), label.set_text_font_family(id, family) |
— | Forma, tamaño, alineación, fuente |
label.set_xloc(id, x, xloc), label.set_yloc(id, yloc) |
— | Forma de leer las coordenadas |
label.get_x(id) |
int |
Coordenada X |
label.get_y(id) |
float |
Coordenada Y |
label.get_text(id) |
string |
Texto |
label.copy(id) |
label |
Copia |
label.delete(id) |
— | Borra la etiqueta |
Anclaje en Y: yloc.price, yloc.abovebar, yloc.belowbar. Formas: label.style_none, label.style_label_up, label.style_label_down, label.style_label_left, label.style_label_right, label.style_label_center, label.style_circle, label.style_square, label.style_diamond, label.style_arrowup, label.style_arrowdown, label.style_triangleup, label.style_triangledown, label.style_flag, label.style_cross, label.style_xcross, label.style_text_outline. Fuentes: font.family_default, font.family_monospace.
box — rectángulos
| Función | Devuelve | Qué hace |
|---|---|---|
box.new(left, top, right, bottom, border_color = color.blue, border_width = 1, border_style = line.style_solid, extend = extend.none, xloc = xloc.bar_index, bgcolor = na, text = na, text_size = size.auto, text_color = color.white, text_halign = text.align_center, text_valign = text.align_center, text_wrap = text.wrap_none) |
box |
Rectángulo con texto opcional |
box.set_left(id, x), box.set_right(id, x), box.set_top(id, y), box.set_bottom(id, y) |
— | Un lado |
box.set_lefttop(id, x, y), box.set_rightbottom(id, x, y) |
— | Esquina completa |
box.set_xloc(id, left, right, xloc) |
— | Ambos X y forma de leerlos |
box.set_border_color(id, color), box.set_border_width(id, width), box.set_border_style(id, style) |
— | Borde |
box.set_bgcolor(id, color), box.set_extend(id, extend) |
— | Fondo y extensión |
box.set_text(id, text), box.set_text_color(id, color), box.set_text_size(id, size), box.set_text_halign(id, align), box.set_text_valign(id, align) |
— | Texto interior |
box.get_left(id), box.get_right(id) |
int |
Coordenadas X |
box.get_top(id), box.get_bottom(id) |
float |
Coordenadas Y |
box.copy(id) |
box |
Copia |
box.delete(id) |
— | Borra el rectángulo |
Alineación de texto: text.align_left, text.align_center, text.align_right, text.align_top, text.align_bottom. Ajuste de línea: text.wrap_none, text.wrap_auto.
table — tablas
La tabla está fijada en una esquina del panel y no se mueve con las velas. No más de 2000 celdas.
| Función | Devuelve | Qué hace |
|---|---|---|
table.new(position, columns, rows, bgcolor = na, frame_color = na, frame_width = 0, border_color = na, border_width = 0) |
table |
Tabla del tamaño pedido |
table.cell(id, column, row, text = "", width = 0, height = 0, text_color = color.black, text_halign = text.align_center, text_valign = text.align_center, text_size = size.normal, bgcolor = na, tooltip = na, text_font_family = font.family_default) |
— | Rellena una celda |
table.cell_set_text(id, column, row, text), table.cell_set_tooltip(…, text) |
— | Texto y tooltip de la celda |
table.cell_set_text_color(…, color), table.cell_set_bgcolor(…, color) |
— | Colores de la celda |
table.cell_set_text_size(…, size), table.cell_set_text_halign(…, align), table.cell_set_text_valign(…, align), table.cell_set_text_font_family(…, family) |
— | Formato del texto |
table.cell_set_width(…, width), table.cell_set_height(…, height) |
— | Tamaño de la celda |
table.set_position(id, position) |
— | Esquina del panel |
table.set_bgcolor(id, color), table.set_frame_color(id, color), table.set_frame_width(id, width), table.set_border_color(id, color), table.set_border_width(id, width) |
— | Fondo, marco, líneas entre celdas |
table.merge_cells(id, start_column, start_row, end_column, end_row) |
— | Fusiona un rectángulo de celdas |
table.clear(id, start_column, start_row, end_column = na, end_row = na) |
— | Limpia una celda o rango |
table.delete(id) |
— | Borra la tabla |
Posición: position.top_left, position.top_center, position.top_right, position.middle_left, position.middle_center, position.middle_right, position.bottom_left, position.bottom_center, position.bottom_right.
heatmap — mapa de calor
Dibuja celdas “precio × barra” bajo las velas igual que la heatmap incorporada. Funciona solo en scripts con overlay = true. Hasta cuatro capas (layer 0…3).
| Función | Qué hace |
|---|---|
heatmap.cell(price, value, layer = 0) |
Coloca un valor en la celda a precio price de la barra actual |
heatmap.depth(side = 0, min_qty = na, layer = 0) |
Rellena la capa con el libro de órdenes grabado de esa barra. side: 1 — solo bids, −1 — solo asks, 0 — ambos |
heatmap.config(layer = 0, grid = na, palette = na, opacity = na, gamma = na, low = na, high = na, scale = na, cut = na, merge = na) |
Estilo de la capa: paso de precio, paleta, opacidad en %, contraste, umbrales de paleta en %, cima de escala, recorte de celdas débiles, forma de sumar repeticiones |
Paletas: heatmap.viridis (por defecto), heatmap.magma, heatmap.inferno, heatmap.plasma, heatmap.turbo, heatmap.cividis, heatmap.ocean, heatmap.fire, heatmap.mono, heatmap.spectrum, heatmap.forest, heatmap.violet. Repeticiones de celda en la barra: heatmap.merge_max (por defecto) o heatmap.merge_sum.
Colecciones: array, map, matrix
El tipo de elemento se indica al crear: array.new<float>(0), map.new<string, float>(). Para que la colección sobreviva entre barras, créala con var. Las funciones se pueden llamar también como métodos: a.push(x) es lo mismo que array.push(a, x).
array
| Función | Devuelve | Qué hace |
|---|---|---|
array.new<T>(size = 0, initial = na) |
array<T> |
Array de size elementos con valor initial |
array.from(v0, v1, …) |
array<T> |
Array de los valores listados, hasta diez |
array.size(id) |
int |
Número de elementos |
array.get(id, index), array.set(id, index, value) |
T, — |
Lectura y escritura por índice |
array.push(id, value), array.pop(id) |
—, T |
Añadir al final, sacar del final |
array.unshift(id, value), array.shift(id) |
—, T |
Añadir al inicio, sacar del inicio |
array.insert(id, index, value), array.remove(id, index) |
—, T |
Insertar y eliminar por índice |
array.clear(id) |
— | Vaciar |
array.includes(id, value) |
bool |
¿Existe el valor? |
array.indexof(id, value), array.lastindexof(id, value) |
int |
Primera y última posición del valor |
array.sort(id, order = order.ascending) |
— | Ordena in-place; order.descending — descendente |
array.sum(id), array.avg(id) |
float |
Suma y promedio; na se ignoran |
array.min(id, nth = 0), array.max(id, nth = 0) |
float |
Mínimo y máximo; nth = 1 — segundo en orden |
array.join(id, separator = ",") |
string |
Elementos unidos por separador |
Otras funciones array
| Función | Devuelve | Qué hace |
|---|---|---|
array.fill(id, value, index_from = 0, index_to = na) |
— | Rellena un rango con un valor |
array.slice(id, index_from, index_to) |
array<T> |
Parte del array |
array.concat(id1, id2) |
array<T> |
Añade el segundo al primero |
array.copy(id) |
array<T> |
Copia |
array.reverse(id) |
— | Invierte in-place |
array.sort_indices(id, order = order.ascending) |
array<int> |
Índices en orden de ordenación |
array.binary_search(id, value), array.binary_search_leftmost(…), array.binary_search_rightmost(…) |
int |
Búsqueda binaria en array ordenado |
array.equals(id1, id2) |
bool |
Arrays iguales elemento a elemento |
array.median(id), array.mode(id), array.range(id) |
float |
Mediana, moda, rango |
array.stdev(id, biased = true), array.variance(id, biased = true) |
float |
Desviación estándar y varianza |
array.covariance(id1, id2, biased = true) |
float |
Covarianza de dos arrays |
array.abs(id) |
array<float> |
Array de módulos |
array.percentile_linear_interpolation(id, percentage) |
float |
Percentil con interpolación |
array.percentrank(id, index) |
float |
Rango porcentual del elemento |
map
| Función | Devuelve | Qué hace |
|---|---|---|
map.new<K, V>() |
map<K, V> |
Diccionario vacío |
map.put(id, key, value) |
V |
Escribe un valor, devuelve el anterior |
map.get(id, key) |
V |
Valor por clave o na |
map.contains(id, key) |
bool |
¿Existe la clave? |
map.remove(id, key) |
V |
Elimina la clave, devuelve el valor |
map.clear(id), map.size(id) |
—, int |
Vaciar; número de pares |
map.keys(id), map.values(id) |
array<K>, array<V> |
Claves y valores como array |
map.copy(id) |
map<K, V> |
Copia |
matrix — matrices
| Función | Devuelve | Qué hace |
|---|---|---|
matrix.new<T>(rows = 0, columns = 0, initial = na) |
matrix<T> |
Matriz del tamaño pedido |
matrix.get(id, row, column), matrix.set(id, row, column, value) |
T, — |
Leer y escribir elemento |
matrix.rows(id), matrix.columns(id) |
int |
Dimensiones |
matrix.add_row(id, row = na, values = na), matrix.add_col(id, column = na, values = na) |
— | Añade fila o columna; sin índice — al final |
matrix.remove_row(id, row = na), matrix.remove_col(id, column = na) |
array<T> |
Elimina fila/columna y la devuelve |
matrix.row(id, row), matrix.col(id, column) |
array<T> |
Fila o columna como array |
matrix.fill(id, value, from_row = 0, to_row = na, from_column = 0, to_column = na) |
— | Rellena un área |
matrix.copy(id), matrix.transpose(id) |
matrix<T> |
Copia y transpuesta |
matrix.mult(id1, id2), matrix.sum(id1, id2), matrix.diff(id1, id2) |
matrix<float> |
Producto, suma, diferencia de matrices |
matrix.det(id), matrix.trace(id) |
float |
Determinante y traza |
matrix.inv(id) |
matrix<float> |
Matriz inversa |
matrix.is_square(id) |
bool |
¿Matriz cuadrada? |
Límites: array — 100 000 elementos, map — 50 000 pares, matrix — 1 000 000 elementos.
request.security — otra temporalidad e instrumento
| Función | Devuelve | Qué hace |
|---|---|---|
request.security(symbol, timeframe, expression, gaps = false, lookahead = false, ignore_invalid_symbol = false) |
float |
Calcula expression en otra temporalidad o instrumento y devuelve el resultado en las barras del gráfico |
htfEma = request.security(sym.ticker, "60", ta.ema(close, 20))symbol—"EXCHANGE:SYMBOL"osym.ticker,timeframe— cadenas como"5","60","4h","1D","1W".- Una barra no cerrada del marco superior cambia hasta su cierre — tome
expression[1]si necesita historia inmutable. lookahead = truemira al futuro en la historia; el compilador lo avisará.- Dentro de
expressionno se puede leer el libro de órdenes ni la cinta de operaciones ni variables del gráfico — solo entradas y las propias series. - Límite — 8 pares distintos “instrumento + temporalidad” y 32 llamadas por script.
Ejemplos en la sección Otra temporalidad y otro instrumento.
Alertas y registro
| Función | Qué hace |
|---|---|
alert(message, freq = alert.freq_once_per_bar_close) |
Envía una alerta con texto. Solo funciona en vivo; en la historia está silenciosa |
alertcondition(condition, title, message = na) |
Declara una condición para que el usuario ponga una alerta desde el terminal. Se dispara al cierre de barra |
log.info(message), log.warning(message), log.error(message) |
Escribe una línea en la pestaña «Registro» del Editor. En la historia está silencioso |
Frecuencia alert: alert.freq_all — en cada pasada, alert.freq_once_per_bar — una vez por barra en la primera ocurrencia, alert.freq_once_per_bar_close — una vez por barra al cierre. Más detalles en Alertas desde scripts.
strategy — estrategias
Funciona solo en un script declarado con strategy(...). El probador ejecuta órdenes emuladas sobre la historia — no se colocan en el exchange. Cómo está hecho el probador se explica en Estrategias y probador.
Órdenes
| Función | Qué hace |
|---|---|
strategy.entry(id, direction, qty = na, limit = na, stop = na, oca_name = na, oca_type = strategy.oca.none, comment = na, when = true) |
Entrada en strategy.long o strategy.short. Tiene en cuenta el modelo de posición y pyramiding; una entrada contra la posición la invertirá |
strategy.order(id, direction, qty = na, limit = na, stop = na, oca_name = na, oca_type = strategy.oca.none, comment = na, when = true) |
Orden que elude las reglas de entrada: no respeta el modelo de posición ni pyramiding |
strategy.exit(id, from_entry = na, qty = na, qty_percent = na, profit = na, limit = na, loss = na, stop = na, trail_price = na, trail_points = na, trail_offset = na, oca_name = na, comment = na, when = true) |
Salida por take, stop o trailing. profit, loss, trail_points — en ticks; limit, stop, trail_price — en precio |
strategy.close(id, comment = na, qty = na, qty_percent = na, when = true) |
Cierra la posición de la entrada id al mercado |
strategy.close_all(comment = na, when = true) |
Cierra todo |
strategy.cancel(id, when = true), strategy.cancel_all(when = true) |
Cancela órdenes no ejecutadas |
Si qty no se especifica, el tamaño se toma de defaultQtyType y defaultQtyValue de la declaración. Grupos OCA: strategy.oca.none, strategy.oca.cancel, strategy.oca.reduce.
Estado
| Nombre | Tipo | Qué contiene |
|---|---|---|
strategy.position_size |
float |
Tamaño de la posición: positivo — largo, negativo — corto |
strategy.position_avg_price |
float |
Precio medio de entrada |
strategy.position_entry_name |
string |
Nombre de la entrada que abrió la posición |
strategy.openprofit, strategy.netprofit |
float |
Resultado no realizado y realizado |
strategy.grossprofit, strategy.grossloss |
float |
Suma de ganancias y suma de pérdidas |
strategy.equity, strategy.initial_capital |
float |
Capital actual e inicial |
strategy.max_drawdown, strategy.max_runup |
float |
Mayor drawdown y mayor runup |
strategy.wintrades, strategy.losstrades, strategy.eventrades |
int |
Operaciones ganadoras, perdedoras, en cero |
strategy.opentrades, strategy.closedtrades |
int |
Operaciones abiertas y cerradas |
strategy.margin_liquidation_price |
float |
Precio de liquidación dado un margen |
strategy.funding_paid |
float |
Funding pagado y recibido |
Campos de operaciones y constantes
Los campos de una operación abierta por índice i — strategy.opentrades.<campo>(i), y de una cerrada — strategy.closedtrades.<campo>(i):
| Campo | Tipo | Qué contiene |
|---|---|---|
entry_price, entry_bar_index, entry_time, entry_id |
float, int, int, string |
Precio, barra, tiempo y nombre de la entrada |
size |
float |
Tamaño de la operación |
profit, max_runup, max_drawdown |
float |
Resultado, mejor y peor momento de la operación |
commission, funding |
float |
Comisión y funding de la operación |
exit_price, exit_bar_index, exit_time, exit_id, exit_reason |
float, int, int, string, int |
Solo en cerradas: precio, barra, tiempo, nombre y razón de salida |
Razones de salida: strategy.exit_reason.stop_loss, take_profit, trailing_stop, market_order, reverse, oca, liquidation, end_of_data. Esta versión no devuelve la razón oca.
Constantes de la declaración: strategy.long, strategy.short, strategy.model.netting, strategy.model.hedging, strategy.qty.fixed, strategy.qty.cash, strategy.qty.percent_of_equity, strategy.qty.risk_percent, strategy.commission.percent, strategy.commission.cash_per_contract, strategy.commission.cash_per_order, strategy.fill.conservative, strategy.fill.optimistic.
Datos de order flow
Estos espacios son lo que no existe en lenguajes de indicadores normales: clústeres, delta, interés abierto, tasa de financiación, historia del libro de órdenes y datos en vivo. Si no hay datos para la barra, el valor es na, no cero. De dónde vienen los datos y cómo comprobar su disponibilidad se explica en Datos de mercado: clústeres, delta, interés abierto, tasa de financiación, historia del libro, libro de órdenes y cinta de operaciones en vivo, screener.
Historia: disponible en cada barra
| Espacio | Nombres |
|---|---|
cluster — clústeres de la barra |
available (datos cargados), levels (número de niveles), total (volumen de la barra), delta, poc y poc_index (precio y índice del nivel con más volumen), max_cell (volumen de la celda más grande), grid_step (paso de precio), stacked_buy / stacked_sell (precio de inicio de una serie de desbalances), stacked_buy_steps / stacked_sell_steps (longitud de la serie en niveles) |
cluster — funciones |
cluster.price(index), cluster.bid(index), cluster.ask(index) — precio y volúmenes del nivel, contado desde abajo; cluster.imbalance(index) → int: 1 — predominio de compras, −1 — ventas, 0 — ninguno; cluster.value_area(coverage) → [low, high] — zona de valor con la fracción de volumen coverage |
delta — delta de la barra |
available, value (compras menos ventas), buy, sell, cum (acumulada), min / max (extremos dentro de la barra), open / high / low / close (delta como vela), trades (número de operaciones), usd (en moneda cotizada) |
oi — interés abierto |
available, open, high, low, close, usd, coins, change (cambio respecto a la barra anterior) |
funding — tasa de financiación |
available, rate (estimación de la tasa), interval_hours (int, horas entre liquidaciones), settled (en la barra hubo liquidación), settled_rate (tasa aplicada), cum (acumulada) |
depth — historia del libro de órdenes |
available, levels, grid_step, best_bid, best_ask, max_cell; depth.price(index), depth.qty(index), depth.side(index) (1 — bid, −1 — ask); depth.at(price); depth.bid_sum(percent), depth.ask_sum(percent), depth.imbalance(percent) — en la franja percent % desde el centro; depth.max_bid(percent), depth.max_ask(percent) → [price, qty] |
Solo en vivo: en la historia siempre na
| Espacio | Nombres |
|---|---|
book — libro de órdenes |
available, spread, mid; book.bid(index), book.ask(index) — precios de niveles desde el mejor; book.bid_qty(index), book.ask_qty(index) — volúmenes; book.imbalance(depth) — desbalance en depth niveles, −1…1 |
tape — cinta de operaciones |
available, last_price, last_qty, last_side (1 — comprador, −1 — vendedor); tape.count(window_ms) → int, tape.buy_volume(window_ms), tape.sell_volume(window_ms), tape.max_print(window_ms) — en los últimos window_ms milisegundos |
screener — métricas del screener |
available; screener.natr(window), screener.rvol(window), screener.avg_vol(window), screener.btc_corr(window), screener.change(window), screener.oi_delta(window), screener.vol(window) |
Las ventanas del screener son cadenas: natr — "1m", "5m"; rvol — "1h", "24h"; avg_vol — "1m", "5m", "15m", "1h"; btc_corr — "1m", "5m"; change y oi_delta — "1m", "5m", "1h", "24h" (change además "15m"); vol — "1m", "5m", "15m", "1h", "24h". Una ventana no listada devuelve na.