[TOC]

Introdução a palavras-chave, gramática, configurações

Estrutura do código

A estrutura geral do código em Pine é a seguinte:

<version>
<declaration_statement>
<code>

Notas

Notas símbolos suportados pela linguagem Pine da FMZ: notas de linha única//, notas de várias linhas/* */, tal como o método das notas no seguinte exemplo:

[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')

Versão

Uma instrução de compilador da seguinte forma diz ao compilador qual versão do Pine que o script foi escrito com:

//@version=5

O padrão é a versão V5, que pode ser omitido do código//@version=5.

Declaração de declaração

• indicator()
• strategy()

A instrução de declaração determina o tipo de script, que por sua vez determina o que é permitido nele, e como ele é usado e executado. Defina propriedades-chave do script, como seu nome, onde ele aparecerá quando for adicionado ao gráfico, a precisão e o formato dos valores numéricos que ele exibe, e certos valores numéricos que governam seu comportamento em tempo de execução, por exemplo, o número máximo de objetos de desenho para exibir no gráfico. Para estratégias, os atributos incluem argumentos que controlam o backtesting, como capital inicial, comissões, deslizamento, etc.indicator()oustrategy()A declaração deve ser incluída num código de estratégia em Pine of FMZ.

Código

Linhas em um script que não são comentários ou instruções do compilador, que são instruções, que implementam o algoritmo do script.

• Declaração variável
• Reatribuição de variáveis
• Declaração de função
• Chamadas de funções integradas, chamadas de funções definidas pelo utilizador
• if, for, whileouswitche outras construções

As declarações podem ser organizadas de várias maneiras.

• Algumas instruções podem ser expressas em uma linha, como a maioria das declarações de variáveis, linhas contendo apenas uma chamada de função ou declarações de função de linha única.
• As instruções no escopo global de um script (ou seja, partes que não fazem parte de um bloco local) não podem começar com umspaceoutabAs linhas que começam na primeira posição de uma linha são por definição parte do escopo global do script.
• Alocal blockUm bloco local deve ser recuado por uma aba ou quatro espaços (caso contrário, ele será analisado como o código concatenado da linha anterior, que é determinado como o conteúdo contínuo da linha anterior de código), e cada bloco local define um escopo local diferente.
• Várias instruções de linha única podem ser concatenadas em uma única linha usando vírgulas (,) como delimitadores.
• Uma linha pode conter comentários ou apenas comentários.
• As linhas também podem ser enroladas (continuadas em várias linhas).

Por exemplo, incluir três blocos locais, um na declaração de função personalizada e dois na declaração de variável usando a estrutura if, da seguinte forma:

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 linha nova

As linhas longas podem ser divididas em várias linhas, ou enroladas. Uma linha enrolada deve ser recuada por qualquer quantidade de espaço em branco, desde que não seja um múltiplo de 4 (esses limites são usados para recuar blocos locais).

a = open + high + low + close

Pode ser embalado como (observe-se que o número de espaços indentados por linha não é múltiplo de 4):

a = open +
      high +
          low +
             close

Uma chamada longa pode ser enrolada 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)

As declarações em declarações de funções definidas pelo usuário também podem ser enroladas. No entanto, uma vez que um bloco local deve começar sintaticamente com um recuo (4 espaços ou 1 guia), ao dividi-lo para a próxima linha, a continuação de uma declaração deve começar com mais de um recuo (não igual a 4 múltiplos de 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")

Série Temporal

A série temporal não é um tipo ou formato de dados, mas sim um conceito de uma estrutura básica na linguagem PINE.

Pegue a variável embutidaopenPor exemplo, oopena variável incorporada registra o preço de abertura de cada representação int BAR, se estaopené um período de representação int de 5 minutos dados.openA variável registra o preço de abertura de cada representação int de 5 minutos BAR (bar).openPara se referir aos valores anteriores (valores passados) na série temporal, usamos o[]Quando a estratégia é executada em uma certa representação int BAR,open[1]O significado é referir-se ao preço de abertura da anterior representação int BAR da atual representação int BAR.

Emboraséries temporaisé muito semelhante à estrutura de dados array, embora a linguagem PINE também tenha um tipo de matriz.

As séries temporais concebidas em linguagem de pinho pode facilmente calcular o valor acumulado do preço de fechamento no código de estratégia, e não há necessidade de usar estruturas de loop como para, apenas a função embutidata.cum(close)Para outro exemplo, precisamos calcular o valor médio da diferença entre o preço mais alto e o preço mais baixo dos últimos 14 int representação BARs (ou seja, os 14 int representação BARs mais próximos do momento atual quando o código é executado), que pode ser escrito como:ta.sma(high - low, 14)

O resultado de chamar uma função em uma série de tempo também vai deixar um traço na série de tempo, novamente usamos o[]Por exemplo, ao testar se o preço de fechamento da representação int atual BAR excede o valor máximo do preço mais alto na última 10 representação int BAR (excluindo a representação int atual BAR).breach = close > ta.highest(close, 10)[1], e também podemos escreverbreach = close > ta.highest(close[1], 10)Então...ta.highest(close, 10)[1]eta.highest(close[1], 10)são equivalentes.

Esta informação pode ser verificada 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 produzirá os valores de a e b em cada BAR na série de tempo correspondente.

Argumentos de modelo da biblioteca de classe comercial de linguagem de pinho

Instruções para definir os argumentos do modelo incorporado Pine Language Trade Class Library da estratégia PINE.

Configurações de negociação

• Modo de execução Modelo de preço de encerramento: o modelo é executado apenas após a conclusão do BAR atual e a operação é executada quando o próximo BAR começa. Modelo de preço em tempo real: O modelo é executado toda vez que o preço se move e há um sinal para executar o comércio imediatamente.
• Se a ordem de negociação não especificar o montante da transação, a transação será executada de acordo com o montante fixado.
• Quantidade máxima de encomenda para uma única transação: Determinar o montante máximo de cada encomenda para evitar impactar o mercado de acordo com o mercado real e esta definição de argumento.
• Pontos de deslizamento: Determinação do deslizamento quando se faz uma encomenda de acordo com oPricing Currency PrecisionPor exemplo, a precisão da moeda de preço é definida em 2, que é precisa até o segundo ponto decimal, precisa para 0,01. Então, cada ponto de pontos de deslizamento representa 0,01 unidades de preço. Neste momento, o ponto de deslizamento é definido em 5, e o deslizamento ao colocar uma ordem é 0,05 (o deslizamento refere-se à parte do preço que transborda ao colocar uma ordem para melhor e negociação de ordem de desvantagem).
• O número de período mais longo da variável: afeta o número de K-line BAR no gráfico.SetMaxBarLenemjavascript srategy.

Opções de futuros

• Código de variedade: código do contrato, só precisa de ser definido quando o objeto de troca é um objeto de troca não pontual.
• O volume mínimo de negociação do contrato no momento da colocação de uma ordem.

Opções de negociação ao vivo

• Progresso de recuperação automática: recupera automaticamente o estado antes da última parada de estratégia.
• Tempos de tentativa de ordem: se a ordem não for preenchida, a ordem será cancelada e a ordem será substituída para tentar negociar.
• Intervalo de votação de rede (milissegundos): válido apenas para o protocolo REST, controla o intervalo de solicitação de rede para evitar que as solicitações sejam muito frequentes e excedam o limite de troca.
• Tempo de sincronização da conta (segundos): o período de tempo para sincronizar os dados da conta.
• Tempo de sincronização de posição após a abertura de uma posição (milissegundos): Somente para posições repetidas causadas por atrasos de dados em algumas bolsas, definir um tempo de sincronização maior pode aliviar tais problemas.
• Múltipla de alavancagem: define o múltiplo de alavancagem.

Negociação à vista, outras configurações

• Volume de negociação de um lote: o volume de negociação por defeito de um lote, válido apenas para o local.
• Volume mínimo de transacções: O volume mínimo de transacções.
• Precisão da moeda de preço: A precisão do preço, ou seja, o número de casas decimais no preço.
• Precisão da variedade de negociação: a precisão da quantidade da encomenda, ou seja, o número de casas decimais da quantidade da encomenda.
• Taxa de manipulação: Calcule alguns dados de acordo com esta definição, 0,002 significa 2/1000.
• Intervalo de estatísticas de lucros e perdas: é utilizado apenas para a apresentação de estatísticas de lucros e perdas no mercado real.
• Falha de tentativa de reinicialização (ms): intervalo de tentativa de reinicialização quando a solicitação de rede falha.
• Usar proxy: válido apenas para o protocolo REST.
• Ocultar erros de rede comuns: Ocultar registos de erros comuns na área de log.
• Endereço de base do interruptor: válido apenas para o protocolo REST.
• Notificações push: mensagens push para caixas de correio, etc.

Comércio de encomendas

Posição aberta

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

Posição de fechamento

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 comercial

O mecanismo de posição da linguagem PINE é semelhante à posição unidirecional. Por exemplo, ao manter uma posição na direção longa (posição longa), se houver uma ordem de operação de venda, uma ordem planejada, etc. (na direção oposta da posição), a execução será acionada, e a posição na direção longa será fechada primeiro. (Feche todas as posições longas), e depois execute a ordem acionada (na direção oposta em relação à posição antes do fechamento).

Ordem prevista

Quando você faz uma ordem usando o comando de colocação de ordem, se nenhum preço for especificado, o padrão é uma ordem de mercado. Além da ordem de mercado, você também pode fazer uma ordem por meio de uma ordem planejada, que não opera imediatamente para fazer uma ordem. A ordem planejada existe na fila de ordem planejada do programa quando não é acionada e pode ser vista na guia da tabela Planeada Ordem das informações de status (ou seja, a barra de status quando a estratégia está sendo executada) durante o processo de execução.Encomenda real/testes de retrospectivaO sistema só irá colocar uma ordem quando o preço de mercado em tempo real preencher as condições para desencadear estas ordens planeadas. Por conseguinte, é normal que estas ordens tenham um ligeiro desvio no preço do comércio.strategy.entryfunção para fazer um pedido, podemos especificar olimit, 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    

• ordem limite

  Quando a ordem é uma ordem de compra (ou seja, a ordem de compra é uma ordem de compra).directionO argumento éstrategy.long), a ordem só será activada quando o preço de mercado actual for inferior a este preço. Quando a ordem é uma ordem de venda (ou seja, a ordem de vendadirectionO argumento éstrategy.short), a ordem só será activada se o preço de mercado actual for superior a este preço.

• ordem de parada

  Quando a ordem é uma ordem de compra, a ordem só será acionada quando o preço de mercado atual for superior a este preço. Quando uma ordem for uma ordem de venda, a ordem só será acionada se o preço corrente do mercado for inferior a esse preço.

• ordem de limite de parada

  OlimitestopOs argumentos podem ser definidos ao mesmo tempo, e a ordem será acionada no preço que preencher as condições primeiro.

Ordem de percentagem do capital próprio

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

Após especificardefault_qty_type=strategy.percent_of_equity, definidodefault_qty_valueA quantidade da ordem é calculada de acordo com o montante da moeda denominada na conta. Por exemplo: se a conta corrente tiver 10.000 USDT, definir uma ordem de 1% significa colocar uma ordem com uma escala de 100 USDT (calculada com base no preço atual no momento da venda).

Declaração, estruturas lógicas palavras-chave

Var

var é uma palavra-chave usada para atribuir e inicialização única de variáveis. Em geral, a gramática de atribuição de variáveis que não contém a palavra-chave var faz com que o valor da variável s seja substituído toda vez que os dados são atualizados.

var variable_name = expression

Explicação:

• variable_name- Qualquer nome de uma variável de utilizador permitido em Pine Script (pode conter letras maiúsculas e minúsculas em latim, números e sublinhados (_), mas não pode começar por um número).
• expressionQualquer expressão aritmética, tal como definir uma variável regular, a expressão será avaliada e atribuída à variável uma vez.

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 contém o preço de fechamento da primeira barra de cada barra da série. A variável b contém o preço de encerramento da primeira barra de preços verde da série. A variável c detém o preço de fechamento da décima barra verde da série.

No FMZ, é dividido em modelo de preço em tempo real e modelo de preço de fechamento.varevarip.

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 preços em tempo real O código de teste acima é executado em duas fases: 1. fase de representação int histórica. 2. fase de representação int em tempo real.var, varipsão executados incrementalmente em cada rodada de execução de código de estratégia (porqueif trueAssim, pode-se ver que os números exibidos na representação int BAR do resultado do backtest são incrementados por 1 um por um. Quando a fase de representação int histórica termina, a fase de representação int em tempo real começa.var, varipporque é um modelo de preço em tempo real, o código de estratégia será executado uma vez para cada mudança de preço em uma representação int BAR,i := i + 1eii := ii + 1A diferença é que ii é modificado toda vez. Embora i também seja modificado toda vez, o valor anterior será restaurado quando a lógica de estratégia é executada na próxima rodada, e o valor de i não será atualizado até que a representação int atual BAR seja concluída (ou seja, o valor anterior não será restaurado quando a lógica de estratégia é executada na próxima rodada).

• Modelo de preço de encerramento Uma vez que o modelo de preço de fechamento executa a lógica de estratégia apenas uma vez por representação int BAR desaparecido.varevaripNo exemplo acima, comportam-se exatamente da mesma forma incrementalmente no modelo de preço de fechamento, tanto na fase de representação int histórica como na fase de representação int em tempo real, aumentando em 1 por representação int BAR.

variável

varip (var intrabar persist) é uma palavra-chave usada para atribuir e inicializar variáveis de uma só vez. É semelhante à palavra-chave var, mas uma variável declarada com varip mantém seu valor entre as atualizações do candelabro ao vivo.

varip variable_name = expression

Explicação:

• variable_name- Qualquer nome de uma variável de usuário permitido em um script Pine (pode conter letras maiúsculas e minúsculas em latim, números e sublinhas (_), mas não pode começar com um número).
• expression- Qualquer expressão aritmética, como o tempo definindo variáveis regulares.

Exemplo

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

Quando se usa var, o gráfico retornará o valor de bar_index. Com varip, o mesmo comportamento ocorre em barras históricas, mas em barras vivas, o gráfico retorna um valor que aumenta em um para cada tick.

ObservaçõesEle só pode ser usado com tipos simples como float, int, bool, string e matrizes desses tipos.

verdade

Representa o valor de uma variável bool, ou um valor que pode ser calculado quando uma expressão usa umcomparaçãooulógico. operator.

ObservaçõesConsulte as descrições deComparaçãoOperadores eÉ lógico. Operators.

Veja também: bool

Falso

Representa o valor de uma variável bool e o resultado de operações de comparação e operações lógicas.

ObservaçõesConsulte as descrições deComparaçãoOperadores eÉ lógico. Operators.

Veja também: bool

se

Uma instrução If define um bloco de instruções que devem ser executadas quando a condição de uma expressão é atendida.

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

Observações var_declarationX- Esta variável obtém o valor da declaração secondition- Se a condição for verdadeira, a lógica no bloco de declaraçãothené utilizado (var_decl_then0, var_decl_then1, etc.). Se a condição for falsa, a lógica no bloco de instruçõeselse ifouelseé utilizado (var_decl_else0, var_decl_else1, etc.).return_expression_thenereturn_expression_else- A última expressão do módulo ou a expressão do bloco else devolve o valor final da instrução.

O tipo do valor de retorno da instrução if depende do tipo dereturn_expression_thenereturn_expression_else. Quando executado no TradingView, seus tipos devem ser correspondidos: quando você tem um valor de cadeia no bloco else, não é possível retornar um valor inteiro do bloco em questão. Quando executado no FMZ, o exemplo a seguir não relatará um erro. Quando o valor y é open, o valor do gráfico ao desenhar é 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)

OelseNeste caso, se a condição for falsa, a variável var_declarationX é atribuída um valor vazio (na, falso ou ):

Exemplo

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

Os blocos de then, else if, else são movidos quatro espaços:

Exemplo

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

O valor resultante doifPode ser útil se você precisar de efeitos colaterais de expressões, por exemplo, na negociação de estratégia:

Exemplo

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

Se as instruções podem conter-se mutuamente:

Exemplo

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

para

A construção for permite que várias instruções sejam executadas repetidamente:

[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 opcional que será atribuída como o valor da expressão return_expression do loop.counter- Uma variável que mantém o valor do contador do loop, incrementando/decrementando em 1 ou o valor step_num em cada iteração do loop.from_num- O valor inicial do contador.to_num- O valor final do contador. O loop quebra quando o contador é maior que to_num (ou menor que to_num no caso de from_num > to_num).step_num- O valor de incremento/decremento do contador. É opcional. O padrão é +1 ou -1, dependendo do maior de from_num ou to_num. Ao usar valores, o contador também é incrementado/decrementado de acordo com o maior de from_num ou to_num, então o sinal +/- de step_num é opcional.statements | continue | break- Qualquer número de instruções, ou as palavras-chave continue ou break, recuadas por 4 espaços ou uma única aba.return_expression- O valor de retorno do loop, se presente, é atribuído à variável em var_declaration. Se o loop sair devido às palavras-chave continue ou break, o valor de retorno do loop é o valor de retorno da última variável atribuída um valor antes da saída do loop.continue- Uma palavra-chave que só pode ser usada em loops, faz com que a próxima iteração do loop seja executada.break- A palavra-chave para sair do circuito.

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

Para... para dentro.

Ofor...inconstruct permite que várias instruções sejam repetidas para cada elemento da matriz.array_element, ou com dois argumentos:[index, array_element]A segunda forma não afeta a função do loop. Ele mantém o controle do índice da iteração atual na primeira variável da tupla.

[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 opcional a que será atribuído o valor dos circuitosreturn_expression. index- Uma variável opcional que acompanha o índice de iteração atual. O índice começa em 0. As variáveis são imutáveis dentro do corpo do loop. Quando usado, ele deve estar contido em uma tupla que também contenhaarray_element. array_element- Uma variável que contém cada elemento de matriz consecutivo a ser processado no loop.array_id- O ID da matriz da iteração do loop.statements | continue | break- Qualquer número de instruções, ou as palavras-chave continue ou break, recuadas por 4 espaços ou uma única aba.return_expression- O valor de retorno do loop é atribuído à variável emvar_declarationSe o loop sair devido às palavras-chave continue ou break, o valor de retorno do loop é a variável que foi atribuída pela última vez antes do loop sair.continue- Uma palavra-chave que só pode ser usada em loops, faz com que a próxima iteração do loop seja executada.break- A palavra-chave para sair do circuito.

Permite modificar elementos de uma matriz ou seu tamanho dentro de um loop. Aqui, usamos a forma de um argumento defor...inPara determinar, para cada barra, quantas barras têm um valor OHLC superior à SMA do valor close:

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 argumentos de para... para definir os valores de nossoisPosmatriz paratrueQuando os seus valores correspondentes em nossovaluesArrayAs matrizes são positivas:

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

enquanto

Owhiledeclaração permite iteração condicional de blocos de código nativos.

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

Explicação:variable_declaration- Declaração opcional de variáveis.return expressionpode fornecer um valor de inicialização para esta variável.boolean_expression- Se for verdade, executar o bloco local dowhileSe for falso, a execução do script continua após owhile statement. continue- Ocontinuepalavra-chave faz com que o loop se ramifique para a próxima iteração.break- ObreakA execução do script é retomada após owhile statement. return_expression- Linha opcional que fornece o valor de retorno dowhile statement.

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)

ObservaçõesO bloco de código nativo após a inicialwhileA linha deve ser recuada por quatro espaços ou uma aba.whileloop, a expressão booleana seguintewhiledeve eventualmente tornar-se falsa, oubreakdeve ser executado.

Mudança

O operador do switch transfere o controlo para uma das várias instruções com base na condição e no valor 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

comutação com expressão:

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)

comutação 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)

RetornoO valor da última expressão no bloco de instruções local executado.

ObservaçõesApenas um doslocal_blockinstâncias oudefault_local_blockpode ser executado.default_local_blockA introdução do novo sistema de=>O resultado de um bloco é executado apenas se o bloco anterior não for executado.switchdeclaração é atribuída a uma variável edefault_local_blocknão é especificado, a instrução retornanaselocal_blockQuando atribuir o resultado de umswitchdeclaração para uma variável, todoslocal_blockAs instâncias devem retornar um valor do mesmo tipo.

Veja também: if ?:

série

série é uma palavra-chave que indica o tipo de série de dados.series keyword.

Operador

=

Utilizado para atribuir valores a variáveis, mas apenas quando a variável é declarada (utilizada pela primeira vez).

:=

O operador de atribuição atribui um valor à variável à esquerda.

!=

Aplicável a expressões de qualquer tipo.

expr1 != expr2

RetornoValor booleano, ou uma sequência de valores booleanos.

%

Modulo (resíduo inteiro), aplicável a expressões numéricas.

expr1 % expr2

RetornoValor inteiro ou flutuante, ou série de valores.

ObservaçõesEm Pine Script, quando o restante inteiro é calculado, o quociente é truncado, ou seja, arredondado para o valor absoluto mais baixo.

Exemplo: -1 % 9 = -1 - 9 * truncado(-1/9) = -1 - 9 * truncado(-0,111) = -1 - 9 * 0 = -1.

%=

Atribuição de módulo, aplicável a expressões numéricas.

expr1 %= expr2

Exemplo

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

RetornoValor inteiro ou flutuante, ou série de valores.

*

Atribuição de multiplicação, aplicável a expressões numéricas.

expr1 * expr2

RetornoValor inteiro ou flutuante, ou série de valores.

*=

Atribuição de multiplicação, aplicável a expressões numéricas.

expr1 *= expr2

Exemplo

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

RetornoValor inteiro ou flutuante, ou série de valores.

+

Adição ou unário mais. Aplicável a expressões numéricas ou cadeias.

expr1 + expr2

+ expr

RetornoO binário+da cadeia retorna a combinação de expr1 e expr2 Numero devolve um inteiro ou um valor de ponto flutuante ou uma sequência de valores: Binário + retorna expr1 mais expr2. Unário + retorna expr (nada é adicionado à simetria do operador unário).

ObservaçõesVocê pode usar operadores aritméticos com números, bem como com variáveis de série.

+=

Atribuição aditiva Aplica-se a expressões numéricas ou cordas.

expr1 += expr2

Exemplo

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

RetornoPara strings, retorna a concatenação de expr1 e expr2. Para números, retorna um inteiro ou valor flutuante, ou série de valores.

ObservaçõesVocê pode usar operadores aritméticos com números, bem como com variáveis de série.

-

Subtração ou menos unário, aplicável a expressões numéricas.

expr1 - expr2

- expr

RetornoRetorna um valor inteiro ou com ponto flutuante, ou uma série de valores: Binário + retorna expr1 menos expr2. Unário-Retorna a negação de expr.

ObservaçõesVocê pode usar operadores aritméticos com números, bem como com variáveis de série.

-=

Assegnação de subtração, aplicável a expressões numéricas.

expr1 -= expr2

Exemplo

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

RetornoValor inteiro ou flutuante, ou série de valores.

/

Assegnação de divisão, aplicável a expressões numéricas.

expr1 / expr2

RetornoValor inteiro ou flutuante, ou série de valores.

/=

Assegnação de divisão, aplicável a expressões numéricas.

expr1 /= expr2

Exemplo

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

RetornoValor inteiro ou flutuante, ou série de valores.

<

Aplicável a expressões numéricas.

expr1 < expr2

RetornoValor booleano, ou série de valores booleanos.

<=

Menor ou igual a. Aplicável a expressões numéricas.

expr1 <= expr2

RetornoValor booleano, ou série de valores booleanos.

==

Aplicável a expressões de qualquer tipo.

expr1 == expr2

RetornoValor booleano, ou série de valores booleanos.

=>

O operador => é utilizado em declarações de funções definidas pelo utilizador e emswitch statements.

A gramática da declaração de função é:

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

A<local_block>é zero ou mais instruções de Pine Script.<function_result>é uma variável, uma expressão ou uma tupla.

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

ReacçõesVocê pode aprender mais sobre funções definidas pelo usuário nas páginas do Manual do usuário sobre declaração de funções e bibliotecas de script.

>

Maior que. Aplicável a expressões numéricas.

expr1 > expr2

RetornoValor booleano, ou série de valores booleanos.

>=

Maior que ou igual a. Aplicável a expressões numéricas.

expr1 >= expr2

RetornoValor booleano, ou série de valores booleanos.

?:

Operador condicional ternário.

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)

Retornoexpr2 se expr1 for avaliado como verdadeiro, expr3 de outra forma. O valor zero (0 e também NaN, +Infinity, -Infinity) é considerado falso, qualquer outro valor é verdadeiro.

ObservaçõesUse na para else ramo se não precisar dele. Você pode combinar dois ou mais operadores?: para obter o equivalente a uma declaração semelhante a switch (ver exemplos acima). Você pode usar operadores aritméticos com números, bem como com variáveis de série.

Veja também: na

[]

O subscrito da série fornece acesso aos valores anteriores da série expr1. expr2 é o número de barras no passado, e deve ser numérico.

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)

RetornoUma série de valores.

Veja também: math.floor

e

Aplicável a expressões booleanas.

expr1 and expr2

RetornoValor booleano, ou série de valores booleanos.

ou

OR lógico, aplicável a expressões booleanas.

expr1 or expr2

RetornoValor booleano, ou série de valores booleanos.

Não, não.

Negativa lógica (NOT). Aplicável a expressões booleanas.

not expr1

RetornoValor booleano, ou série de valores booleanos.

Palavras-chave de tipo de dados

Bool

Palavra-chave usada para declarar explicitamente o tipo bool (booleano) de uma variável ou de um argumento.

Exemplo

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

ObservaçõesMencionar explicitamente o tipo em uma declaração de variável é opcional, exceto quando é inicializado com na. Saiba mais sobre tipos de Pine Script na página do Manual do Usuário no Sistema de Tipos.

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

int

Palavra-chave utilizada para declarar explicitamente o tipo int (integer) de uma variável ou de um argumento.

Exemplo

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

ObservaçõesMencionar explicitamente o tipo em uma declaração de variável é opcional, exceto quando é inicializado com na. Saiba mais sobre tipos de Pine Script na página do Manual do Usuário no Sistema de Tipos.

Veja também: var varip float bool color string

flutuante

Palavra-chave utilizada para declarar explicitamente o tipo float (ponto flutuante) de uma variável ou de um argumento.

Exemplo

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

ObservaçõesMencionar explicitamente o tipo numa declaração de variável é opcional, exceto quando é inicializado com na.

Veja também: var varip int bool color string

cordel

Palavra-chave utilizada para declarar explicitamente o tipo string de uma variável ou de um argumento.

Exemplo

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

ObservaçõesMencionar explicitamente o tipo em uma declaração de variável é opcional, exceto quando é inicializado com na. Saiba mais sobre tipos de Pine Script na página do Manual do Usuário no Sistema de Tipos.

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

cor

Palavra-chave utilizada para declarar explicitamente o tipo color de uma variável ou de um argumento.

Exemplo

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

ObservaçõesOs literais de cores têm o seguinte formato: #RRGGBB ou #RRGGBBAA. Os pares de letras representam valores hexadecimais de 00 a FF (0 a 255 em decimal), onde os pares RR, GG e BB são os valores dos componentes vermelho, verde e azul das cores. AA é um valor opcional para a transparência das cores (ou componente alfa), onde 00 é invisível e FF opaco. Quando nenhum par AA é fornecido, FF é usado. As letras hexadecimais podem ser maiúsculas ou minúsculas.

Mencionar explicitamente o tipo em uma declaração de variável é opcional, exceto quando é inicializado com na. Saiba mais sobre tipos de Pine Script na página do Manual do Usuário no Sistema de Tipos.

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

matriz

Palavra-chave usada para declarar explicitamente o tipo array de uma variável ou um argumento.array.new<type>, array.from function.

Exemplo

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

ObservaçõesObjetos de matriz são sempre de forma série.

Veja também: var array.new array.from

Objetos

Objetos na linguagem PINE são instâncias de tipos definidos pelo usuário (UDTs), que podem ser entendidos como classes sem método que permitem que os usuários criem tipos personalizados em estratégias para organizar diferentes valores em uma entidade.

Definição dos tipos

Vamos definir um tipo de ordem para armazenar informações de ordem:

type order
    float price
    float amount
    string symbol

• Os tipos são declarados utilizando otype keyword.
• A palavra-chave do tipo é seguida pelo nome do tipo.
• O primeiro tipo de linha define o nome do tipo, indentado em quatro espaços e define os campos contidos no tipo.
• Cada campo precisa declarar o seu tipo de dados, como int, float, string.

Criação de objetos

Utilizando o tipo declarado, chamar onew()função para criar um objeto:

order1 = order.new()

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

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

Você também pode 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)   // Output {"data":{"price":46002.8,"amount":1,"symbol":"swap"},"_meta":0,"_type":"order"}

Neste exemplo:

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

Também pode ser escrito 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 a utilização 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 você usa a palavra-chave var para declarar uma variável atribuída a um objeto de um tipo definido pelo usuário, a palavra-chave se aplica automaticamente a todos os campos do objeto.

• O objeto firstBar é declarado usando a palavra-chave var, de modo que seus campos (índice, preço, volume) manterão seus valores em cada iteração, começando com a primeira entrada e terminando com a última entrada.
• O objeto currentBar não é declarado com a palavra-chave var, então seus campos serão reinicializados em cada entrada e você terá um novo objeto em cada iteração.

Ao traçar os campos de índice dos dois objetos, você pode comparar as diferenças entre eles. firstBar.index manterá o valor definido anteriormente em cada iteração, enquanto currentBar.index será reinicializado em cada iteração para o valor bar_index da entrada atual.

Tipos de objetos para utilização da palavra-chave 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, a palavra-chave varip é usada para indicar que os campos de um objeto persistem durante toda a execução do script e não retornam em barras não confirmadas. Na declaração do tipo Counter, o campo de barras não usa a palavra-chave varip, então ele rola de volta em cada barra não confirmada. O objeto contador é declarado usando a palavra-chave var, então ele persiste durante toda a execução do script. Em cada iteração, tanto o campo de barras quanto o campo de ticks são incrementados em 1. Por fim, ao traçar os campos counter.bars e counter.ticks, você pode comparar a diferença entre eles. O valor de counter.bars retrocede em cada barra não confirmada, enquanto o valor de counter.ticks continua a aumentar até o final da execução do script.

Mais.