Inventor de Tutoriais de Introdução à Língua PINE

Autora:Sonhos pequenos, Criado: 2022-05-30 16:23:43, Atualizado: 2022-09-28 17:10:21

[TOC]

Inventor de Tutoriais de Introdução à Língua PINE

O vídeo acompanha o tutorial:Quantificar negociações é muito difícil de começar? Usar o modo de negociação Pine para começar a explorar a linguagem.

A plataforma de negociação quantitativa do inventor suporta políticas de redação da linguagem Pine, suporte a retrospecção, execução em disco rígido de políticas da linguagem Pine, compatibilidade com versões mais baixas da linguagem Pine.FMZ.COM(em inglês)Praça da EstratégiaO site também oferece uma ampla gama de ferramentas para pesquisar e transferir as políticas do Pine (script).

O FMZ não só suporta a linguagem Pine, mas também o poderoso gráfico da linguagem Pine. As funções do FMZ, a riqueza de ferramentas úteis, o gerenciamento eficiente e fácil, também aumentam ainda mais a utilidade da política do Pine. O FMZ é baseado na compatibilidade com a linguagem Pine, e também faz um certo número de extensões, otimizações e recortes no idioma Pine.

O que você pode fazer para evitar que o vírus se espalhe por todo o mundo é simplesmente dar um breve resumo das diferenças mais óbvias:

1, Política de Pine no FMZ, código inicial de marcação de versão//@versionComeçou com o códigostrategy、indicatorA expressão não é obrigatória e o FMZ não está disponível.importImportaçãolibraryA função de.

O que você pode ver em algumas estratégias é:

//@version=5
indicator("My Script", overlay = true)
src = close
a = ta.sma(src, 5)
b = ta.sma(src, 50)
c = ta.cross(a, b)
plot(a, color = color.blue)
plot(b, color = color.black)
plotshape(c, color = color.red)

Ou seja:

//@version=5
strategy("My Strategy", overlay=true)

longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
if (longCondition)
    strategy.entry("My Long Entry Id", strategy.long)

shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))
if (shortCondition)
    strategy.entry("My Short Entry Id", strategy.short)

O FMZ pode ser simplificado como:

src = close
a = ta.sma(src, 5)
b = ta.sma(src, 50)
c = ta.cross(a, b)
plot(a, color = color.blue, overlay=true)
plot(b, color = color.black, overlay=true)
plotshape(c, color = color.red, overlay=true)

Ou:

longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
if (longCondition)
    strategy.entry("My Long Entry Id", strategy.long)

shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))
if (shortCondition)
    strategy.entry("My Short Entry Id", strategy.short)

2, política (script) Algumas configurações relacionadas a transações são definidas pelo parâmetro "Pine Language Transaction Library" na interface da política FMZ.
- Modelos de preços de fechamento e modelos de preços em tempo real No Trading View, podemos usarstrategyFunçõescalc_on_every_tickParâmetros para configurar o script de estratégia para executar a lógica de estratégia em tempo real a cada mudança de preço.calc_on_every_tickOs parâmetros devem ser definidos comotruePor defeito.calc_on_every_tickOs parâmetros são:falseA partir daí, a estratégia é executada somente quando a linha K BAR do atual programa estiver completamente desligada. No FMZ, os parâmetros do modelo "Pine Language Exchange Library" são definidos.
- Preço, quantidade de unidades, etc. precisão numérica de controle na execução da política é necessária para ser especificado no FMZ Na visão de negociação, não há problemas de precisão no momento do pedido em tempo real, pois só é possível fazer testes de simulação. No FMZ, a estratégia Pine pode ser executada em tempo real. Então, a estratégia precisa especificar com flexibilidade a precisão do preço da variedade de negociação, a precisão do número de pedidos. Esses ajustes de precisão controlam os pequenos dígitos dos dados relevantes, evitando que os dados não atendam aos requisitos de anúncios da bolsa e não possam ser pedidos.
- Código de contrato de futuros A variedade de negociação no FMZ, se for um contrato, possui duas propriedades. Os atributos são "pares de negociação" e "código de contrato", que, além de ser necessário definir claramente os pares de negociação no disco real e no retrospecto, também exigem o código de contrato específico no parâmetro "código de variedade" do modelo "Pine Language Trading Library"; por exemplo, um contrato permanente é preenchido.swapO código do contrato é específico para o mercado em que o negócio é realizado. Por exemplo, alguns negócios contam com todos os contratos trimestrais, onde você pode preencher.quarterO código destes contratos é o mesmo que o código dos contratos futuros definidos na API da linguagem Javascript/python/c++ da FMZ.
Outras configurações, como o mínimo de sub-unidades, o sub-unidades padrão, etc., podem ser consultadas na documentação da linguagem Pine."Pine Language Exchange Library" (Livro de Troca de Línguas em Pinheiros)Introdução aos parâmetros.
3、runtime.debug 、runtime.log、runtime.errorFunções da extensão FMZ, para depuração.

Três funções foram adicionadas à plataforma FMZ para o debug.
- runtime.debugA função não é geralmente usada para imprimir informações de variáveis no console.
- runtime.log: Exportação de conteúdo no diário.. FMZ PINE tem função específica..
```
runtime.log(1, 2, 3, close, high, ...)，可以传多个参数。
```
- runtime.error: quando chamado, causa erros de execução e traz mensagens de erro especificadas no parâmetro de mensagem.
```
runtime.error(message)
```
4 e expandido em funções gráficasoverlayParâmetros

A linguagem Pine no FMZ, funções gráficasplot、plotshape、plotcharE assim por diante.overlaySuporte de parâmetros, permitindo especificar imagens no diagrama principal ou no subdiagrama.overlayConfiguraçãotrueA imagem foi colocada no diagrama principal.falseDesenhar em sub-gráficos. Fazer com que a política Pine no FMZ seja executada para desenhar sub-gráficos e sub-gráficos simultaneamente.
5、syminfo.mintickValorização de variáveis internas

syminfo.mintickA variável intrínseca é definida como o valor mínimo da variedade atual; em FMZDisco real/RevisãoO parâmetro do modelo no "Pine Language Trading Library" na interface permite controlar o valor de precisão da moeda de preço. A precisão da moeda de preço é definida como 2 para que o preço seja preciso até o segundo ponto decimal quando o preço é negociado, quando a unidade mínima de variação do preço é de 0.01.syminfo.mintickO valor é 0.01 ∞.
6. Os preços médios no FMZ PINE Script são os preços que incluem as taxas de manutenção

Por exemplo: o preço do pedido é de 8000, a direção de venda, o número de mãos é de 1 (um, dois), o preço médio após a transação não é de 8000, menos de 8000 (o custo inclui taxas de processamento).

Base da língua pine

Quando começamos a aprender o básico da linguagem Pine, podemos não estar familiarizados com as instruções e a gramática do código em alguns exemplos. Não importa, podemos familiarizar-nos com o conceito, entender o objetivo do teste, ou consultar a documentação da linguagem Pine do FMZ para ver as instruções. Em seguida, siga o tutorial passo a passo para se familiarizar gradualmente com a gramática, instruções, funções e variáveis internas.

Execução do modelo

É muito necessário conhecer conceitos relacionados, como o processo de execução de um script da linguagem Pine, para começar a aprender. As estratégias da linguagem Pine são baseadas em gráficos e podem ser entendidas como uma série de cálculos e operações executadas em gráficos em ordem cronológica, começando com os primeiros dados que já foram carregados. O volume de dados carregados inicialmente é limitado. O tempo real geralmente é determinado pelo volume máximo de dados retornados pela interface de troca, e o limite de tempo de retorno é determinado pelos dados fornecidos pela fonte de dados do sistema de retorno. A primeira linha KBar, a primeira linha da esquerda do gráfico, ou seja, o primeiro dado do conjunto de dados do gráfico, cujo valor de índice é 0.bar_indexReferindo-se ao valor de índice da linha KBar atual na execução do script Pine.

plot(bar_index, "bar_index")

plotA função é uma das funções que mais usaremos no futuro. A utilização é muito simples, é desenhar linhas no gráfico de acordo com os parâmetros transmitidos, os dados transmitidos são:bar_indexA linha é chamadabar_indexPode-se ver que o valor da linha chamada bar_index no primeiro nome Bar é 0, com o aumento do Bar para a direita aumentando 1 em seguida.

Dependendo da configuração da estratégia, o modelo de execução da estratégia também é diferente, dividido em:收盘价模型e实时价模型O conceito de modelo de preço de fechamento, modelo de preço em tempo real, também foi apresentado anteriormente.

Modelo de preços de fechamento

Quando o código da estratégia é executado, o ciclo da linha KBar atual é totalmente executado, o que significa que o ciclo da linha K está terminado quando a linha K é fechada. Ao executar a lógica da estratégia Pine novamente, o sinal de negociação desencadeado será executado no início da próxima linha KBar.
Modelo de preços em tempo real

Quando o código de estratégia é executado, o K-line Bar atual é executado de forma instantânea, independentemente de ser fechado ou não.

Quando a política da linguagem Pine é executada da esquerda para a direita no gráfico, a linha KBar no gráfico é dividida em历史Bare实时BarO que é isso?

História Bar

Quando a estratégia é configurada para "modelo de preço real" e começa a ser executada, todas as K-lines Bar no gráfico, exceto a linha K Bar no extremo direito, são历史BarA lógica estratégica está em cada uma delas.历史BarA função pode ser executada apenas uma vez. Quando a estratégia é configurada para "modelo de preço de fechamento" e começa a ser executada, todos os Bar no gráfico são历史BarA lógica estratégica está em cada uma delas.历史BarA função pode ser executada apenas uma vez.

Computação baseada no histórico Bar: O código da estratégia é executado uma vez no estado de fechamento da História Bar, e então o código da estratégia continua a ser executado na próxima História Bar até que todas as Histórias Bar sejam executadas uma vez.
Bar em tempo real

Quando a estratégia é executada no último K-line Bar no extremo direito, o Bar é chamado de Bar em tempo real. Quando o Bar em tempo real é fechado, ele se transforma em um Bar em tempo real passado (que se torna um Bar histórico).

Quando a estratégia é configurada para "modelo de preço em tempo real", a lógica estratégica é executada uma vez por cada mudança de mercado no Bar em tempo real. A política definida como "modelo de preço de fechamento" não mostra o Bar em tempo real no gráfico quando é executada.

Computação baseada no Bar em tempo real: Se a política for definida como "modelo de preço de fechamento" e o gráfico não mostrar o Bar em tempo real, o código da política será executado apenas uma vez no fechamento do Bar atual. Se a política for definida como "modelo de preço real", o cálculo no Bar real e o Bar histórico são completamente diferentes, e um código de política é executado para cada mudança de mercado no Bar real; por exemplo, uma variável interna.high、low、closeNo Bar histórico, é certo que esses valores podem mudar a cada vez que o mercado muda no Bar real; portanto, dados como indicadores calculados com base nesses valores também podem mudar em tempo real.closeO preço é sempre o preço mais recente do momento.highelowSempre representam os máximos e mínimos máximos alcançados desde o início do actual Real-time Bar. Estas variáveis embutidas representam o valor final quando o Real-time Bar foi atualizado pela última vez.

Mecanismo de retrocesso quando a estratégia é executada no Bar em tempo real (modelo de preço em tempo real): Quando executado no Bar em tempo real, a variável definida pelo usuário que é reiniciada antes da execução de cada nova iteração da política é chamada de reverter. Para entender o mecanismo de reverter, vamos usar um exemplo do código de teste abaixo.

Atenção:
```
/*backtest 
...
..
.
*/
```
O conteúdo do pacote é a informação de configuração de retrospecção guardada em forma de código na plataforma FMZ.
```
/*backtest
start: 2022-06-03 09:00:00
end: 2022-06-08 15:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/

var n = 0
if not barstate.ishistory
    runtime.log("n + 1之前, n:", n, " 当前bar_index:", bar_index)
    n := n + 1
    runtime.log("n + 1之后, n:", n, " 当前bar_index:", bar_index)
  
plot(n, title="n")
```
Nós só examinamos as cenas executadas em tempo real Bar, então usamosnot barstate.ishistoryA restrição de expressão é apenas para a soma de n variáveis em tempo real Bar e é usada antes e depois de executar a operação de soma.runtime.logA função produz informações no registro da política.plotA curva desenhada n pode ser vista como 0 quando a política foi executada no histórico Bar. Quando executada até o Bar em tempo real, a operação foi desencadeada com n acrescidos de 1, e a operação foi executada com n acrescidos de 1 por cada rodada de execução da política no Bar em tempo real. Pode ser observado a partir da informação do log que n é reiniciado para o valor final da política anterior quando a política foi executada em cada rodada.

Afinal, o que se passa é que a gente não tem dinheiro. Quando a política é executada no Bar em tempo real, um código de política é executado a cada atualização de caixa. 2, quando executado no Bar em tempo real, a variável é revertida antes de cada execução do código da política. 3, quando executado no Bar em tempo real, a variável é submetida uma vez na atualização de encerramento.

Como os dados são reversíveis, as operações de gráficos como curvas em gráficos também podem causar redesenhos, por exemplo, modificamos o código do teste que acabamos de fazer, o teste de disco real:
```
var n = 0
if not barstate.ishistory
    runtime.log("n + 1之前, n:", n, " 当前bar_index:", bar_index)
    n := open > close ? n + 1 : n
    runtime.log("n + 1之后, n:", n, " 当前bar_index:", bar_index)
  
plot(n, title="n")
```
Imagens do momento A

Imagens do momento B

A única coisa que alteramos é esta frase:n := open > close ? n + 1 : nNo primeiro gráfico, podemos ver que no momento A, n é adicionado a 1, porque o preço de abertura é maior do que o preço de fechamento. O valor da curva n é 5 e, em seguida, o movimento, a atualização do preço é exibido como no segundo gráfico. Neste momento, o preço de abertura é menor do que o preço de fechamento.
Contexto das variáveis na função

A seguir, vamos examinar as variáveis dentro das funções da linguagem Pine. De acordo com as descrições de alguns tutoriais da linguagem Pine, as variáveis dentro das funções diferem das variáveis fora delas:

O histórico das variáveis de série utilizadas na função Pine é criado por cada chamada consecutiva da função. Se a função não for chamada em cada coluna executada pelo script, isso resultará em uma diferença entre os valores históricos dentro do local da função e os valores históricos da série externa. Portanto, se a função não for chamada em cada coluna, as séries com o mesmo valor de índice dentro e fora da função não referirão ao mesmo ponto histórico.

Não é um pouco difícil de ler? Tudo bem, nós resolvemos o problema com um código de teste que está sendo executado no FMZ:
```
/*backtest
start: 2022-06-03 09:00:00
end: 2022-06-08 15:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
  
f(a) => a[1]
f2() => close[1]  

oneBarInTwo = bar_index % 2 == 0
plotchar(oneBarInTwo ? f(close) : na, title = "f(close)", color = color.red, location = location.absolute, style = shape.xcross, overlay = true, char = "A")   
plotchar(oneBarInTwo ? f2() : na, title = "f2()", color = color.green, location = location.absolute, style = shape.circle, overlay = true, char = "B")   
plot(close[2], title = "close[2]", color = color.red, overlay = true)
plot(close[1], title = "close[1]", color = color.green, overlay = true)
```
Retrospecção de imagem de execução

O código de teste é relativamente simples e é usado principalmente para examinar dados citados de duas maneiras:f(a) => a[1]ef2() => close[1]。
- f(a) => a[1]Como usar um parâmetro de transmissão para retornar a funçãoa[1]。
- f2() => close[1]A partir daí, o usuário pode usar a função "configure"closeA função retorna no final.close[1]。
[]O símbolo é usado para a operação de referência de valores históricos de variáveis da série de dados, close[1] que é uma referência ao preço de fechamento no Bar anterior ao preço de fechamento atual. Nosso código de teste traça 4 dados no gráfico:
- plotchar(oneBarInTwo ? f(close) : na, title = "f(close)", color = color.red, location = location.absolute, style = shape.xcross, overlay = true, char = "A")Desenhe um caracter A, colorido em vermelho, apenas quando oneBarInTwo for verdadeiro, e a posição desenhada (no eixo Y) é:f(close)O valor de retorno.
- plotchar(oneBarInTwo ? f2() : na, title = "f2()", color = color.green, location = location.absolute, style = shape.circle, overlay = true, char = "B")Desenhe um símbolo B, colorido em verde, apenas quando oneBarInTwo for verdadeiro, e o posicionamento desenhado (no eixo Y) é:f2()O valor de retorno.
- plot(close[2], title = "close[2]", color = color.red, overlay = true)A linha de desenho, colorida em vermelho, é desenhada (no eixo Y):close[2]Ou seja, o preço de fechamento no Bar, na segunda linha anterior ao número Bar atual (de 2 para a esquerda).
- plot(close[1], title = "close[1]", color = color.green, overlay = true)A linha desenhada, colorida em verde, e a posição desenhada (no eixo Y) é:close[1]Ou seja, o preço de fechamento no Bar, na linha 1 anterior ao número Bar atual (de 1 para a esquerda).
Os screenshots executados através da retrospecção da estratégia podem ser vistos, embora a função usada na figura A seja marcadaf(a) => a[1]Funções usadas para marcar a imagem Bf2() => close[1]Todos são usados[1] para referenciar dados históricos em séries de dados, mas a posição da marca "A" e "B" no gráfico é completamente diferente. A posição da marca "A" sempre cai na linha vermelha, ou seja, o código na estratégia.plot(close[2], title = "close[2]", color = color.red, overlay = true)A linha desenhada é a linha que usa dados.close[2]。

A razão é através do índice da linha KBar, ou seja, a variável interna.bar_indexCalcular se a marcação "A" e "B" é feita. A marcação "A" e "B" não é feita em cada linha KBar.f(a) => a[1]O valor que é citado dessa forma é comparado com a função se a função não for chamada em cada bar.f2() => close[1]Este método cita valores diferentes (mesmo que seja usado o mesmo índice, como [1]).
Algumas funções embutidas precisam ser calculadas em cada Bar para calcularem seus resultados corretamente.

A situação é ilustrada por um exemplo simples:
```
res = close > close[1] ? ta.barssince(close < close[1]) : -1
plot(res, style = plot.style_histogram, color=res >= 0 ? color.red : color.blue)
```
Vamos chamar a função para o código.ta.barssince(close < close[1])Escreve-se num operador triangular.condition ? value1 : value2O que é que isso significa?close > close[1]时去调用ta.barssince函数。可偏偏ta.barssinceA função está a calcular a partir da última vez.close < close[1]O número de linhas K no momento da criação; quando a função ta.barssince é chamada, é close > close[1], ou seja, o preço de fechamento atual é maior que o preço de fechamento do último Bar, e a função ta.barssince não é executada quando a condição close < close[1] é chamada, nem há uma posição mais recente.

Ta.barssince: Quando chamada, a função retorna na se a condição nunca foi atendida antes da linha K atual.

A imagem é a seguinte:

Assim, quando se desenha, apenas se desenha dados quando a variável res tem um valor ((-1) ∞.

Para evitar esse problema, podemos simplesmente usar ota.barssince(close < close[1])As chamadas de funções são retiradas dos operadores triangulares e escritas no exterior de qualquer ramificação de condições possíveis; permitindo que elas executem cálculos em cada linha KBar.
```
a = ta.barssince(close < close[1])
res = close > close[1] ? a : -1
plot(res, style = plot.style_histogram, color=res >= 0 ? color.red : color.blue)
```

Sequência de tempo

O conceito de sequência de tempo é muito importante na linguagem Pine e é um conceito que devemos entender quando aprendemos a linguagem Pine. A sequência de tempo não é um tipo, mas a estrutura básica de uma continuidade de valores de variáveis armazenadas ao longo do tempo.openÉ uma variável embutida (built-in) da linguagem Pine, cuja estrutura é para armazenar a sequência de tempo do preço de abertura de cada linha KBar. Pode ser entendida como:openEsta estrutura de sequência de tempo representa o preço de abertura de todas as K-strings no K-string atual, desde o primeiro Bar no início até o Bar no momento em que o script atual é executado. Se o K-string atual for um ciclo de 5 minutos, então citamos (ou usamos) no código da estratégia PineopenO tempo é o preço de abertura da linha KBar na execução atual do código da estratégia.[]Operador. Use quando a política Pine é executada em uma linha KBar.open[1]Indica a referênciaopenO preço de abertura da linha KBar anterior a esta linha KBar executada pelo script atual na sequência de tempo (ou seja, o preço de abertura do último ciclo da linha K).

As variáveis na sequência de tempo são muito fáceis de calcular. Então nós temos uma função interna.ta.cumPor exemplo:

ta.cum

Cumulative (total) sum of `source`. In other words it's a sum of all elements of `source`.
ta.cum(source) → series float
RETURNS
Total sum series.
ARGUMENTS
source (series int/float)
SEE ALSO
math.sum

Código de teste:

v1 = 1
v2 = ta.cum(v1)
plot(v1, title="v1")
plot(v2, title="v2")
plot(bar_index+1, title="bar_index")

Há muitas semelhanças.ta.cumEsta função embutida pode processar diretamente dados da sequência de tempo, comota.cumO primeiro passo é somar os valores correspondentes a cada K-lineBar, e depois usamos um gráfico para facilitar o entendimento.

Processo de execução estratégica	Variação interna bar_index	V1	V2
A estratégia é executada na primeira linha KBar	0	1	1
A estratégia é executada na 2a linha KBar.	1	1	2
A estratégia é executada na terceira linha K, Bar.	2	1	3
…	…	…	…
A estratégia é executada na n + 1a linha K Bar.	N	1	N+1

Como pode ser visto, na verdade v1, v2 e até mesmo bar_index são estruturas de sequência de tempo, com dados correspondentes em cada Bar. Este código de teste distingue entre o "modelo de preço em tempo real" e o "modelo de preço de fechamento" apenas se o gráfico mostra o Bar em tempo real. Para medir a velocidade, usamos o "modelo de preço de fechamento".

Porque a variável v1 é 1, em cada Bar.ta.cum(v1)Quando a função é executada na primeira linha KBar, o resultado é 1, dado que só há a primeira linha Bar. Quandota.cum(v1)Quando executado na segunda linha KBar, já existem duas linhas KBar (a primeira correspondente é 0, a segunda correspondente é 1), então o resultado é 2, atribuindo-se a variável v2, e assim por diante.bar_indexEntão, se você começar a partir de zero, então você está aumentando.bar_index + 1O gráfico de observação também pode ver a linha.v2ebar_indexAfinal, o que eu quero dizer é que a maioria dos blogueiros não tem nada a ver com isso.

Eu também posso.ta.cumA função embutida calcula a soma dos preços de fechamento de todos os Bar no gráfico atual, então só pode ser escrito assim:ta.cum(close)Quando a política é executada para o lado direito da barra de tempo realta.cum(close)O resultado calculado é a soma dos preços de fechamento de todos os Bars no gráfico (só adicionado ao Bar atual quando não é executado até o extremo direito).

As variáveis na sequência de tempo também podem ser operadas com operadores, como o código:ta.sma(high - low, 14)A partir daí, você pode fazer uma mudança.high(Bar mais alto da linha K) menoslow(K linha Bar preço mínimo), usado por última vezta.smaA função procura a média.

Os resultados das chamadas de funções também deixam traços de valores na sequência de tempo.
```
v1 = ta.highest(high, 10)[1]
v2 = ta.highest(high[1], 10)
plot(v1, title="v1", overlay=true)
plot(v2, title="v2", overlay=true)
```
O código do teste é executado no teste de retest, e pode ser observadov1ev2Os valores são os mesmos e as linhas desenhadas no gráfico também se sobrepõem completamente. Os resultados calculados por chamadas de funções deixam traços de valores na sequência de tempo, como códigos.ta.highest(high, 10)[1]Entre eles:ta.highest(high, 10)Os resultados calculados pela chamada da função também podem ser usados para[1] referir seu valor histórico. Baseado no correspondente Bar anterior ao Bar atualta.highest(high, 10)O resultado do cálculo é:ta.highest(high[1], 10)Por isso.ta.highest(high[1], 10)eta.highest(high, 10)[1]O que é que ele tem a ver com isso?

Avaliar a informação usando outra função de gráfico:
```
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, overlay=true)
plotchar(true, title="b", char=str.tostring(b), location=location.belowbar, color=color.green, overlay=true)
```
Pode-se ver que os valores das variáveis a e b na sequência de tempo são exibidos acima e abaixo do correspondente Bar. O código do gráfico pode ser mantido durante o aprendizado, pois pode ser necessário frequentemente exportar informações no gráfico para observação em testes.

Estrutura do script

Estrutura geral

Na parte inicial do tutorial, resumimos algumas diferenças entre o uso da linguagem Pine no FMZ e o uso da linguagem Pine no Trading View.indicator()、strategy()O blogueiro também escreveu sobre o assunto:library()É claro que, para ser compatível com versões anteriores do script do Pine, as políticas são escritas como://@version=5，indicator()，strategy()O que você pode fazer? Algumas configurações de estratégia também podem ser feitas em:strategy()A função transmite configurações de parâmetros.

<version>
<declaration_statement>
<code>

<version>Informações de controle de versão podem ser omitidas.

Notas

Língua Pine//Como notação de uma única linha, FMZ expandiu a notação, uma vez que a linguagem Pine não possui notações de várias linhas./**/Para notas de várias linhas.

Código

As linhas que não são comentários ou instruções do compilador no script são as instruções que implementam o algoritmo do script. Uma instrução pode ser uma delas.

Declaração de variáveis
Redesignação de variáveis
Declaração de funções
Chamadas de funções embutidas, chamadas de funções definidas pelo usuário
if，for，whileOuswitchEstruturas equivalentes

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 para a chamada de funções ou declarações de funções de uma única linha; outras, como estruturas, sempre requerem várias linhas, porque requerem um bloco local.
As frases de âmbito global do roteiro (ou seja, partes que não pertencem a blocos locais) não podem ser interpretadas como:空格Ou制表符(tab) começa. Seu primeiro caractere também deve ser o primeiro caractere da linha. A linha que começa na primeira posição da linha, por definição, faz parte do escopo global do script.
A estrutura ou a declaração de funções de várias linhas sempre requer umlocal blockO bloco local deve ser reduzido a um símbolo ou quatro espaços (caso contrário, ele será resolvido como a linha de código serial anterior, ou seja, será considerado como o conteúdo contínuo da linha anterior), e cada bloco local define um escopo local diferente.
Múltiplas frases de uma única linha podem ser encadernadas em uma linha usando o vírgula ((,) como separador.
Uma linha pode conter um comentário ou apenas um comentário.
As linhas também podem ser enroladas (continua em várias linhas).

Por exemplo, três blocos locais, um em declarações de funções personalizadas e dois em declarações de variáveis, usam a estrutura if, com o seguinte código:

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

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

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

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

Mudança de código

As linhas longas podem ser divididas em várias linhas, ou podem ser "enroladas". As linhas enroladas devem ser enroladas em qualquer número de espaços, desde que não sejam múltiplos de 4 (estas fronteiras são usadas para enrolar blocos).

a = open + high + low + close

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

a = open +
      high +
          low +
             close

Uma chamada longa de plot ((() pode ser embalada em.

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)

As declarações de uma função definida pelo usuário também podem ser encapsuladas. No entanto, como o local deve começar gramaticalmente com um encolhimento ((quatro espaços ou um símbolo), quando dividido para a linha seguinte, a parte contínua da declaração deve começar com mais de um encolhimento ((não é igual a um múltiplo de 4 espaços)); por exemplo:

test(c, o) =>
    ret = c > o ?
       (c > o+5000 ? 
          1 :
              0):
       (c < o-5000 ? 
          -1 : 
              0)
           
                   
a = test(close, open)
plot(a, title="a")

Identificadores e operadores

Identificador

Antes de conhecermos as variáveis, primeiro precisamos entender o conceito de símbolos de barras.FunçõeseVariaçõesO nome de ((para nomear variáveis, funções) ▽).FunçõesComo você verá no próximo tutorial, primeiro vamos aprender a usar símbolos de símbolos.

1, os identificadores devem ser em maiúsculas.(A-Z)Ou em minúsculas.(a-z)Letras ou traços(_)A primeira letra do identificador é o início.
O primeiro caracter do identificador pode ser seguido pelo seguinte caracter.Letras、Linha inferiorOuNúmeros。
O nome do identificador é escrito em letras maiúsculas.

Por exemplo, identificadores com os seguintes nomes:

fmzVar
_fmzVar
fmz666Var
funcName
MAX_LEN
max_len
maxLen
3barsDown  // 错误的命名！使用了数字字符作为标识符的开头字符

Como a maioria das linguagens de programação, a linguagem Pine também tem sugestões de escrita.

1, todas as letras maiúsculas são usadas para nomear as constantes.
2, UtilizaçãoA regra do pequeno cumeO nome é usado para outros identificadores.

// 命名变量、常量
GREEN_COLOR = #4CAF50
MAX_LOOKBACK = 100
int fastLength = 7

// 命名函数
zeroOne(boolValue) => boolValue ? 1 : 0

Operador

Os operadores são alguns símbolos de operações usados na linguagem de programação para construir expressões, e as expressões são regras de computação projetadas para um propósito de computação quando escrevemos políticas. Os operadores na linguagem Pine são classificados por função como:

Os operadores de atribuição, os operadores de cálculo, os operadores de comparação, os operadores de lógica, os operadores de comparação, os operadores de cálculo, os operadores de cálculo, os operadores de comparação, os operadores de cálculo, os operadores de cálculo, os operadores de cálculo, os operadores de cálculo, os operadores de cálculo, os operadores de cálculo, os operadores de cálculo, os operadores de cálculo, os operadores de cálculo, os operadores de cálculo, os operadores de cálculo, os operadores de cálculo, os operadores de cálculo, os operadores de cálculo.? :O operador triangular,[]O operador de referência histórica.

Operador de cálculo*Por exemplo, há o seguinte código de teste para distinguir o tipo de problema causado pelo operador da linguagem Pine no Trading View que retorna resultados:

//@version=5
indicator("")
lenInput = input.int(14, "Length")
factor = year > 2020 ? 3 : 1
adjustedLength = lenInput * factor
ma = ta.ema(close, adjustedLength)  // Compilation error!
plot(ma)

Quando o script é executado no Trading View, um erro é compilado, porque:adjustedLength = lenInput * factorDepois de multiplicar, o resultado éseries intTipo (série), no entantota.emaO segundo parâmetro da função não suporta esse tipo. No entanto, não há restrições rigorosas no FMZ, e o código acima pode ser executado normalmente.

Em seguida, vamos ver juntos o uso de vários operadores.

Operador de atribuição

Existem dois tipos de operadores de atribuição:=、:=A partir daí, o curso começa com a introdução de uma série de exemplos.

=Os operadores são usados para atribuir valores a uma variável para inicialização ou declaração.=Inicialização, as variáveis após a declaração de atribuição começam com esse valor em cada Bar seguinte. Estas são as declarações de variáveis válidas:

a = close           // 使用内置变量赋值给a
b = 10000           // 使用数值赋值
c = "test"          // 使用字符串赋值
d = color.green     // 使用颜色值赋值
plot(a, title="a")
plot(b, title="b")
plotchar(true, title="c", char=str.tostring(c), color=d, overlay=true)

Cuidado.a = closeAssinatura de uma declaração, em que a variável a é o preço de fechamento (close) do Bar atual para cada variável Bar; outras variáveisb、c、dO sistema de retrospecção em FMZ pode ser testado e os resultados podem ser vistos no gráfico.

:=Usado para reatribuir valores a variáveis existentes, pode ser simplesmente entendido como:=Os operadores são usados para modificar valores de variáveis já declaradas e initializadas. Se for usado.:=O operador pode causar erros em atribuições de variáveis não initializadas ou declaradas, como:

a := 0

Então,:=Os operadores de atribuição são geralmente usados para reatribuir variáveis já existentes, por exemplo:

a = close > open 
b = 0 
if a
    b := b + 1

plot(b)

julgar seclose > open(ou seja, o BAR atual é o raio de luz), a variável é o valor verdadeiro (true); executará o código no bloco local da declaração seb := b + 1, usando o operador de atribuição:=Re-atribuir o valor a b, acrescentando um 1; e depois usar a função de plot para traçar o valor da variável b em cada BAR da sequência de tempo em um gráfico, ligando-a em linha;

Será que nós pensamos que a existência de um ponto de viragem BAR e b continuará adicionando 1? Claro que não, aqui nós declaramos para a variável b, não usamos nenhuma palavra-chave para especificar quando initializamos para 0.b=0O resultado do código é que a variação b é redefinida para 0 sempre que a variação a for verdadeira.close > openEntão, a b é 1 quando a função plot é executada, mas a b é re-atribuída a 0 na próxima execução.

No que diz respeito ao operador de atribuição, é necessário ampliar a explicação de duas palavras-chave:var、varip

Var

Na verdade, essa palavra-chave já foi vista e usada em tutoriais anteriores, mas não foi abordada em detalhes.

var é a palavra-chave usada para atribuir e inicializar variáveis de uma só vez. Normalmente, a sintaxe de atribuição de variáveis que não contém a palavra-chave var leva a que o valor da variável seja coberto a cada vez que os dados são atualizados. Em contraste, quando as variáveis de atribuição com a palavra-chave var são usadas, elas podem manter-se em silêncio, mesmo que os dados sejam atualizados.

Nós ainda usamos este exemplo, mas nós usamos isso quando nós atribuímos b.varPalavras-chave:
```
a = close > open 
var b = 0 
if a
    b := b + 1

plot(b)
```
varA palavra-chave permite que a variável b execute apenas a primeira atribuição inicial e não redefina b para 0 a cada execução da lógica da estratégia, de modo que as linhas desenhadas durante a execução podem ser observadas como b é a quantidade de barras de luz que ocorreram no atual K line BAR.

As variáveis declaradas var podem ser escritas não apenas em escala global, mas também em blocos de código, como neste exemplo:
```
strategy(overlay=true)
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 preço de fechamento da linha do primeiro pilar da série. A variável titânio b mantém o preço de fechamento da primeira barra de preços de titânio verde da série. A variável c mantém o preço de fechamento da décima série de bolinhas de rosa.
variável

varipA primeira vez que vemos essa palavra-chave, podemos ver a descrição da palavra-chave:

varip (var intrabar persist) é uma palavra-chave usada para atribuir e iniciar variáveis de uma só vez. É semelhante à palavra-chave var, mas as variáveis que usam a declaração varip mantêm seus valores entre as atualizações de linhas K em tempo real.

Não é difícil de entender? Não faz mal, nós explicamos através de exemplos e é fácil de entender.
```
strategy(overlay=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
i := i + 1
ii := ii + 1
```
Este código de teste se apresenta de forma diferente no modelo de preço de fechamento e no modelo de preço em tempo real:

Modelo de preços em tempo real: Lembre-se de que a execução da estratégia foi dividida em fases BAR históricas e BAR em tempo real.var、varipVariações declaradasi、iiA operação de incremento é executada a cada rodada de execução do código da estratégia. Assim, pode-se ver que os números exibidos no resultado da linha K BAR são cada um incrementados por 1 quando o estágio da linha K histórico termina e começa o estágio da linha K em tempo real. As variáveis da declaração var, varip começam a mudar. Como é um modelo de preços em tempo real, cada mudança de preço em uma linha K BAR é executada uma vez com o código da estratégia.i := i + 1eii := ii + 1A diferença é que i é modificado cada vez que a lógica da política é executada. Embora a lógica da política seja modificada cada vez que a mesma é executada, o valor anterior é restaurado (lembre-se do mecanismo de regressão que discutimos no capítulo anterior "Execução do modelo?"), e o valor de i não é determinado até que o atual K-line BAR seja atualizado (ou seja, não seja restaurado no próximo ciclo de execução da lógica da política).

Modelo de preço de fechamento: Como o modelo de preço de fechamento executa uma lógica de estratégia quando cada linha K BAR termina; portanto, no modelo de preço de fechamento, o estágio da linha K histórica e o estágio da linha K em tempo real, as variáveis da declaração var, varip e varip apresentam-se de forma perfeitamente consistente no exemplo acima, cada vez que a linha K BAR aumenta 1.

Operador aritmético

Operador	Explicação
+	Gafa
-	Diminuição da lei
*	Multiplicação
/	Exclusão
%	Modelagem

+、-O operador pode ser usado como um operador binário ou como um operador primário. Os outros operadores aritméticos só podem ser usados como operadores binários e retornam erros se usados como um operador primário.

1, os operadores de cálculo são de tipo numérico em ambos os lados, o resultado é o tipo numérico, inteiro ou ponto flutuante, dependendo do resultado da operação. 2, se algum dos operadores for uma string, o operador é+O resultado do cálculo é uma string, o valor é convertido em formato de string e depois as strings são empilhadas. Se for outro operador de cálculo, tenta converter a string em um valor e depois opera. 3, se um dos números de operação for na, o resultado do cálculo é o valor nulo na, que é exibido na NaN quando impresso no FMZ.

a = 1 + 1 
b = 1 + 1.1
c = 1 + "1.1"
d = "1" + "1.1"
e = 1 + na 

runtime.log("a:", a, ", b:", b, ", c:", c, ", d:", d, ", e:", e)   
// a: 2 , b: 2.1 , c: 11.1 , d: 11.1 , e: NaN

A linguagem Pine no FMZ é um pouco diferente da linguagem Pine no Trading View. A linguagem Pine no FMZ não é muito rigorosa em termos de requisitos de tipos de variáveis.

a = 1 * "1.1"
b = "1" / "1.1"
c = 5 % "A" 

plot(a)
plot(b)
plot(c)

Em FMZ é possível, mas em vista de negociação, o tipo de erro é reportado. Quando os números de operação de ambos os lados do operador aritmético são linhas, o sistema calcula depois de converter as linhas para valores. Se a linha não é numerada, o resultado do sistema é nulo na.

Compare os operadores

Os operadores de comparação são binários.

Operador	Explicação
<	Menos do que
>	maior do que
<=	Menos do que é igual a
>=	É maior do que igual a
==	Igual
!=	Não é igual

Exemplo de teste:

a = 1 > 2 
b = 1 < 2 
c = "1" <= 2 
d = "1" >= 2 
e = 1 == 1 
f = 2 != 1 
g = open > close 
h = na > 1 
i = 1 > na

runtime.log("a:", a, ", b:", b, ", c:", c, ", d:", d, ", e:", e, ", f:", f, ", g:", g, ", h:", h, ", i:", i)   
// a: false , b: true , c: true , d: false , e: true , f: true , g: false , h: false , i: false

Como podemos ver, o operador de comparação é muito simples de usar, mas é o operador que mais usamos quando escrevemos políticas.close、openE assim por diante. Como com o operador de operação, o Pine no FMZ é diferente do Pine no Trading View, o FMZ não tem um tipo de requisição particularmente rigoroso, então declarações como essa são usadas para definir o tipo de requisição.d = "1" >= 2No FMZ, não há erros, a execução é feita com a conversão de uma string para um valor numérico e depois a comparação.

Operador lógico

Operador	Símbolo de código	Explicação
Não	Não, não.	Operação semelhante, não operada
e	e	Operador binário, operado com ()
Ou	ou	Operador binário, ou operação

Quando falamos de operadores lógicos, então devemos falar de uma tabela de valores reais. Como aprendemos no ensino médio, só que aqui nós testamos em sistemas de retrospecção, aprendemos:

a = 1 == 1  // 使用比较运算符构成的表达式，结果为布尔值
b = 1 != 1
c = not b   // 逻辑非操作符
d = not a   // 逻辑非操作符

runtime.log("测试逻辑操作符：and", "#FF0000")
runtime.log("a:", a, ", c:", c, ", a and c:", a and c)
runtime.log("a:", a, ", b:", b, ", a and b:", a and b)
runtime.log("b:", b, ", c:", c, ", b and c:", b and c)
runtime.log("d:", d, ", b:", b, ", d and b:", d and b)

runtime.log("测试逻辑操作符：or", "#FF0000")
runtime.log("a:", a, ", c:", c, ", a or c:", a or c)
runtime.log("a:", a, ", b:", b, ", a or b:", a or b)
runtime.log("b:", b, ", c:", c, ", b or c:", b or c)
runtime.log("d:", d, ", b:", b, ", d or b:", d or b)

runtime.error("stop")

Para não deixar que o sistema de retrospecção continue a imprimir informações que afetam a observação, usamos um sistema de retrospecção de imagens de imagens de imagem.runtime.error("stop")Após a execução de uma impressão, o envio de um erro anormal faz com que o rastreamento seja interrompido, e depois pode-se observar a informação de saída, descobrindo que o conteúdo impresso e a tabela de valores reais são na verdade os mesmos.

Operador triangular

Usando três operadores? :Expresso triangular com combinação de números operacionaiscondition ? valueWhenConditionIsTrue : valueWhenConditionIsFalseNós já fomos familiarizados em cursos anteriores. As chamadas expressões tridimensionais, os operadores tridimensionais significam que o número total de operações é três.

condition ? valueWhenConditionIsTrue : valueWhenConditionIsFalseO que é isso?conditionO valor da expressão, se for verdade, é:valueWhenConditionIsTrueSeconditionO valor para a expressão hipotética é:valueWhenConditionIsFalse。

A partir daí, o blog foi criado para ajudar os usuários a entenderem o que realmente significa o blog.

a = close > open
b = a ? "阳线" : "阴线"
c = not a ? "阴线" : "阳线"
plotchar(a, location=location.abovebar, color=color.red, char=b, overlay=true)
plotchar(not a, location=location.belowbar, color=color.green, char=c, overlay=true)

O que acontece se você encontrar uma estrela cruzada, não importa! As expressões triangulares também podem ser embutidas, como fizemos no tutorial anterior.

a = close > open
b = a ? math.abs(close-open) > 30 ? "阳线" : "十字星" : math.abs(close-open) > 30 ? "阴线" : "十字星"
c = not a ? math.abs(close-open) > 30 ? "阴线" : "十字星" : math.abs(close-open) > 30 ? "阳线" : "十字星"
plotchar(a, location=location.abovebar, color=color.red, char=b, overlay=true)
plotchar(not a, location=location.belowbar, color=color.green, char=c, overlay=true)

É o equivalente acondition ? valueWhenConditionIsTrue : valueWhenConditionIsFalseO que é?valueWhenConditionIsTrue、valueWhenConditionIsFalseA expressão trinitária também é usada em vez disso.

Operador histórico

Usando o operador histórico[]Os valores históricos são os valores da variável na linha K antes do BAR da linha K atual quando o script é executado.[]Os operadores são usados após chamadas de variáveis, expressões e funções.[]O valor entre parênteses é o deslocamento dos dados históricos que queremos citar da distância do atual K-line BAR. Por exemplo, se eu quiser citar o preço de fechamento de um K-line BAR anterior, escrevo:close[1]。

O que eu quero dizer com isso é que, no entanto, o que eu quero dizer com isso é que, no entanto, o que eu quero dizer com isso é que, no entanto, o que eu quero dizer com isso é que o que eu quero dizer com isso é que o que eu quero dizer é que o que eu quero dizer é que o que eu quero dizer é que o que eu quero dizer é que o que eu quero dizer é que o que eu quero dizer é que o que eu quero dizer.

high[10]
ta.sma(close, 10)[1]
ta.highest(high, 10)[20]
close > nz(close[1], open)

[]O operador só pode ser usado uma vez no mesmo valor, então escrever assim é errado e dá um erro:

a = close[1][2]   // 错误

E você pode ver aqui, alguns dos meus colegas podem dizer:[]A construção de séries é muito parecida com a construção de arquivos. A seguir, vamos dar um exemplo para mostrar a diferença entre uma série e uma matriz na linguagem Pine.

strategy("test", overlay=true)

a = close
b = close[1]
c = b[1]

plot(a, title="a")
plot(b, title="b")
plot(c, title="c")

Não é?a = close[1][2]O que é que ele está a fazer?

b = close[1]
c = b[1]

A partir daí, o que é mais importante é que você não se esqueça de escrever em separado, e isso não é um erro, se você entender o que você está fazendo de forma normal.b = close[1]Depois da atribuição, b deve ser um valor, no entantoc = b[1]b ainda pode ser usado novamente para referenciar valores históricos usando o operador histórico. Como pode ser visto, o conceito de série na linguagem Pine não é tão simples quanto um conjunto de arquivos. Pode ser entendido como o valor histórico no Bar anterior de um próximo atribuído a b. b também é uma estrutura de sequência de tempo que pode continuar referenciando seus valores históricos.

Podemos arrastar o gráfico para o lado esquerdo e observar que na primeira linha K, os valores de b e c são ambos vazios. Isso ocorre porque, quando o script é executado na primeira linha K BAR, não existe uma referência para a frente, um valor histórico de dois ciclos.na、nzA função interna é a função de julgar (na verdade, nós também abordamos isso em estudos anteriores).nz、naFunções, lembra-se em que seção?) trata de situações específicas de valores vazios, como:

close > nz(close[1], open)    // 当引用close内置变量前一个BAR的历史值时，如果不存在，则使用open内置变量

Este é um tratamento para referências possíveis a um vazio ((na)).

Prioridade do operador

Nós já aprendemos muitos operadores da linguagem Pine que formam expressões através de várias combinações de operadores e números de operações. Então, qual é a prioridade dessas operações quando se calcula na expressão?

Prioridades	Operador
9	`[]`
8	A função de um operador`+` 、`-`e`not`
7	`*`、`/`、`%`
6	Quando o operador binário`+`、`-`
5	`>`、`<`、`>=`、`<=`
4	`==`、`!=`
3	`and`
2	`or`
1	`?:`

A parte expressiva de alta prioridade é operada primeiro, se a prioridade for a mesma, é operada de esquerda para direita.()A expressão de uma fração é obrigada a ser operada antes de ser envolvida.

Variações

Declaração de variáveis

Nós já aprendemos o conceito de símbolos de símbolos de símbolos de símbolos, símbolos de símbolos de símbolos de símbolos de símbolos de símbolos de símbolos de símbolos de símbolos de símbolos de símbolos de símbolos de símbolos de símbolos de símbolos de símbolos de símbolos de símbolos.

Modelo de declaração: A primeira coisa que se escreve quando se declara uma variável é "modo de declaração". 1, usar palavras-chavevarNão. 2 - Use palavras-chavevaripNão, não é. Não escrevi nada.

var、varipA palavra-chave é algo que já aprendemos no capítulo anterior, "Operadores de atribuição", e que não é mais descrito aqui.i = 1Como já dissemos anteriormente, a variável declarada e a atribuição são executadas em todas as linhas KBAR.
Tipo A linguagem Pine no FMZ não é rigorosa em termos de requisitos de tipo e geralmente pode ser omitida. No entanto, para ser compatível com as políticas de script no Trading View, as variáveis podem ser declaradas com tipos.
```
int i = 0 
float f = 1.1
```
Os tipos no Trading View são mais exigentes, e o seguinte código é usado no Trading View:
```
baseLine0 = na          // compile time error!
```
Identificador O identificador é o nome de uma variável, o nome do identificador foi mencionado no capítulo anterior e pode ser visto:https://www.fmz.com/bbs-topic/9390#标识符

Em resumo, declarar uma variável pode ser escrito:

// [<declaration_mode>] [<type>] <identifier> = value 
   声明模式             类型     标识符       = 值

Aqui, o operador de atribuição é usado:=Quando uma variável é declarada, dá-lhe um valor. Quando é declarada, o valor pode ser uma cadeia, um valor numérico, uma expressão, uma chamada de função, ou um número.if、 for、whileOuswitchAs estruturas de e-mails (as estruturas de palavras-chave e expressões serão explicadas em detalhes em nossas aulas posteriores, na verdade, aprendemos em aulas anteriores a atribuição de simples expressões de e-mails, que podemos rever).

Aqui nós nos concentramos em explicar a função de entrada, que é uma função que nós usamos com muita frequência quando nós criamos políticas.

Função de entrada:

input函数，参数defval、title、tooltip、inline、group

A função de entrada no FMZ é um pouco diferente da função de entrada no Trading View, embora seja usada como entrada de atribuição de parâmetros de estratégia. A seguir, vamos detalhar o uso da função de entrada no FMZ com um exemplo:

param1 = input(10, title="参数1名称", tooltip="参数1的描述信息", group="分组名称A")
param2 = input("close", title="参数2名称", tooltip="参数2的描述信息", group="分组名称A")
param3 = input(color.red, title="参数3名称", tooltip="参数3的描述信息", group="分组名称B")
param4 = input(close, title="参数4名称", tooltip="参数4的描述信息", group="分组名称B")
param5 = input(true, title="参数5名称", tooltip="参数5的描述信息", group="分组名称C")

ma = ta.ema(param4, param1)
plot(ma, title=param2, color=param3, overlay=param5)

O que é frequentemente usado para atribuir valores às variáveis quando declaradas é a função de entrada. A função de entrada no FMZ desenha automaticamente o controle para definir os parâmetros da política na interface da política do FMZ. Os controles suportados no FMZ atualmente possuem caixas de entrada de valores, caixas de entrada de texto, caixas de desvio, seleção de buracos.

A função de entrada é uma função que pode ser executada por um número de parâmetros.

defval: o valor padrão das opções de parâmetros de política definidas pela função de entrada, com suporte a variáveis, números e strings embutidos na linguagem Pine
title: nome do parâmetro que a política mostra na interface da política do disco real / retrô.
tooltip: A dica do parâmetro da política, quando o mouse pausa sobre o parâmetro da política, mostra o texto que o parâmetro foi configurado.
group: nome do grupo de parâmetros da política, pode ser dado para o grupo de parâmetros.

Além de declarações de variáveis individuais e atribuições, a linguagem Pine também declara um conjunto de variáveis e atribuições:

[变量A,变量B,变量C] = 函数 或者 ```if```、 ```for```、```while```或```switch```等结构

O mais comum é que usamosta.macdQuando a função calcula o indicador MACD, uma vez que o indicador MACD é um indicador multilíneo, calcula-se três conjuntos de dados; portanto, pode ser escrito como:

[dif,dea,column] = ta.macd(close, 12, 26, 9)

plot(dif, title="dif")
plot(dea, title="dea")
plot(column, title="column", style=plot.style_histogram)

É muito fácil desenhar um gráfico MACD usando o código acima, não só funções embutidas que podem retornar várias variáveis, como funções personalizadas que podem retornar vários dados.

twoEMA(data, fastPeriod, slowPeriod) =>
    fast = ta.ema(data, fastPeriod)
    slow = ta.ema(data, slowPeriod)
    [fast, slow]

[ema10, ema20] = twoEMA(close, 10, 20)
plot(ema10, title="ema10", overlay=true)
plot(ema20, title="ema20", overlay=true)

Usar estruturas como if como atribuição de várias variáveis é similar ao modo de escrever funções personalizadas acima.

[ema10, ema20] = if true
    fast = ta.ema(close, 10)
    slow = ta.ema(close, 20)
    [fast, slow]

plot(ema10, title="ema10", color=color.fuchsia, overlay=true)
plot(ema20, title="ema20", color=color.aqua, overlay=true)

Estrutura condicional

Algumas funções não podem ser escritas em blocos de código local que não possuem uma ramificação condicional.

barcolor ((), fill ((), hline ((), indicator ((), plot ((), plotcandle ((), plotchar ((), plotshape (()

Compilação de relatórios de erros no Trading View. O limite no FMZ não é tão severo, mas também é recomendável seguir as normas de escrita no Trading View.

strategy("test", overlay=true)
if close > open 
    plot(close, title="close")
else 
    plot(open, title="open")

If

Próxima página

Mais.