[TOC] ¿Qué quieres decir?

Introducción a las palabras clave, gramática, configuración

Estructura del código

La estructura general del código en Pine es la siguiente:

<version>
<declaration_statement>
<code>

Las notas

Notas símbolos soportados por el lenguaje Pine de FMZ: notas de una sola línea//, notas de varias líneas/* */, como el método de las notas del siguiente ejemplo:

[macdLine, signalLine, histLine] = ta.macd(close, 12, 26, 9)  // calculate the MACD indicator

/*
The plot function draws the indicator line on the chart
*/
plot(macdLine, color = color.blue, title='macdLine')
plot(signalLine, color = color.orange, title='signalLine')
plot(histLine, color = color.red, title='histLine')

Versión

Una instrucción de compilador de la siguiente forma le dice al compilador qué versión de Pine fue escrita con el script:

//@version=5

La versión predeterminada es V5, que puede omitirse del código//@version=5.

Declaración de la declaración

• indicator()
• strategy()

La declaración determina el tipo de script, que a su vez determina lo que está permitido en él, y cómo se utiliza y ejecuta. Establece propiedades clave del script, como su nombre, donde aparecerá cuando se agrega al gráfico, la precisión y el formato de los valores numéricos que muestra, y ciertos valores numéricos que rigen su comportamiento en tiempo de ejecución, por ejemplo, el número máximo de objetos de dibujo para mostrar en el gráfico.indicator()o bienstrategy()La declaración debe incluirse en un código de estrategia en Pine de FMZ.

Código

Líneas en un script que no son comentarios o instrucciones del compilador, que son instrucciones, que implementan el algoritmo del script. Una instrucción puede ser uno de estos contenidos.

• Declaración variable
• Reasignación de las variables
• Declaración de función
• Llamadas de funciones integradas, llamadas de funciones definidas por el usuario
• if, for, whileo bienswitchy otras construcciones

Las declaraciones pueden organizarse de varias maneras.

• Algunas instrucciones pueden expresarse en una sola línea, como la mayoría de las declaraciones variables, las líneas que contienen solo una llamada de función o las declaraciones de función de una sola línea.
• Las instrucciones en el alcance global de un script (es decir, partes que no son parte de un bloque local) no pueden comenzar con unspaceo bientabLas líneas que comienzan en la primera posición de una línea son por definición parte del alcance global del script.
• A. El trabajo.local blockUn bloque local debe estar recubierto por una pestaña o cuatro espacios (de lo contrario, se analizará como el código concatenado de la línea anterior, que se determina como el contenido continuo de la línea anterior de código), y cada bloque local define un alcance local diferente.
• Múltiples declaraciones de una sola línea pueden ser concatenadas en una sola línea mediante el uso de comas (,) como delimitadores.
• Una línea puede contener comentarios o sólo comentarios.
• Las líneas también se pueden envolver (continuar en varias líneas).

Por ejemplo, incluye tres bloques locales, uno en la declaración de función personalizada y dos en la declaración de variable utilizando la estructura if, como sigue:

indicator("", "", true)             // Declaration statement (global scope), can be omitted

barIsUp() =>                        // Function declaration (global scope)
    close > open                    // Local block (local scope)

plotColor = if barIsUp()            // Variable declaration (global scope)
    color.green                     // Local block (local scope)
else
    color.red                       // Local block (local scope)

runtime.log("color", color = plotColor)  // Call a built-in function to output the log (global scope)

Código de línea nueva

Las líneas largas se pueden dividir en múltiples líneas, o envueltas. Una línea envuelta debe estar recubierta por cualquier cantidad de espacio en blanco, siempre que no sea un múltiplo de 4 (estos límites se utilizan para recubierto de bloques locales).

a = open + high + low + close

Puede ser envuelto como (tenga en cuenta que el número de espacios recubiertos por línea no es un múltiplo de 4):

a = open +
      high +
          low +
             close

Una llamada de trama larga puede ser envuelta como:

close1 = request.security(syminfo.tickerid, "D", close)      // closing price data series of syminfo.tickerid daily level of the current trading pair
close2 = request.security(syminfo.tickerid, "240", close)    // closing price data series of syminfo.tickerid 240-minute level of the current trading pair
plot(ta.correlation(close, open, 100),                       // Line-long plot() calls can be wrapped
   color = color.new(color.purple, 40),
   style = plot.style_area,
   trackprice = true)

Sin embargo, dado que un bloque local debe comenzar sintácticamente con un guión (4 espacios o 1 pestaña), al dividirlo en la siguiente línea, la continuación de una instrucción debe comenzar con más de un guión (no igual a 4 múltiplos de espacios).

test(c, o) =>
    ret = c > o ?
       (c > o+5000 ? 
          1 :
              0):
       (c < o-5000 ? 
          -1 : 
              0)

a = test(close, open)
plot(a, title="a")

Serie de tiempo

La serie temporal no es un tipo de datos o formato, sino que es un concepto de una estructura básica en el lenguaje PINE. Se utiliza para almacenar valores que cambian continuamente en el tiempo, cada valor corresponde a un punto en el tiempo. La estructura del concepto de serie temporal es adecuada para procesar y registrar una serie de datos que cambian con el tiempo.

Tome la variable incorporadaopenPor ejemplo, elopenla variable incorporada registra el precio de apertura de cada representación int BAR, si estaopenes un período de 5 minutos de datos de representación int.openLa variable registra el precio de apertura de cada representación de int de 5 minutos BAR (bar).openPara referirse a los valores anteriores (valores pasados) en la serie temporal, utilizamos el valor de apertura de la representación int actual BAR.[]Cuando la estrategia se ejecuta en una cierta representación int BAR,open[1]El significado es referirse al precio de apertura de la anterior representación int BAR de la actual representación int BAR.

Aunqueserie de tiempoEs muy parecido a la estructura de datos array, aunque el lenguaje PINE también tiene un tipo de matriz.

Las series temporales diseñadas en lenguaje de pino pueden calcular fácilmente el valor acumulado del precio de cierre en el código de estrategia, y no hay necesidad de utilizar estructuras de bucle como para, sólo la función incorporadata.cum(close)Para otro ejemplo, necesitamos calcular el valor promedio de la diferencia entre el precio más alto y el precio más bajo de los últimos 14 BARs de representación de int (es decir, los 14 BARs de representación de int más cercanos al momento actual en que se ejecuta el código), que se puede escribir como:ta.sma(high - low, 14)

El resultado de llamar a una función en una serie de tiempo también dejará un rastro en la serie de tiempo, de nuevo usamos el[]Por ejemplo, al probar si el precio de cierre de la representación actual de int BAR excede el valor máximo del precio más alto en la última representación de int 10 BAR (excluyendo la representación actual de int BAR).breach = close > ta.highest(close, 10)[1], y también podemos escribirbreach = close > ta.highest(close[1], 10)Así que...ta.highest(close, 10)[1]yta.highest(close[1], 10)son equivalentes.

Esto se puede verificar con el siguiente código:

strategy("test pine", "test", true) 

a = ta.highest(close, 10)[1]
b = ta.highest(close[1], 10)

plotchar(true, title="a", char=str.tostring(a), location=location.abovebar, color=color.red)
plotchar(true, title="b", char=str.tostring(b), location=location.belowbar, color=color.green)

El código de prueba anterior producirá los valores de a y b en cada BAR en la serie de tiempo correspondiente.

Argumentos de plantilla de la biblioteca de clase comercial de la lengua de pino

Instrucciones para establecer los argumentos de la plantilla incorporada Pine Language Trade Class Library de la estrategia PINE.

Configuración del comercio

• Modo de ejecución Modelo de precio de cierre: el modelo se ejecuta solo después de que se complete el BAR actual y la operación se ejecuta cuando comience el siguiente BAR. Modelo de precios en tiempo real: El modelo se ejecuta cada vez que el precio se mueve, y hay una señal para ejecutar la operación inmediatamente.
• Si la orden de negociación no especifica el importe de la operación, la operación se ejecutará de acuerdo con el importe establecido.
• Cantidad máxima de pedido para una operación única: Determinar el importe máximo de cada pedido para evitar que afecte al mercado de acuerdo con el mercado real y este argumento.
• Puntos de deslizamiento: Determinar el deslizamiento al realizar una orden de acuerdo con el punto de deslizamiento de la orden.Pricing Currency PrecisionEn este momento, el punto de deslizamiento se establece en 5, y el deslizamiento al colocar una orden es de 0.05 (el deslizamiento se refiere a la parte del precio que se desborda al colocar una orden para una mejor y una orden de comercio de desventaja).
• El número de período más largo de la variable: afecta el número de K-línea BAR en el gráfico.SetMaxBarLenEn eljavascript srategy.

Opciones de futuros

• Código de variedad: código del contrato, solo debe establecerse cuando el objeto de intercambio sea un objeto de intercambio no puntual.
• En el caso de las operaciones de negociación, el volumen mínimo de negociación de un contrato es el volumen mínimo de negociación de un contrato.

Opciones de negociación en vivo

• Progreso de recuperación automática: recupera automáticamente el estado antes de la última parada de la estrategia.
• Tiempos de repetición de la orden: si la orden no se cumple, la orden se cancelará y la orden se colocará de nuevo para tratar de operar.
• Intervalo de votación de red (millisegundos): solo válido para el protocolo REST, controla el intervalo de solicitud de red para evitar que las solicitudes sean demasiado frecuentes y excedan el límite de intercambio.
• Tiempo de sincronización de cuenta (segundos): el período de tiempo para sincronizar los datos de cuenta.
• Tiempo de sincronización de posición después de abrir una posición (millisegundos): Solo para posiciones repetidas causadas por retrasos de datos en algunos intercambios, establecer un tiempo de sincronización más largo puede aliviar tales problemas.
• Múltiple de apalancamiento: establece el múltiplo de apalancamiento.

Negociación al contado, otros ajustes

• Volumen de negociación de un lote: el volumen de negociación por defecto de un lote, que solo es válido para el spot.
• El volumen mínimo de operaciones: El volumen mínimo de operaciones.
• Precisión de la moneda del precio: la precisión del precio, es decir, el número de decimales en el precio.
• Precisión de la variedad de comercio: la precisión de la cantidad de pedido, es decir, el número de decimales de la cantidad de pedido.
• Tarifa de manipulación: Calcular algunos datos de acuerdo con este ajuste, 0,002 significa 2/1000.
• Intervalo de estadísticas de pérdidas y ganancias: solo se utiliza para mostrar estadísticas de pérdidas y ganancias en el mercado real.
• Reintento fallido (ms): Intervalo de reintentos cuando la solicitud de red falla.
• Usar proxy: sólo válido para el protocolo REST.
• Ocultar errores comunes de red: Ocultar los registros de errores comunes en el área de registro.
• Dirección de base del interruptor: válida sólo para el protocolo REST.
• Notificaciones push: mensajes push a los buzones, etc.

Comercio de pedidos

Posición abierta

strategy(title = "open long example", pyramiding = 3)                                // The number of orders placed in the same direction allowed by pyramiding
strategy.entry("long1", strategy.long, 0.01)                                         // Open a long position at the market price, specify the group label as long1
strategy.entry("long2", strategy.long, 0.02, when = close > ta.ema(close, 10))       // The condition is triggered, the order is executed, and the market price opens a long position
strategy.entry("long3", strategy.long, 0.03, limit = 30000)                          // Specify the (lower) price, plan to place a buy order, wait for a deal to open a position, and open a position at a limit price

Posición cerrada

strategy(title = "close long example", pyramiding = 2)                              // The number of orders placed in the same direction allowed by pyramiding
strategy.entry("long1", strategy.long, 0.1)                                         // Open a long position at the market price, specify the group label as long1
strategy.entry("long2", strategy.long, 0.1)                                         // Open a long position at the market price, specify the group label as long2
strategy.close("long1", when = strategy.position_size > 0.1, qty_percent = 50, comment = "close buy entry for 50%")   // To close a position, specify to close 50% of the positions whose group label is long1
strategy.close("long2", when = strategy.position_size > 0.1, qty_percent = 80, comment = "close buy entry for 80%")   // To close a position, specify to close 80% of the positions whose group label is long2

Mecanismo de comercio

El mecanismo de posición del lenguaje PINE es similar a la posición unidireccional. Por ejemplo, al mantener una posición en la dirección larga (posición larga), si hay una orden de operación de venta, una orden planificada, etc. (en la dirección opuesta a la posición), la ejecución se activará, y la posición en la dirección larga se cerrará primero. (Cerrar todas las posiciones largas), y luego ejecutar la orden activada (en la dirección opuesta en relación con la posición antes del cierre).

Orden planificada

Cuando se coloca una orden utilizando el comando de colocación de órdenes, si no se especifica precio, el valor predeterminado es una orden de mercado. Además de la orden de mercado, también se puede colocar una orden a través de una orden planificada, que no opera inmediatamente para colocar una orden. La orden planificada existe en la cola de orden planificada del programa cuando no se activa, y se puede ver en la pestaña de la tabla Plano de orden de la información de estado (es decir, la barra de estado cuando la estrategia se está ejecutando) durante el proceso de ejecución.orden real/prueba de retroceso. El sistema solo colocará una orden cuando el precio de mercado en tiempo real cumpla con las condiciones para activar estas órdenes planificadas. Por lo tanto, es normal que estas órdenes tengan una leve desviación en el precio comercial.strategy.entryfunción para hacer un pedido, podemos especificar ellimit, stop arguments.

var isTrade = false 
if not barstate.ishistory and not isTrade
    isTrade := true 
    strategy.entry("test 1", strategy.long, 0.1, stop=close*1.3, comment="test 1 order")                     // stop
    strategy.entry("test 2", strategy.long, 0.2, limit=close*0.7, comment="test 2 order")                    // limit
    strategy.entry("test 3", strategy.short, 0.3, stop=close*0.6, limit=close*1.4, comment="test 3 order")   // stop-limit    

• orden límite

  Cuando la orden es una orden de compra (es decir, el precio de compra de la orden de compra de la orden de compra).directionEl argumento esstrategy.long), la orden sólo se activará cuando el precio de mercado actual sea inferior a este precio. Cuando la orden es una orden de venta (es decir, ladirectionEl argumento esstrategy.short), la orden sólo se activará si el precio de mercado actual es superior a este precio.

• orden de detención

  Cuando la orden es una orden de compra, la orden solo se activará cuando el precio de mercado actual sea mayor que este precio. Cuando una orden es una orden de venta, la orden solo se activará si el precio actual del mercado es inferior a ese precio.

• orden de límite de detención

  Ellimitystoplos argumentos pueden establecerse al mismo tiempo, y la orden se activará al precio que cumpla las condiciones primero.

Porcentaje del capital propio

//@version=5
strategy("Percent of Equity Order", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100)  

// Simple moving average crossover strategy
longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))  

// If the moving average crossover condition is met, buy or sell
if (longCondition)
    strategy.entry("Long", strategy.long)  

if (shortCondition)
    strategy.entry("Short", strategy.short)
  

Después de especificardefault_qty_type=strategy.percent_of_equity, puestodefault_qty_valueEn el caso de la orden denominada en una moneda denominada en la cuenta, la cantidad de la orden se calcula de acuerdo con la cantidad de la moneda denominada en la cuenta. Por ejemplo: si la cuenta corriente tiene 10.000 USDT, establecer una orden de 1% significa colocar una orden con una escala de 100 USDT (calculada en función del precio actual al momento de la venta).

Declaración, palabras clave de estructura lógica

el var

var es una palabra clave utilizada para asignar e iniciar variables de una sola vez. En general, la gramática de asignación de variables que no contiene la palabra clave var hace que el valor de la variable s sea sobrescrito cada vez que se actualizan los datos.

var variable_name = expression

Explicación:

• variable_name- Cualquier nombre de una variable de usuario permitido en Pine Script (puede contener letras mayúsculas y minúsculas latinas, números y subrayados (_), pero no puede comenzar con un número).
• expressionCualquier expresión aritmética, como definir una variable regular, la expresión será evaluada y asignada a la variable una vez.

Ejemplo

// Var keyword example
var a = close
var b = 0.0
var c = 0.0
var green_bars_count = 0
if close > open
    var x = close
    b := x
    green_bars_count := green_bars_count + 1
    if green_bars_count >= 10
        var y = close
        c := y
plot(a, title = "a")
plot(b, title = "b")
plot(c, title = "c")

La variable a contiene el precio de cierre de la primera barra de cada barra de la serie. La variable b contiene el precio de cierre de la primera barra de precios verde de la serie. La variable c contiene el precio de cierre de la décima barra verde de la serie.

En FMZ, se divide en modelo de precio en tiempo real y modelo de precio de cierre. Usamos el siguiente código para probar las variables declaradas porvaryvarip.

strategy("test pine", "test 1", true) 

// Test var varip
var i = 0
varip ii = 0

// Print the i and ii changed in each round of the strategy logic on the graph
plotchar(true, title="ii", char=str.tostring(ii), location=location.abovebar, color=color.red)
plotchar(true, title="i", char=str.tostring(i), location=location.belowbar, color=color.green)

// Each round of logic execution increments i and ii by 1
if true
    i := i + 1
    ii := ii + 1

• Modelo de precios en tiempo real El código de prueba anterior se ejecuta en dos fases: 1. fase de representación de int histórico. 2. fase de representación de int en tiempo real. En el modelo de precios en tiempo real, fase de representación de int histórico, las variables i y ii declaradas porvar, varipSe ejecutan incrementalmente en cada ronda de ejecución de código de estrategia (porqueif truePor lo tanto, se puede ver que los números que se muestran en la representación int BAR del resultado de la prueba de retroceso se incrementan uno por uno. Cuando termina la fase de representación int histórica, comienza la fase de representación int en tiempo real.var, varipDebido a que es un modelo de precios en tiempo real, el código de estrategia se ejecutará una vez por cada cambio de precio en una representación int BAR,i := i + 1yii := ii + 1La diferencia es que ii se modifica cada vez. Aunque i también se modifica cada vez, el valor anterior se restablecerá cuando se ejecute la lógica de estrategia en la siguiente ronda, y el valor de i no se actualizará hasta que se complete la representación int actual BAR (es decir, el valor anterior no se restablecerá cuando se ejecute la lógica de estrategia en la siguiente ronda). Por lo tanto, se puede ver que la variable i sigue aumentando en 1 para cada BAR. Pero la variable ii se acumula varias veces para cada BAR.

• Modelo de precios de cierre Dado que el modelo de precio de cierre ejecuta la lógica de la estrategia sólo una vez por representación int BAR desaparecido.varyvaripEn el ejemplo anterior, se comportan exactamente igual incrementalmente en el modelo de precio de cierre, tanto en la fase de representación de int histórica como en la fase de representación de int en tiempo real, incrementando en 1 por representación de int BAR.

variedad

varp (var intrabar persist) es una palabra clave utilizada para asignar e iniciar variables de una sola vez. Es similar a la palabra clave var, pero una variable declarada con varp conserva su valor entre las actualizaciones de candlestick en vivo.

varip variable_name = expression

Explicación:

• variable_name- Cualquier nombre de una variable de usuario permitido en una escritura Pine (puede contener letras mayúsculas y minúsculas latinas, números y subrayados (_), pero no puede comenzar con un número).
• expression- Cualquier expresión aritmética, como el tiempo que define las variables regulares.

Ejemplo

// varip
varip int v = -1
v := v + 1
plot(v)

Cuando se usa var, la gráfica devuelve el valor de bar_index. Con varip, el mismo comportamiento ocurre en barras históricas, pero en barras en vivo, el gráfico devuelve un valor que aumenta en uno por cada tick.

Las observacionesSolo se puede usar con tipos simples como float, int, bool, string y matrices de estos tipos.

Es cierto

Representa el valor de una variable bool, o un valor que se puede calcular cuando una expresión utiliza uncomparacióno bienes lógico operator.

Las observacionesPor favor, vea las descripciones deComparaciónOperadores yEs lógico. Operators.

Véase también bool

- No es cierto.

Representa el valor de una variable bool y el resultado de operaciones de comparación y operaciones lógicas.

Las observacionesPor favor, vea las descripciones deComparaciónOperadores yEs lógico. Operators.

Véase también bool

si es

Una instrucción If define un bloque de instrucciones que deben ejecutarse cuando se cumple la condición de una expresión.

Código universal de:

var_declarationX = if condition
    var_decl_then0
    var_decl_then1
    ...
    var_decl_thenN
    return_expression_then
else if [optional block]
    var_decl_else0
    var_decl_else1
    ...
　　var_decl_elseN
　　return_expression_else
else
    var_decl_else0
    var_decl_else1
    ...
    var_decl_elseN
    return_expression_else

Las observaciones var_declarationX- Esta variable obtiene el valor de la declaración sicondition- Si la condición es verdadera, la lógica en el bloque de la declaraciónthense utiliza (var_decl_then0, var_decl_then1, etc.). Si la condición es falsa, la lógica en el bloque de la declaraciónelse ifo bienelsese utiliza (var_decl_else0, var_decl_else1, etc.).return_expression_thenyreturn_expression_else- La última expresión del módulo o la expresión del bloque else devuelve el valor final de la instrucción.

El tipo de valor de retorno de la instrucción if depende del tipo dereturn_expression_thenyreturn_expression_else. Cuando se ejecuta en TradingView, sus tipos deben coincidir: cuando tiene un valor de cadena en el bloque else, no es posible devolver un valor entero del bloque de entonces. Cuando se ejecuta en el FMZ, el siguiente ejemplo no reportará un error. Cuando el valor y es open, el valor de la gráfica al dibujar es n/a.

Ejemplo

// This code compiles
x = if close > open
    close
else
    open  

// This code doesn't compile by trading view
// y = if close > open
//     close
// else
//     "open"
plot(x)

ElelseEn este caso, si la condición es falsa, a la variable var_declarationX se le asigna un valor vacío (na, false o ):

Ejemplo

// if
x = if close > open
    close
// If current close > current open, then x = close.
// Otherwise the x = na.
plot(x)

Los bloques de then, else if, else se mueven cuatro espacios:

Ejemplo

// if
x = if open > close
    5
else if high > low
    close
else
    open
plot(x)

El valor resultante de laifPuede ser útil si necesita efectos secundarios de las expresiones, por ejemplo, en el comercio de estrategias:

Ejemplo

if (ta.crossover(high, low))
    strategy.entry("BBandLE", strategy.long, stop=low)
else
    strategy.cancel(id="BBandLE")

Si las instrucciones pueden contenerse entre sí:

Ejemplo

// if
float x = na
if close > open
    if close > close[1]
        x := close
    else
        x := close[1]
else
    x := open
plot(x)

para

La construcción for permite ejecutar varias instrucciones repetidamente:

[var_declaration =] for counter = from_num to to_num [by step_num]
    statements | continue | break
    return_expression

var_declaration- Una declaración de variable opcional que se asignará como el valor de la expresión return_expression del bucle.counter- Una variable que mantiene el valor del contador del bucle, incrementando/decrementando en 1 o el valor step_num en cada iteración del bucle.from_num- El valor inicial del contador. Se permiten los valores/expresiones de serie int/float.to_num- El valor final del contador. El bucle se rompe cuando el contador es mayor que to_num (o menor que to_num en el caso de from_num > to_num). series int/float valores/expresiones están permitidos, pero sólo se evalúan en la primera iteración del bucle.step_num- El valor de incremento/decremento del contador. Es opcional. El valor predeterminado es +1 o -1, dependiendo del mayor de from_num o to_num. Cuando se utilizan valores, el contador también se incrementa/decremente de acuerdo con el mayor de from_num o to_num, por lo que el signo +/- de step_num es opcional.statements | continue | break- Cualquier número de instrucciones, o las palabras clave continue o break, recubiertas por 4 espacios o una sola pestaña.return_expression- El valor de retorno del bucle, si está presente, se asigna a la variable en var_declaration. Si el bucle sale debido a las palabras clave continue o break, el valor de retorno del bucle es el valor de retorno de la última variable asignada un valor antes de la salida del bucle.continue- Una palabra clave que sólo puede ser usada en bucles, hace que se ejecute la siguiente iteración del bucle.break- La palabra clave para salir del bucle.

Ejemplo

// Here, we count the quantity of bars in a given 'lookback' length which closed above the current bar's close
qtyOfHigherCloses(lookback) =>
    int result = 0
    for i = 1 to lookback
        if close[i] > close
            result += 1
    result
plot(qtyOfHigherCloses(14))

Véase también for...in while

para... en

Elfor...inconstruct permite que se repitan múltiples instrucciones para cada elemento de la matriz. Se puede usar con cualquiera de los argumentos:array_element, o con dos argumentos:[index, array_element]La segunda forma no afecta a la función del bucle, sino que hace un seguimiento del índice de la iteración actual en la primera variable del tuple.

[var_declaration =] for array_element in array_id
    statements | continue | break
    return_expression

[var_declaration =] for [index, array_element] in array_id
    statements | continue | break
    return_expression

var_declaration- Una declaración de variable opcional a la que se asignará el valor de los buclesreturn_expression. index- Una variable opcional que hace un seguimiento del índice de iteración actual. El índice comienza en 0. Las variables son inmutables dentro del cuerpo del bucle. Cuando se usa, debe estar contenida en un tuplo que también contengaarray_element. array_element- Una variable que contiene cada elemento de matriz consecutivo a procesar en el bucle.array_id- El ID de la matriz de la iteración del bucle.statements | continue | break- Cualquier número de instrucciones, o las palabras clave continue o break, recubiertas por 4 espacios o una sola pestaña.return_expression- El valor de retorno del bucle se asigna a la variable envar_declarationSi el bucle sale debido a las palabras clave continue o break, el valor de retorno del bucle es la variable que se asignó por última vez antes de que el bucle saliera.continue- Una palabra clave que sólo puede ser usada en bucles, hace que se ejecute la siguiente iteración del bucle.break- La palabra clave para salir del bucle.

Permite modificar elementos de una matriz o su tamaño dentro de un bucle. Aquí, usamos la forma de un solo argumento defor...inpara determinar, para cada barra, cuántas barras tienen un valor OHLC mayor que la SMA del valor close:

Ejemplo

// Here we determine on each bar how many of the bar's OHLC values are greater than the SMA of 'close' values
float[ ] ohlcValues = array.from(open, high, low, close)
qtyGreaterThan(value, array) =>
    int result = 0
    for currentElement in array
        if currentElement > value
            result += 1
        result
plot(qtyGreaterThan(ta.sma(close, 20), ohlcValues))

Aquí, usamos la forma de dos argumentos de para...en para establecer los valores de nuestroisPosmatriz atrueCuando sus valores correspondientes en nuestravaluesArraylas matrices son positivas:

Ejemplo

// for...in
var valuesArray = array.from(4, -8, 11, 78, -16, 34, 7, 99, 0, 55)
var isPos = array.new_bool(10, false)  

for [index, value] in valuesArray
    if value > 0
        array.set(isPos, index, true)  

if barstate.islastconfirmedhistory
    runtime.log(str.tostring(isPos))

Véase también for while array.sum array.min array.max

mientras...

Elwhilela declaración permite la iteración condicional de bloques de código nativos.

variable_declaration = while boolean_expression
    ...
    continue
    ...
    break
    ...
    return_expression

Explicación:variable_declaration- Declaración de variables opcional.return expressionpuede proporcionar un valor de inicialización para esta variable.boolean_expression- Si es cierto, ejecutar el bloque local de lawhileSi es falso, la ejecución del script continúa después de lawhile statement. continue- ElcontinueLa palabra clave hace que el bucle se ramifique a la siguiente iteración.break- ElbreakLa ejecución del script se reanuda después de lawhile statement. return_expression- Línea opcional que proporciona el valor de retorno de lawhile statement.

Ejemplo

// This is a simple example of calculating a factorial using a while loop.
int i_n = input.int(10, "Factorial Size", minval=0)
int counter   = i_n
int factorial = 1
while counter > 0
    factorial := factorial * counter
    counter   := counter - 1

plot(factorial)

Las observacionesEl bloque de código nativo después de la inicialwhilePara terminar una línea debe haber cuatro espacios o una pestaña.whilebucle, la expresión booleana siguientewhiledebe llegar a ser falsa, obreakdebe ser ejecutado.

el cambio

El operador de conmutación transfiere el control a una de varias instrucciones basadas en la condición y el valor de la expresión.

[variable_declaration = ] switch expression
    value1 => local_block
    value2 => local_block
    ...
    => default_local_block

[variable_declaration = ] switch
    boolean_expression1 => local_block
    boolean_expression2 => local_block
    ...
    => default_local_block

cambio con expresión:

Ejemplo

// Switch using an expression

string i_maType = input.string("EMA", "MA type", options = ["EMA", "SMA", "RMA", "WMA"])

float ma = switch i_maType
    "EMA" => ta.ema(close, 10)
    "SMA" => ta.sma(close, 10)
    "RMA" => ta.rma(close, 10)
    // Default used when the three first cases do not match.
    => ta.wma(close, 10)

plot(ma)

cambio sin expresión:

Ejemplo

strategy("Switch without an expression", overlay = true)

bool longCondition  = ta.crossover( ta.sma(close, 14), ta.sma(close, 28))
bool shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))

switch
    longCondition  => strategy.entry("Long ID", strategy.long)
    shortCondition => strategy.entry("Short ID", strategy.short)

Las devolucionesEl valor de la última expresión en el bloque de instrucciones local ejecutado.

Las observacionesSólo uno de loslocal_blockcasos odefault_local_blockpuede ser ejecutado.default_local_blocksólo se introduce con el=>El resultado de un bloque de etiquetado, y sólo se ejecuta si el bloque anterior no se ejecuta.switchla declaración se asigna a una variable ydefault_local_blockno se especifica, la instrucción devuelvenasi eslocal_blockCuando se asigna el resultado de unswitchdeclaración a una variable, todoslocal_blocklas instancias deben devolver un valor del mismo tipo.

Véase también if ?:

serie

serie es una palabra clave que indica el tipo de serie de datos.series keyword.

El operador

=

Se utiliza para asignar valores a las variables, pero solo cuando se declara la variable (utilizada por primera vez).

:=

El operador de asignación asigna un valor a la variable de la izquierda. Se utiliza para asignar valores a variables declaradas previamente.

!=

Aplicable a expresiones de cualquier tipo.

expr1 != expr2

Las devolucionesValor booleano, o una secuencia de valores booleanos.

%

Modulo (residuo entero), aplicable a las expresiones numéricas.

expr1 % expr2

Las devolucionesValor entero o flotante, o serie de valores.

Las observacionesEn Pine Script, cuando se calcula el resto entero, el cociente se trunca, es decir, se redondea hacia el valor absoluto más bajo.

Ejemplo: -1 % 9 = -1 - 9 * truncado(-1/9) = -1 - 9 * truncado(-0.111) = -1 - 9 * 0 = -1.

%=

Aplicable a las expresiones numéricas.

expr1 %= expr2

Ejemplo

// Equals to expr1 = expr1 % expr2.
a = 3
b = 3
a %= b
// Result: a = 0.
plot(a)

Las devolucionesValor entero o flotante, o serie de valores.

*

Aplicable a las expresiones numéricas.

expr1 * expr2

Las devolucionesValor entero o flotante, o serie de valores.

*=

Aplicable a las expresiones numéricas.

expr1 *= expr2

Ejemplo

// Equals to expr1 = expr1 * expr2.
a = 2
b = 3
a *= b
// Result: a = 6.
plot(a)

Las devolucionesValor entero o flotante, o serie de valores.

+

Adición o unario más. Aplicable a expresiones numéricas o cadenas.

expr1 + expr2

+ expr

Las devolucionesEl binario+de la cadena devuelve la combinación de expr1 y expr2 Número devuelve un valor entero o con coma flotante, o una secuencia de valores: El binario + devuelve expr1 más expr2. Unario + devuelve expreso (nada se agrega a la simetría del operador unario).

Las observacionesPuede utilizar operadores aritméticos con números, así como con variables de serie.

+=

Se aplica a expresiones numéricas o cadenas.

expr1 += expr2

Ejemplo

// Equals to expr1 = expr1 + expr2.
a = 2
b = 3
a += b
// Result: a = 5.
plot(a)

Las devolucionesPara cadenas, devuelve la concatenación de expr1 y expr2. Para números, devuelve un valor entero o flotante, o serie de valores.

Las observacionesPuede utilizar operadores aritméticos con números, así como con variables de serie.

-

Sustracción o menos unario. Aplicable a las expresiones numéricas.

expr1 - expr2

- expr

Las devolucionesDevuelve un valor entero o con coma flotante, o una serie de valores: El binario + devuelve expr1 menos expr2. Unario-devuelve la negación de expr.

Las observacionesPuede utilizar operadores aritméticos tanto con números como con variables de serie.

-=

Aplicable a las expresiones numéricas.

expr1 -= expr2

Ejemplo

// Equals to expr1 = expr1 - expr2.
a = 2
b = 3
a -= b
// Result: a = -1.
plot(a)

Las devolucionesValor entero o flotante, o serie de valores.

/

Aplicable a las expresiones numéricas.

expr1 / expr2

Las devolucionesValor entero o flotante, o serie de valores.

/=

Aplicable a las expresiones numéricas.

expr1 /= expr2

Ejemplo

// Equals to expr1 = expr1 / expr2.
a = 3
b = 3
a /= b
// Result: a = 1.
plot(a)

Las devolucionesValor entero o flotante, o serie de valores.

<

Aplicable a las expresiones numéricas.

expr1 < expr2

Las devolucionesValor booleano, o serie de valores booleanos.

<=

Menor o igual a. Aplicable a las expresiones numéricas.

expr1 <= expr2

Las devolucionesValor booleano, o serie de valores booleanos.

==

Es aplicable a expresiones de cualquier tipo.

expr1 == expr2

Las devolucionesValor booleano, o serie de valores booleanos.

=>

El operador => se utiliza en las declaraciones de funciones definidas por el usuario y enswitch statements.

La gramática de la declaración de la función es:

<identifier>([<argument_name>[=<default_value>]], ...) =>
    <local_block>
    <function_result>

A. El trabajo.<local_block>es cero o más instrucciones de Pine Script.<function_result>es una variable, una expresión, o un tuplo.

Ejemplo

// single-line function
f1(x, y) => x + y
// multi-line function
f2(x, y) => 
    sum = x + y
    sumChange = ta.change(sum, 10)
    // Function automatically returns the last expression used in it
plot(f1(30, 8) + f2(1, 3))

Las enmiendasPuede obtener más información sobre las funciones definidas por el usuario en las páginas del Manual del usuario sobre las funciones de declaración y las bibliotecas de guiones.

>

Más grande que. aplicable a las expresiones numéricas.

expr1 > expr2

Las devolucionesValor booleano, o serie de valores booleanos.

>=

Más grande o igual a. Aplicable a las expresiones numéricas.

expr1 >= expr2

Las devolucionesValor booleano, o serie de valores booleanos.

?:

Operador condicional ternario.

expr1 ? expr2 : expr3

Ejemplo

// Draw circles at the bars where open crosses close
s2 = ta.cross(open, close) ? math.avg(open,close) : na
plot(s2, style=plot.style_circles, linewidth=2, color=color.red)  

// Combination of ?: operators for 'switch'-like logic
c = timeframe.isintraday ? color.red : timeframe.isdaily ? color.green : timeframe.isweekly ? color.blue : color.gray
plot(hl2, color=c)

Las devolucionesexpr2 si expr1 se evalúa como verdadero, expr3 de lo contrario. El valor cero (0 y también NaN, +Infinity, -Infinity) se considera falso, cualquier otro valor es verdadero.

Las observacionesUtilice na para else rama si no la necesita. Puede combinar dos o más operadores?: para lograr el equivalente de una declaración similar a switch (ver los ejemplos anteriores). Puede utilizar operadores aritméticos con números, así como con variables de serie.

Véase también na

[]

El subíndice de la serie proporciona acceso a los valores anteriores de la serie expr1. expr2 es el número de barras en el pasado, y debe ser numérico.

expr1[expr2]

Ejemplo

// [] can be used to "save" variable value between bars
a = 0.0 // declare `a`
a := a[1] // immediately set current value to the same as previous. `na` in the beginning of history
if high == low // if some condition - change `a` value to another
    a := low
plot(a)

Las devolucionesUna serie de valores.

Véase también math.floor

y

Lógico y aplicable a las expresiones booleanas.

expr1 and expr2

Las devolucionesValor booleano, o serie de valores booleanos.

o bien

OR lógico, aplicable a las expresiones booleanas.

expr1 or expr2

Las devolucionesValor booleano, o serie de valores booleanos.

No lo es

La negación lógica (NOT) es aplicable a las expresiones booleanas.

not expr1

Las devolucionesValor booleano, o serie de valores booleanos.

Palabras clave de tipo de datos

Bool también

Palabra clave utilizada para declarar explícitamente el tipo bool (booleano) de una variable o un argumento. Las variables Bool pueden tener valores: true, false o na.

Ejemplo

// bool
bool b = true    // Same as `b = true`
b := na
plot(b ? open : close)

Las observacionesMencionar explícitamente el tipo en una declaración de variable es opcional, excepto cuando se inicializa con na.

Véase también var varip int float color string true false

Int

Palabra clave utilizada para declarar explícitamente el tipo int (número entero) de una variable o un argumento.

Ejemplo

// int
int i = 14    // Same as `i = 14`
i := na
plot(i)

Las observacionesMencionar explícitamente el tipo en una declaración de variable es opcional, excepto cuando se inicializa con na.

Véase también var varip float bool color string

flotación

Palabra clave utilizada para declarar explícitamente el tipo float (punto flotante) de una variable o un argumento.

Ejemplo

// float
float f = 3.14    // Same as `f = 3.14`
f := na
plot(f)

Las observacionesMencionar explícitamente el tipo en una declaración de variable es opcional, excepto cuando se inicializa con na.

Véase también var varip int bool color string

la cuerda

Palabra clave utilizada para declarar explícitamente el tipo string de una variable o un argumento.

Ejemplo

// string
string s = "Hello World!"    // Same as `s = "Hello world!"`
// string s = na // same as "" 
plot(na, title=s)

Las observacionesMencionar explícitamente el tipo en una declaración de variable es opcional, excepto cuando se inicializa con na.

Véase también var varip int float bool str.tostring str.format

el color

Palabra clave utilizada para declarar explícitamente el tipo color de una variable o un argumento.

Ejemplo

// color
color textColor = color.green
if barstate.islastconfirmedhistory
    runtime.log("test", textcolor = textColor)

Las observacionesLos literales de color tienen el siguiente formato: #RRGGBB o #RRGGBBAA. Los pares de letras representan valores hexadecimales de 00 a FF (0 a 255 en decimal) donde los pares RR, GG y BB son los valores para los componentes rojos, verdes y azules del color. AA es un valor opcional para la transparencia del color (o componente alfa) donde 00 es invisible y FF opaco. Cuando no se suministra el par AA, se usa FF. Las letras hexadecimales pueden ser mayúsculas o minúsculas.

Mencionar explícitamente el tipo en una declaración de variable es opcional, excepto cuando se inicializa con na.

Véase también var varip int float string color.rgb color.new

el conjunto

Palabra clave utilizada para declarar explícitamente el tipo array de una variable o un argumento.array.new<type>, array.from function.

Ejemplo

// array
array<float> a = na
a := array.new<float>(1, close)
plot(array.get(a, 0))

Las observacionesLos objetos de matriz son siempre de forma serie.

Véase también var array.new array.from

Objetos

Los objetos en el lenguaje PINE son instancias de tipos definidos por el usuario (UDT), que se pueden entender como clases sin métodos que permiten a los usuarios crear tipos personalizados en estrategias para organizar diferentes valores en una entidad.

Definición de los tipos

Definamos un tipo de orden para almacenar la información de la orden:

type order
    float price
    float amount
    string symbol

• Los tipos se declaran utilizando eltype keyword.
• La palabra clave tipo es seguida por el nombre tipo.
• El tipo de primera línea define el nombre del tipo, con cuatro espacios reprimidos, y define los campos contenidos en el tipo.
• Cada campo debe declarar su tipo de datos, como int, float, string.

Creación de objetos

Utilizando el tipo declarado, llame alnew()función para crear un objeto:

order1 = order.new()

order1 = order.new(100, 0.1, "BTC_USDT")

order1 = order.new(amount = 0.1, symbol = "BTC_USDT", price = 100)

También puede crear objetos vacíos:

order order1 = na

Veamos un ejemplo práctico:

type order
    float price
    float amount
    string symbol

if strategy.position_size == 0 and open > close
    strategy.entry("long", strategy.long, 1)

order1 = order.new(strategy.opentrades.entry_price(strategy.opentrades - 1), strategy.opentrades.size(strategy.opentrades - 1), syminfo.ticker)
// runtime.log(order1)   // Output {"data":{"price":46002.8,"amount":1,"symbol":"swap"},"_meta":0,"_type":"order"}

En este ejemplo:

order1 = order.new(strategy.opentrades.entry_price(strategy.opentrades - 1), strategy.opentrades.size(strategy.opentrades - 1), syminfo.ticker)

También se puede escribir como:

order order1 = na
order1 := order.new(strategy.opentrades.entry_price(strategy.opentrades - 1), strategy.opentrades.size(strategy.opentrades - 1), syminfo.ticker)

Tipo de objeto para la palabra clave var

//@version=5
indicator("Objects using `var` demo")

//@type A custom type to hold index, price, and volume information.
type BarInfo
    int   index = bar_index
    float price = close
    float vol   = volume

//@variable A `BarInfo` instance whose fields persist through all iterations, starting from the first bar.
var BarInfo firstBar = BarInfo.new()
//@variable A `BarInfo` instance declared on every bar.
BarInfo currentBar = BarInfo.new()

// Plot the `index` fields of both instances to compare the difference.
plot(firstBar.index, "firstBar")
plot(currentBar.index, "currentBar")

Cuando se utiliza la palabra clave var para declarar una variable asignada a un objeto de un tipo definido por el usuario, la palabra clave se aplica automáticamente a todos los campos del objeto.

• El objeto firstBar se declara utilizando la palabra clave var, por lo que sus campos (índice, precio, volumen) conservarán sus valores en cada iteración, comenzando desde la primera entrada y terminando con la última entrada.
• El objeto currentBar no se declara con la palabra clave var, por lo que sus campos se reiniciarán en cada entrada y tendrá un nuevo objeto en cada iteración.

Al trazar los campos de índice de los dos objetos, puede comparar las diferencias entre ellos. firstBar.index mantendrá el valor establecido previamente en cada iteración, mientras que currentBar.index se reinicializará en cada iteración al valor bar_index de la entrada actual.

Tipos de objetos para el uso de la palabra clave varip

//@version=5
indicator("Objects using `varip` fields demo")

//@type A custom type that counts the bars and ticks in the script's execution.
type Counter
    int       bars  = 0
    varip int ticks = 0

//@variable A `Counter` object whose reference persists throughout all bars.
var Counter counter = Counter.new()

// Add 1 to the `bars` and `ticks` fields. The `ticks` field is not subject to rollback on unconfirmed bars.
counter.bars  += 1
counter.ticks += 1

// Plot both fields for comparison.
plot(counter.bars, "Bar counter", color.blue, 3)
plot(counter.ticks, "Tick counter", color.purple, 3)

En Pine, la palabra clave varip se utiliza para indicar que los campos de un objeto persisten durante toda la ejecución del script y no vuelven a rodar en barras no confirmadas. En la declaración del tipo Contador, el campo bares no utiliza la palabra clave varip, por lo que se vuelve a rodar en cada barra no confirmada. El objeto contador se declara utilizando la palabra clave var, por lo que persiste durante toda la ejecución del script. En cada iteración, tanto el campo de barras como el campo de ticks se incrementan en 1. Por último, al trazar los campos counter.bars y counter.ticks, puede comparar la diferencia entre ellos. El valor de counter.bars vuelve a rodar en cada barra no confirmada, mientras que el valor de counter.ticks continúa aumentando hasta el final de la ejecución del script.

Más.