[TOC]

Palavras-chave, gramática e configuração

Estrutura do código

A estrutura geral que o código do Pine segue:

<version>
<declaration_statement>
<code>

Comentários

Sinal de comentário para a linguagem Pine do FMZ: comentário de linha única//Comentários múltiplos/* */Por exemplo, a forma de escrever a nota no exemplo a seguir:

[macdLine, signalLine, histLine] = ta.macd(close, 12, 26, 9)  // 计算MACD指标

/*
plot函数在图表上画出指标线
*/
plot(macdLine, color = color.blue, title='macdLine')
plot(signalLine, color = color.orange, title='signalLine')
plot(histLine, color = color.red, title='histLine')

Edição

A seguinte forma de instrução de compilador diz ao compilador em qual versão do script o Pine foi escrito:

//@version=5

A versão padrão é a versão v5, que pode ser omitida no código//@version=5。

Declaração

• indicator()
• strategy()

A declaração define o tipo de script, que determina o que é permitido nele, e como é usado e executado. Define os atributos-chave do script, como seu nome, onde ele aparecerá quando for adicionado ao gráfico, a precisão e o formato dos valores que ele exibirá, e os valores que gerenciam certas ações quando ele for executado, como o número máximo de objetos de gráfico que ele exibirá no gráfico.indicator()oustrategy()Declaração.

Código

As linhas de um script que não são comentários ou instruções do compilador são sentenças, que implementam o algoritmo do script. Uma sentença pode ser um desses conteúdos.

• Declaração de variáveis
• Reatribuição de variáveis
• Declaração de função
• Chamadas de funções embutidas, chamadas de funções definidas pelo usuário
• if，for，whileouswitchEstrutura de equivalência

As frases podem ser organizadas de várias maneiras.

• Algumas declarações podem ser expressas em uma única linha, como a maioria das declarações de variáveis, que contêm apenas uma linha de chamada de função ou uma declaração de função de uma única linha. Outras, como as estruturas, sempre precisam de várias linhas, pois precisam de um bloco local.
• As declarações de âmbito global do script (ou seja, as partes que não pertencem ao bloco local) não podem ser consideradas como空格ou制表符Comece (tabulação) O primeiro caractere deles também deve ser o primeiro caractere da linha As linhas que começam na primeira posição da linha, por definição, fazem parte do alcance global do script
• Uma estrutura ou uma declaração de função de várias linhas sempre requer umlocal blockUm bloco local deve ser encolhido em um marcador ou em quatro espaços (caso contrário, será analisado como uma sequência da linha anterior de código, ou seja, julgado como um contínuo da linha anterior de código), e cada bloco local define um alcance local diferente.
• Várias frases de uma linha podem ser seqüenciadas em uma linha usando a vírgula ((,) como separador.
• Uma linha pode conter comentários ou apenas comentários.
• As linhas também podem ser fechadas (continua em linhas múltiplas).

Por exemplo, incluindo três blocos locais, um na declaração de função personalizada e dois usando a estrutura if na declaração de variável, com o seguinte código:

indicator("", "", true)             // 声明语句(全局范围)，可以省略不写

barIsUp() =>                        // 函数声明(全局范围)
    close > open                    // 本地块(本地范围)

plotColor = if barIsUp()            // 变量声明 (全局范围)
    color.green                     // 本地块 (本地范围)
else
    color.red                       // 本地块 (本地范围)

runtime.log("color", color = plotColor)  // 调用一个内置函数输出日志 (全局范围)

Código de mudança de linha

As linhas longas podem ser divididas em várias linhas, ou “enroladas”. As linhas enroladas devem ser encolhidas em qualquer número de espaços, desde que não sejam múltiplos de 4.

a = open + high + low + close

Pode ser embalado como ((observe que o número de espaços em cada linha não é um múltiplo de 4):

a = open +
      high +
          low +
             close

Uma chamada longa de plot ((() pode ser embalada como ▽.

close1 = request.security(syminfo.tickerid, "D", close)      // syminfo.tickerid 当前交易对的日线级别收盘价数据系列
close2 = request.security(syminfo.tickerid, "240", close)    // syminfo.tickerid 当前交易对的240分钟级别收盘价数据系列
plot(ta.correlation(close, open, 100),                       // 一行长的plot()调用可以被包装
   color = color.new(color.purple, 40),
   style = plot.style_area,
   trackprice = true)

A frase na declaração de função definida pelo usuário também pode ser empacotada. No entanto, como o bloco local deve começar gramaticalmente com uma contração (((4 espaços ou 1 símbolo), quando dividido para a linha seguinte, a parte de continuação da frase deve começar com uma contração ou mais (((não é igual ao múltiplo de 4 espaços)).

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

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

Sequência de tempo

A sequência de tempo não é um tipo ou formato de dados, mas um conceito de estrutura básica na linguagem PINE. Usado para armazenar valores que variam continuamente no tempo, cada valor correspondendo a um ponto de tempo. A estrutura desse conceito de sequência de tempo é adequada para ser aplicada ao processamento e registro de uma série de dados que mudam com o tempo. Com variáveis embutidasopenPor exemplo:openA variável embutida registra o preço de abertura de cada linha K BAR, se estaopenEntão, esse é o número de 5 minutos de um ciclo de K.openA variável registrada é o preço de abertura de cada linha K BAR ((coluna) por 5 minutos. Quando o seu programa de estratégia é executado, o código faz referênciaopenIsto é, o preço de abertura da linha BAR em que o K está atualmente. Para referir o valor anterior na sequência de tempo (valor anterior), usamos[]O operador histórico, quando a estratégia é executada em uma linha KBAR,open[1]O que significa que o preço de abertura de uma linha K BAR anterior à linha K BAR atual.

EmboraSequência de tempoÉ fácil lembrar a estrutura de dados “array”, embora a linguagem PINE também tenha tipos de arrays. No entanto, eles são conceitos completamente diferentes da sequência temporal.

A linguagem PINE concebeu uma sequência de tempo que permite calcular facilmente o valor acumulado do preço de fechamento no código da estratégia, sem a necessidade de usar uma estrutura circular como for, usando apenas funções embutidas na linguagem PINE.ta.cum(close)Por outro exemplo, precisamos calcular o valor médio do diferencial entre o valor máximo e o valor mínimo das últimas 14 linhas K BAR (ou seja, as 14 linhas K BAR mais próximas no momento atual de execução do código) que podem ser escritas como:ta.sma(high - low, 14)

O resultado da chamada de uma função na sequência de tempo também deixa uma marca na sequência de tempo.[]O operador histórico cita o valor anterior. Por exemplo, para testar se o valor de fechamento do atual K-line BAR excede o valor máximo do valor máximo dos últimos 10 K-lines BAR (excluindo o atual K-line BAR). Podemos escrever:breach = close > ta.highest(close, 10)[1]Também pode ser escritobreach = close > ta.highest(close[1], 10)Por isso.ta.highest(close, 10)[1]eta.highest(close[1], 10)É equivalente.

A verificação pode ser feita com o seguinte 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)

O código de teste acima irá expor a e b em cada BAR em seus valores de sequência de tempo correspondentes, e você verá que a e b são sempre iguais, então os dois métodos de representação são equivalentes.

História de referência

O Trading View tem um limite máximo de itens para referências de dados históricos (até 5.000 itens), como o seguinte código:

//@version=6
indicator("test")

ema = ta.ema(close, 10000)      // 报错：Error on bar 0: The 'ema'->'sum' function references too many historical candles (10000), the limit is 5000.
plot(ema, "ema")

// pre10000 = ema[10000]        // 报错：Invalid number of bars back specified in the history-referencing operator. It accepts a value between 0 and 5000.
// plot(pre10000, "pre10000")

A política de linguagem Pine em FMZ é chamada de “Configuração de transações” no “Pine Language Transaction Classroom”, com o parâmetro: “Numero de períodos mais longos de variáveis” define especificamente o número máximo de itens de dados que podem ser citados.

indicator("test")

ema = ta.ema(close, 1000)  // ema = ta.ema(close, 3000) 则报错：Invalid number 3000 of bars back specified in the history-referencing operator. It accepts a value between 0 and 2000.
plot(ema, "ema")

O parâmetro “Mais longo período de variação” não deve ser definido como muito grande, e pode ser usado para referenciar dados em uma política apropriada.

Parâmetros de modelagem da biblioteca de classes de transação da linguagem Pine

Configuração de parâmetros para o modelo embutido da política PINE, o “Pine Language Exchange Repository”.

Configurações de transação

• Execução Modelo de preço de fechamento: executa o modelo até o final do BAR atual e executa a transação quando o BAR inferior começa. Modelagem de preços em tempo real: executa o modelo a cada mudança de preço e executa a transação imediatamente com o sinal.
• Número de mãos de posição aberta por defeito: se a instrução de negociação não especificar o número de negociações, execute a negociação de acordo com o número definido.
• Máximo número de pedidos por transação única: De acordo com a liquidação real, em combinação com a configuração deste parâmetro, determine o número máximo de pedidos por transação, evitando o impacto no disco.
• Ponto de deslizamento:定价货币精度O parâmetro e esse parâmetro determinam o preço de deslizamento no momento do pedido. Por exemplo, a precisão de precificação da moeda é definida como 2, ou seja, exata para o segundo lugar da minúscula, exata para 0,01. Então, cada ponto de deslizamento representa 0,01 unidades de precificação.
• Número de ciclos mais longos da variável: número de BARs de linhas K do gráfico afetado, comjavascriptChamadas na estratégiaSetMaxBarLenA função é a mesma.

Opções de Futuros

• Código de variedade: Código de contrato, que só precisa ser definido quando o objeto da bolsa é um objeto de bolsa não-local.
• Número mínimo de contratos: O número mínimo de transações do contrato no momento da encomenda.

Opções reais

• Progresso de recuperação automática: recuperação automática do estado antes da interrupção da última estratégia.
• Número de tentativas de reencaminhamento: se a ordem não for executada, a ordem será cancelada e a transação será reencaminhada. Este parâmetro é usado para limitar o número máximo de tentativas de reencaminhamento.
• Intervalo de pesquisa da rede ((milliseconds): válido apenas para o protocolo REST, controle do intervalo de solicitação da rede, evite solicitações muito frequentes, além dos limites da bolsa.
• Tempo de sincronização das contas (segundos): período de tempo para sincronizar os dados das contas.
• Tempo de sincronização de posições após a abertura da posição (milliseconds): apenas para a abertura de posições repetidas causadas por atrasos de dados de algumas exchanges, a configuração de tempo de sincronização maior pode mitigar esse tipo de problema.
• Multiplice de alavancagem: configure o multiplicador de alavancagem.

Negociação em dinheiro, outras configurações

• Volume de transação de uma mão: o volume de transação de uma mão padrão, válido apenas para o dinheiro.
• Número mínimo de transações: Número mínimo de transações
• Precificação monetária: Precificação do preço, ou seja, o número de dígitos do preço.
• Precisão da variedade de transação: a precisão da quantidade seguinte, ou seja, o número menor da quantidade seguinte.
• Taxa de processamento: 0,002 indica 2 milésimos para alguns dados calculados de acordo com essa configuração.
• Intervalos de perda e prejuízo: somente em disco rígido.
• Falha de repetição ((ms): intervalo de repetição quando a solicitação da rede falha.
• Agente de uso: válido apenas para o protocolo REST.
• Esconde erros comuns na rede: Esconde erros comuns na área de registro.
• O endereço de base de comutação é válido apenas para o protocolo REST.
• Notificações de envio: envio de mensagens para a caixa de correio, etc.

Faça um pedido

Abrir uma posição

strategy(title = "open long example", pyramiding = 3)                                // pyramiding 允许的同方向下单的次数
strategy.entry("long1", strategy.long, 0.01)                                         // 市价开多仓，指定分组标签为long1
strategy.entry("long2", strategy.long, 0.02, when = close > ta.ema(close, 10))       // 条件触发，执行下单，市价开多仓
strategy.entry("long3", strategy.long, 0.03, limit = 30000)                          // 指定（较低的）价格，计划下买单订单，等待成交开仓，限价开仓

Posições equilibradas

strategy(title = "close long example", pyramiding = 2)                              // pyramiding 允许的同方向下单的次数
strategy.entry("long1", strategy.long, 0.1)                                         // 市价开多仓，指定分组标签为long1
strategy.entry("long2", strategy.long, 0.1)                                         // 市价开多仓，指定分组标签为long2
strategy.close("long1", when = strategy.position_size > 0.1, qty_percent = 50, comment = "close buy entry for 50%")   // 平仓，指定平掉分组标签为long1的仓位的50%持仓
strategy.close("long2", when = strategy.position_size > 0.1, qty_percent = 80, comment = "close buy entry for 80%")   // 平仓，指定平掉分组标签为long2的仓位的80%持仓

Mecanismo de negociação

O mecanismo de posicionamento da linguagem PINE é semelhante ao de um posicionamento unidirecional. Por exemplo, quando se detém uma posição em direção a várias posições, se houver ordens de venda de operações, planos, etc. em sentido oposto em relação à direção da posição, as ordens de execução são acionadas, em seguida, as ordens acionadas são acionadas em sentido oposto em relação à posição anterior.

Planilha

Quando o comando de encomenda é usado, a lista de preços é assumida por defeito se não for especificado qualquer preço. Além da lista de preços, a lista de planos também pode ser encomendada por meio da lista de planos, mas a lista de planos não opera a lista de planos imediatamente. A lista de planos pode ser incluída na cota de encomendas de planos que não existem no processo ao ser acionada.Disco rígido / retrospectivaA informação de estado de tempo (ou seja, o estado da estratégia em execução) é visto na seção de páginas do formulário “Ordens planejadas”. Quando o preço do mercado em tempo real atende às condições, o sistema só faz um pedido real quando esses planos são acionados. Portanto, esses pedidos são normais se houver um ligeiro desvio no preço de transação.strategy.entryQuando uma função é encomendada, podemos especificarlimit、stopParâmetros

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    

• Ordem de limite

O preço limite de um pedido é definido quando o pedido é pago (ou seja,directionOs parâmetros sãostrategy.longA ordem é acionada apenas quando o preço atual do mercado é inferior a esse preço. Quando a encomenda é para venda por encomenda (ou seja,directionOs parâmetros sãostrategy.shortA ordem só é acionada quando o preço atual do mercado é superior a esse preço.

• Pedido de stop

Estabelecer um preço de parada de uma ordem, quando a ordem é uma compra, a ordem só será acionada se o preço atual do mercado for superior a esse preço. Quando um pedido é um pedido de venda, o pedido só é acionado quando o preço atual do mercado é inferior a esse preço.

• Ordem de stop-limit

Pode ser configurado simultaneamentelimit、stopParâmetro: A ordem é acionada pelo preço mais qualificado.

Percentagem de direitos

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

// 简单的均线交叉策略
longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))  

// 如果均线交叉条件满足，则买入或卖出
if (longCondition)
    strategy.entry("Long", strategy.long)  

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

Especificaçãodefault_qty_type=strategy.percent_of_equityDepois, configuraçãodefault_qty_valuePor exemplo: a conta atual tem 10.000 USDT, e a ordem de 1% é a ordem de compra com o tamanho de 100 USDT (calculada com o preço atual no momento da venda).

Declaração, palavras-chave estrutura lógica

var

var é a palavra-chave usada para a distribuição e a inicialização de variáveis. Normalmente, a sintaxe de atribuição de variáveis que não contém a palavra-chave var faz com que o valor da variável seja coberto sempre que os dados são atualizados. Por outro lado, quando as variáveis são atribuídas com a palavra-chave var, elas podem ser mantidas na barra de estado apesar da atualização dos dados, e somente alteradas se as condições das if-expressions forem atendidas.

var variable_name = expression

Explicação:

• variable_name- Qualquer nome de variável de usuário permitido no Pine Script, que pode conter letras latinas maiúsculas e minúsculas, números e sublinhados_), mas não começa com um número).
• expression- Qualquer expressão aritmética, tal como a definição de uma variável regular.

Exemplo

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

A variável ‘a’ mantém o valor de fechamento do primeiro pilar de cada linha da série. A variável ‘b’ mantém o preço de fechamento da primeira barra de preço de alumínio verde da série. A variável ‘c’ mantém o preço de fechamento da décima chiclete verde da série.

No FMZ, os modelos de preços são os modelos de preços em tempo real, os modelos de preços de fechamento e os modelos de preços de fechamento.var、varipA variável da declaração é testada com o seguinte código:

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

// 测试 var varip
var i = 0
varip ii = 0

// 将策略逻辑每轮改变的i、ii打印在图上
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)

// 每轮逻辑执行都给i、ii递增1
if true
    i := i + 1
    ii := ii + 1

• Modelo de preço em tempo real O código de teste acima foi dividido em duas fases: 1) Histórico K-linha 2.) Real K-linha 3.) Quando o modelo de preço em tempo real, a fase histórica K-linhavar、varipAs variáveis i, ii da declaração executam uma operação incremental em cada rodada de execução do código da estratégia, porqueif truePortanto, execute o bloco de código condicional correspondente). Assim, pode-se ver que os números exibidos na linha BAR do resultado do teste K são incrementados em 1 cada um. Quando o estágio da linha K histórica termina, o estágio da linha K em tempo real começa.var、varipAs variáveis declaradas começam a mudar de forma diferente. Como é um modelo de preço em tempo real, o código de estratégia é executado uma vez por cada mudança de preço dentro de uma linha KBAR.i := i + 1eii := ii + 1A diferença é que ii é modificado a cada vez. Embora i seja modificado a cada vez, o valor de i é restabelecido na próxima rodada de execução da lógica da estratégia, até que o atual K line BAR seja concluído para atualizar o valor de i. Portanto, você pode ver que a variável i continua a aumentar 1 por BAR. Mas a variável ii acumula várias vezes por BAR.

• Modelo de preço de fechamento Como o modelo de preço de fechamento executa uma lógica de estratégia para cada K-line BAR. Assim, no modelo de preço de fechamento, a fase de linha K histórica e a fase de linha K em tempo real são separadas.var、varipAs variáveis declaradas são exatamente as mesmas em cada K line BAR incrementado de 1 .

varip

varip ((var intrabar persist) é uma palavra-chave usada para a distribuição e inicialização de variáveis de uma só vez. É semelhante à palavra-chave var, mas a variável que usa a declaração varip mantém seu valor entre as atualizações de linha K em tempo real.

varip variable_name = expression

Explicação:

• variable_name- Qualquer nome de variável de usuário permitido no Pine script que possa conter letras maiúsculas e minúsculas, números e sublinhados_), mas não começa com um número).
• expression- Qualquer expressão aritmética, como quando se define uma variável regular. Na primeira linha K, a expressão é calculada apenas uma vez e é atribuída à variável uma vez.

Exemplo

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

Usando var, o gráfico retorna o valor de bar_index. Usando varip, o mesmo acontece na linha K histórica, mas na linha K em tempo real, o gráfico retorna um valor que aumenta para cada tick.

Nota: Só pode ser usado com tipos simples, como float, int, bool, string, e com arrays desses tipos.

true

Representar um valor de uma variável de tipo Boole, ou quando a expressão é usadaComparaçãoouLógicaValores que podem ser calculados no operador.

Nota: Veja tambémComparaçãoO operador eLógicaDescrição do operador:

Veja também bool

false

Indica o valor de uma variável de tipo Boole, e o resultado de operações de comparação e operações lógicas.

Nota: Veja tambémComparaçãoO operador eLógicaDescrição do operador:

Veja também bool

if

Uma sentença if define um bloco de sentenças que deve ser executado para satisfazer uma condição de expressão. A linguagem de scripting Pine, em sua 4a edição, permite que você use a sintaxe de else if.

Código genérico:

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

Nota: var_declarationX- Esta variável obtém o valor da frase if condition- Use bloco de declarações se a condição for verdadeirathenA lógica no interiorvar_decl_then0，var_decl_then1Se a condição for false, use o bloco de sentenças.else ifouelseA lógica no interiorvar_decl_else0，var_decl_else1E assim por diante. return_expression_then , return_expression_else- A última expressão no módulo ou a expressão do bloco else retornará o valor final da frase. Se a declaração da variável estiver no final, seu valor será o valor resultante.

O tipo de retorno de um valor de uma declaração if depende dereturn_expression_thenereturn_expression_elseQuando executado no TradingView, seus tipos devem coincidir: quando você tem um valor de string no bloco else, é impossível retornar um valor inteiro do bloco then. Quando executado no FMZ, o exemplo a seguir não comete erros, quando o valor y é “open”, o valor do gráfico de plot é n/a.

Exemplo

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

Pode ser omitidoelseBloco Neste caso, se a condição for false, a variável var_declarationX será atribuída a um valor empty (na, false ou ):

Exemplo

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

Pode-se usar vários blocos de else if ou não usar nenhum. Os blocos de then, else if e else são movidos em quatro espaços:

Exemplo

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

Pode ser ignorado.ifO valor de resultado da expressão ((var_declarationX= pode ser omitido)). Pode ser útil se você precisar de efeitos colaterais da expressão, por exemplo, em estratégias de negociação:

Exemplo

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

As sentenças If podem ser incluídas:

Exemplo

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

for

A estrutura ‘for’ permite a execução repetida de várias frases:

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

var_declaration- Uma declaração de variável selecionável, que será atribuída ao valor da expressão return_expression do loop. counter- A variável que guarda o valor do contador de volta, aumentando/diminuindo 1 ou o valor step_num em cada iterativa da volta. from_num- Valores iniciais do contador. Permite o uso de thresholds int/float series/expressões. to_num- o valor final do contador. O ciclo é interrompido quando o contador é maior do que to_num (ou menor do que to_num no caso de from_num > to_num). O uso de thresholds int/float thresholds/expressions é permitido, mas eles são avaliados apenas na primeira iteração do ciclo. step_num- O valor de acréscimo/decaimento do contador. É opcional. O valor padrão é +1 ou -1, dependendo do maior de from_num ou to_num. statements | continue | break- Escreva um número arbitrário de frases, ou palavras-chave ‘continue’ ou ‘break’, em 4 espaços ou uma tabulação. return_expression- O valor de retorno do loop, se existir, é atribuído a uma variável na declaração var. Se o loop for retirado devido à palavra-chave continue ou break, o valor de retorno do loop é o valor de retorno da última variável a ser atribuída antes da saída do loop. continue- Palavras-chave que só podem ser usadas no loop. Isso faz com que a próxima iterativa do loop seja executada. break- Palavras-chave para sair do círculo.

Exemplo

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

Veja também for...in while

for…in

for...inA estrutura permite executar várias instruções repetidas para cada elemento da matriz. Pode ser usada com qualquer dos seguintes parâmetros:array_element, ou com dois argumentos:[index, array_element]A segunda forma não afeta a função do ciclo. Ela segue o índice da iteração atual na primeira variável do módulo.

[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- uma declaração de variável selecionável, que será atribuída ao cicloreturn_expressionValor de index- Variavel opcional que acompanha o índice de iteração atual. O índice começa em 0. A variável é imutável no corpo circular. Quando usada, ela deve ser incluída em um que também seja incluído.array_elementSubgrupo de array_element- Contém a variável de cada elemento da matriz contínua a ser processado no ciclo. Esta variável é imutável no corpo do ciclo. array_id- ID de matriz para a repetição do círculo. statements | continue | break- Escreva um número arbitrário de frases, ou palavras-chave ‘continue’ ou ‘break’, em 4 espaços ou uma tabulação. return_expression- O valor de retorno do loop é atribuído avar_declarationA variável, se existir. Se o loop sair devido a palavras-chave ‘continue’ ou ‘break’, o valor de retorno do loop será o último valor atribuído antes do loop sair. continue- Palavras-chave que só podem ser usadas no loop. Isso faz com que a próxima iterativa do loop seja executada. break- Palavras-chave para sair do círculo.

É permitido modificar o elemento ou o tamanho da matriz no loop. Aqui, usamosfor...inA forma monoparametrica para determinar, em cada linha K, quantos valores de OHLC da linha K são maiores do que os valores de ‘close’ do SMA:

Exemplo

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

Aqui, nós usamos a forma de dois parâmetros de for…in para fazer o nossoisPosO valor da matriz é trueQuando eles estão em nosso.valuesArrayO valor correspondente na matriz é a hora correta:

Exemplo

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

Veja também for while array.sum array.min array.max

while

whileO enunciado permite a iteração condicional de blocos de código locais.

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

Explicação: variable_declaration- Declarações de variáveis opcionais.return expressionPode-se fornecer um valor de inicialização para esta variável. boolean_expression- Execute se for verdadewhileSe for false, então emwhileO texto é executado após a frase. continue - continueAs palavras-chave levam o ciclo a se ramificar para a próxima geração. break - breakA palavra-chave que causa o fim do ciclo.whileA frase é seguida de uma recuperação. return_expression- Oferta.whileUma linha opcional que retorna o valor de uma frase.

Exemplo

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

Nota: Inicialmente.whileO bloco de código local após a linha deve ser comprimido em quatro espaços ou um marcador.whileO ciclo.whileA expressão de Boole posterior tem de ser false, ou tem de ser executada.break。

switch

O operador switch transfere o controle para uma das várias sentenças de acordo com o valor da condição e da expressão.

[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

A expressão “switch”:

Exemplo

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

Switch sem expressão:

Exemplo

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)

Devolver valores O valor da última expressão no bloco de declarações locais executado.

Nota: Só pode ser executadolocal_blockExemplos oudefault_local_blockUm deles.default_local_blockApenas com=>O marcador é introduzido juntamente e executado somente se o bloco anterior não for executado. SeswitchO resultado da sentença é atribuído a uma variável e não é especificadodefault_local_blockSe não houver execução,local_block, então a frase voltanaNão, não.switchQuando o resultado de uma sentença é atribuído a uma variável, todas aslocal_blockA instância deve retornar valores do mesmo tipo.

Veja também if ?:

series

series é uma palavra-chave que indica o tipo de série de dados.seriesAs palavras-chave geralmente não são necessárias.

Operador

=

É usado para atribuir valores a variáveis, mas apenas quando as variáveis são declaradas.

:=

O operador de atribuição atribui a variável à esquerda. É usado para atribuir a variável declarada anteriormente.

!=

Não é igual a ≠ ≠ ≠ ≠ ≠ ≠

expr1 != expr2

Devolver valores Um valor de bur, ou uma série de valores de bur.

%

Número modulo ((número inteiro excedente) [2]. Aplica-se a expressões de valor numérico [2].

expr1 % expr2

Devolver valores Um valor inteiro ou um valor de ponto flutuante, ou uma série de valores.

Nota: No script Pine, quando o saldo de números inteiros é calculado, o negócio será interrompido. Ou seja, o valor recebido terá o mesmo símbolo que o dividendo.

Exemplo: -1 % 9 = -1 - 9 * truncate ((-¹⁄₉) = -1 - 9 * truncate ((-0.111) = -1 - 9 * 0 = -1 ◦

%=

Definição de módulo. Aplica-se a expressões numéricas.

expr1 %= expr2

Exemplo

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

Devolver valores Um valor inteiro ou um valor de ponto flutuante, ou uma série de valores.

*

Multiplicação. Aplica-se a expressões numéricas.

expr1 * expr2

Devolver valores Um valor inteiro ou um valor de ponto flutuante, ou uma série de valores.

*=

A multiplicação é designada. Aplica-se a expressões numéricas.

expr1 *= expr2

Exemplo

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

Devolver valores Um valor inteiro ou um valor de ponto flutuante, ou uma série de valores.

+

Adição ou um número positivo. Aplica-se a expressões numéricas ou strings.

expr1 + expr2

+ expr

Devolver valores Binário de Strings+Retorna a fusão de express1 e express2 O número retorna um inteiro ou um valor de ponto flutuante, ou uma série de valores: O binário ‘+’ retorna expressão 1 mais expressão 2. 1 yuan + 1 yuan retorna expr ((Não adicione nada ao operador de 1 yuan de simetria) ▽

Nota: Você pode usar operadores de aritmética com números, bem como um conjunto de variáveis. No caso de usar um conjunto de variáveis, os operadores são aplicados aos elementos.

+=

A designação de adição aplica-se a expressões numéricas ou strings .

expr1 += expr2

Exemplo

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

Devolver valores Para uma string, retorne a sequência de expressões expr1 e expr2. Para números, retorne um inteiro ou um valor de ponto flutuante, ou uma série de valores.

Nota: Você pode usar operadores de aritmética com números, bem como um conjunto de variáveis. No caso de usar um conjunto de variáveis, os operadores são aplicados aos elementos.

-

O método de subtração ou umitero-negativo. Aplica-se a expressões numéricas.

expr1 - expr2

- expr

Devolver valores Retorna um valor inteiro ou um valor de ponto flutuante, ou uma série de valores: O binário ‘+’ retorna expressão 1 menos expressão 2. Um dólar.-Retorna a expressão negativa de ∂.

Nota: Você pode usar operadores de aritmética com números, bem como um conjunto de variáveis. No caso de usar um conjunto de variáveis, os operadores são aplicados aos elementos.

-=

Designação de subtração. Aplica-se a expressões numéricas.

expr1 -= expr2

Exemplo

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

Devolver valores Um valor inteiro ou um valor de ponto flutuante, ou uma série de valores.

/

Exclusão: aplica-se a expressões numéricas.

expr1 / expr2

Devolver valores Um valor inteiro ou um valor de ponto flutuante, ou uma série de valores.

/=

Designação de exclusão. Aplica-se a expressões numéricas.

expr1 /= expr2

Exemplo

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

Devolver valores Um valor inteiro ou um valor de ponto flutuante, ou uma série de valores.

<

Menor que ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠

expr1 < expr2

Devolver valores Um valor de bur, ou uma série de valores de bur.

<=

Menor ou igual a ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠

expr1 <= expr2

Devolver valores Um valor de bur, ou uma série de valores de bur.

==

É igual a … Aplica-se a qualquer tipo de expressão …

expr1 == expr2

Devolver valores Um valor de bur, ou uma série de valores de bur.

=>

O operador ‘=>’ é usado para declarar funções definidas pelo usuário eswitchNa frase:

A sintaxe da declaração de função é:

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

Um.<local_block>São zero ou mais frases de Pine. <function_result>É uma variável, uma expressão ou um grupo.

Exemplo

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

Nota: Você pode obter mais informações sobre funções definidas pelo usuário nas páginas de declarações de funções e biblioteca de scripts do manual do usuário.

>

Maior do que aplica-se a expressões numéricas

expr1 > expr2

Devolver valores Um valor de bur, ou uma série de valores de bur.

>=

Maior que ou igual a. Aplica-se a expressões numéricas.

expr1 >= expr2

Devolver valores Um valor de bur, ou uma série de valores de bur.

?:

O operador de condição triangular。

expr1 ? expr2 : expr3

Exemplo

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

Devolver valores Se expr1 for avaliado como verdadeiro, expr2 será, caso contrário, expr3. Os valores de zero ((0 e NaN +, Infinity, -Infinity) são considerados falsos, os outros valores são verdadeiros.

Nota: Se você não precisar, use na como uma ramificação de naelse. Você pode combinar dois ou mais operadores ?: para implementar uma frase semelhante à da supressão de um parênquima (veja o exemplo acima). Você pode usar operadores de aritmética com números, bem como um conjunto de variáveis. No caso de usar um conjunto de variáveis, os operadores são aplicados aos elementos.

Veja também na

[]

Subsérie ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠

expr1[expr2]

Exemplo

// [] 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)

Devolver valores Uma série de valores.

Veja também math.floor

and

A lógica AND aplica-se às expressões de Boole .

expr1 and expr2

Devolver valores Um valor de bur, ou uma série de valores de bur.

or

A lógica OR ≠ aplica-se às expressões de Boole ≠

expr1 or expr2

Devolver valores Um valor de bur, ou uma série de valores de bur.

not

A inversão lógica ((NOT) aplica-se às expressões de Boole.

not expr1

Devolver valores Um valor de bur, ou uma série de valores de bur.

Tipo de dados Palavras-chave

bool

A palavra-chave do tipo bool ((Bool)) usada para declarar explicitamente uma variável ou um parâmetro. O valor da variável “Bool” pode ser verdadeiro, falso ou na.

Exemplo

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

Nota: É opcional mencionar o tipo explicitamente na declaração da variável, a menos que seja iniciado com na. Para mais informações sobre o tipo Pine, consulte a página do manual do usuário do sistema de tipos.

Veja também var varip int float color string true false

int

Palavras-chave do tipo int ((inteiro)) para variáveis ou parâmetros declarados explicitamente.

Exemplo

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

Nota: É opcional mencionar o tipo explicitamente na declaração da variável, a menos que seja iniciado com na. Para mais informações sobre o tipo Pine, consulte a página do manual do usuário do sistema de tipos.

Veja também var varip float bool color string

float

Palavras-chave do tipo float () para variáveis ou parâmetros declarados explicitamente.

Exemplo

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

Nota: É opcional mencionar o tipo explicitamente na declaração da variável, a menos que seja iniciado com na.

Veja também var varip int bool color string

string

Palavras-chave do tipo “string” para variáveis ou parâmetros declarados explicitamente.

Exemplo

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

Nota: É opcional mencionar o tipo explicitamente na declaração da variável, a menos que seja iniciado com na. Para mais informações sobre o tipo Pine, consulte a página do manual do usuário do sistema de tipos.

Veja também var varip int float bool str.tostring str.format

color

Palavras-chave do tipo “color” usadas para declarar variáveis ou parâmetros de expressões.

Exemplo

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

Nota: Os caracteres de cor têm o seguinte formato: #RRGGBB ou #RRGGBBAA. Os pares de letras representam os valores de dezesseis dígitos de 00 a FF ((de dezesseis dígitos de 0 a 255), onde RR, GG e BB são os valores das proporções de vermelho, verde e azul das cores. AA é o valor opcional da transparência da cor (ou a proporção alfa), onde 00 é invisível e FF não é transparente. É opcional mencionar o tipo explicitamente na declaração da variável, a menos que seja iniciado com na. Para mais informações sobre o tipo Pine, consulte a página do manual do usuário do sistema de tipos.

Veja também var varip int float string color.rgb color.new

array

Palavras-chave para o tipo de array de arrays de variáveis ou parâmetros declarados explicitamente. Pode ser usadoarray.new<type>,array.fromA função cria um objeto de matriz ((ou ID) }}.

Exemplo

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

Nota: Os objetos da matriz são sempre em forma de conjuntos de conjuntos.

Veja também var array.new array.from

Objects

Os objetos da linguagem PINE são exemplos de tipos definidos pelo usuário (UDT), que podem ser entendidos como classes sem métodos, permitindo que o usuário crie tipos personalizados em uma política para organizar diferentes valores em uma entidade.

Definição de tipo

Vamos definir um tipo de ordem para armazenar a informação do pedido:

type order
    float price
    float amount
    string symbol

• usartypeTipo de declaração da palavra-chave
• A palavra-chave type é seguida pelo nome do tipo.
• A primeira linha type define o nome do tipo, e depois, em quatro espaços, define os campos que o tipo contém.
• Cada campo precisa declarar seu tipo de dados, como int, float, string.

Objeto de criação

Utilize o tipo declarado, chamadanew()Objeto de criação da função:

order1 = order.new()

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

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

Também é possível criar objetos vazios:

order order1 = na

Vejamos um exemplo prático:

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)   // 输出 {"data":{"price":46002.8,"amount":1,"symbol":"swap"},"_meta":0,"_type":"order"}

O exemplo é esta frase:

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

A expressão pode também ser escrita da seguinte forma:

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 o uso da palavra-chave 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")

Quando uma variável é atribuída a um objeto do tipo definido pelo usuário, a declaração da palavra-chave var é aplicada automaticamente a todos os campos desse objeto. Isso significa que um objeto declarado com a palavra-chave var manterá seu estado entre cada iteração, sem a necessidade de reiniciar seus valores de campo em cada iteração.

• O objeto firstBar é declarado com a palavra-chave var, então seu campo ((index, price, vol) manterá seu valor em cada iterativa, desde o primeiro item até o fim do último.
• O objeto currentBar não usa a declaração de palavra-chave var, então seus campos serão reinicializados em cada entrada e haverá um novo objeto em cada interação.

Ao mapear os campos de índice de dois objetos, você pode comparar as diferenças entre eles. firstBar.index manterá o valor previamente definido em cada iterativa, enquanto que currentBar.index será reinicializado em cada iterativa como o valor bar_index do item atual.

Tipo de objeto para uso de 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)

Em Pine, o uso da palavra-chave varip pode indicar que o campo do objeto persiste durante toda a execução do script, sem rolar dentro da coluna não confirmada. Em uma declaração do tipo Counter, o campo bars não usa a palavra-chave varip e, portanto, rola dentro de cada coluna não confirmada. O campo ticks u