LootX

Referencia de funciones

Actualizado 30 de septiembre de 2026 Esta página en PDF

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.

Loot
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.
  • = na en 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
Loot
htfEma = request.security(sym.ticker, "60", ta.ema(close, 20))
  • symbol — "EXCHANGE:SYMBOL" o sym.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 = true mira al futuro en la historia; el compilador lo avisará.
  • Dentro de expression no 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.

Siguiente

FAQ

¿Por qué sma(close, 20) no compila?
En LootScript todas las funciones de indicador viven en el espacio ta: escribe ta.sma(close, 20). El compilador no reconoce el nombre sin el espacio y muestra el error LS2002.
¿Se puede pasar a ta.sma una longitud que cambie de barra en barra?
No. La longitud de la ventana debe conocerse antes de la primera barra: un literal, input.int o una constante. De lo contrario el compilador mostrará LS2014.
¿Cuántas salidas puede dibujar un indicador con plot?
Un script puede declarar hasta 64 salidas, pero el panel del gráfico dibuja las tres primeras series plot.
¿Hay historial para book.* y tape.*?
No, el libro de órdenes y la cinta de operaciones están disponibles solo en vivo: en barras históricas sus valores son na. El historial del libro de órdenes por barras está en el espacio depth.