Язык Loot
LootScript — indicadores y alertas personalizados en el terminal, backtest de estrategias.
1Lenguaje LootScript
Qué es LootScript: indicadores, estrategias y bibliotecas que funcionan directamente en el terminal sobre los datos del gráfico. Qué datos están disponibles, cómo activar los scripts y qué no hacen.
LootScript es el lenguaje de scripts del terminal LootX. Con él se escriben indicadores propios, estrategias para probar ideas sobre el historial y bibliotecas de funciones comunes. Un script es un archivo de texto que se ejecuta directamente en el terminal sobre los datos del gráfico al que lo agregaste: velas, volumen, delta, clústeres, interés abierto, tasa de financiación.
Así se ve un indicador completo: el delta de cada vela en columnas debajo del gráfico:
indicator("Дельта бара", overlay = false)
d = delta.available ? delta.value : na
plot(d, "Дельта", style = plot.style_columns, color = d >= 0 ? color.teal : color.red)Abrir el editor, escribir un indicador y agregarlo al gráfico.
Sintaxis y tiposVariables, na, historial de velas, condiciones, bucles, funciones.
Parámetros de entrada, líneas, niveles, marcadores, etiquetas y colores.
Datos de mercadoDelta, clústeres, interés abierto, tasa de financiación, libro de órdenes, otras temporalidades.
Estrategias y testerReglas de entrada y salida, ejecución sobre el historial, informe de operaciones.
Referencia de funcionesTodas las funciones y constantes integradas del lenguaje.
Qué se puede escribir
La primera línea del script declara su tipo, y del tipo depende lo que el script tiene permitido hacer.
| Tipo | Primera línea | Qué hace |
|---|---|---|
| Indicador | indicator("Название") |
Calcula valores por velas y los dibuja: líneas, histogramas, niveles, marcadores, fondo, etiquetas. Dibuja sobre el precio o en un panel separado debajo del gráfico. |
| Estrategia | strategy("Название") |
Lo mismo que un indicador, más reglas de entrada y salida. Las órdenes de la estrategia son virtuales: las ejecuta el Tester de estrategias sobre el historial y muestra operaciones, curva de capital y métricas. |
| Biblioteca | library("Название", 1) |
Guarda funciones que otros scripts tuyos pueden incluir. No se agrega al gráfico y no dibuja nada. |
Además de tus propios scripts, puedes importar scripts ya hechos en formato Pine Script: el terminal los traducirá a LootScript al importarlos. Cómo funciona y qué revisar después de la traducción, en la página Importar desde Pine Script.
Qué datos están disponibles para el script
- Velas del gráfico:
open,high,low,close,volume, el tiempo de la vela y derivados comohl2. - Flujo de órdenes: delta de compras y ventas agresivas, clústeres por niveles de precio, interés abierto, tasa de financiación, historial grabado del libro de órdenes, métricas del screener.
- Libro de órdenes en vivo y cinta de operaciones — solo en la vela actual, aún no cerrada: su historial no se graba.
- Otras temporalidades e instrumentos — mediante la consulta de una serie desde una temporalidad mayor o desde otra moneda.
Si el exchange no entrega algún indicador o no hay datos para una vela, el script recibe no un cero, sino el valor especial na — “sin valor”. En el gráfico eso es una interrupción de la línea, no un falso cero. Detalles y cobertura por exchange en la página Datos de mercado.
Dónde se ejecuta el script
El script funciona dentro del terminal en tu computadora. No se envía ni se ejecuta en el servidor de LootX.
- Aislamiento. El script no tiene acceso a la red, a archivos, a conexiones de exchanges ni a API keys. Esas funciones simplemente no existen en el lenguaje: ni por accidente ni a propósito el script puede transmitir tus datos a ningún lado.
- Límites. Un bucle demasiado largo o un arreglo enorme detiene solo ese script. Los demás indicadores, los paneles y el propio terminal siguen funcionando, y el motivo de la detención se ve en el editor.
- Archivos. Cada script es un archivo separado con extensión
.loot. En Windows se guardan en la carpeta%APPDATA%\TradingTerminal\scripts\, fuera de la carpeta de instalación, por eso las actualizaciones del terminal no los tocan. Mover un script a otra computadora es copiar el archivo.
Cómo activar los scripts
Los scripts son un módulo aparte que se activa para tu cuenta de LootX. Para que funcione, inicia sesión con tu cuenta en el terminal.
Cuando el módulo está activo, en la ventana de indicadores del gráfico (botón ƒ en el panel del gráfico) aparecen las secciones Favoritos, Mis scripts, Integrados y Estrategias, y arriba los botones Importar… y Editor….
Cuando el módulo no está activo, los scripts no se muestran en absoluto: la ventana de indicadores contiene solo los indicadores integrados, no hay editor ni importación. Tampoco hay candados ni ofertas de compra: el terminal se ve como si los scripts no existieran. En cuanto el acceso esté disponible, la ventana de indicadores se reorganiza sola, no hace falta reiniciar el terminal.
El acceso se otorga por cuenta, como parte de un plan o por separado. Los planes vigentes están en la página Suscripciones.
Qué no hacen los scripts
- No accede a internet ni lee archivos. Todo lo que el script conoce son los datos del gráfico en el que está.
- No se publica ni se vende. No hay catálogo de scripts: un script es tu archivo local, y solo puedes compartirlo pasando el archivo.
- No ejecuta Pine Script directamente. Los scripts en ese formato primero se traducen a LootScript al importarlos; no se garantizan cifras idénticas a las de otras plataformas.
Siguiente
https://docs.lootx.trade/es/loot/overview
2Referencia 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.
Siguiente
https://docs.lootx.trade/es/loot/reference
3Primer script
Paso a paso: cómo abrir el editor de LootScript, escribir un indicador de dos líneas, añadirlo al gráfico, leer errores y encontrar el archivo del script. Segundo ejemplo: un canal con ajustes.
En esta página recorrerá el camino desde un editor vacío hasta su propio indicador en el gráfico: escribirá un script de dos líneas, verá cómo el editor detecta errores, sabrá dónde está el archivo y añadirá la ventana de ajustes. Necesitará un gráfico abierto y scripts activados; si no están en la ventana de indicadores, lea la sección Cómo activar los scripts.
Abra el editor
Abra la ventana de indicadores
En el panel del gráfico, haga clic en el botón ƒ — su tooltip es «Indicadores».
Inicie el editor
Haga clic en Editor… junto al campo de búsqueda o en Nuevo script en la parte inferior de la ventana. Para abrir un script existente, búsquelo en la sección Mis scripts y haga clic en el lápiz Editar script de su fila (o seleccione la fila y pulse Ctrl+E).
Localice los botones necesarios
El editor se abre en una ventana separada con su propio botón en la barra de tareas; puede moverla a un segundo monitor. En la parte superior está la lista desplegable de scripts y los botones Nuevo, Guardar y Añadir al gráfico; abajo, las pestañas Problemas, Registro y Salida.
El editor recuerda el panel del gráfico desde cuya ventana de indicadores se abrió; añadirá el script en ese panel. Si el editor se abre de otra manera, el script irá al panel de gráfico activo.
Escriba el indicador
El botón Nuevo (Ctrl+N) crea un script a partir de una plantilla: una media móvil con un ajuste:
indicator("Без названия", overlay = true)
length = input.int(20, "Length", minval = 1)
plot(ta.ema(close, length), "EMA", color = color.orange)Sustituya el texto por el indicador funcional más corto: una media simple de 20 velas:
indicator("Мой первый индикатор", overlay = true)
plot(ta.sma(close, 20), "Средняя 20", color = color.orange)Qué está escrito aquí:
indicator(...)es la declaración, primera línea obligatoria de cualquier script. El nombre aparecerá en la lista Mis scripts y en la leyenda del gráfico.overlay = truedibuja sobre las velas; conoverlay = falseel indicador tendrá un panel separado bajo el gráfico.ta.sma(close, 20)es la media de los precios de cierre de las últimas 20 velas.plot(...)dibuja una línea: un valor por cada vela. El segundo argumento es el nombre de la línea en los ajustes,colores el color.
El script se ejecuta para cada vela, en orden desde la más antigua hasta la actual. Las primeras 19 velas no tienen suficiente historial para la media, por lo que la línea no comienza desde el borde izquierdo; es normal. El editor indica cuántas velas tarda este «calentamiento» en la barra de estado inferior.
Mientras escribe, el editor sugiere nombres de funciones y constantes; tras el paréntesis de apertura muestra los parámetros de la función y, al pasar el cursor sobre un nombre, su descripción. La lista de sugerencias se puede invocar manualmente con Ctrl+Space.
Guarde y añada al gráfico
- Guardar (Ctrl+S) escribe el script en la carpeta de scripts. Mientras haya cambios sin guardar, aparece un punto
•antes del nombre del archivo en el título de la ventana. - Añadir al gráfico (Ctrl+Enter) comprueba el script, lo guarda y lo coloca en el panel del gráfico. En el panel del editor aparecerá el mensaje: «Mi primer indicador» añadido al gráfico.
Listo: la línea está en el gráfico y el nombre del indicador en la leyenda. El indicador se guarda en la vista y volverá tras reiniciar el terminal.
Cómo muestra el editor los errores
El script se comprueba solo, un instante después de que deje de escribir. El resultado se ve en la cabecera del editor: compilando…, luego ok · 12 ms o, si algo va mal, errores: 1 o advertencias: 1.
Pruebe a equivocarse: escriba ta.smaa en lugar de ta.sma. El lugar del error se subraya con una línea ondulada, el contador de la cabecera muestra errores: 1 y en la pestaña Problemas aparece una fila con el código de error, la explicación y la posición:
LS2002 Неизвестное имя «ta.smaa» — проверьте написание или объявите его выше Стр 3:6Un doble clic en la fila lleva el cursor al lugar del error. Cada error tiene un código permanente del tipo LS####, y el texto sugiere de inmediato cómo corregirlo. El análisis de errores frecuentes está en la página Errores de compilación y ejecución.
Un script con errores no se añadirá al gráfico: Añadir al gráfico responderá «Un script con errores no se coloca en el gráfico; véase «Problemas»» y moverá el cursor al primer error. En la ventana de indicadores, dicho script se marca con una etiqueta roja con el número de errores en lugar de la etiqueta Script.
También hay errores en tiempo de ejecución; por ejemplo, un bucle que no cabe en el tiempo asignado. Entonces el script se detiene y la causa se ve en la pestaña Salida: «Script detenido: …». Los demás indicadores y el terminal siguen funcionando.
Edición de un script que ya está en el gráfico
Mientras edita, el gráfico sigue mostrando la versión que añadió. En cuanto el editor tiene una versión correcta distinta de la del gráfico, ocurren dos cosas:
- en el panel del editor aparece el botón Actualizar indicador;
- en la leyenda del indicador en el gráfico aparece un icono de actualización.
Cualquiera de ellos guarda el script y lo sustituye en todos los gráficos donde esté. Añadir al gráfico para un script que ya está añadido en algún lugar hace lo mismo: actualiza todas las copias, no coloca una segunda. Cuántos paneles recibirán la nueva versión lo muestra la etiqueta en gráficos: N en la cabecera del editor.
Dónde están los archivos
En Windows, los scripts se guardan en la carpeta %APPDATA%\TradingTerminal\scripts\, un archivo .loot por script. Es texto plano; puede abrirlo con cualquier editor, copiarlo o guardarlo en una copia de seguridad. La carpeta está fuera de la carpeta de instalación, por lo que las actualizaciones del terminal no la tocan.
El nombre del archivo se genera a partir del título en el primer guardado: los espacios se sustituyen por guiones bajos y la cirílica se conserva. «Mi primer indicador» se convertirá en el archivo Мой_первый_индикатор.loot.
Cuando la carpeta se crea por primera vez, se incluyen seis scripts iniciales: Dos medias móviles, RSI con zonas, Impulso de volumen, Delta acumulada, Interés frente a precio y Tasa de financiación anualizada. Están en la sección Mis scripts; conviene abrirlos y analizarlos.
Segundo ejemplo: canal con ajustes
Hagamos un script más útil: un canal de una media y dos bordes a una distancia de varias desviaciones estándar. El periodo, la anchura y la fuente de precio se llevarán a los ajustes, y los bordes superior e inferior se resaltarán en rojo cuando el precio los supere.
indicator("Канал вокруг средней", overlay = true)
length = input.int(20, "Период", minval = 2)
mult = input.float(2.0, "Ширина в сигмах", minval = 0.1, step = 0.1)
src = input.source(close, "Источник")
basis = ta.sma(src, length)
dev = mult * ta.stdev(src, length)
upper = basis + dev
lower = basis - dev
plot(basis, "Середина", color = color.gray)
plot(upper, "Верх", color = close > upper ? color.red : color.teal)
plot(lower, "Низ", color = close < lower ? color.red : color.teal)Novedades:
- Cada llamada
input.*se convierte en una fila en la ventana de ajustes del indicador, en el orden en que está escrita.minvalimpide introducir un periodo menor que dos, ystep = 0.1significa que el campo de anchura muestra un decimal. input.sourcese convierte en una lista desplegable de series:close,open,hl2,volumey otras.- El color de los bordes es una expresión, por lo que se calcula para cada vela por separado.
Añada el script al gráfico y haga doble clic en su fila de la leyenda (o haga clic en el icono de ajustes que hay en ella). En la pestaña Entradas están sus tres ajustes: cambie el periodo y las líneas se recalcularán al instante. Los valores se recuerdan para este indicador en este gráfico; el botón Por defecto devuelve los escritos en el código. En la pestaña Estilo están el color de la media y el grosor de cada línea; en la pestaña Visibilidad, las casillas para ocultar cualquiera de las tres líneas. El color de los bordes no está en los ajustes: lo elige el propio script en cada vela.
Siguientes pasos
https://docs.lootx.trade/es/loot/first-script
4Синтаксис и типы
Как устроен LootScript: выполнение по барам, объявление скрипта, пять форм присваивания, типы и квалификаторы, na, история x[n], операторы, условия, switch, циклы, функции и свои типы.
Эта страница — краткое описание языка: как выполняется скрипт, как объявлять переменные, какие есть типы, что такое na, как читать прошлые бары, как писать условия, циклы и функции. Все примеры — целые рабочие скрипты: их можно вставить в редактор и добавить на график.
Как выполняется скрипт
Всё, что написано на верхнем уровне файла, выполняется один раз на каждый бар — от самого старого загруженного к текущему, строка за строкой. Поэтому переменная в LootScript хранит не одно число, а значение на каждом баре, и к прошлым значениям можно обратиться.
indicator("Тело свечи")
body = close - open // считается заново на каждом баре
plot(body, "Тело", style = plot.style_columns)На текущем, ещё не закрытом баре скрипт пересчитывается с каждым новым тиком, начиная с состояния, которое было на закрытии предыдущего бара. Закрытые бары при этом не пересчитываются.
Объявление
Первая инструкция скрипта — ровно одно объявление: indicator(...), strategy(...) или library(...). Выше него могут стоять только комментарии и необязательная строка версии #version 1. Без объявления скрипт не скомпилируется с ошибкой «Нет объявления скрипта — начните с indicator(“Название”)».
#version 1
// Комментарии и строка версии могут стоять выше объявления.
indicator("Размах бара", shortTitle = "Размах", overlay = false)
plot(high - low, "Размах", style = plot.style_histogram)Главные параметры индикатора: title — название в списке скриптов, shortTitle — короткое имя для легенды, overlay — рисовать поверх цены (true) или в отдельной панели (false, по умолчанию). Параметры стратегии описаны на странице Стратегии и тестер.
Переменные и присваивание
| Форма | Что делает |
|---|---|
x = выражение |
Объявляет переменную. На каждом баре она считается заново. |
x := выражение |
Присваивает новое значение уже объявленной переменной. Тип должен совпадать. |
var x = выражение |
Объявляет переменную один раз, на первом баре. Значение переходит на следующие бары. |
varip x = выражение |
Как var, но значение сохраняется и между тиками текущего бара. |
[a, b, c] = функция(...) |
Раскладывает несколько результатов функции по переменным. |
Для изменения уже объявленной переменной есть и короткие формы: +=, -=, *=, /=, %=. Тип можно указать явно: float level = 0. Имена встроенных рядов и пространств (close, volume, ta и других) заняты — назвать так свою переменную нельзя.
Главное отличие от привычных языков — обычная переменная не накапливает значение между барами. Для счётчиков и сумм нужен var:
indicator("Счётчик зелёных свечей")
var greens = 0 // объявляется один раз и переживает переход к следующему бару
if close > open {
greens += 1
}
today = 0 // а эта переменная равна 0 на каждом новом баре
today := today + 1 // поэтому здесь всегда 1
plot(greens, "Зелёных с начала истории")varip нужен редко — например, чтобы считать тики внутри бара. На истории тиков нет, поэтому такое значение на прошлых барах будет другим, чем было вживую. Если значение varip попадает на график, редактор предупредит о перерисовке.
Типы
| Тип | Что хранит | Пример |
|---|---|---|
int |
целое число | 14, 1_000_000, 0xFF |
float |
дробное число | 2.5, .5, 1e-9 |
bool |
истина или ложь | true, false |
string |
текст | "BTC", 'BTC' |
color |
цвет с прозрачностью | #FF9800, #FF980080, color.teal |
Есть и составные типы: массивы array<float>, словари map<string, float>, матрицы matrix<float>, а также ваши собственные типы и перечисления (см. ниже) и графические объекты line, box, label, table.
Правила, о которые спотыкаются чаще всего:
- Тип фиксируется при объявлении. После
x = 1присвоитьx := 2.5нельзя:x— целое. Пишитеx = 1.0илиfloat x = 1. - Целое превращается в дробное само, обратно — только явно:
math.round,math.floor,math.ceil,math.trunc. - Деление целых — целое:
7 / 2равно3. Нужна дробь — сделайте одно из чисел дробным:7.0 / 2. - Возведение в степень
^всегда даёт дробное число:2 ^ 3равно8.0. - Строку нельзя сложить с числом.
"Цена: " + closeне скомпилируется — пишите"Цена: " + str.tostring(close). - Условие — только
bool.if volume { … }— ошибка; пишитеif volume > 0 { … }.
Квалификаторы: насколько значение постоянно
Кроме типа у каждого значения есть квалификатор — насколько оно постоянно во время работы скрипта. От слабого к сильному:
| Квалификатор | Когда известно значение | Пример |
|---|---|---|
const |
уже при компиляции | 14, "EMA" |
input |
после чтения настроек, дальше не меняется | input.int(14, "Период") |
simple |
при запуске, дальше не меняется | шаг цены инструмента |
series |
может меняться на каждом баре | close, bar_index |
На практике это важно в одном месте: периоды функций ta.* должны быть постоянными — литералом или настройкой. Иначе функции пришлось бы пересобирать своё состояние на каждом баре.
indicator("Период из настроек")
len = input.int(14, "Период", minval = 2)
plot(ta.rsi(close, len), "RSI")
// ta.rsi(close, bar_index) не скомпилируется:
// «length» в «ta.rsi» требует значение не слабее input, а передано seriesna — нет значения
na означает «значения нет»: не хватает истории для расчёта, биржа не отдаёт показатель, в данных дыра. na есть в любом типе.
- Арифметика с
naдаётna:na + 1— этоna. - Любое сравнение с
naложно, поэтомуif x > 0приx = naне выполнится. - Проверяйте отсутствие только через
na(x). Записьx == naкомпилятор отклонит с ошибкой «Сравнение с na всегда ложно — используйте na(x)». nz(x)подставляет 0 вместоna,nz(x, v)— значениеv. То же короче:x ?? v.naна графике — разрыв линии, а не ноль.
indicator("Средняя без пустого начала", overlay = true)
avg = ta.sma(close, 50) // на первых 49 барах — na
line1 = na(avg) ? close : avg // проверка через na(x)
line2 = avg ?? close // то же короче
plot(line2, "Средняя или цена", color = color.orange)История: x[n]
x[n] — значение x на баре, который был n баров назад; x[0] — текущее. Работает с любым рядом, в том числе с вашими переменными.
indicator("Наклон средней")
ma = ta.ema(close, 20)
slope = ma - ma[1] // изменение за один бар
plot(slope, "Наклон", style = plot.style_histogram,
color = slope >= 0 ? color.teal : color.red)- Если
nбольше числа баров до начала истории, результат —na, а не ошибка. nможет меняться от бара к бару:close[len]при переменномlenдопустимо.- Отрицательный индекс — ошибка: заглядывать в будущие бары нельзя.
- Настраивать глубину истории не нужно: скрипту доступна вся история, загруженная на график.
Операторы
От высшего приоритета к низшему:
| Приоритет | Операторы |
|---|---|
| 1 | x[n], вызов f(…), доступ через точку a.b |
| 2 | ^ — степень, вычисляется справа налево |
| 3 | унарные -, +, not |
| 4 | *, /, % |
| 5 | +, - |
| 6 | <, >, <=, >= |
| 7 | ==, != |
| 8 | and |
| 9 | or |
| 10 | ?? — замена na |
| 11 | ? : — условное выражение |
- Сравнения не сцепляются: вместо
a < b < cпишитеa < b and b < c. andиorне вычисляют правую часть, если ответ уже ясен по левой.- Степень старше унарного минуса:
-2 ^ 2равно-4. Нужно4— пишите(-2) ^ 2. - Дробные числа сравнивайте с допуском:
math.approx(a, b), потому что0.1 + 0.2 == 0.3ложно.
Условия
Блоки всегда в фигурных скобках. if бывает инструкцией и выражением; для простого выбора из двух есть ? :.
indicator("Направление бара")
dir = 0
if close > open {
dir := 1
} else if close < open {
dir := -1
}
// if как выражение: обе ветки обязательны
bodySize = if close >= open { close - open } else { open - close }
// условный оператор для простых случаев
barColor = dir > 0 ? color.teal : color.red
plot(bodySize, "Тело", style = plot.style_columns, color = barColor)switch
switch выбирает первую подходящую ветку. Форма с объектом сравнивает его со значениями веток, форма без объекта проверяет условия по порядку. Ветка => без условия — ветка по умолчанию. Проваливания в следующую ветку нет. Когда switch возвращает значение, ветка по умолчанию обязательна.
indicator("Средняя на выбор", overlay = true)
kind = input.string("EMA", "Тип средней", options = ["EMA", "SMA", "WMA"])
ma = switch kind {
"EMA" => ta.ema(close, 20)
"SMA" => ta.sma(close, 20)
=> ta.wma(close, 20)
}
zone = switch {
close > ma * 1.02 => 1
close < ma * 0.98 => -1
=> 0
}
plot(ma, "Средняя", color = zone == 1 ? color.teal : zone == -1 ? color.red : color.gray)Циклы
for i in a .. b перебирает числа от a включительно до b не включительно. Шаг задаётся словом by, в том числе отрицательный. Переменная цикла существует только внутри цикла и не меняется в теле.
indicator("Зелёные свечи за N баров")
n = input.int(10, "Сколько баров", minval = 1, maxval = 200)
greens = 0
for i in 0 .. n { // i = 0, 1, …, n − 1
if close[i] > open[i] {
greens += 1
}
}
plot(greens, "Зелёных", style = plot.style_columns)indicator("Виды циклов")
total = 0
for i in 0 .. 10 by 2 { // 0, 2, 4, 6, 8
total += i
}
for i in 10 .. 0 by -1 { // 10, 9, …, 1
if i % 3 == 0 {
continue // сразу к следующему шагу
}
total += i
}
var closes = array.new<float>(0)
closes.push(close)
if closes.size() > 20 {
closes.shift()
}
sum = 0.0
for v in closes { // по элементам массива; for [i, v] in … — с индексом
sum += v
}
k = 0
while k < 100 {
k += 7
if k > 50 {
break // выход из цикла
}
}
plot(sum / closes.size(), "Средняя из массива")Бесконечный цикл терминал не повесит: у скрипта есть бюджет операций на бар и лимит времени. Превысив их, скрипт остановится с сообщением «Скрипт исчерпал бюджет операций на бар — упростите цикл» или «Скрипт превысил лимит времени на проход».
Функции
Функция объявляется словом func. Короткая форма — выражение после =>, длинная — тело в скобках с return. Типы параметров можно не указывать — они выводятся из вызовов, а у параметров могут быть значения по умолчанию. Аргументы передаются по порядку или по имени.
indicator("Z-оценка объёма")
func barRange(h, l) => h - l
func zscore(series float src, input int len) => float {
m = ta.sma(src, len)
s = ta.stdev(src, len)
return s == 0 ? na : (src - m) / s
}
func scaled(x, k = 2.0) => x * k
z = zscore(volume, 50)
plot(z, "Z объёма", style = plot.style_columns, color = z > 2 ? color.orange : color.gray)
plot(scaled(barRange(high, low), k = 0.5), "Полразмаха")- Рекурсии нет. Функция не может вызывать саму себя, ни напрямую, ни через другую функцию. Повторение пишется циклом.
- Состояние — у каждого вызова своё. Если внутри функции есть
ta.*илиvar, два вызова одной функции ведут независимые расчёты:
indicator("Два вызова одной функции", overlay = true)
func smooth(src, len) => ta.ema(src, len)
fast = smooth(close, 10) // своя средняя
slow = smooth(close, 30) // другая, независимая средняя
plot(fast, "Быстрая", color = color.teal)
plot(slow, "Медленная", color = color.orange)Функции, нужные в нескольких скриптах, выносят в библиотеку: скрипт с объявлением library("Имя", 1), перед функциями — слово export, в другом скрипте — import Имя/1 as имя. Библиотека берётся из вашей папки скриптов.
Несколько результатов
Некоторые функции возвращают сразу несколько рядов: ta.bb, ta.macd, ta.kc, ta.dmi, ta.supertrend и другие. Их результат раскладывается по переменным в квадратных скобках; число имён должно совпадать с числом результатов.
indicator("Полосы Боллинджера", overlay = true)
[basis, upper, lower] = ta.bb(close, 20, 2.0)
plot(basis, "Середина", color = color.gray)
plot(upper, "Верх", color = color.teal)
plot(lower, "Низ", color = color.teal)Свои типы и перечисления
type собирает несколько полей в одну структуру. Объект создаётся через Имя.new(...), поля читаются и меняются через точку.
indicator("Последний локальный максимум", overlay = true)
type Swing {
int barIndex
float price
}
var Swing last = Swing.new(barIndex = 0, price = high)
ph = ta.pivothigh(high, 5, 5)
if not na(ph) {
last.barIndex := bar_index - 5
last.price := ph
}
plot(last.price, "Максимум", style = plot.style_stepline, color = color.orange)enum — закрытый список вариантов с подписями. Удобнее строк: опечатка в имени варианта — ошибка компиляции, а не тихо не сработавшее условие. Вместе с input.enum перечисление превращается в выпадающий список в настройках — см. Настройки и отрисовка.
indicator("Режим рынка")
enum Regime {
trend = "Тренд"
flat = "Флэт"
}
regime = math.abs(close - close[20]) > ta.atr(14) * 3 ? Regime.trend : Regime.flat
plot(regime == Regime.trend ? 1 : 0, "Тренд", style = plot.style_stepline)Функции ta.* внутри условий
Функции вроде ta.ema, ta.rsi или ta.atr помнят своё состояние с прошлого бара. Если бы такой вызов выполнялся только на части баров — внутри if или одной ветки ? :, — его расчёт пропускал бы бары и тихо давал неверные числа.
LootScript этого не допускает: компилятор сам выносит каждый вызов ta.* из условия и выполняет его на каждом баре, а условие лишь выбирает, использовать ли результат. Поэтому такой код считает RSI правильно:
indicator("RSI только на зелёных барах")
r = close > open ? ta.rsi(close, 14) : na
plot(r, "RSI", style = plot.style_circles)Вынести вызов нельзя, только если его аргумент сам рождается внутри ветки. Тогда компилятор не угадывает, а сообщает: «Аргумент «len» нельзя вычислить вне ветки — вынесите вызов ta.* на верхний уровень». Решение — посчитать аргумент до условия:
indicator("Аргумент до условия")
// Так нельзя — len объявлена внутри ветки:
// if close > open {
// len = 10
// e = ta.ema(close, len)
// }
len = 10
e = ta.ema(close, len)
plot(close > open ? e : na, "EMA на зелёных барах", style = plot.style_circles)Комментарии и перенос строк
//— комментарий до конца строки,/* … */— блочный, блоки можно вкладывать друг в друга.- Инструкция заканчивается с концом строки, точка с запятой не нужна.
- Длинное выражение продолжается на следующей строке, если строка оборвана внутри скобок, заканчивается оператором или следующая строка начинается с оператора,
?или:.
indicator("Перенос строк")
typical = high
+ low
+ close
signal = close > open
? typical / 3
: na
plot(signal, "Типичная цена на зелёных барах", style = plot.style_circles)Дальше
https://docs.lootx.trade/es/loot/syntax
5Ajustes y renderizado
Ajustes input.* en la ventana del indicador, líneas plot y sus estilos, niveles hline, rellenos fill, fondo y color de velas, marcadores, etiquetas, segmentos, rectángulos, tablas, colores y transparencia. Límites: tres plot dibujables y 500 objetos de cada tipo.
Esta página trata sobre lo que el usuario ve y puede cambiar. Aquí se describen los ajustes que el script expone en la ventana del indicador, las líneas y sus estilos, los niveles y rellenos, el fondo y el color de las velas, los marcadores, las etiquetas, los segmentos, los rectángulos y las tablas, así como los colores y la transparencia. Al final hay una sección sobre los límites que conviene conocer de antemano.
Ajustes: input.*
Cada llamada a input.* se convierte en una fila de la pestaña Entradas en la ventana de ajustes del indicador. Las filas aparecen en el orden en que están escritas las llamadas en el script. El primer argumento establece el valor por defecto; el segundo, la etiqueta de la fila.
| Llamada | Qué aparece en la ventana de ajustes |
|---|---|
input.int |
Campo para un número entero |
input.float |
Campo para un número decimal |
input.bool |
Casilla de verificación |
input.color |
Selector de color |
input.string |
Lista desplegable si se define options; sin ella, campo de texto |
input.source |
Lista desplegable de series: open, high, low, close, hl2, hlc3, ohlc4, hlcc4, volume |
input.enum |
Lista desplegable con las etiquetas del enum |
input.timeframe |
Campo de texto; con options, lista desplegable |
input.symbol |
Campo de texto |
El ejemplo siguiente reúne cinco tipos de ajustes en un solo script:
indicator("Средняя на выбор", overlay = true)
enum Basis {
sma = "Простая"
ema = "Экспоненциальная"
wma = "Взвешенная"
}
basis = input.enum(Basis.ema, "Тип средней")
length = input.int(50, "Период", minval = 1, maxval = 500)
src = input.source(close, "Источник")
lineColor = input.color(color.orange, "Цвет линии")
showBg = input.bool(false, "Подсвечивать фон")
avg = switch basis {
Basis.sma => ta.sma(src, length)
Basis.ema => ta.ema(src, length)
=> ta.wma(src, length)
}
plot(avg, "Средняя", color = lineColor, linewidth = 2)
bgcolor(showBg and close > avg ? color.new(color.teal, 40) : na, title = "Фон")En la ventana de ajustes aparecerá la lista desplegable «Тип средней» con los elementos «Простая», «Экспоненциальная» y «Взвешенная». Debajo estarán el campo del período, la lista de fuentes, el selector de color y la casilla de verificación. Cómo declarar enums se explica en la sección Свои типы и перечисления.
Parámetros de números y cadenas
minvalymaxvalestablecen los límites: el campo no aceptará un período menor queminvalni mayor quemaxval.stepeninput.floatdefine cuántos decimales muestra el campo: constep = 0.1se ve un decimal. El campo no tiene flechas; el valor se escribe con el teclado.optionseninput.stringyinput.timeframeconvierte el campo en una lista desplegable. El valor por defecto debe ser uno de los elementos; de lo contrario, el compilador dará un error.tooltip,groupeinlineson aceptados por el compilador, pero por ahora no afectan el aspecto de la ventana de ajustes.
indicator("Цена для расчёта")
mode = input.string("Закрытие", "Считать по", options = ["Закрытие", "Середина свечи"])
price = mode == "Закрытие" ? close : hl2
plot(ta.rsi(price, 14), "RSI", color = color.purple)En input.source, el valor por defecto también puede ser una serie de datos de mercado, como delta.cum. Esa serie aparecerá como primer elemento de la lista, antes de las series de precios. Si el valor por defecto es una expresión como (high + low) / 2, no habrá fila en la ventana de ajustes: no hay nada que elegir.
Todavía no existen ajustes separados para la hora, la sesión de trading ni para el precio que se elige con un clic en el gráfico.
Dónde se guardan los valores elegidos
Los valores se recuerdan por separado para cada indicador en cada gráfico: dos copias del mismo script en paneles distintos pueden tener períodos diferentes. El botón Por defecto en la ventana de ajustes restaura los valores escritos en el código.
El valor está vinculado al nombre de la variable en la que se guarda la llamada a input.*. La etiqueta de la fila se puede cambiar libremente y el valor elegido se conserva. Las filas también se pueden reordenar. Pero si se renombra la variable (length por period), el ajuste volverá al valor del código.
La ventana de ajustes se abre con doble clic en la fila del indicador en la leyenda del gráfico o con el icono de ajustes de esa fila. Además de la pestaña Entradas, contiene Estilo y Visibilidad, de las que se habla más adelante.
Líneas: plot
plot dibuja una serie, un valor por cada vela. Solo el primer argumento (la propia serie) es obligatorio. Los demás parámetros se indican por nombre:
title: nombre de la línea en la leyenda y en la ventana de ajustes;color: color, constante o calculado en cada vela;linewidth: grosor;style: modo de renderizado, véase la tabla;offset: desplazamiento de un número determinado de velas: positivo a la derecha, negativo a la izquierda;show_last: dibujar solo las últimas N velas;join = true: unir con una línea los puntos de los estiloscirclesycross;editable = false: quitar la línea de la ventana de ajustes;display = display.none: ocultar la línea al añadirla; se puede activar en la pestaña Visibilidad.
| Estilo | Aspecto |
|---|---|
plot.style_line |
Línea quebrada, estilo por defecto |
plot.style_linebr |
Igual que line |
plot.style_stepline |
Escalones |
plot.style_stepline_diamond |
Escalones con rombos |
plot.style_histogram |
Columnas finas desde cero, con grosor de línea |
plot.style_columns |
Columnas desde cero, con ancho de vela |
plot.style_area |
Área rellena hasta cero |
plot.style_areabr |
Igual que area |
plot.style_circles |
Puntos |
plot.style_cross |
Cruces |
La línea siempre se interrumpe donde la serie no tiene valor (na) y no salta el hueco con un segmento recto. Por eso los pares line/linebr y area/areabr se dibujan igual.
indicator("Стили линий")
d = close - open
plot(d, "Тело свечи", style = plot.style_histogram, color = d >= 0 ? color.teal : color.red)
plot(ta.sma(d, 10), "Средняя 10", style = plot.style_stepline, color = color.orange, linewidth = 2)
plot(ta.sma(d, 30), "Средняя 30", style = plot.style_circles, color = color.gray)Color por velas
El color puede ser una expresión: en ese caso se calcula de nuevo en cada vela. El color na significa que en esa vela no hay línea:
indicator("Средняя только над ценой", overlay = true)
m = ta.sma(close, 50)
plot(m, "Средняя", color = close > m ? color.teal : na)Qué obtiene la línea en la ventana de ajustes
- En la pestaña Estilo se ajusta el grosor de cada línea. La fila de color aparece solo en las líneas con color constante: si el script elige el color en cada vela, no hay nada que cambiar en la ventana.
- En la pestaña Visibilidad, cada línea tiene una casilla para mostrarla u ocultarla. Aparece si hay más de una línea o si la línea está oculta mediante
display. - Una línea con
editable = falseno recibe filas en ninguna pestaña.
Niveles y rellenos
hline dibuja una línea horizontal a un precio constante, por ejemplo, los límites de las zonas del RSI. El precio debe ser un número o un ajuste input.*: una serie que cambia vela a vela no sirve aquí. Para una línea así se necesita plot. El estilo de la línea se define con hline.style_solid, hline.style_dashed y hline.style_dotted.
fill rellena el área entre dos fronteras. Para obtener una frontera, el resultado de hline o plot se guarda en una variable:
indicator("RSI с зонами")
length = input.int(14, "Период", minval = 1)
r = ta.rsi(close, length)
top = hline(70, "Перекупленность", color = color.gray, linestyle = hline.style_dashed)
bottom = hline(30, "Перепроданность", color = color.gray, linestyle = hline.style_dashed)
fill(top, bottom, color = color.new(color.purple, 30), title = "Зона")
plot(r, "RSI", color = r > 70 ? color.red : r < 30 ? color.teal : color.purple)Las dos fronteras deben ser del mismo tipo: dos niveles hline o dos líneas plot. El compilador no acepta un relleno entre una línea y un nivel.
El color de relleno entre dos líneas puede cambiar vela a vela. Así se obtiene una «nube» a partir de dos medias móviles:
indicator("Облако", overlay = true)
fast = ta.ema(close, 9)
slow = ta.ema(close, 21)
pf = plot(fast, "Быстрая", color = color.teal)
ps = plot(slow, "Медленная", color = color.orange)
fill(pf, ps, color = fast > slow ? color.new(color.teal, 50) : color.new(color.red, 50), title = "Облако")También hay relleno con degradado. Defina top_value y bottom_value para indicar las alturas donde el color es igual a top_color y bottom_color; entre ellas, el color transita suavemente. Esas alturas deben ser números constantes. Si se necesita un relleno hasta un nivel constante, conviértalo en una línea: plot(50). Pero recuerde que cuenta como una de las tres líneas dibujables.
indicator("RSI с градиентом")
r = ta.rsi(close, 14)
pr = plot(r, "RSI", color = color.purple)
pm = plot(50, "Середина", color = color.gray)
fill(pr, pm, top_value = 80, bottom_value = 50,
top_color = color.new(color.teal, 160), bottom_color = color.new(color.teal, 0))Fondo y color de velas
bgcolor pinta el fondo debajo de la vela; barcolor cambia el color de la propia vela. Ambos aceptan un color calculado en cada vela; en las velas con color na no cambia nada.
indicator("Подсветка объёма", overlay = true)
avgVol = ta.sma(volume, 20)
spike = volume > avgVol * 2
bgcolor(spike ? color.new(color.orange, 40) : na, title = "Всплеск объёма")
barcolor(close > open ? color.teal : color.red, title = "Цвет свечей")Marcadores: plotshape y plotchar
plotshape coloca un icono en las velas donde la condición es verdadera. plotchar hace lo mismo con cualquier símbolo.
indicator("Пересечения", overlay = true)
fast = ta.ema(close, 9)
slow = ta.ema(close, 21)
plotshape(ta.crossover(fast, slow), "Вверх", style = shape.triangleup,
location = location.belowbar, color = color.teal, size = size.small)
plotshape(ta.crossunder(fast, slow), "Вниз", style = shape.triangledown,
location = location.abovebar, color = color.red, size = size.small)
plotchar(volume > ta.sma(volume, 20) * 3, "Объём", char = "●", location = location.top, color = color.orange)- Forma,
shape.*:triangleup,triangledown,arrowup,arrowdown,circle,square,diamond,cross,xcross,flag,labelup,labeldown. - Ubicación,
location.*:abovebar— encima de la vela,belowbar— debajo de la vela,topybottom— en los bordes superior e inferior del panel. En un panel separado debajo del gráfico, «encima de la vela» y «debajo de la vela» también significan el borde superior y el inferior: ese panel tiene su propia escala y los precios de las velas no están marcados en ella. - Tamaño,
size.*:auto,tiny,small,normal,large,huge. textañade una etiqueta corta al icono. Cuando el gráfico está muy alejado y las velas son estrechas, las etiquetas se ocultan y los iconos permanecen.
Objetos gráficos
Además de las series, el script puede dibujar objetos individuales: etiquetas label.new, segmentos line.new, rectángulos box.new y tablas table.new. Cada llamada a *.new devuelve un objeto. Se puede mover con las funciones set_* (label.set_xy, line.set_x2, box.set_top, etc.), leer con get_*, copiar con copy o eliminar con delete.
En horizontal, el objeto está vinculado por defecto al número de vela, bar_index. Con el parámetro xloc = xloc.bar_time, la coordenada se define por el tiempo de la vela. El parámetro extend (extend.right, extend.left, extend.both) prolonga el borde de un segmento o rectángulo hasta el límite del gráfico.
El objeto permanece en el gráfico hasta que se elimina. El script se ejecuta en cada vela, por lo que label.new sin condición creará una etiqueta por cada vela. Para mantener un solo objeto y moverlo, guárdelo en una variable var y elimine el anterior:
indicator("Последний пивот", overlay = true, maxLabelsCount = 50)
ph = ta.pivothigh(high, 10, 10)
var line level = na
if not na(ph) {
label.new(bar_index - 10, ph, str.tostring(ph), style = label.style_label_down,
color = color.orange, textcolor = color.white, size = size.small)
line.delete(level)
level := line.new(bar_index - 10, ph, bar_index, ph, extend = extend.right,
color = color.orange, style = line.style_dashed)
}El script etiqueta cada máximo encontrado y traza una línea punteada desde el último hacia la derecha. Al mismo tiempo elimina la línea punteada anterior.
No puede haber más de 500 objetos vivos de cada tipo a la vez. Cuando aparece el número 501, el más antiguo desaparece. Los parámetros maxLinesCount, maxLabelsCount y maxBoxesCount en indicator() reducen este límite. Un valor mayor que 500 se recorta a 500.
Tablas
La tabla no está vinculada a las velas, sino a una esquina o borde del panel, y no se mueve al desplazar el gráfico. La posición se define con position.*: top_left, top_center, top_right, middle_left, middle_center, middle_right, bottom_left, bottom_center, bottom_right. Las celdas se rellenan con table.cell. Conviene hacerlo solo en la última vela, para no reescribir la tabla en todo el historial:
indicator("Сводка", overlay = true)
var t = table.new(position.top_right, 2, 2, bgcolor = color.new(color.black, 160))
if barstate.islast {
table.cell(t, 0, 0, "RSI", text_color = color.white)
table.cell(t, 1, 0, str.tostring(math.round(ta.rsi(close, 14), 1)), text_color = color.white)
table.cell(t, 0, 1, "ATR", text_color = color.white)
table.cell(t, 1, 1, str.tostring(math.round(ta.atr(14), 2)), text_color = color.white)
}Una tabla no puede tener más de 200 columnas ni 200 filas. No se crea una tabla con más de 2000 celdas.
Colores
Colores con nombre: 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.
El color también se puede escribir con código: #FF8800 es opaco, #FF880040 tiene transparencia. El último par de dígitos define la opacidad: 00 es completamente transparente, FF es sólido.
color.rgb(r, g, b)compone un color a partir de componentes de 0 a 255. El cuarto argumento es la opacidad; por defecto, 255.color.from_gradient(value, bottomValue, topValue, bottomColor, topColor)devuelve un color intermedio entre los dos extremos según la posición devalueen el rango. Es útil para colorear un oscilador de frío a caliente.naen lugar de un color significa «no dibujar».
indicator("RSI в цвете")
r = ta.rsi(close, 14)
heat = color.from_gradient(r, 30, 70, color.rgb(0, 150, 136), color.rgb(244, 67, 54))
plot(r, "RSI", color = heat, linewidth = 2)
bgcolor(r > 70 ? color.new(color.red, 30) : r < 30 ? color.new(color.teal, 30) : na, title = "Зоны")Siguiente
https://docs.lootx.trade/es/loot/inputs-drawing
6Datos de mercado: clústeres, delta, interés abierto y libro de órdenes
Qué lee un script en LootScript además de las velas: clústeres, delta, interés abierto, tasa de financiación, historial y libro de órdenes en vivo, cinta de operaciones, screener, otra temporalidad e instrumento.
Además de las velas, un script en LootScript lee datos del flujo de órdenes: clústeres, delta, interés abierto, tasa de financiación, el historial del libro de órdenes grabado, el libro de órdenes en vivo y la cinta de operaciones, y las métricas del screener. No hace falta activar nada: en cuanto el script referencia, por ejemplo, cluster.poc, el terminal se suscribe automáticamente a los clústeres del instrumento y de la temporalidad del gráfico —incluso si el gráfico muestra velas normales. Cuando se quita el script del gráfico, la suscripción se libera.
En esta página — qué hay en cada espacio de nombres, de dónde vienen los datos, en qué exchanges están disponibles y cómo obtener valores de otra temporalidad u otro instrumento.
Regla principal: ausencia de datos = na, no 0
Cualquier valor referido en esta página puede ser na. Sucede si el exchange no está cubierto por el servidor, la temporalidad no está soportada, la historia aún se está cargando o la barra es más antigua que la historia disponible. Un cero significaría «no hubo trades», y eso es un hecho diferente: sumar ceros sustituidos puede parecer plausible y a la vez ser incorrecto.
Cada espacio de nombres tiene una bandera de disponibilidad — cluster.available, delta.available, oi.available, etc. Compruébala o usa la función na(x). El compilador no permite comparar con na usando ==.
indicator("Накопленная дельта без подмены нулём", overlay = false)
var float cvd = 0.0
if delta.available {
cvd := cvd + delta.value
}
plot(delta.available ? cvd : na, "CVD", color = color.teal)Por qué faltan datos lo indica la leyenda del gráfico junto al nombre del script: “exchange no cubierto”, “temporalidad no compatible”, “cargando datos…”, “no hay libro de órdenes abierto”, “screener no disponible”.
Origen de los datos
| Espacio | Qué es | Historia en el gráfico |
|---|---|---|
cluster.* |
Clústeres (footprint) de la barra: volumen por precios | Hay, desde el servidor de clústeres |
delta.* |
Delta de compras y ventas agresivas | Hay |
oi.* |
Interés abierto | Hay |
funding.* |
Tasa de financiación y sus cálculos | Hay |
depth.* |
Libro de órdenes grabado por el servidor, por barras | Hay, con profundidad limitada |
book.* |
Libro de órdenes en vivo | Solo la última barra |
tape.* |
Cinta de operaciones en vivo | Solo la última barra |
screener.* |
Métricas del screener por instrumento | Solo la última barra |
Clústeres: cluster.*
El volumen de cada nivel de precio dentro de la barra, separado en compras y ventas agresivas — los mismos datos que dibuja el gráfico footprint. Los niveles se numeran de abajo arriba, de 0 a cluster.levels - 1.
| Nombre | Qué devuelve |
|---|---|
cluster.available |
Si hay clústeres en esta barra |
cluster.levels |
Número de niveles de precio en la barra |
cluster.price(i) |
Precio del nivel i |
cluster.bid(i) |
Compras agresivas en el nivel i |
cluster.ask(i) |
Ventas agresivas en el nivel i |
cluster.total |
Todo el volumen de la barra |
cluster.delta |
Compras menos ventas en todos los niveles |
cluster.poc, cluster.poc_index |
Precio y número del nivel con mayor volumen |
cluster.max_cell |
Volumen de la celda más grande de la barra |
cluster.imbalance(i) |
Desbalance del nivel: +1 compras, -1 ventas, 0 ninguno |
cluster.stacked_buy, cluster.stacked_sell |
Precio desde el que comienza la serie más larga de niveles con desbalance |
cluster.stacked_buy_steps, cluster.stacked_sell_steps |
Longitud de esa serie en niveles |
cluster.value_area(pct) |
Límite inferior y superior de la zona de valor; pct — fracción de volumen, 0.7 = 70 % |
cluster.grid_step |
Paso de la rejilla de precios de la barra |
Fíjate en los nombres: cluster.bid(i) son compras que “quitaron” un ask, no órdenes de compra en el libro.
Hay clústeres en temporalidades desde 30 segundos hasta 1 día.
indicator("POC и зона стоимости", overlay = true)
[vaLow, vaHigh] = cluster.value_area(0.7)
plot(cluster.poc, "POC", color = color.orange, style = plot.style_circles)
plot(vaHigh, "Верх зоны", color = color.gray, style = plot.style_linebr)
plot(vaLow, "Низ зоны", color = color.gray, style = plot.style_linebr)Delta: delta.*
La diferencia entre compras agresivas y ventas agresivas en la barra. Los volúmenes están en monedas (la divisa base).
| Nombre | Qué devuelve |
|---|---|
delta.value |
Delta de la barra: compras menos ventas |
delta.buy, delta.sell |
Esas dos partes por separado |
delta.cum |
Delta acumulada desde el inicio de la historia cargada |
delta.min, delta.max |
Mínima y máxima de la delta dinámica dentro de la barra |
delta.open, delta.high, delta.low, delta.close |
Delta de la barra en formato vela |
delta.trades |
Número de operaciones en la barra |
delta.usd |
Delta en la moneda cotizada, por sumas de las propias operaciones |
delta.available |
Si hay delta en esta barra |
delta.min y delta.max no se pueden deducir de los clústeres — indican el recorrido de la delta dentro de la barra y las calcula el servidor. Muestran, por ejemplo, que los compradores llevaron la barra y luego fue cerrada por vendedores. delta.usd es más preciso que delta.value * close: en barras volátiles el precio de las operaciones difiere mucho del precio de cierre.
delta.cum empieza en cero en la primera barra cargada, por lo que su nivel depende de la profundidad de la historia cargada. Compara cambios, no valores absolutos.
La delta está disponible en temporalidades desde 30 segundos.
indicator("Дельта и разворот внутри бара", overlay = false)
d = delta.value
reversed = delta.available and d < 0 and delta.max > -d
plot(d, "Дельта", style = plot.style_columns, color = d >= 0 ? color.teal : color.red)
plotshape(reversed, "Разворот", style = shape.xcross, location = location.top, color = color.orange, size = size.tiny)Interés abierto: oi.*
| Nombre | Qué devuelve |
|---|---|
oi.open, oi.high, oi.low, oi.close |
Interés abierto por barra en las unidades que publica el exchange |
oi.coins |
Interés abierto en monedas |
oi.usd |
Interés abierto en la moneda cotizada |
oi.change |
Cambio de oi.close respecto a la barra anterior |
oi.available |
Si hay datos en esta barra |
Las unidades de oi.open…oi.close varían entre exchanges; para comparar exchanges usa oi.coins u oi.usd. El interés abierto llega en una rejilla de minutos: en temporalidades en segundos todos los valores son na.
indicator("Цена и открытый интерес", overlay = false)
dp = ta.change(close)
build = oi.available and dp > 0 and oi.change > 0
plot(oi.change, "Изменение OI", style = plot.style_columns, color = build ? color.teal : color.gray)Tasa de financiación: funding.*
| Nombre | Qué devuelve |
|---|---|
funding.rate |
Pronóstico de la tasa para el próximo cálculo |
funding.interval_hours |
Horas entre cálculos |
funding.settled |
true en la barra donde se hizo el cálculo |
funding.settled_rate |
Tasa efectivamente debitada en esa barra; si hay varios cálculos en la barra — su suma |
funding.cum |
Suma de tasas debitadas en la historia cargada |
funding.available |
Si el instrumento tiene tasa de financiación |
La tasa es una fracción, no porcentajes: 0.0001 = 0.01 %. El gráfico la muestra en porcentajes; el lenguaje no la reescala. Para comprobar hipótesis en la historia usa funding.settled_rate: funding.rate es un pronóstico que puede cambiar hasta el mismo cálculo. El spot no tiene funding; en temporalidades en segundos los valores son na.
indicator("Фандинг за расчёт, %", overlay = false)
plot(funding.rate * 100, "Прогноз ставки", style = plot.style_area, color = funding.rate >= 0 ? color.teal : color.red)
plotshape(funding.settled, "Расчёт", style = shape.circle, location = location.bottom, color = color.orange, size = size.tiny)Historial del libro de órdenes: depth.*
El libro de órdenes tal como lo grabó el servidor — los mismos datos que dibuja el mapa de calor — desglosado por barras. A diferencia del book.* en vivo, estos valores existen en cada barra grabada. Los precios se agrupan en cestas; el volumen de la cesta es el mayor volumen que estuvo en esa cesta durante la barra, en monedas.
| Nombre | Qué devuelve |
|---|---|
depth.available |
Si el libro está grabado para esa barra |
depth.levels |
Número de cestas no vacías en la barra |
depth.price(i) |
Límite inferior de la cesta i, en orden ascendente |
depth.qty(i) |
Mayor volumen que estuvo en la cesta durante la barra |
depth.side(i) |
+1 bids, -1 asks, 0 cesta estuvo en ambas caras |
depth.at(price) |
Volumen en la cesta donde cae el precio |
depth.grid_step |
Tamaño de la cesta en unidades de precio |
depth.best_bid, depth.best_ask |
Mejores precios al final de la barra |
depth.max_cell |
Volumen de la cesta más pesada |
depth.bid_sum(pct), depth.ask_sum(pct) |
Volumen del lado dentro de pct % desde el centro |
depth.imbalance(pct) |
Desbalance en la misma banda: de -1 a +1 |
depth.max_bid(pct), depth.max_ask(pct) |
Precio y volumen de la cesta más pesada del lado dentro de la banda |
Limitaciones:
- Los datos están donde está la mapa de calor del servidor, y en temporalidades desde un segundo.
- El servidor guarda una banda de aproximadamente ±4 % respecto al precio. Fuera de ella
depth.atdevuelvena; dentro de la banda una cesta vacía devuelve0. - La profundidad histórica es limitada: las barras más antiguas de una historia larga devuelven
na. - Los valores de la barra en formación cambian mientras llegan datos.
indicator("Перекос записанного стакана", overlay = false)
band = input.float(1.0, "Полоса, % от цены", minval = 0.1, maxval = 4.0, step = 0.1)
imb = depth.imbalance(band)
plot(imb, "Перекос", style = plot.style_columns, color = imb >= 0 ? color.teal : color.red)Para dibujar el libro grabado bajo las velas basta una sola línea heatmap.depth() en el script con overlay = true. Colores y umbrales están en la página Настройки и отрисовка.
indicator("Записанный стакан теплом", overlay = true)
heatmap.config(palette = heatmap.inferno, low = 25)
heatmap.depth()Libro de órdenes en vivo y cinta: book.* y tape.*
El libro de órdenes en vivo y la cinta no los graba nadie, por eso los valores existen solo en la última barra, y en la historia siempre son na. Requieren tener abierta la panel del libro de órdenes del mismo instrumento: de lo contrario book.available y tape.available son falsos, y en la leyenda aparece “no hay libro de órdenes abierto”. En modo repetición estos datos no están disponibles.
| Nombre | Qué devuelve |
|---|---|
book.bid(i), book.ask(i) |
Precio del nivel i; 0 — mejor precio |
book.bid_qty(i), book.ask_qty(i) |
Volumen en el nivel, en monedas |
book.spread |
Mejor ask menos mejor bid |
book.mid |
Punto medio entre los mejores precios |
book.imbalance(n) |
Desbalance de volumen en los n niveles superiores de cada lado: de -1 a +1 |
book.available |
Si hay snapshot del libro |
tape.last_price, tape.last_qty |
Precio y volumen de la última operación |
tape.last_side |
+1 comprador agresor, -1 vendedor, 0 — aún no hubo operaciones |
tape.count(ms) |
Número de operaciones en los últimos ms milisegundos |
tape.buy_volume(ms), tape.sell_volume(ms) |
Volumen de compras y ventas agresivas en la ventana |
tape.max_print(ms) |
Operación más grande en la ventana |
tape.available |
Si la cinta está conectada |
La ventana de la cinta y la profundidad de book.imbalance se fijan con un número en el código o con la opción input.int. La ventana se cuenta desde la hora de la última operación en el exchange, no desde el reloj del equipo. El script solo tiene acceso al tail de la cinta —unas dos mil últimas operaciones—, por lo que en mercados muy activos una ventana larga no mostrará todo el intervalo.
Cuando un valor así se pasa a plot, el editor avisa: “Los datos sólo están en tiempo real — en el historial la serie está vacía”. Es esperado: a la izquierda de la última barra la serie está vacía. Las estrategias no pueden leer estos datos — véase Стратегии и тестер.
indicator("Перекос стакана", overlay = false)
levels = input.int(20, "Уровней с каждой стороны", minval = 1, maxval = 200)
imb = book.available ? book.imbalance(levels) : na
plot(imb, "Перекос", style = plot.style_area, color = imb >= 0 ? color.teal : color.red)
hline(0, "Ноль", color = color.gray)Screener: screener.*
Las métricas del screener para el instrumento del gráfico son los mismos números que aparecen en sus columnas. No tienen historia: el valor existe solo en la última barra. La ventana se pasa como cadena, y no todas las métricas aceptan todas las ventanas.
| Función | Qué muestra | Ventanas |
|---|---|---|
screener.change(w) |
Cambio de precio | "1m" "5m" "15m" "1h" "24h" |
screener.vol(w) |
Volumen | "1m" "5m" "15m" "1h" "24h" |
screener.avg_vol(w) |
Volumen promedio | "1m" "5m" "15m" "1h" |
screener.rvol(w) |
Volumen relativo | "1h" "24h" |
screener.natr(w) |
NATR | "1m" "5m" |
screener.oi_delta(w) |
Cambio del interés abierto | "1m" "5m" "1h" "24h" |
screener.btc_corr(w) |
Correlación con BTC | "1m" "5m" |
screener.available |
Si el instrumento está cubierto por el screener | — |
Una ventana no listada en la tabla da na. Una métrica que no entra en tu suscripción al screener también es na. El editor marca la salida de estos valores con la misma advertencia que para el libro: en la historia la serie está vacía.
indicator("Скринер: RVOL и NATR", overlay = false)
plot(screener.rvol("1h"), "RVOL 1h", color = color.orange)
plot(screener.natr("5m"), "NATR 5m", color = color.teal)Cobertura por exchange
| Exchange | Clústeres y delta | Interés abierto y tasa de financiación |
|---|---|---|
| Binance, Bybit, OKX, Bitget, Gate.io, MEXC, KuCoin, BingX, AsterDEX | spot y futuros | Futuros |
| Hyperliquid | Futuros; spot — no | Futuros |
| Binance Alpha | No: el exchange no publica el lado agresor | No |
| Upbit | No | No |
| Datos | Temporalidades |
|---|---|
| Clústeres | De 30 segundos a 1 día |
| Delta | Desde 30 segundos |
| Interés abierto, tasa de financiación | Desde 1 minuto |
| Historial del libro de órdenes | Desde 1 segundo, donde esté la mapa de calor del servidor |
| Libro en vivo, cinta | Cualquier temporalidad, si está abierto el panel del libro |
| Screener | Cualquier temporalidad, para instrumentos que el screener ve |
La cobertura la determina el servidor de datos y puede cambiar. Es más seguro fiarse de la bandera .available y de la indicación en la leyenda.
Otra temporalidad y otro instrumento
request.security evalúa una expresión en otra serie — una temporalidad superior o otra moneda — y alinea el resultado con las barras del gráfico.
request.security(symbol, timeframe, expression, gaps = false, lookahead = false, ignore_invalid_symbol = false)- symbol — en formato «EXCHANGE:Ticker», como en TradingView:
"BINANCE:BTCUSDT.P", donde.Pes el futuro perpetuo. El instrumento del gráfico essym.ticker. - timeframe — cadena tipo
"5","60","4h","1D","1W". La temporalidad del gráfico estf.period. - expression — un número o varios números entre corchetes:
[high, low].
Sin adelantarse al cierre. Por defecto la barra del gráfico ve el valor del último cierre de la barra superior. Por eso una EMA horaria en 5 minutos es en escalón que solo se mueve al cierre de la hora. Así el resultado en historia coincide con lo que habrías visto en vivo.
gaps = true— el valor solo está en la primera barra del gráfico donde aparece la barra superior nueva; despuésna.ignore_invalid_symbol = true— un símbolo desconocido dana. Sin esto el script falla con error “Символ … неизвестен”.
Dentro de la expresión están disponibles las velas de la otra serie y los cálculos sobre ellas. No puedes pasar la variable del gráfico allí — solo los valores de input.*. El libro, la cinta y el screener no compilan dentro de la petición; clústeres, delta, interés abierto y funding de la otra serie devuelven na. Un script puede pedir hasta 8 pares “instrumento + temporalidad” distintos y hasta 32 llamadas a request.security.
indicator("EMA старшего таймфрейма", overlay = true)
len = input.int(20, "Длина EMA", minval = 2, maxval = 500)
tfHigh = input.timeframe("60", "Старший таймфрейм")
emaHigh = request.security(sym.ticker, tfHigh, ta.ema(close, len))
plot(emaHigh, "EMA", color = color.orange, style = plot.style_stepline)indicator("Спред к другой бирже", overlay = false)
other = input.symbol("BYBIT:BTCUSDT.P", "Сравнить с")
px = request.security(other, tf.period, close, ignore_invalid_symbol = true)
plot(close - px, "Разница", color = color.orange)Siguientes lecturas
https://docs.lootx.trade/es/loot/market-data
7Estrategias y Probador de estrategias
Cómo escribir una estrategia en LootScript y probarla sobre el historial en el probador: declaración strategy(), órdenes, modelo de ejecución, costes, pestañas del informe y limitaciones del backtest.
Una estrategia es un script que, además de dibujar líneas en el gráfico, envía órdenes. Las órdenes no las ejecuta un exchange real sino un simulador dentro del terminal: ejecuta la estrategia sobre el historial del gráfico con comisiones, deslizamiento y tasa de financiación, y muestra el resultado en la ventana Probador de estrategias.
Declaración strategy()
La primera línea diferencia una estrategia de un indicador: strategy(...) en lugar de indicator(...). Todo lo demás —ajustes, renderizado, datos de mercado— funciona igual. Las funciones strategy.* en un indicador no se compilan: “strategy.* disponible solo en strategy(…)”.
| Parámetro | Por defecto | Qué establece |
|---|---|---|
initialCapital |
10000 |
Capital inicial |
defaultQtyType, defaultQtyValue |
strategy.qty.fixed, 1 |
Tamaño de la orden si no se especifica qty |
commissionType, commissionValue |
porcentaje, no definido | Comisión: strategy.commission.percent — porcentaje sobre el volumen (0.05 = 0,05 %), strategy.commission.cash_per_contract — importe por unidad de cantidad, strategy.commission.cash_per_order — importe por ejecución |
slippageTicks |
0 |
Deslizamiento en ticks |
pyramiding |
0 |
Cuántas entradas en una misma dirección pueden estar abiertas; 0 — una sola |
positionModel |
strategy.model.netting |
Una posición agregada o posiciones separadas long/short (strategy.model.hedging) |
processOrdersOnClose |
false |
Ejecutar órdenes de mercado al cierre de la vela actual |
calcOnEveryTick |
false |
Permitir órdenes en la vela en formación |
marginLong, marginShort, leverage |
0, 0, 1 |
Margen en porcentaje o apalancamiento; con 0 la liquidación no se modela |
applyFunding |
true |
Tener en cuenta la tasa de financiación |
fillModel |
strategy.fill.conservative |
Suposición sobre el recorrido del precio dentro de la vela |
Los valores de parámetros solo pueden ser números y constantes literales. Una expresión o input.* en la declaración es un error de compilación. El parámetro calcOnOrderFills es aceptado, pero en esta versión no tiene efecto: en la pestaña “Propiedades” del probador aparece marcado como “no actúa en esta build”.
El tamaño de la orden cuando qty = na lo define defaultQtyType:
| Tipo | Qué significa defaultQtyValue |
|---|---|
strategy.qty.fixed |
Cantidad en monedas (moneda base) |
strategy.qty.cash |
Importe en la moneda cotizada |
strategy.qty.percent_of_equity |
Porcentaje del capital actual |
strategy.qty.risk_percent |
Porcentaje del capital que arriesgas hasta un stop protector |
Para strategy.qty.risk_percent se necesita un strategy.exit con stop (loss o stop); de lo contrario el compilador aborta: “requiere un stop respecto al cual calcular el tamaño”. La cantidad se redondea hacia abajo al paso de cantidad del instrumento. Si tras redondear queda cero, la orden se rechaza y se cuenta en el probador como “Rechazadas (por tamaño)”.
Órdenes
| Función | Qué hace |
|---|---|
strategy.entry(id, direction, qty, limit, stop, …) |
Abre o gira una posición. Respeta el modelo de posición y pyramiding |
strategy.order(id, direction, qty, limit, stop, …) |
Igual pero sin respetar el modelo de posición ni pyramiding |
strategy.exit(id, from_entry, qty, qty_percent, profit, limit, loss, stop, trail_price, trail_points, trail_offset, …) |
Coloca la salida —take, stop o trailing— para una entrada abierta |
strategy.close(id, comment, qty, qty_percent) |
Cierra la entrada con una orden de mercado |
strategy.close_all(comment) |
Cierra todo |
strategy.cancel(id), strategy.cancel_all() |
Elimina órdenes aún no ejecutadas |
La dirección — strategy.long o strategy.short. Todas las funciones admiten el opcional when: when = false evita la ejecución. Entradas, salidas y cierres admiten además comment — etiqueta de texto para la orden.
- Tipo de entrada. Sin
limitnistop— orden de mercado; conlimit— orden límite; constop— orden stop; con ambos — stop-limit. Unstrategy.entryrepetido con el mismoidreemplaza la orden pendiente. - Giro. En el modelo
nettinguna entrada en la dirección opuesta cierra la posición actual y abre la nueva en una sola acción. - Unidades de salida.
profityloss— en ticks desde el precio de entrada;limitystop— precios absolutos. El trailing se define con el par:trail_offsetmástrail_priceotrail_points. - Un
strategy.exitsin niveles no hace nada. El compilador avisará: “strategy.exit sin ningún nivel (profit/loss/stop/limit/trail) — operación vacía”. - Mover el stop. Un
strategy.exitrepetido con el mismoidreemplaza la salida — así se mueve el stop.
El estado de la estrategia se lee por filas: strategy.position_size (con signo, short es negativo), strategy.position_avg_price, strategy.equity, strategy.netprofit, strategy.openprofit, strategy.opentrades, strategy.closedtrades, strategy.funding_paid y más — la lista completa está en el referente.
Cómo el probador ejecuta las órdenes
Una orden enviada en una vela se ejecuta no antes de la siguiente vela. La decisión se toma al cierre de la vela, y ejecutarla al mismo precio implicaría mirar hacia adelante.
| Orden | Ejecución |
|---|---|
| Mercado | En la apertura de la siguiente vela más el deslizamiento. Con processOrdersOnClose = true — al cierre de la vela actual |
| Límite | Cuando el precio pasa el límite, al precio límite. Si la vela abrió más allá del límite — en la apertura |
| Stop | Cuando el precio pasa el stop, al precio del stop más deslizamiento. En caso de gap — en la apertura más deslizamiento |
Recorrido del precio dentro de la vela. El probador no conoce el recorrido real del precio dentro de la vela y lo asume. El modelo strategy.fill.conservative (por defecto) considera que el precio primero fue al peor extremo: en una vela alcista — apertura → mínimo → máximo → cierre; en una bajista — al revés. Si en una sola vela están stop y take, se dispara el stop. El modelo strategy.fill.optimistic asume lo contrario — sirve solo para comparar. En esta versión no hay reejecución sobre marcos menores: en la columna «Ruta» cada operación se marca como supuesta por el modelo.
Costes.
- Comisión. Si
commissionValueno está definido, el probador usa la tarifa por defecto: 0,02 % en ejecuciones límite y 0,05 % en órdenes de mercado y stop. La tarifa de tu cuenta y los rebates al terminal son desconocidos. Un valor especificado se aplica a todas las ejecuciones. - Deslizamiento —
slippageTicksen tu contra en ejecuciones de mercado y stop. Las órdenes límite no deslizan. - Tasa de financiación se descuenta en cada liquidación real del exchange — a la tasa real y al precio de cierre de la vela de cálculo. Para ello se requieren datos de financiación: futuros de exchanges desde la tabla de cobertura.
- Margen. Con
marginLong/marginShorto apalancamiento > 1 el probador modela un margen aislado simplificado. Una posición larga se liquida en precio entrada × (1 − m/2), la corta en entrada × (1 + m/2), donde m es la fracción del margen inicial. Una operación liquidada pierde todo el margen inicial.
Las operaciones no cerradas al final del historial se cierran al cierre de la última vela por la razón “fin de datos”.
Probador de estrategias
Añada la estrategia al gráfico
En el Editor pulse Añadir al gráfico (Ctrl+Enter). Un script con errores no se añadirá al gráfico.
Abra el probador
En la barra de herramientas del Editor pulse Probador de estrategias… — el botón está activo solo para scripts con strategy(...). Otra vía: desde los ajustes de la estrategia en la leyenda del gráfico (engranaje), botón Probador de estrategias….
Espere a que termine el proceso
El probador calcula sobre las velas cargadas en el gráfico. Mientras no haya velas, la ventana muestra “La estrategia aún no se ha calculado: espere a la carga de velas”. Cuando llegan nuevas velas, el resultado se recalcula automáticamente; el botón Recalcular lanza un recorrido completo manualmente.
Si hay varias estrategias en el gráfico, puedes seleccionar la que quieras directamente en la ventana del probador.
| Pestaña | Qué contiene |
|---|---|
| Resumen | Baldosas “Beneficio neto”, “Profit factor”, “Máx. drawdown (por cierres)”, “Porcentaje ganadoras”, “SQN”; franja “Qué no conoce este backtest”; curvas de capital, “comprar y mantener”, capital sin tasa de financiación y dos drawdowns |
| Métricas | Resultado, riesgo (drawdown por cierres y dentro de vela por separado, Sharpe, Sortino, Calmar), operaciones (porcentaje ganadoras, medias y mayores, rachas), costes (comisión y tasa de financiación) |
| Operaciones | Tabla de operaciones: entrada, salida, motivo, volumen, P&L, run-up, drawdown, comisión, financiación. Clic en la fila centra el gráfico en la vela de entrada; Ctrl+C copia las filas seleccionadas |
| Propiedades | Parámetros de la declaración, rango de velas, paso de precio, paso de cantidad, lote mínimo, comisión, contadores del proceso: órdenes rechazadas, saltadas por pyramiding, liquidaciones, cálculos de financiación |
En el título de la ventana — etiquetas de modo: conservative o optimistic por el modelo de ejecución y close-fill si processOrdersOnClose = true. Las etiquetas optimistic y close-fill indican que el resultado en vivo probablemente será peor.
Qué no puede leer la estrategia
Libro de órdenes en vivo y cinta de operaciones. Una estrategia que lea book.* o tape.* no se compila: “La estrategia lee … el libro y la cinta no tienen historial, el backtest sería ficticio”. Para historial del libro existe depth.*, para operaciones — delta.* y cluster.*.
Screener. screener.* también existe solo en la última vela, pero el compilador permite compilar esa estrategia. En el historial los valores del screener son na, por eso las condiciones con ellos no se cumplen y no habrá operaciones basadas en ellos en el informe.
Mirar hacia adelante. request.security(..., lookahead = true) en una estrategia muestra en el editor la advertencia “La estrategia mira hacia adelante … el informe está marcado como inalcanzable en tiempo real”. Trata ese informe como optimista: en el historial la estrategia ve valores que en vivo todavía no existirían. Más detalles en la sección de Datos de mercado.
Ejemplo
Ruptura de canal con confirmación por delta. Entrada — al cierre fuera del canal de los últimos len velas, si la delta de la vela coincide. Stop en ATR, take al doble.
strategy("Пробой канала с дельтой", overlay = true,
initialCapital = 10000,
defaultQtyType = strategy.qty.percent_of_equity, defaultQtyValue = 20,
commissionValue = 0.05, slippageTicks = 2)
len = input.int(20, "Канал, баров", minval = 5, maxval = 200)
stopAtr = input.float(1.5, "Стоп, ATR", minval = 0.5, maxval = 10, step = 0.1)
needFlow = input.bool(true, "Подтверждать дельтой")
upper = ta.highest(high, len)[1]
lower = ta.lowest(low, len)[1]
atr = ta.atr(14)
flowLong = not needFlow or (delta.available and delta.value > 0)
flowShort = not needFlow or (delta.available and delta.value < 0)
if close > upper and flowLong and strategy.position_size <= 0 {
strategy.entry("L", strategy.long, comment = "пробой вверх")
}
if close < lower and flowShort and strategy.position_size >= 0 {
strategy.entry("S", strategy.short, comment = "пробой вниз")
}
stopTicks = math.round(atr * stopAtr / sym.tick_size)
strategy.exit("L-x", from_entry = "L", loss = stopTicks, profit = stopTicks * 2)
strategy.exit("S-x", from_entry = "S", loss = stopTicks, profit = stopTicks * 2)
plot(upper, "Верх канала", color = color.teal)
plot(lower, "Низ канала", color = color.red)En un exchange sin delta (por ejemplo, Binance Alpha) con la opción “Confirmar por delta” activada la estrategia no realizará ninguna operación: delta.available allí es falso. Esto es la regla na en acción, no un error.
Limitaciones
- Solo simulación: no hay órdenes reales.
- Las órdenes límite se ejecutan como si fueras el primero en la cola. Para estrategias maker esto es la principal causa de resultados inflados.
- Tus operaciones no mueven el precio; no hay ejecuciones parciales: una orden se ejecuta entera o no se ejecuta.
- El recorrido del precio dentro de la vela se asume por un modelo, no se extrae de un timeframe menor.
- La liquidación está simplificada: no se modelan el motor de liquidaciones del exchange, ADL ni el fondo de seguros.
- La comisión es la tarifa por defecto, no la de tu cuenta.
- Falta de datos no es falta de movimiento: una vela sin clústeres igualmente tuvo movimiento.
- El resultado depende de cuánto historial esté cargado en el gráfico.
Dónde seguir
https://docs.lootx.trade/es/loot/strategies
8Alertas desde scripts
Cómo un script en LootScript notifica que se cumplió una condición: alert() y alertcondition(), frecuencia, activación de condiciones, adónde llega la notificación y qué no ofrecen las alertas desde scripts.
Un script puede notificarte de que en el mercado en vivo se cumplió una condición: ruptura de un nivel, un pico de delta, cruce de líneas. Para eso en LootScript hay dos funciones — alert(), que el script llama por sí mismo, y alertcondition(), una condición que activas manualmente.
La activación pasa por el mismo flujo que las demás notificaciones del terminal: registro en la pestaña Alertas, sonido, etiqueta emergente. Todo eso se procesa localmente en tu equipo: las alertas funcionan mientras el terminal esté en ejecución y el script esté en el gráfico.
Dos maneras
alert() |
alertcondition() |
|
|---|---|---|
| Quién decide si debe sonar | Código del script | Tú: debes activar la condición |
| Cuándo suena | Según la frecuencia elegida, incluida en una vela sin cerrar | Solo al cierre de la vela, no más de una vez por vela |
| Texto | Cualquier cadena; puedes ensamblarla con números | Texto fijo en el código |
| Dónde se activa | Siempre, mientras el script esté en el gráfico | Con la casilla en la consola del editor |
Si la alerta debe sonar siempre, usa alert(). Si el script declara varias señales y solo algunas deben sonar, decláralas con alertcondition() y activa las que necesites.
alert(): alerta desde el código
alert(message, freq = alert.freq_once_per_bar_close)message — cadena. Los números se insertan con str.tostring: "Цена " + str.tostring(close). El texto llega en la notificación tal cual; el terminal no lo traduce ni lo corrige.
La frecuencia se fija con la constante:
| Frecuencia | Cuándo suena |
|---|---|
alert.freq_once_per_bar_close |
Por defecto. Una vez, cuando la vela cerró: en la primera actualización de la vela siguiente, con los valores de la vela cerrada |
alert.freq_once_per_bar |
En el primer momento en que la llamada se ejecutó en esa vela — incluso si la vela aún se está formando. Luego guarda silencio hasta la siguiente vela |
alert.freq_all |
En cada recálculo de la vela en vivo donde se ejecutó la llamada |
La frecuencia se evalúa por cada llamada a alert() por separado: dos llamadas en un mismo script no se silencian entre sí. En un recálculo el script no envía más de 16 alertas; las restantes se descartan.
Ejemplo: alerta por un pico de delta, en cuanto aparece en la vela que se está formando.
indicator("Всплеск дельты", overlay = false)
mult = input.float(3.0, "Во сколько раз больше обычного", minval = 1.5, step = 0.5)
base = ta.sma(math.abs(delta.value), 50)
spike = delta.available and math.abs(delta.value) > base * mult
plot(delta.value, "Дельта", style = plot.style_columns, color = delta.value >= 0 ? color.teal : color.red)
if spike {
alert("Всплеск дельты: " + str.tostring(delta.value, "#.##"), freq = alert.freq_once_per_bar)
}Donde no hay delta, delta.available es falso y la alerta guarda silencio — más detalles sobre la regla na en la sección Datos de mercado.
alertcondition(): condición que activas tú
alertcondition(condition, title, message)condition — expresión booleana, title — nombre de la condición, message — texto de la notificación. title y message son cadenas literales en el código; no puedes construirlas a partir de números. Si no hay message, en la notificación irá title.
La condición suena solo al cierre de la vela, no más de una vez por vela y solo si está activada. Por defecto todas las condiciones están desactivadas.
Añade el script al gráfico
En el Editor de scripts haz clic en Añadir al gráfico.
Abre la pestaña «Salida»
En la consola bajo el código selecciona la pestaña Salida. Allí se muestran los valores de las series en la última vela y la lista «Condiciones de alertas (alertcondition) — activa las que necesites».
Activa las condiciones
Marca las casillas de las condiciones por las que quieras recibir notificaciones. Si el script está en varios gráficos, cada uno tiene su propia lista.
El historial no genera alertas
Las alertas suenan solo en actualizaciones en vivo. El primer cálculo tras cargar el gráfico, tras cambiar de instrumento o tras cargar historial más antiguo se considera historia: sobre velas pasadas ni alert() ni alertcondition() se disparan. Por eso, al añadir un script al gráfico no recibirás una oleada de notificaciones por el pasado.
Puedes comprobar la condición sobre el historial visualmente: dibuja su marca con plotshape — señalará cada vela donde la alerta se habría disparado.
Adónde llega la alerta
Cada activación:
- Se registra en la pestaña «Alertas» con la fuente «Alerta de script». En la entrada aparecen el texto del mensaje, el nombre del script y, para
alertcondition(), el nombre de la condición. La lista se abre en una ventana separada o panel del espacio de trabajo; el filtro Fuentes deja solo las alertas de script. - Reproduce un sonido. Se selecciona en Ajustes → Alertas, bloque «Sonidos», línea «Alerta de script»: lista de sonidos y un interruptor que silencia el sonido.
- Muestra una etiqueta «Nombre del script: texto».
- Resalta la pestaña del espacio de trabajo donde está el gráfico con el script.
Las demás notificaciones del terminal se describen en la página Alertas y niveles.
Registro: log.*
Para depurar condiciones hay un registro. log.info, log.warning y log.error escriben una línea en la pestaña Registro de la consola del editor — la misma donde están Problemas y Salida.
- El registro, como las alertas, solo se escribe en actualizaciones en vivo — en el historial guarda silencio.
- Por vela — no más de 16 líneas; las restantes se descartan.
- La consola guarda las últimas 256 líneas. Las más antiguas se expulsan; su número se muestra como «filas desplazadas». El botón Limpiar borra el registro.
indicator("Проверка условия", overlay = true)
len = input.int(20, "Канал, баров", minval = 2, maxval = 500)
upper = ta.highest(high, len)[1]
plot(upper, "Верх канала", color = color.teal)
if barstate.islast {
log.info("Закрытие " + str.tostring(close) + ", верх канала " + str.tostring(upper))
}Ejemplo: ruptura del canal
El script dibuja el límite superior del canal, marca las rupturas con un triángulo y las notifica de dos maneras: alert() suena siempre, y la condición «Ruptura al alza» solo si la activas.
indicator("Пробой канала с алертом", overlay = true)
len = input.int(20, "Канал, баров", minval = 2, maxval = 500)
upper = ta.highest(high, len)[1]
breakUp = ta.crossover(close, upper)
plot(upper, "Верх канала", color = color.teal)
plotshape(breakUp, "Пробой", style = shape.triangleup, location = location.belowbar, color = color.teal, size = size.small)
if breakUp {
alert("Пробой вверх, цена " + str.tostring(close), alert.freq_once_per_bar_close)
}
alertcondition(breakUp, "Пробой вверх", "Цена закрылась выше канала")El límite se toma con un desplazamiento [1] — sobre velas previas; de lo contrario el máximo actual siempre estaría dentro del canal. La frecuencia freq_once_per_bar_close significa que la alerta llegará tras el cierre de la vela por encima del canal, y el triángulo en el gráfico quedará exactamente donde sonó la alerta. En un script real normalmente se deja uno de los dos métodos — aquí están ambos para comparar.
Siguiente lectura
https://docs.lootx.trade/es/loot/alerts
9Asistente IA en el Editor
Chat con un modelo IA en el Editor de LootScript: escribe y corrige scripts, los prueba en velas reales y responde sobre el mercado. Qué proveedores hay, dónde pegar la clave y qué sale del equipo.
En el Editor de LootScript hay un chat con un modelo IA. Describa con palabras qué indicador necesita: el asistente escribirá el código directamente en el editor, lo compilará, lo ejecutará sobre velas reales y explicará el resultado. También corrige scripts ya hechos, aclara código ajeno y responde preguntas del mercado usando los datos del terminal.
Usted elige el modelo: en la nube —con su propia API key— o local —en su propio equipo. Las solicitudes van desde el terminal directamente al proveedor elegido, sin pasar por servidores de LootX.
Cómo abrir el asistente
- Pulse ƒ en la barra del gráfico —se abrirá la ventana Indicadores.
- Pulse Editor… junto a la barra de búsqueda o abra su script.
- En la barra superior del editor, junto a Añadir al gráfico, pulse Asistente.
El chat se colocará a la derecha del código. Puede ajustar el ancho arrastrando el separador. La cruz en la cabecera del chat (Ocultar chat) lo cierra sin borrar la conversación; volver a pulsar Asistente lo restaura.
Conexión del modelo
Abra la tarjeta de conexión
La primera vez que haga una pregunta la tarjeta se abrirá sola. Después podrá abrirla con el engranaje Clave y conexión en la cabecera del chat.
Elija proveedor
La lista está en la tabla abajo. Por defecto está seleccionado Claude.
Pegue la API key
Debajo del campo hay un enlace Obtener clave en … —lleva al panel del proveedor. La clave guardada no se muestra: déjelo vacío para no cambiarla, o pulse Eliminar clave.
Verifique el modelo y guarde
El campo Modelo viene con un valor por defecto; en las sugerencias hay otros. Puede escribir cualquier nombre que conozca el proveedor. Pulse Guardar.
| Proveedor | Qué se necesita |
|---|---|
| Claude | API key de Anthropic. La suscripción de Claude no sirve — Anthropic prohíbe que programas de terceros la usen. |
| Gemini | API key de Google. La suscripción de Gemini no sirve por la misma razón. |
| OpenAI, DeepSeek, Grok, Mistral, Qwen, Kimi, GLM, Groq | API key del proveedor. |
| OpenRouter | API key de OpenRouter: a través de él están disponibles modelos de distintas compañías. |
| Ollama, LM Studio | No se necesita clave: el modelo funciona en su equipo. Arranque el servidor, cargue el modelo y escriba su nombre. |
| Compatible con OpenAI | Cualquier servidor con API en formato OpenAI Chat Completions: gateway, vLLM, proxy corporativo. Indique la dirección (suele terminar en /v1), el modelo y la clave, si el servidor la requiere. |
Las solicitudes en la nube se facturan según la tarifa de su cuenta con el proveedor, por separado de LootX. Después de cada respuesta en el chat se muestra cuántos tokens se consumieron en entrada y en salida.
Un modelo local necesita soporte de tool calling. Sin él el asistente no podrá escribir en el editor ni comprobar código.
Proxy y su propia dirección
Si el servicio del proveedor no es accesible directamente desde su red, indique un proxy en el campo Proxy — http://host:port o socks5://usuario:contraseña@host:port. El proxy es común para todos los proveedores. El campo Dirección API (para su gateway) se usa solo si accede al proveedor a través de su propio gateway.
Qué puede hacer el asistente
- Escribe un script nuevo según su descripción y coloca el código en el editor.
- Corrige uno existente —de forma puntual, sin reescribir todo el archivo.
- Se prueba a sí mismo. Compila el código y lo ejecuta sobre velas reales —por defecto en el instrumento y la temporalidad del gráfico, hasta 5000 barras anteriores; a petición, en cualquier otra. Verifica resultados fila por fila y busca errores de ejecución.
- Añade el script al gráfico cuando lo pida.
- Responde sobre el mercado. Toma velas de cualquier instrumento del terminal, métricas del screener (volatilidad, volumen, interés abierto, tasa de financiación, spread) y ordena el mercado: «¿Qué contratos de futuros son ahora los más volátiles?».
- Consulta la referencia del lenguaje, revisa los indicadores integrados y los scripts de su biblioteca.
Cada paso aparece en la cinta como una línea: «Compilando», «Ejecutando sobre velas», «Corrigiendo código». Si el modelo muestra su razonamiento, este queda plegado en el bloque Razonamiento. Puede interrumpir la respuesta con el botón Detener.
Todo lo que el asistente escribe en el editor se deshace con el habitual Ctrl+Z. Si el código viene como bloque, en su cabecera aparecen botones. Para un script completo está Al editor —reemplaza el código en el editor; para un fragmento está Insertar en la posición del cursor. Ambos tienen Copiar.
Comandos rápidos
Escriba / en el campo de entrada —aparecerá la ayuda. Los mismos comandos están también como botones en un chat vacío. El texto tras el comando es su aclaración: /fix mire el volumen.
| Команда | Что делает |
|---|---|
/fix |
Encuentra y corrige errores: compila, ejecuta sobre velas, repara errores y filas con na. Conserva su intención y estilo; al final enumera los cambios. |
/explain |
Explica en palabras sencillas qué calcula el script, qué efecto tiene cada ajuste, qué dibuja y cómo leer las señales. No cambia el código. |
/optimize |
Acelera el script sin cambiar resultados: sustituye loops caseros por funciones integradas, elimina trabajo innecesario y verifica con una ejecución que los valores no cambiaron. |
Otra palabra tras la barra se envía al modelo como una pregunta normal.
Imágenes y capturas del gráfico
Puede adjuntar una imagen a la pregunta: con el clip bajo el campo de entrada, pegando desde el portapapeles (Ctrl+V) o arrastrando el archivo al chat. El botón con el icono de gráfico junto al clip adjunta una captura del mismo panel donde se añadirá el script. En una sola pregunta puede adjuntar hasta seis imágenes. Antes de enviar, las imágenes grandes se reducen.
No todos los modelos procesan imágenes. Si el modelo elegido no soporta imágenes, el chat mostrará un aviso antes de enviar. Si el terminal no sabe si el modelo ve imágenes y el proveedor rechaza la pregunta, las imágenes volverán al campo de entrada.
Historial de conversaciones
La conversación está ligada al script. Abra otro script —verá la conversación asociada a él. Cierre el editor o reinicie el terminal —la conversación permanecerá.
- En un script nuevo sin guardar la conversación no se escribe en disco. Se guardará junto al script cuando pulse Guardar por primera vez.
- El icono Nuevo chat en la cabecera inicia una conversación nueva y borra la anterior del disco.
- Si borra el script, se borra también su conversación.
- Mientras el asistente responde no puede abrir otro script: primero detenga la respuesta.
Toda la conversación se envía al modelo con cada pregunta, por eso un chat largo encarece las consultas. El tamaño de la conversación en tokens se muestra con un número en la cabecera del chat, por ejemplo «42k». Pulse sobre él para comprimir la conversación en un resumen: a partir de entonces el asistente la recordará por ese resumen. El terminal pliega los resultados de ejecuciones antiguas y las imágenes. En el historial guardado, las imágenes antiguas se sustituirán con el tiempo por la nota «La imagen de esta pregunta ya no se almacena».
Qué sale del equipo
Al proveedor elegido, directamente:
- sus mensajes y las imágenes adjuntas;
- el nombre del script, número de líneas y errores, el instrumento y la temporalidad del gráfico —con cada pregunta;
- el código del editor y el informe del compilador —cuando el asistente lee o corrige el script;
- los datos que el asistente haya pedido: velas, métricas del screener, resultados de ejecuciones, fragmentos de la documentación del lenguaje.
No sale:
- Secrets. El asistente no ve API keys de exchanges. La API key del proveedor se guarda en este equipo cifrada, no se sincroniza con la configuración y solo se transmite al propio proveedor —para autenticación. Del texto que se envía al modelo el terminal elimina todo lo que se parezca a una clave, token o contraseña, así como rutas a archivos en disco. Un mensaje en el que usted mismo haya pegado algo que parezca una clave no se envía: el chat le pedirá eliminar el secreto.
- Saldo. El asistente no tiene acceso a saldos, posiciones ni órdenes —solo ve lo que usted muestre en una captura. No puede poner órdenes.
- Historial del chat. Está en este equipo cifrado y no entra en la sincronización, ni en la exportación de ajustes, ni en el Informe del programa.
Con Ollama o LM Studio la conversación y el código no salen del equipo.
Limitaciones
- No hay datos en tiempo real en las ejecuciones de verificación. Clústeres, delta, interés abierto, tasa de financiación, libro de órdenes, cinta de operaciones, screener e historial del libro al ejecutar sobre velas están a
na. La lógica que dependa de ellos el asistente no puede comprobarla —añada el script al gráfico y compruébelo usted mismo. - Límite de pasos. Por respuesta el asistente no realiza más de 24 pasos; después resume. Una respuesta truncada por longitud se puede continuar: pídalo.
- El modelo se equivoca. La ejecución detecta errores de compilación y de runtime, pero no errores de idea. Antes de confiar en señales, revise el script en el gráfico.
- Rechazos del proveedor. El chat muestra el texto con el nombre del proveedor: clave no aceptada, límite de peticiones agotado, saldo o cuota insuficientes, sin conexión, servidor local sin respuesta. Para reestablecer la conexión compruebe Internet o indique un proxy.
Siguientes pasos
https://docs.lootx.trade/es/loot/ai-assistant
10Importar desde Pine Script
Cómo trasladar un indicador de Pine Script a LootScript: dónde está el botón de importación, qué convierte el conversor automáticamente, qué marca para revisar y cómo pulir el resultado.
Si un indicador ya está escrito en Pine Script, no hace falta reescribirlo a mano. El terminal convierte el archivo .pine a LootScript: cambia la sintaxis y los nombres, añade lo que falta y escribe notas al principio del archivo indicando qué se modificó y dónde el conversor tuvo que adivinar.
El conversor es un traductor, no una capa de compatibilidad. No garantiza los mismos números que en el entorno original, y no añade al terminal funciones que allí no existen. Por eso, después de importar debes abrir el script, leer las notas y comprobarlo en el Gráfico. LootScript se desarrolló de forma independiente y no está ligado a TradingView: la sintaxis es similar a propósito, pero los lenguajes no son compatibles.
Cómo importar
Abra la ventana Indicadores
Presione ƒ en el panel del Gráfico — se abrirá la ventana Indicadores.
Haga clic en «Importar…»
El botón está junto a la barra de búsqueda. Seleccione un archivo .pine, .loot o .txt. El archivo .loot irá a la biblioteca tal cual. El archivo .pine —o un archivo de texto similar a Pine Script— pasará por el conversor.
Lea el resultado
Debajo de la barra de búsqueda aparecerá una de estas líneas:
- «Importado «…»» — no hay notas, el script está listo;
- «Importado «…»: notas del conversor — N, ver encabezado del script»;
- «Importado «…», pero el script no compila (errores: N)…» — junto al texto se mostrará el primer error.
La ventana cambiará a la sección Mis scripts, y en la búsqueda se pondrá el nombre del nuevo script.
Abra el script en el Editor
Lea el encabezado con las notas y corrija lo que indique. Cómo — más abajo.
La importación no sobrescribe un script con el mismo nombre: el nuevo recibirá un sufijo, por ejemplo -2. El archivo original no se modifica.
A través de la carpeta de scripts
También puedes simplemente colocar el archivo nombre.pine en la carpeta de scripts — en Windows es %APPDATA%\TradingTerminal\scripts. Al siguiente inicio, el terminal creará junto a él nombre.loot. Si nombre.loot ya existe, no se tocará — no perderás tus cambios. Para convertir de nuevo, por ejemplo después de actualizar el terminal, elimina el .loot.
Qué hace el conversor
- Indentación → llaves. Los bloques
if,else if,else, bucles y funciones reciben llaves. Las líneas de continuación se unen en una sola. - Funciones.
f(x) =>se convierte enfunc f(x), y la última expresión de la función se convierte en unreturnexplícito. - Bucles. El inclusivo
for i = 0 to 9pasa a semi-abiertofor i in 0 .. 10. La dirección se toma del paso o de literales de los límites; si no se ve, el conversor asume que el bucle es ascendente y lo indica. - Condicionales como valores. Un
ifcon una sola expresión en las ramas se convierte en operador ternario;switchrecibe llaves. - Transparencia → alfa. En Pine Script la transparencia va de 0 a 100, donde 0 es opaco. En LootScript alfa va de 0 a 255, donde 255 es opaco.
color.new(c, 50)se convertirá encolor.new(c, 128), y el argumentotransp=se transformará en uncolor.new(…)alrededor del color. - Nombres. Los nombres antiguos sin espacio de nombres reciben uno:
sma→ta.sma.study→indicator,security→request.security,tostring→str.tostring,syminfo.*→sym.*,timeframe.*→tf.*. La forma cortainput(…)recibe tipo:input.int,input.source, etc. - Nombres reservados. Una variable cuyo nombre en LootScript sea palabra clave o espacio de nombres (
delta,oi,tf,sym,func…) recibe un guion bajo al final en todas sus apariciones:delta→delta_. - Argumentos extra — aquellos que no existen en la función en LootScript — se eliminan.
- Declaración. Si el archivo no contenía
indicator(…)ostrategy(…), el conversor añadirá unindicatorcon el nombre del archivo. - Comentarios y líneas vacías permanecen en su sitio.
El conversor no rechaza ningún archivo. La línea que no entienda no la elimina, la deja como comentario // [не разобрано] … en la misma posición.
Encabezado con notas
La primera línea del encabezado indica de dónde viene el archivo — «Importado desde un script en Pine Script (versión 5). Notas del conversor:». Luego, una línea por cada modificación, en orden de las líneas del origen: «Línea N: tipo: qué — detalles». Las notas se escriben en el idioma de la interfaz.
| Tipo de nota | Qué significa | ¿Revisar? |
|---|---|---|
| renombrado | Nombre reemplazado por el análogo en LootScript | no |
| recalculado | Transparencia convertida a alfa | no |
| reescrito | Cambió la forma: bucle, return, tipo de input corto |
echar un vistazo |
| el nombre «…» está reservado en LootScript | A la variable se le añadió un guion bajo | no |
| no había declaración indicator(…) | Se añadió la declaración usando el nombre del archivo | no |
| argumento eliminado | La función en LootScript no tiene ese parámetro | sí |
| suposición | El conversor adivinó: dirección del bucle, tipo de entrada que no pudo deducir | sí |
| no está en esta build | Esa función no existe en el terminal — el script no compilará por “nombre desconocido” | sí |
| no analizado | La línea no se pudo parsear; se conserva como comentario | sí |
Cuando lo hayas comprobado, puedes eliminar el encabezado — son comentarios ordinarios.
Ejemplo
Pequeño indicador en Pine Script: columnas del rango de la vela, resaltadas cuando el rango es el doble del promedio.
//@version=5
indicator("Range spike", overlay=false)
len = input.int(20, "Length")
avgRange(n) =>
r = high - low
ta.sma(r, n)
base = avgRange(len)
spike = high - low > base * 2
plot(high - low, style=plot.style_columns, color=spike ? color.orange : color.new(color.gray, 60))
plot(base, color=color.blue, trackprice=true)Así lo escribe el conversor:
// Импортировано из скрипта на Pine Script (версия 5). Заметки конвертера:
//
// Строка 6: переписано: avgRange — неявный возврат последнего оператора записан как return
// Строка 9: пересчитано: transp → alpha — прозрачность 0…100 пересчитана в альфу 0…255
// Строка 10: аргумент снят: plot: trackprice — такого параметра в LootScript нет
indicator("Range spike", overlay = false)
len = input.int(20, "Length")
func avgRange(n) {
r = high - low
return ta.sma(r, n)
}
base = avgRange(len)
spike = high - low > base * 2
plot(high - low, color = spike ? color.orange : color.new(color.gray, 102), style = plot.style_columns)
plot(base, color = color.blue)La función recibió llaves y return, la transparencia 60 pasó a alfa 102, y trackprice se eliminó — ese parámetro no existe. La nota «argumento eliminado» pide que verifiques si ese parámetro era necesario en sentido lógico. Aquí solo dibujaba la línea del último valor, y el script funciona sin él.
Cómo comprobar y pulir
- Lee el encabezado. Empieza por las líneas con tipos «argumento eliminado», «suposición», «no está en esta build» y «no analizado».
- Mira la pestaña Problemas en la consola del Editor. Un script con errores no se añadirá al Gráfico.
- Usa ‘Añadir al gráfico’ y compáralo con lo que mostraba el original en varios tramos del histórico.
- Pide ayuda al asistente. Abre el Asistente de IA y escribe
/fix— él compilará el script, lo ejecutará sobre velas y corregirá errores. Puedes añadir una aclaración:/fix analiza las notas del conversor en el encabezado./explainexplicará qué hace el script.
Qué no se transfiere
- Funciones que no existen en el terminal. El nombre queda en el código, la nota «no está en esta build» y el error del compilador señalan la misma ubicación. Sustituye la llamada a mano o pide al asistente que sugiera un análogo.
- Cadenas multilínea, importación de librerías ajenas, exportación de funciones. El conversor traslada lo que puede serializar y marca lo demás.
- Más de tres líneas. El panel de Gráfico dibuja solo las primeras tres
plotdel script. Distribuye filas adicionales en scripts separados. - Trading real. La declaración
strategy(…)se traslada, pero una estrategia en LootScript solo opera en el Probador de estrategias — en cuenta simulada.
Siguientes pasos
https://docs.lootx.trade/es/loot/pine-import
11Errores de compilación y ejecución
Todos los códigos LS que puede mostrar el Editor y el gráfico de LootScript: texto del mensaje, causa y solución, errores frecuentes con ejemplos, límites de ejecución y casos en los que en vez de error se obtiene na.
Cada mensaje del compilador y del ejecutor de LootScript empieza por un código del tipo LS2008. El código no cambia entre versiones ni depende del idioma de la interfaz, por eso conviene buscarlo: aquí están todos los códigos que puede mostrar el terminal, con el texto del mensaje, la causa y la forma de arreglarlo.
Los mensajes se muestran en ruso si la interfaz del terminal está en ruso, y en inglés en cualquier otro idioma. Primero están los errores que aparecen con más frecuencia, luego los errores de ejecución y la tabla completa.
Где видны ошибки
При компиляции. El Editor compila el script en cada pausa de escritura. Lo que encuentra aparece en la pestaña “Problemas” en la parte inferior del Editor: código, texto y posición como «Стр 6:6». Un doble clic en la línea lleva el cursor al lugar del error. En el encabezado del Editor se muestra el resultado: «ок · 12 мс», «предупреждений: 2» o «ошибок: 1».
При выполнении. Un script sin errores de compilación puede detenerse en algún bar: se acabó el presupuesto de operaciones, un índice salió de los límites de un array, el símbolo es desconocido. Entonces en la pestaña “Salida” aparecerá una línea «Script detenido: LS6004: …», y en la ventana del Probador de estrategias se verá la misma causa. Los demás scripts, paneles y el terminal siguen funcionando.
Las diagnósticas son de tres niveles:
| Уровень | Что значит | Что с графиком |
|---|---|---|
| Ошибка | Скрипт не собран | No se añade al gráfico: «Un script con errores no se coloca en el gráfico — vea “Problemas”». Si el script ya estaba en los gráficos, permanece la versión anterior que funcionaba |
| Предупреждение | Скрипт собран, но результат может обмануть: например, перерисуется на живом баре | El script funciona |
| Сведение | Скрипт собран, но какая-то его настройка ничего не делает | El script funciona |
Как устроены коды
| Коды | Этап | О чём |
|---|---|---|
| LS0001–LS0009 | Чтение текста | Символы, строки, числа, цвета, директива #version |
| LS1000–LS1012 | Разбор | Скобки, блоки, порядок операторов, объявление скрипта |
| LS2000–LS2030 | Типы и имена | Неизвестные имена, типы, аргументы, na |
| LS3000–LS3033 | Смысл программы | ta.* в ветках, рекурсия, стратегии, библиотеки, request.security |
| LS4000–LS4009 | Пределы компиляции | Слишком много рядов, выводов, вызовов |
| LS5000–LS5013 | Перерисовка и честность теста | Значения, которые на истории выглядят иначе, чем вживую |
| LS6000–LS6036 | Выполнение | Бюджеты, индексы, коллекции, строки, объекты рисования |
| LS0999 | Внутренний сбой | Дефект компилятора — о нём нужно сообщить |
Частые ошибки компиляции
LS1009 — нет объявления скрипта
«Нет объявления скрипта — начните с indicator(“Название”)». El primer operador del fichero debe ser indicator(...), strategy(...) o library(...). Esta misma ошибка aparece si la declaración existe pero hay algo escrito antes. Los comentarios y la directiva #version 1 no molestan.
// Так нельзя: объявление не первое
len = input.int(14, "Длина")
indicator("RSI")indicator("RSI")
len = input.int(14, "Длина")Una segunda declaración en el mismo fichero da LS1008: el script sólo puede tener una.
LS2002 — неизвестное имя
«Неизвестное имя «…» — проверьте написание или объявите его выше». Normalmente es una errata o una función sin su namespace: todas las funciones de indicadores están en ta, las matemáticas en math, los colores en color.
avg = sma(close, 20)avg = ta.sma(close, 20)La misma falla ocurre si se lee una variable antes de la línea donde se declara. La lista completa de nombres está en la Referencia de funciones.
LS2008 — сравнение с na
«Сравнение с na всегда ложно — используйте na(x)». Cualquier comparación con na, incluyendo == y !=, da false, por eso el compilador no permite esa escritura.
x = ta.sma(close, 50)
plot(x == na ? close : x)x = ta.sma(close, 50)
plot(na(x) ? close : x)Lo mismo se escribe más corto con ??: plot(x ?? close).
LS2014 — значение меняется от бара к бару там, где нужна постоянная
««…» в «…» требует значение не слабее input, а передано series — возьмите input.*(…) или литерал». La longitud de la ventana en ta.* debe conocerse antes del primer bar. Una longitud que se elige condicionalmente en cada bar no es válida.
len = close > open ? 10 : 20
avg = ta.sma(close, len)Calcule ambas variantes y elija el resultado, no la longitud:
fast = ta.sma(close, 10)
slow = ta.sma(close, 20)
avg = close > open ? fast : slowSi la longitud debe fijarla el usuario, tómela de input.int(...).
LS3004 — вызов ta.* зависит от переменной из ветки
«Аргумент «…» нельзя вычислить вне ветки — вынесите вызов ta.* на верхний уровень». Las funciones ta.* recuerdan barras pasadas, por eso el compilador las evalúa en cada bar aunque la llamada esté dentro de un if. Si el argumento se declara solo dentro de la rama, en otras barras simplemente no existe.
var float avgBody = na
if close > open {
body = close - open
avgBody := ta.sma(body, 10)
}body = close - open
avgBody = ta.sma(body, 10)LS2017, LS2007, LS1006 — строки, условия и сравнения
Estas tres errores comparten causa: LootScript no convierte tipos implícitamente.
| Код | Сообщение | Как исправить |
|---|---|---|
| LS2017 | «Строку нельзя складывать с числом (… + …) — используйте str.tostring(…)» | "RSI " + str.tostring(r) en lugar de "RSI " + r |
| LS2007 | «Условие должно быть bool, а здесь …» | if volume > 0 en lugar de if volume — los números no son truthy |
| LS1006 | «Сравнения не сцепляются — напишите a < b and b < c» | low < close and close < high en lugar de low < close < high |
LS2018 и LS2019 — имя уже занято
««…» уже объявлено в этой области» (LS2018) — la variable se declaró por segunda vez con =. Para cambiar su valor use :=.
level = high
level := low««…» затеняет встроенное имя — выберите другое» (LS2019) — variable, función o tipo se llamaron igual que un series o función incorporada: close, time, hour, volume. Renombre, por ejemplo startHour en vez de hour. Los nombres de espacios como color o position pueden usarse como nombres de variable.
LS2004 и LS2005 — аргументы вызова
««…» ожидает … аргумент(ов), а передано …» (LS2004) и «У «…» нет параметра «…»» (LS2005). Compruebe la llamada con la firma en la Referencia: los nombres de parámetros se escriben exactamente como allí.
plot(close, colour = color.red)plot(close, color = color.red)LS3011 и LS5011 — стратегии
«strategy.* доступно только в strategy(…)» (LS3011): órdenes y estado de posición existen solo en un script declarado con strategy(...). Reemplace indicator("…") por strategy("…").
«Стратегия читает «…»: у стакана и ленты нет истории, бэктест был бы вымыслом» (LS5011): la estrategia se prueba sobre la historia, y book.* y tape.* no tienen historia — en cada bar pasado allí hay na.
strategy("Перекос стакана")
if book.imbalance(10) > 0.5 {
strategy.entry("L", strategy.long)
}Para historia del libro de órdenes existe el espacio depth: donde el libro está grabado, depth.* da valores en cada bar.
strategy("Перекос стакана")
if depth.imbalance(1.0) > 0.5 {
strategy.entry("L", strategy.long)
}LS5000–LS5006 — предупреждения о перерисовке
Estas advertencias no impiden que el script funcione. Indican que una línea en la historia se verá distinta de como se vio en vivo:
- LS5001 — llega al gráfico un valor que solo existe en el bar en vivo (
barstate.isrealtime,barstate.isnew). - LS5000 — llega al gráfico la variable
varip: acumula ticks del bar en vivo que no existen en la historia. - LS5006 — llegan al gráfico
book.*otape.*: en la historia la serie está vacía. - LS5003 — valor de un higher timeframe desde
request.securitysin[1]: el bar no cerrado aún va a cambiar. - LS5002 —
lookahead = trueenrequest.security: en la historia el script ve el futuro. - LS5005 — llegan al gráfico
math.randomotimenow: dos ejecuciones dan líneas distintas.
Si es intencionado — por ejemplo un indicador solo para trading en vivo — la advertencia puede dejarse.
LS3016 — настройка принята и ничего не делает
Esto es un aviso informativo, no un error. Aparece en scripts trasladados de otras plataformas: el parámetro existe por compatibilidad pero no influye en el terminal. La segunda parte del mensaje explica por qué.
| Что написано | Пояснение в сообщении |
|---|---|
maxBarsBack в объявлении |
la historia se carga por columnas completas |
format, precision, scale в объявлении |
el formato y escala los gestiona el terminal |
timeframe в объявлении |
el script se calcula en la temporalidad del gráfico; otra da request.security |
Grosor, estilo u otra opción de salida definida por expresión y no por constante (el color de plot o marcas que cambian por barra) |
esta compilación sólo lee esa opción como constante |
color en el cuarto y siguientes plot |
el panel dibuja solo las tres primeras series |
location.absolute en plotshape o plotchar |
la marca no tiene un series al que pegarse |
display, que el series no soporta |
ese series no tiene esa superficie |
Ошибки выполнения
Un error de ejecución detiene el script en el bar donde ocurrió. El texto aparece en la pestaña “Salida” como «Script detenido: LS6004: …».
LS6004 и LS6005 — скрипт работает слишком долго
«Скрипт исчерпал бюджет операций на бар — упростите цикл» (LS6004) y «Скрипт превысил лимит времени на проход» (LS6005). Cada bar tiene un presupuesto de 2 000 000 de operaciones. El tiempo también está limitado: todo el pase por la historia — 2 s, un tick de bar en vivo — 20 ms. Casi siempre la causa es un bucle que no termina o que procesa demasiados datos en cada bar.
var int n = 0
i = 0
while i < 10 {
n := n + 1
}var int n = 0
i = 0
while i < 10 {
n := n + 1
i := i + 1
}LS6002 и LS5004 — чтение будущего
El índice de la historia x[n] no puede ser negativo: close[-1] significaría el siguiente bar. Si el número negativo está literal en el texto, el compilador lo detendrá inmediatamente (LS5004). Si nace de un cálculo, el script se detendrá en el bar con el error «Desplazamiento negativo de historia — no se puede leer el futuro» (LS6002). Un índice mayor que el número de barras cargadas no provoca error: da na.
LS6001, LS6007, LS6019 — коллекции и объекты
- LS6001 «Индекс … вне границ» —
array.get,array.setomatrix.getfuera del tamaño. Compruebearray.size(a)antes de acceder. - LS6007 «Обращение к пустому объекту (na)» — la colección se declaró pero no se creó:
var array<float> a = nay luegoa.push(x). Créela conarray.new<float>(). - LS6019 «Объект рисования уже удалён или вытеснен по потолку — создайте его заново». Viven simultáneamente 500 objetos del mismo tipo, el más antiguo es desalojado. Eleve el límite con
maxLinesCount,maxLabelsCountomaxBoxesCounten la declaración o reutilice el objeto conset_*.
LS6017 и LS6018 — инструмент и таймфрейм в request.security
«Символ «…» неизвестен — проверьте формат «ПЛОЩАДКА:СИМВОЛ» или задайте ignore_invalid_symbol = true» (LS6017) y «Таймфрейм «…» не разбирается — ожидается «5», «60», «4h», «1D», «1W»» (LS6018). Con ignore_invalid_symbol = true un instrumento desconocido da na en vez de detenerse.
Пределы выполнения
| Что ограничено | Предел | Код при превышении |
|---|---|---|
| Операций на бар | 2 000 000 | LS6004 |
| Время прохода по истории / тика живого бара | 2 с / 20 мс | LS6005 |
| Элементов массива | 100 000 | LS6003 |
| Пар в словаре | 50 000 | LS6003 |
| Элементов матрицы | 1 000 000 | LS6003 |
Длина окна ta.* |
100 000 баров | LS6034 |
| Длина одной строки | 100 000 символов | LS6014 |
| Ячеек в таблице | 2000 | LS6029 |
| Слоёв теплового поля | 4 (от 0 до 3) | LS6036 |
| Объектов рисования одного вида | 500 по умолчанию | старые вытесняются |
Разных пар «инструмент + таймфрейм» в request.security |
8 | — |
Вызовов request.security |
32 | LS4009 при компиляции |
Когда ошибки нет, а значения нет
Muchas situaciones que en otros lenguajes harían caer el programa en LootScript dan na — un hueco en el gráfico, no una detención:
- la aritmética con
nadana:close - xconxvacío también es vacío; x[n]más allá del inicio de la historia —na;- la división entera por cero —
na, y la división en coma flotante por cero no detiene el script; book.*,tape.*yscreener.*en barras históricas —na;- clústeres, delta, interés abierto y la historia del libro de órdenes —
naen barras donde no hay datos. Compruebecluster.available,delta.availabley las flags adyacentes; ta.*en las primeras barras, hasta que la ventana se llena, —na.
na en el gráfico nunca se dibuja como cero: la línea se corta. Para sustituir el valor use nz(x), x ?? fallback o fixnan(x).
Все коды
LS0001–LS0009 и LS0999 — чтение текста
| Код | Сообщение | Что делать |
|---|---|---|
| LS0001 | Неожиданный символ «…» | Уберите символ, которого нет в языке |
| LS0002 | Строка не закрыта — добавьте закрывающую кавычку до конца строки | Закройте кавычку на той же строке |
| LS0003 | Блочный комментарий не закрыт — добавьте */ | Закройте /* … */ |
| LS0004 | Неизвестная escape-последовательность «…» в строке | Допустимы \n, \r, \t, \0, \\, \", \' и \u{…}; одиночную \ удвойте |
| LS0005 | Неверный числовой литерал «…» | Проверьте запись числа |
| LS0006 | Число «…» не помещается в тип | Уменьшите число |
| LS0007 | Неверный литерал цвета «…» — ожидается #RRGGBB или #RRGGBBAA | Шесть или восемь шестнадцатеричных цифр |
| LS0008 | Разделитель разрядов «_» стоит в начале, в конце или сдвоен | Пишите 1_000_000 |
| LS0009 | Неверная директива версии — ожидается #version <число> первой строкой | #version 1 в первой строке |
| LS0999 | Компилятор не справился с этим файлом — это дефект сборки, сообщите о нём | Сообщите в поддержку, приложите скрипт |
LS1000–LS1012 — разбор
| Код | Сообщение | Что делать |
|---|---|---|
| LS1000 | Неожиданно: … | Проверьте строку на лишние символы |
| LS1001 | Ожидалось «…», а встретилось … | Чаще всего не закрыта скобка |
| LS1002 | Ожидалось выражение, а встретилось … | После оператора или запятой не хватает значения |
| LS1004 | Ожидалось имя, а встретилось … | После var, func, . нужно имя |
| LS1005 | Ожидался блок в фигурных скобках, а встретилось … | Добавьте { … } |
| LS1006 | Сравнения не сцепляются — напишите a < b and b < c | Разбейте на два сравнения через and |
| LS1008 | Второе объявление скрипта — у скрипта может быть только одно | Оставьте одно объявление |
| LS1009 | Нет объявления скрипта — начните с indicator(“Название”) | Первой строкой — indicator, strategy или library |
| LS1010 | Слишком глубокая вложенность (больше 64) — вынесите часть в функцию | Разбейте выражение или блок |
| LS1012 | Тело if / for / while пишется в фигурных скобках: if cond { … } | Добавьте фигурные скобки |
LS2000–LS2030 — типы и имена
| Код | Сообщение | Что делать |
|---|---|---|
| LS2000 | Несовпадение типов: ожидался …, а получен … | Передайте значение нужного типа |
| LS2001 | Нельзя преобразовать … в … | Преобразуйте явно: str.tostring, math.round |
| LS2002 | Неизвестное имя «…» — проверьте написание или объявите его выше | Исправьте опечатку, добавьте пространство (ta.), объявите выше |
| LS2003 | «…» — не функция, вызывать нельзя | Уберите скобки: это ряд или константа |
| LS2004 | «…» ожидает … аргумент(ов), а передано … | Сверьте число аргументов со справочником |
| LS2005 | У «…» нет параметра «…» | Исправьте имя параметра |
| LS2006 | Аргумент «…» передан дважды | Уберите повтор |
| LS2007 | Условие должно быть bool, а здесь … | Сравните явно: x > 0, not na(x) |
| LS2008 | Сравнение с na всегда ложно — используйте na(x) | na(x) вместо x == na |
| LS2014 | «…» в «…» требует значение не слабее …, а передано … — возьмите input.*(…) или литерал | Литерал, input.* или константа вместо ряда |
| LS2015 | «…» объявлено константой — присваивать нельзя; объявите через var | Настройку input.*, переменную цикла и параметр функции менять нельзя — скопируйте значение в свою переменную |
| LS2017 | Строку нельзя складывать с числом (… + …) — используйте str.tostring(…) | str.tostring или str.format |
| LS2018 | «…» уже объявлено в этой области | := для нового значения или другое имя |
| LS2019 | «…» затеняет встроенное имя — выберите другое | Переименуйте |
| LS2020 | Ветви дают разные типы: … и … | Приведите ветви к одному типу |
| LS2021 | switch без ветви по умолчанию «=> …» — добавьте её | Добавьте => значение |
| LS2022 | У «…» не выведен тип элемента — укажите его: … | array.new<float>() |
| LS2028 | У поля «…» типа «…» не указан тип — напишите его перед именем: float … | float price в объявлении type |
| LS2029 | export «…»: у экспортируемой функции обязаны быть объявлены типы всех параметров и тип результата | Укажите типы |
| LS2030 | «…» в «…» читается до первого бара — нужен литерал или именованная константа | В объявлении — только постоянные значения |
LS3000–LS3033 — смысл программы
| Код | Сообщение | Что делать |
|---|---|---|
| LS3002 | «…» вызывает саму себя — рекурсия в LootScript запрещена | Замените рекурсию циклом |
| LS3003 | Взаимная рекурсия запрещена: … | Разорвите круг вызовов |
| LS3004 | Аргумент «…» нельзя вычислить вне ветки — вынесите вызов ta.* на верхний уровень | Вычислите аргумент и вызов вне if |
| LS3006 | «…» затеняет имя из внешней области (предупреждение) | Переименуйте внутреннюю переменную |
| LS3007 | «…» вне цикла | break и continue — только в цикле |
| LS3008 | return вне функции | return — только в теле функции |
| LS3009 | export «…» возможен только в library(…) | Уберите export или сделайте файл библиотекой |
| LS3010 | «…» без единого уровня (profit/loss/stop/limit/trail) — пустая операция (предупреждение) | Задайте стоп, тейк или трейлинг |
| LS3011 | strategy.* доступно только в strategy(…) | Объявите скрипт через strategy(...) |
| LS3012 | В библиотеке нельзя рисовать и объявлять входы: … | Перенесите вывод и настройки в индикатор |
| LS3013 | «…» внутри request.security не станет строкой настроек — объявите вход выше и передайте его значение | Объявите input.* выше и передайте переменную |
| LS3016 | Настройка «…» принята и ничего не делает: … (сведение) | Можно оставить или удалить |
| LS3018 | Библиотека «…» не найдена в папке библиотек — имя берётся из её library(“…”, N), a не из имени файла | Проверьте имя в объявлении библиотеки |
| LS3019 | Библиотеки «…» версии … нет; установлены: … | Укажите установленную версию |
| LS3020 | «…» внутри request.security: у стакана и ленты нет истории на чужой серии | Уберите book.*, tape.* из выражения |
| LS3025 | Функция «…» объявлена, но не вызывается — её тело проверено лишь пробно (предупреждение) | Вызовите функцию или удалите |
| LS3026 | «…» требует стоп, от которого считать размер: loss/stop у входа или в strategy.exit | Добавьте стоп к входу или strategy.exit |
| LS3028 | Эта сборка не поддерживает: … | Перепишите без этой конструкции |
| LS3029 | Ветвь switch для «…» повторяется — вторая недостижима | Уберите повтор |
| LS3030 | «…» — переменная графика, а выражение request.security считается на другой серии; передайте значение через input.* или посчитайте его внутри выражения | Посчитайте внутри выражения |
| LS3031 | Библиотеки импортируют друг друга по кругу: … | Разорвите круг импортов |
| LS3032 | В библиотеке «…» допустимы только объявления функций и импорты — здесь … | Уберите из библиотеки остальной код |
| LS3033 | Библиотека «…» не компилируется (…) — откройте её в Editor и почините | Исправьте ошибку в самой библиотеке |
LS4000–LS4009 — пределы компиляции
| Код | Сообщение | Что делать |
|---|---|---|
| LS4000 | Слишком много рядов: … при пределе 512 — уберите лишние ta.* или переиспользуйте переменные | Сократите число вызовов ta.* и переменных с историей |
| LS4001 | Программа слишком велика (больше 4096 встраиваний) — упростите функции | Уменьшите число вызовов пользовательских функций |
| LS4002 | Слишком много plot — панель рисует не больше трёх рядов | Выводов — рядов plot, отметок plotshape и plotchar, фона bgcolor — не больше 64; рисуются первые три plot |
| LS4009 | Слишком много вызовов request.security: …, предел 32 | Объедините вызовы |
LS5000–LS5013 — перерисовка и тестер
| Код | Сообщение | Что делать |
|---|---|---|
| LS5000 | Значение varip доходит до вывода — на истории оно будет другим (перерисовка) (предупреждение) | Используйте var, если нужна одинаковая история |
| LS5001 | Значение только живого бара доходит до вывода — на истории его нет (перерисовка) (предупреждение) | Используйте barstate.isconfirmed |
| LS5002 | lookahead = true читает будущее — на истории результат недостижим в реальном времени (предупреждение) | Уберите lookahead = true |
| LS5003 | Старший таймфрейм без смещения — незакрытый бар перерисуется; добавьте [1] (предупреждение) | request.security(…, close[1]) |
| LS5004 | Отрицательное смещение сдвигает вывод в прошлое — на истории линия знает будущее | Уберите отрицательный индекс x[-n] |
| LS5005 | Недетерминированное значение доходит до вывода — два прогона дадут разный ряд (предупреждение) | Не выводите math.random и timenow на график |
| LS5006 | Данные есть только в реальном времени — на истории ряд пуст (предупреждение) | Для истории libro de órdenes используйте depth.* |
| LS5011 | Стратегия читает «…»: у стакана и ленты нет истории, бэктест был бы вымыслом | Уберите book.*, tape.* из стратегии |
| LS5012 | Стратегия заглядывает вперёд («…») — отчёт помечен как недостижимый в реальном времени (предупреждение) | Уберите lookahead = true |
| LS5013 | «…» включён: заявки исполняются по закрытию бара, отчёт помечен (сведение) | Уберите processOrdersOnClose, если нужен реалистичный отчёт |
LS6000–LS6036 — выполнение
| Код | Сообщение | Что делать |
|---|---|---|
| LS6001 | Индекс … вне границ | Проверьте размер коллекции перед обращением |
| LS6002 | Отрицательное смещение истории — читать будущее нельзя | Индекс истории должен быть ≥ 0 |
| LS6003 | Превышен предел размера коллекции (…) — коллекция создана в строке … | Ограничьте рост: удаляйте старые элементы |
| LS6004 | Скрипт исчерпал бюджет операций на бар — упростите цикл | Проверьте условие выхода из цикла |
| LS6005 | Скрипт превысил лимит времени на проход | Уменьшите работу на каждом баре |
| LS6007 | Обращение к пустому объекту (na) | Создайте коллекцию или объект до обращения |
| LS6014 | Строка длиннее потолка в 100000 знаков — укоротите её или соберите по частям | Сократите строку |
| LS6015 | Неизвестный часовой пояс «…» — нужен идентификатор IANA, например «Europe/Berlin» | Пояс в формате IANA |
| LS6017 | Символ «…» неизвестен — проверьте формат «ПЛОЩАДКА:СИМВОЛ» или задайте ignore_invalid_symbol = true | Исправьте символ |
| LS6018 | Таймфрейм «…» не разбирается — ожидается «5», «60», «4h», «1D», «1W» | Исправьте таймфрейм |
| LS6019 | Объект рисования уже удалён или вытеснен по потолку — создайте его заново | Проверяйте объект или поднимите предел |
| LS6020 | str.format: плейсхолдеру {…} не передан аргумент | Передайте аргумент для каждого {n} |
| LS6021 | str.match: шаблон исчерпал бюджет шагов — упростите его | Упростите регулярное выражение |
| LS6026 | Исчерпан общий бюджет коллекций скрипта (… ячеек) — не влезла коллекция из строки … | Сократите число или размер коллекций |
| LS6027 | Недопустимый аргумент «…» в … | Например, отрицательный размер в array.new |
| LS6028 | Исчерпан бюджет строк скрипта (…) — переиспользуйте строки вместо новых на каждом баре | Не собирайте новые строки на каждом баре |
| LS6029 | В таблице больше 2000 ячеек — это потолок панели | Уменьшите таблицу |
| LS6030 | Ячейка таблицы вне сетки: … | Номер столбца и строки — внутри размера таблицы |
| LS6031 | Встроенная функция «…» объявлена, но не реализована — это дефект сборки, сообщите о нём | Сообщите в поддержку |
| LS6032 | Хэндл не указывает на объект нужного вида — объект освобождён или хэндл из другого прогона | Не храните ссылки на удалённые объекты |
| LS6033 | Поле … вне объявления типа «…» — это дефект сборки, сообщите о нём | Сообщите в поддержку |
| LS6034 | Длина окна … больше потолка 100000 — такое окно не поместится в память | Уменьшите длину окна |
| LS6035 | Шаг цикла равен нулю — счётчик не двигается, и конец недостижим | by в цикле for не может быть нулём |
| LS6036 | Слой тепла … вне 0…3 | layer от 0 до 3 |
Коды, которые эта версия не выдаёт
Эти номера закреплены в языке, но текущая версия терминала их не показывает: LS1003, LS1007, LS1011, LS2016, LS3000, LS3001, LS3005, LS4003, LS4004, LS5007, LS6000, LS6006, LS6008, LS6022, LS6023. Например, объявление не первой строкой сейчас сообщается как LS1009, а деление на ноль не останавливает скрипт с LS6000.
Дальше
https://docs.lootx.trade/es/loot/errors
12Ejemplos de scripts
Ocho scripts listos en LootScript: medias móviles, RSI, VWAP con bandas, CVD con divergencias, interés abierto, tasa de financiación, disbalances de clústeres y una estrategia para el probador.
Ocho scripts listos en LootScript: desde medias móviles y RSI hasta CVD, interés abierto, tasa de financiación y clústeres. Cada uno es un indicador funcional que puedes añadir al Gráfico y ajustar. Todos los ejemplos compilan sin errores ni advertencias con el compilador de la versión actual.
Cómo ejecutar un ejemplo
- Haga clic en ƒ en el panel del Gráfico; en la ventana Indicadores — Editor….
- En el Editor haga clic en Nuevo (Ctrl+N), reemplace la plantilla por el código del ejemplo y pulse Guardar.
- Pulse Añadir al gráfico (Ctrl+Enter). Las opciones de
input.*aparecerán en la ventana de configuración del indicador.
1. Tres medias móviles con selección de tipo
Rápida, media y lenta del mismo tipo, seleccionable. El fondo se ilumina cuando las tres se alinean a favor de la tendencia.
indicator("Три скользящие", shortTitle = "MA×3", overlay = true)
maType = input.string("EMA", "Тип средней", options = ["EMA", "SMA", "WMA", "HMA"])
src = input.source(close, "Источник")
len1 = input.int(20, "Быстрая", minval = 1)
len2 = input.int(50, "Средняя", minval = 1)
len3 = input.int(200, "Медленная", minval = 1)
func ma(s, len) => switch maType {
"SMA" => ta.sma(s, len)
"WMA" => ta.wma(s, len)
"HMA" => ta.hma(s, len)
=> ta.ema(s, len)
}
m1 = ma(src, len1)
m2 = ma(src, len2)
m3 = ma(src, len3)
plot(m1, "Быстрая", color = m1 >= m1[1] ? color.teal : color.red, linewidth = 2)
plot(m2, "Средняя", color = color.orange)
plot(m3, "Медленная", color = color.gray, linewidth = 2)
bgcolor(m1 > m2 and m2 > m3 ? color.new(color.teal, 20) : m1 < m2 and m2 < m3 ? color.new(color.red, 20) : na)Cómo funciona
input.stringconoptionsse convierte en un menú desplegable en la configuración.- La función
maelige la media medianteswitch. El estadota.*vive por cada llamada, por eso tres llamadas amason tres medias independientes. - El color de la línea rápida es una expresión: si sube respecto a la barra anterior (
m1[1]) es teal, si baja es rojo. - El panel puede dibujar hasta tres líneas
plotpor script — de ahí que haya tres medias.
2. RSI con zonas y alertas
RSI con una banda rellenada entre niveles. La línea y el fondo se colorean cuando el RSI está en sobrecompra o sobreventa.
indicator("RSI с зонами", shortTitle = "RSI", overlay = false)
len = input.int(14, "Период", minval = 2)
src = input.source(close, "Источник")
ob = input.float(70, "Перекупленность", minval = 50, maxval = 100)
os = input.float(30, "Перепроданность", minval = 0, maxval = 50)
r = ta.rsi(src, len)
hOb = hline(ob, "Перекупленность", color = color.red)
hOs = hline(os, "Перепроданность", color = color.teal)
fill(hOb, hOs, color = color.new(color.purple, 20))
plot(r, "RSI", color = r > ob ? color.red : r < os ? color.teal : color.purple, linewidth = 2)
bgcolor(r > ob ? color.new(color.red, 35) : r < os ? color.new(color.teal, 35) : na)
alertcondition(ta.crossunder(r, ob), "RSI вышел из перекупленности", "RSI опустился ниже верхнего уровня")
alertcondition(ta.crossover(r, os), "RSI вышел из перепроданности", "RSI поднялся выше нижнего уровня")Cómo funciona
hlinedevuelve una asa del nivel, yfillrellena la franja entre dos asas.- Los niveles son ajustes
input.float, por eso las líneas y la relleno se mueven con ellos. alertconditiondeclara dos alertas. Por sí solas no suenan — cómo activarlas está en la página Alertas de script.- La alfa en
color.newva de 0 (transparente) a 255 (opaco).
3. VWAP del día con bandas de desviación
Precio ponderado por volumen desde el inicio del día en UTC y una banda de ±σ alrededor.
indicator("VWAP дня с полосами", shortTitle = "VWAP", overlay = true)
src = input.source(hlc3, "Цена")
mult = input.float(1.0, "Ширина полосы, σ", minval = 0.1, step = 0.1)
anchor = session.isfirstbar
vw = ta.vwap(src, anchor)
// Сумма объёма и сумма объёма на квадрат цены с начала дня — для разброса вокруг VWAP.
var float sumV = 0.0
var float sumV2 = 0.0
if anchor {
sumV := 0.0
sumV2 := 0.0
}
if not na(volume) and not na(src) {
sumV := sumV + volume
sumV2 := sumV2 + volume * src * src
}
sigma = sumV > 0 and not na(vw) ? math.sqrt(math.max(sumV2 / sumV - vw * vw, 0)) : na
pUp = plot(vw + mult * sigma, "Верх", color = color.new(color.blue, 150))
plot(vw, "VWAP", color = color.blue, linewidth = 2)
pDn = plot(vw - mult * sigma, "Низ", color = color.new(color.blue, 150))
fill(pUp, pDn, color = color.new(color.blue, 25))Cómo funciona
ta.vwapreinicia el cálculo en la barra donde el ancla es verdadera. En cripto,session.isfirstbares la primera barra después de las 00:00 UTC.- Las variables
varsobreviven entre barras. El mismo ancla las pone a cero, por eso la banda se calcula para el mismo período que el VWAP. - La desviación es la raíz de la media ponderada del cuadrado del precio menos el cuadrado del VWAP.
math.max(…, 0)protege contra pequeños negativos por redondeo. - Tiene sentido en temporalidades intradía. Si quieres VWAP desde la última liquidación de funding, pon
anchor = funding.settled.
4. CVD diaria con divergencias
Delta acumulada que se reinicia cada día, y marcas en las barras donde el precio renovó extremo pero la delta no lo confirmó.
indicator("Дневная кумдельта с расхождениями", shortTitle = "CVD", overlay = false)
len = input.int(20, "Окно поиска максимумов", minval = 3)
var float cvd = 0.0
if session.isfirstbar {
cvd := 0.0
}
if delta.available {
cvd := cvd + delta.value
}
cvdLine = delta.available ? cvd : na
// Цена обновила максимум окна, а кумдельта — нет: покупатели не подтверждают рост.
bearish = high >= ta.highest(high, len) and cvdLine < ta.highest(cvdLine, len)
bullish = low <= ta.lowest(low, len) and cvdLine > ta.lowest(cvdLine, len)
plot(cvdLine, "Кумдельта", color = cvdLine >= 0 ? color.teal : color.red, linewidth = 2)
hline(0, "Ноль", color = color.gray)
plotshape(bearish, "Медвежье расхождение", style = shape.triangledown, location = location.top, color = color.red, size = size.tiny)
plotshape(bullish, "Бычье расхождение", style = shape.triangleup, location = location.bottom, color = color.teal, size = size.tiny)Cómo funciona
delta.valueson compras agresivas menos ventas agresivas por barra. Donde no hay cobertura,delta.availablees falso y la línea se interrumpe en vez de dibujar un cero.- El acumulador
varse reinicia al inicio del día. Si necesitas una CVD que no se reinicie en todo el histórico cargado, usa la seriedelta.cumya preparada. - Divergencia: el precio marca el máximo de la ventana, pero la CVD está por debajo de su máximo en la misma ventana. Para mínimos, el criterio es simétrico.
location.topylocation.bottomcolocan las marcas en los bordes del subpanel, no en el precio.
5. Picos de interés abierto
Cambio del interés abierto barra a barra en porcentaje y marcas donde se sale del rango habitual de variación.
indicator("Изменение открытого интереса", shortTitle = "ΔOI %", overlay = false)
len = input.int(50, "Окно для всплесков", minval = 5)
k = input.float(3.0, "Порог всплеска, σ", minval = 0.5, step = 0.5)
pct = oi.available and oi.close[1] > 0 ? 100 * (oi.close - oi.close[1]) / oi.close[1] : na
sd = ta.stdev(pct, len)
spike = not na(sd) and math.abs(pct) > k * sd
plot(pct, "ΔOI, %", style = plot.style_columns, color = pct >= 0 ? color.teal : color.red)
hline(0, "Ноль", color = color.gray)
plotshape(spike, "Всплеск", style = shape.circle, location = location.top, color = color.orange, size = size.tiny)Cómo funciona
oi.closees el interés abierto al cierre de la barra;oi.close[1]el de la barra anterior. La comprobaciónoi.availableevita calcular cambios desde datos faltantes.- Un pico es una barra donde el cambio absoluto excede
kdesviaciones estándar sobre la ventanalen. - El interés abierto llega con frecuencia minuto a minuto. En temporalidades menores al minuto las barras contiguas repiten el mismo valor y el cambio es cero — eso son datos, no un error.
6. Tasa de financiación
La tasa de financiación de un futuro perpetuo, en porcentaje por periodo o reexpresada a anual, con marcas de pago y resaltado de tasa alta.
indicator("Ставка финансирования", shortTitle = "Funding", overlay = false)
mode = input.string("За период", "Показывать", options = ["За период", "Годовых"])
thr = input.float(0.05, "Порог, %", minval = 0.0, step = 0.01)
perPeriod = funding.rate * 100
periodsPerYear = funding.interval_hours > 0 ? 24.0 / funding.interval_hours * 365 : na
value = mode == "Годовых" ? perPeriod * periodsPerYear : perPeriod
level = mode == "Годовых" ? thr * periodsPerYear : thr
plot(value, "Ставка, %", style = plot.style_columns, color = value >= 0 ? color.teal : color.red)
hline(0, "Ноль", color = color.gray)
plotshape(funding.settled, "Выплата", style = shape.circle, location = location.bottom, color = color.gray, size = size.tiny)
bgcolor(math.abs(value) > level ? color.new(color.orange, 30) : na)Cómo funciona
funding.ratees el factor, no el porcentaje: 0.0001 representa 0,01 %. Por eso la tasa se multiplica por 100.- Para anualizar, la tasa se multiplica por el número de pagos al año.
24.0está escrito con punto para evitar división entera. funding.settledes verdadero en la barra donde hubo pago; ahí se coloca un punto en la parte inferior.- El umbral se define por periodo y para las anualizadas se recalcula con el mismo multiplicador.
7. Disbalances en clústeres
Marcas en el precio donde en los clústeres hay una “escalera” de disbalances o simplemente muchos disbalances, más el nivel de volumen máximo (POC) de cada barra.
indicator("Дисбалансы кластеров", shortTitle = "Imbalance", overlay = true)
minSteps = input.int(3, "Уровней подряд", minval = 2)
minCount = input.int(5, "Дисбалансов в баре", minval = 1)
levels = cluster.available ? cluster.levels : 0
buys = 0
sells = 0
for i in 0 .. levels {
side = cluster.imbalance(i)
if side == 1 {
buys := buys + 1
} else if side == -1 {
sells := sells + 1
}
}
plot(cluster.poc, "POC", style = plot.style_circles, color = color.orange)
plotshape(cluster.stacked_buy_steps >= minSteps, "Лесенка покупок", style = shape.triangleup, location = location.belowbar, color = color.teal, size = size.small)
plotshape(cluster.stacked_sell_steps >= minSteps, "Лесенка продаж", style = shape.triangledown, location = location.abovebar, color = color.red, size = size.small)
plotshape(buys >= minCount, "Много дисбалансов покупок", style = shape.circle, location = location.belowbar, color = color.new(color.teal, 120), size = size.tiny)
plotshape(sells >= minCount, "Много дисбалансов продаж", style = shape.circle, location = location.abovebar, color = color.new(color.red, 120), size = size.tiny)Cómo funciona
cluster.imbalance(i)devuelve +1, −1 o 0 para el nivel de precioi. El umbral de disbalance lo toma la configuración de clústeres del Gráfico, así que el script ve lo mismo que tú.cluster.stacked_buy_stepses cuántos niveles consecutivos hay con disbalance de compras. El buclefor i in 0 .. levelscuenta todos los disbalances de la barra, no solo los consecutivos.- El script se suscribe a los clústeres y funciona sobre un gráfico de velas normal. En exchanges sin cobertura y en temporalidades menores a 30 segundos o mayores a un día no hay clústeres — entonces
levelses 0 y no habrá marcas.
8. Estrategia: cruce de EMA con stop basado en ATR
Entrada largo al cruce de medias, stop y objetivo en múltiplos de ATR, salida por cruce inverso.
strategy("EMA-кросс со стопом по ATR", overlay = true, initialCapital = 10000,
defaultQtyType = strategy.qty.percent_of_equity, defaultQtyValue = 10,
slippageTicks = 2)
fastLen = input.int(12, "Быстрая EMA", minval = 1)
slowLen = input.int(26, "Медленная EMA", minval = 2)
atrLen = input.int(14, "Период ATR", minval = 1)
stopK = input.float(1.5, "Стоп, в ATR", minval = 0.1, step = 0.1)
takeK = input.float(3.0, "Цель, в ATR", minval = 0.1, step = 0.1)
fast = ta.ema(close, fastLen)
slow = ta.ema(close, slowLen)
atr = ta.atr(atrLen)
// ATR запоминается в момент сигнала, чтобы стоп и цель не ползли вслед за волатильностью.
var float riskAtr = na
if ta.crossover(fast, slow) and strategy.position_size == 0 {
riskAtr := atr
strategy.entry("Long", strategy.long)
}
if ta.crossunder(fast, slow) {
strategy.close("Long", comment = "Обратный кросс")
}
if strategy.position_size > 0 {
entry = strategy.position_avg_price
strategy.exit("Стоп/цель", from_entry = "Long", stop = entry - stopK * riskAtr, limit = entry + takeK * riskAtr)
}
plot(fast, "Быстрая", color = color.teal)
plot(slow, "Медленная", color = color.orange)Cómo funciona
- Los parámetros de
strategy(…)son literales: capital 10 000, tamaño de posición 10 % del capital, deslizamiento 2 ticks. No hay comisión fijada, por eso el probador usa la tarifa por defecto: 0,02 % para ejecución límite y 0,05 % para mercado y stop. Tu propia tarifa en porcentaje se define concommissionValue. - La entrada de mercado se ejecuta en la apertura de la barra siguiente, no en el cierre de la señal: así el probador no mira al futuro.
strategy.exitcoloca stop y objetivo desde el precio medio de entrada. Si en una barra se tocan ambos, el probador por defecto considera que se ejecutó el stop.- Resultados — operaciones, curva de capital, drawdowns — aparecen en la ventana Probador de estrategias… del Editor. Más detalles en Estrategias y probador.
Más
https://docs.lootx.trade/es/loot/examples