Erfinder quantifizieren PINE-Einführung in die Sprache

Schriftsteller:Kleine Träume, Erstellt: 2022-05-30 16:23:43, Aktualisiert: 2022-09-28 17:10:21

[TOC]

Erfinder quantifizieren PINE-Einführung in die Sprache

Das ist ein Video-Tutorial:Quantifizierte Transaktionen sind zu schwierig, um einzutauchen?

Die Inventor-Quantitative-Trading-Plattform unterstützt Schreibstrategien in der Pine-Sprache, unterstützt Retargeting, läuft die Pine-Sprache auf Festplatten und ist kompatibel mit niedrigeren Versionen der Pine-Sprache.FMZ.COM(Siehe unten)Das StrategieplatzEs gibt eine Vielzahl von Pine-Strategien (Skripte) für das Suchen und Transportieren.

FMZ unterstützt nicht nur die Sprache Pine, sondern auch die leistungsstarken Grafikfunktionen der Sprache. Die Funktionen der FMZ-Plattform, die umfangreichen praktischen Tools, die effiziente und einfache Verwaltung und die Nützlichkeit der Pine-Skripte werden weiter verbessert. FMZ basiert auf der Kompatibilität mit der Sprache Pine und bietet eine Reihe von Erweiterungen, Optimierungen und Beschnitten für die Sprache Pine.

Ein einfacher Überblick über einige der deutlichsten Unterschiede:

1. Die Pine-Richtlinie auf FMZ, die Versionsmarkierung am Anfang des Codes//@versionUnd das beginnt mit Code.strategy、indicatorDer Satz ist nicht obligatorisch und wird von FMZ vorerst nicht unterstütztimportImportlibraryDie Funktionen sind hier:

Einige der Strategien, die man sehen kann, sehen so aus:

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

Oder sie schreibt:

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

Auf FMZ kann man es so vereinfachen:

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)

Oder:

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, Strategien (Skript) Einige transaktionsbezogene Einstellungen werden durch die Parameter "Pine Language Transaction Library" in der FMZ-Skript-Oberfläche festgelegt.
- Abschluss- und Echtzeit-Preismodelle In der Handelsansicht können wirstrategyDie Funktioncalc_on_every_tickParameter, um ein Strategie-Skript zu erstellen, das bei jeder Preisänderung die Strategie-Logik in Echtzeit ausführt.calc_on_every_tickDie Parameter sollten auftrueUnd das ist der Grund.calc_on_every_tickDie Parameter sind:falseDas bedeutet, dass die Strategie nur dann ausgeführt wird, wenn die aktuelle K-Line BAR vollständig abgelaufen ist. Auf der FMZ wird dies durch die Parameter der Schablone "Pine Language Exchange Library" festgelegt.
- Bei der Ausführung der Strategie ist eine numerische Präzision der Preise, der Stückzahlen usw. auf der FMZ erforderlich. In der Handelsansicht gibt es keine Präzisionsprobleme, da nur simulierte Tests möglich sind. In der FMZ kann die Pine-Strategie in der Praxis ausgeführt werden. Dann ist eine Strategie erforderlich, mit der die Preispräzision, die Anzahl der Bestellungen flexibel festgelegt werden kann. Diese Präzisions-Einstellungen steuern die kleinen Zahlen der relevanten Daten, um zu vermeiden, dass die Daten nicht den Anforderungen der Börsenanzeige entsprechen und daher nicht bestellt werden können.
- Futures-Kontrakt-Code Die Handelsvarietät auf FMZ hat zwei Eigenschaften, wenn es sich um einen Vertrag handelt. Sie ist als "Trading Pair" oder "Contract Code" bezeichnet.swapDer Kontraktcode hängt davon ab, ob die Börse, an der der Handel stattfindet, einen solchen Vertrag hat. Hier können Sie beispielsweise alle Quartalskontrakte ausfüllen.quarter│Diese Kontraktcodes stimmen mit den Futures-Kontraktcodes überein, die in der Java/Python/C++-API-Dokumentation von FMZ definiert sind.│
Weitere Einstellungen, wie z.B. Mindest- und Default-Nummern, finden Sie in der Pine-Dokumentation."Pine ist eine Sprache, in der man sich verhandelt".Einführung in die Parameter.
3、runtime.debug 、runtime.log、runtime.errorFunktionen der FMZ-Erweiterung, für Debugging.

Auf der FMZ-Plattform wurden drei Debugging-Funktionen hinzugefügt.
- runtime.debug: Das Drucken von Variableninformationen auf dem Controller ist in der Regel nicht möglich.
- runtime.log: Inloginhalte ausfüllen.. FMZ PINE hat eine spezielle Funktion..
```
runtime.log(1, 2, 3, close, high, ...)，可以传多个参数。
```
- runtime.error: wird aufgerufen, führt zu Ausführungsfehlern und trägt die Fehlermeldung, die in den Message-Parametern angegeben ist.
```
runtime.error(message)
```
4 und erweitert in der Grafikfunktion.overlayParameter

Pine-Sprache auf FMZ, Grafikfunktionenplot、plotshape、plotcharEs ist so weit.overlayParameterunterstützung, die es erlaubt, Bilder in dem Haupt- oder Nebendiagramm anzugeben.overlayEinstellungentrueSie werden in der Grundriss angezeigt.falseZeichnen Sie in einem Unterdiagramm. Lassen Sie die Pine-Richtlinie auf FMZ laufen, wenn Sie einen Unterdiagramm und ein Unterdiagramm zeichnen.
5、syminfo.mintickDie Werte der Variablen erfassen

syminfo.mintickDie eingebaute Variable ist definiert als der kleinste Schnittwert der aktuellen Sorte.Echtzeitplatte/WiederholungDer Modellparameter "Price Currency Precision" in der "Pine Language Trading Library" in der Oberfläche kann diesen Wert steuern. Die Precision Currency Precision ist auf 2 gesetzt, d.h. der Preis ist bis zum zweiten Dezimalpunkt genau, wobei der Preis mit der geringsten Veränderungseinheit 0.01 geschätzt wird.syminfo.mintickDas ist der Wert von 0.01 ∞.
6. Die durchschnittlichen Preise in FMZ PINE Script sind die Preise, die die Gebühren beinhalten

Zum Beispiel: Auftragspreis 8000, Verkaufsanweisung, Anzahl 1 Hand (ein paar), Durchschnittspreis nach der Transaktion nicht 8000, unter 8000 (die Kosten beinhalten die Bearbeitungsgebühren).

Grundlagen der Pine-Sprache

Wenn wir anfangen, die Grundlagen der Pine-Sprache zu lernen, sind wir vielleicht nicht vertraut mit den Anweisungen und der Code-Symmetrie in einigen Beispielen.

Modelldurchführung

Bei der Einführung in die Sprache Pine ist es sehr notwendig, sich mit Konzepten wie dem Ausführungsverfahren von Pine-Skripten vertraut zu machen. Die Strategien der Pine-Sprache sind grafikbasiert und können als eine Reihe von Berechnungen und Operationen verstanden werden, die in der Reihenfolge der Zeitreihenfolge in einem Diagramm mit den frühesten Daten, die bereits in dem Diagramm geladen wurden, durchgeführt werden. Die Datenmenge, die am Anfang des Diagramms geladen wurde, ist begrenzt.bar_indexVerweist auf den Indexwert von K-LineBar, der zum Zeitpunkt der Ausführung des Pine-Skriptes aktuell ist.

plot(bar_index, "bar_index")

plotDie Funktion ist eine der Funktionen, die wir in Zukunft häufiger verwenden werden.bar_indexDie Linie heißtbar_indexSie können sehen, dass der Wert der Zeile, die als bar_index bezeichnet wird, in der ersten Bar-Name 0 ist, und dass 1 nach rechts zunimmt, wenn Bar zunimmt.

Je nach Einstellung der Strategie unterscheidet sich auch die Modelldurchführung der Strategie.收盘价模型und实时价模型Wir haben die Konzepte der Schlusskursmodelle und der Echtzeit-Kursmodelle bereits kurz vorgestellt.

Modell für die Abschlusspreise

Bei der Ausführung des Strategiecodes ist die Laufzeit der aktuellen K-LineBar vollständig abgeschlossen, und wenn die K-Line geschlossen wird, ist die K-Line-Laufzeit abgeschlossen. Bei dieser Ausführung wird die Pine-Strategie-Logik erneut ausgeführt, und das ausgelöste Handelssignal wird bei Beginn der nächsten K-LineBar ausgeführt.
Echtzeit-Preismodell

Bei der Ausführung des Strategiecodes wird die aktuelle K-LineBar unabhängig davon, ob sie geschlossen ist, bei jeder Marktänderung wiederholt mit der Pine-Strategie-Logik ausgeführt, und das ausgelöste Handelssignal wird sofort ausgeführt.

Wenn die Pine-Sprache-Politik von links nach rechts auf einem Diagramm ausgeführt wird, wird die K-LineBar in einem Diagramm in历史Barund实时BarSiehe auch:

Historische Bar

Wenn die Strategie als "Real Price Model" eingestellt wird, werden alle K-Line-Bars außer der K-Line-Bar auf der rechten Seite des Diagramms ausgeführt.历史BarIch bin nicht derjenige, der das sagt.历史BarDas ist eine sehr schwierige Aufgabe. Wenn die Strategie als "Schließpreismodell" eingestellt wird, werden alle Bars auf dem Diagramm ausgeführt.历史BarIch bin nicht derjenige, der das sagt.历史BarDas ist eine sehr schwierige Aufgabe.

Die Berechnung basiert auf der historischen Bar: Die Strategiecode wird einmal in der Geschichte Bar-Schließung ausgeführt, und dann wird die Strategiecode in der nächsten Geschichte Bar ausgeführt, bis alle Geschichte Baren einmal ausgeführt werden.
Live-Bar

Wenn die Strategie auf die letzte K-Line Bar am rechten Rand ausgeführt wird, wird die Bar zu einer Live-Bar. Wenn die Live-Bar geschlossen wird, wird sie zu einer passiven Live-Bar (die zu einer historischen Bar wird).

Wenn die Strategie als "Real-Time-Preis-Modell" eingestellt ist, wird bei jeder Marktänderung auf der Real-Time-Bar eine Strategie-Logik ausgeführt. Die Strategie, die als "Schließpreismodell" eingestellt ist, zeigt beim Ausführen keine Live-Bar auf dem Chart.

Die Berechnung basiert auf der Echtzeit-Bar: Wenn die Strategie als "Schließpreismodell" eingestellt ist und das Diagramm keine Live-Bar zeigt, wird der Strategiecode nur einmal bei der aktuellen Schließbar ausgeführt. Wenn die Strategie als "Real-Price-Modell" eingestellt wird, ist die Berechnung auf der Real-Time-Bar völlig anders als die Berechnung auf der Historische-Bar, bei der eine Strategie-Code für jede Marktänderung auf der Real-Time-Bar ausgeführt wird.high、low、closeIn der historischen Bar ist festgestellt, dass sich diese Werte bei jeder möglichen Veränderung des Marktes in der Echtzeitbar ändern. Daher werden auch Daten wie Indikatoren, die auf diesen Werten basieren, in Echtzeitbar geändert.closeEs gibt immer einen aktuellen Preis, der den aktuellsten Preis darstellt.highundlowStets die höchsten und niedrigsten Höhen und Tiefen, die seit Beginn der aktuellen Live-Bar erreicht wurden. Diese eingebauten Variablen repräsentieren den Endwert, der bei der letzten Aktualisierung der Live-Bar erreicht wurde.

Ein Rückschlagmechanismus bei der Ausführung von Strategien auf der Echtzeit-Bar (Echtzeit-Preismodell): Bei der Real-Time-Bar-Ausführung wird die Variable, die der Benutzer definiert hat, bei jeder Neuauflage der Strategie vor der Ausführung neu eingestellt.

Bitte beachten Sie:
```
/*backtest 
...
..
.
*/
```
Der Inhalt des Pakets ist die Rückrufkonfigurationsinformationen, die in Codeform auf der FMZ-Plattform gespeichert werden.
```
/*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")
```
Wir haben nur Szenen untersucht, die in Bar-Zeit ausgeführt wurden, also haben wirnot barstate.ishistoryDie Ausdrucksbeschränkung gilt nur für die Realzeit-Bar-Überschreibung von Variablen n und wird vor und nach der Ausführung der Überschreibung verwendet.runtime.logDie Funktion liefert Informationen in den Strategieloggern.plotDie gezeichnete Kurve n zeigt, dass n immer 0 war, als die Strategie in der historischen Bar ausgeführt wurde. Die Operation n plus 1 wurde ausgelöst, als sie bis zur Echtzeitbar ausgeführt wurde, und n plus 1 wurde bei jeder Runde der Ausführung von Strategien in der EchtzeitBar ausgeführt. Aus den Login-Informationen kann beobachtet werden, dass n bei jeder erneuten Ausführung des Strategiekodes auf den Wert der letzten Ausführung der Politik Bar zurückgesetzt wird.

Ich bin der Meinung, dass es nicht richtig ist. 1, wenn die Politik in der Echtzeit in Bar ausgeführt wird, wird bei jedem Geschäftsupdate ein Politikcode ausgeführt. 2. Bei der Ausführung auf der Echtzeit-Bar wird die Variable vor jeder Ausführung des Strategic-Codes rückgängig gemacht. 3. Bei der Ausführung auf RealtimeBar werden die Variablen bei der Schließungserneuerung einmal eingereicht.

Grafikoperationen wie Kurven auf den Diagrammen können auch zu Umschreibungen führen, da die Daten rückwärts rollen.
```
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")
```
Bild von Moment A

Bild von Moment B

Wir haben nur diesen Satz geändert:n := open > close ? n + 1 : nIn der ersten Abbildung kann man sehen, dass in Moment A, da der Eröffnungspreis zu diesem Zeitpunkt höher als der Schließpreis ist, n addiert wird, und die Grafikkurve n einen Wert von 5 zeigt. Dann zeigt sich die Bewegung, die Preisveränderung wie in der zweiten Abbildung.
Kontext der Variablen in einer Funktion

Im Folgenden untersuchen wir gemeinsam die Variablen in den Funktionen der Sprache Pine. Gemäß der Beschreibung in einigen Pine-Tutorials unterscheiden sich Variablen in den Funktionen von Variablen außerhalb der Funktion wie folgt:

Die Geschichte der in der Pine-Funktion verwendeten Reihe von Variablen wird durch jeden aufeinanderfolgenden Aufruf der Funktion erstellt. Wenn die Funktion nicht auf jede Spalte aufgerufen wird, auf die das Skript ausgeführt wird, wird dies zu einer Differenz zwischen den historischen Werten innerhalb des Funktionsobjekts und den historischen Werten der externen Reihe führen. Wenn daher die Funktion nicht auf jede Spalte aufgerufen wird, wird die Reihe, die mit dem gleichen Indexwert innerhalb der Funktion und mit externen Referenzen verwendet wird, nicht auf den gleichen historischen Punkt beziehen.

Ist es nicht etwas schwer zu lesen? Schon gut, wir haben das mit einem Testcode gelöst, der auf FMZ läuft:
```
/*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)
```
Wiederholung des Laufbilds

Die Test-Code ist relativ einfach und zielt vor allem darauf ab, Daten zu untersuchen, die auf zwei Arten zitiert werden:f(a) => a[1]undf2() => close[1]。
- f(a) => a[1]: Wie man die Parameter überträgt, und die Funktion endlich zurückkehrta[1]。
- f2() => close[1]Direkt mit den eingebauten VariablencloseDie Funktion wird endlich zurückgegeben.close[1]。
[]Die Symbole werden für Referenzoperationen an den historischen Werten der Variablen in der Datenserie verwendet, die close[1] beziehen sich auf die Daten des aktuellen Schlusskurses vor dem Schlusskurs Bar.
- plotchar(oneBarInTwo ? f(close) : na, title = "f(close)", color = color.red, location = location.absolute, style = shape.xcross, overlay = true, char = "A")Zeichnen Sie ein Zeichen A, die Farbe ist rot, und zeichnen Sie es nur, wenn oneBarInTwo wahr ist, und die Position (auf der Y-Achse) ist:f(close)Der Wert wird zurückgegeben.
- plotchar(oneBarInTwo ? f2() : na, title = "f2()", color = color.green, location = location.absolute, style = shape.circle, overlay = true, char = "B")Zeichnen Sie ein Zeichen mit B, in grüner Farbe, wenn oneBarInTwo wahr ist, und die Position (auf der Y-Achse) ist:f2()Der Wert wird zurückgegeben.
- plot(close[2], title = "close[2]", color = color.red, overlay = true)Die Linie ist in Rot angezeigt, und die Position (auf der Y-Axis) ist:close[2]Das ist der Schlusskurs auf Bar, der 2. Linie vor der aktuellen Zahl Bar.
- plot(close[1], title = "close[1]", color = color.green, overlay = true)Die Linie ist grün und zeigt (auf der Y-Achse):close[1]Das ist der Verkaufspreis auf Bar, der 1. Linie vor der aktuellen Zahl Bar (die 1. Linie nach links).
Bildschirm, der durch die Strategie Retargeting ausgeführt wird, kann gesehen werden, obwohl Bild A die Funktion markiert, die verwendet wirdf(a) => a[1]und die Funktion, die in Abbildung B markiert wirdf2() => close[1]Alle werden verwendet, um[1] historische Daten in Datenreihen zu referenzieren, aber die Markierungsposition von "A" und "B" auf dem Diagramm ist völlig unterschiedlich. Die Markierungsposition von "A" fällt immer auf die rote Linie, also den Code in der Strategie.plot(close[2], title = "close[2]", color = color.red, overlay = true)Die Daten, die in der Linie verwendet werden, sind:close[2]。

Das ist, weil wir die Index von K-LineBar, die eingebaute Variable, benutzen.bar_indexBerechnen, ob "A" und "B" markiert werden sollen. Die "A" und "B" markiert werden, aber nicht auf jeder K-Line.f(a) => a[1]Wenn die Funktion nicht an jeder Bar aufgerufen wird, wird der Wert, der auf diese Weise referenziert wird, mit der Funktion verglichen.f2() => close[1]Diese Methode bezieht sich auf unterschiedliche Werte (auch wenn der gleiche Index wie [1] verwendet wird).
Einige eingebaute Funktionen müssen an jedem Bar berechnet werden, um ihre Ergebnisse richtig berechnen zu können.

Das kann man mit einem einfachen Beispiel beschreiben:
```
res = close > close[1] ? ta.barssince(close < close[1]) : -1
plot(res, style = plot.style_histogram, color=res >= 0 ? color.red : color.blue)
```
Wir rufen die Funktion in den Code.ta.barssince(close < close[1])Wir schreiben es in einem dreifachen Operator.condition ? value1 : value2Das führt dazu, dass es nur in der Türkei gibt.close > close[1]时去调用ta.barssince函数。可偏偏ta.barssinceDie Funktion wird von der letzten Zeit abgerechnet.close < close[1]Die Anzahl der K-Streifen bei der Einrichtung; die Ta.barssince-Funktion wird bei Anruf von close > close eingesetzt[1], d.h. der aktuelle Schlusskurs ist größer als der Schlusskurs des letzten Bar. Die Ta.barssince-Funktion wird bei Anruf der Bedingung close < close[1] nicht eingesetzt und hat keine letzte Einrichtung.

ta.barssince : Bei Aufruf kehrt die Funktion na zurück, wenn diese Bedingung noch nie vor der aktuellen K-Zeile erfüllt wurde.

Siehe Bild:

Also, wenn wir das Diagramm zeichnen, zeichnen wir nur die Daten, wenn die Res-Variable den Wert ((-1) ∞ hat.

Um dieses Problem zu vermeiden, können wir einfachta.barssince(close < close[1])Funktionsanrufe werden aus den dreifachen Operatoren entnommen und werden in jeder möglichen Bedingungsverzweigung außerhalb geschrieben.
```
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)
```

Zeitreihenfolge

Das Konzept der Zeitreihe ist in der Sprache Pine sehr wichtig und ist ein Konzept, das wir verstehen müssen, wenn wir die Sprache Pine lernen. Eine Zeitreihe ist nicht ein Typ, sondern die grundlegende Struktur für die Kontinuität von Variablen, die mit der Zeit gespeichert werden. Wir wissen, dass Pine-Skripte auf Diagrammen basieren.openist eine Variable in der Pine-Sprache, deren Struktur die Zeitreihe für die Eröffnungspreise für jede K-Zeile Bar speichert.openDiese Zeitreihenstruktur stellt den Startpreis für alle K-String-Bars des aktuellen K-Strings dar, von der ersten Bar, an der es begann, bis zu diesem Bar, an dem das aktuelle Skript ausgeführt wurde. Wenn das aktuelle K-String-String eine 5-minütige Periode ist, dann zitieren wir (oder verwenden) es in der Pine-Strategie-Code.openDer Startpreis von K-LineBar bei der aktuellen Ausführung des Strategiekodes. Wenn ein historischer Wert in der Zeitreihe verwendet werden muss.[]Der Operator. wird verwendet, wenn die Pine-Politik auf einer K-LineBar ausgeführt wird.open[1]Angabe von QuellenopenDer Startpreis des vorherigen K-Line-Bars (d. h. der Startpreis des letzten K-Line-Zyklus) für dieses K-Line-Bar, das das aktuelle Skript in der Zeitreihenfolge ausgeführt hat.

Die Variablen in der Zeitreihe sind sehr praktisch für die Berechnung. Wir haben eine eingebaute Funktion.ta.cumEin Beispiel:

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

Test-Code: Das ist das erste Mal, dass ich einen Test habe.

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

Es gibt viele ähnliche.ta.cumSolche eingebauten Funktionen können Daten aus der Zeitreihe direkt verarbeiten, z. B.ta.cumDas bedeutet, dass wir die entsprechenden Werte der eingegangenen Variablen auf jeder K-LineBar addieren, und dann verwenden wir ein Diagramm, um es zu verstehen.

Strategie und Betrieb	Eingebettete Variable bar_index	V1	V2
Die Strategie läuft auf der ersten K-Linie Bar	0	1	1
Die Strategie läuft auf der zweiten K-Linie Bar.	1	1	2
Die Strategie läuft auf der dritten K-Linie Bar.	2	1	3
…	…	…	…
Die Strategie läuft auf der n + 1 K-Strecke Bar	N	1	N+1

Wie man sieht, sind v1, v2 und sogar bar_index Zeitreihenstrukturen, die für jeden Bar eine entsprechende Datenmenge haben. Der Testcode unterscheidet zwischen "Echtzeit-Preismodell" und "Schließpreismodell" nur, ob die Echtzeit-Bar auf dem Diagramm angezeigt wird.

Die Variable v1 ist für jeden Bar gleich 1.ta.cum(v1)Da die Funktion nur die erste Bar auf der ersten K-Linie Bar ausgeführt wird, ergibt sich für die Variable v2 ein Ergebnis von 1. Wennta.cum(v1)Bei der Ausführung auf der zweiten K-Linie Bar gibt es bereits 2 K-LinienBar (die erste entsprechende Eingabebar_index ist 0, die zweite entsprechende Eingabebar_index ist 1), so dass das Ergebnis 2 ist und die Variable v2 so weiter zugeordnet wird. Es kann tatsächlich beobachtet werden, dass v2 die Anzahl der K-LinienBar in einem Diagramm ist, da die Indexzahl der K-Linien ist.bar_indexWenn wir von 0 ansteigen, dannbar_index + 1Das ist die Anzahl der K-Linienbars.v2undbar_indexIch bin nicht derjenige, der das Problem nicht löst.

Ich kann es auch benutzen.ta.cumDie eingebaute Funktion berechnet die Summe aller Bar-Schließpreise auf dem aktuellen Diagramm und kann nur so geschrieben werden:ta.cum(close), wenn die Strategie in der rechten Echtzeit Bar läuftta.cum(close)Das Ergebnis der Berechnung ist die Summe der Schlusskosten für alle Bar auf dem Diagramm (wenn man nicht bis zur rechten Spitze läuft, nur auf die aktuelle Bar addiert).

Die Variablen in der Zeitreihe können auch mit Operatoren berechnet werden, z. B. Code:ta.sma(high - low, 14)Die Variablen sind in derhigh(K-Line Bar höchste Preis) minuslow(K-Line-Bar-Mindestpreis), zum letzten Mal verwendetta.smaDie Funktion sucht nach dem Mittelwert.

Die Ergebnisse von Funktionsanrufen hinterlassen auch Werte in der Zeitreihe.
```
v1 = ta.highest(high, 10)[1]
v2 = ta.highest(high[1], 10)
plot(v1, title="v1", overlay=true)
plot(v2, title="v2", overlay=true)
```
Der Testcode wird beim Nachprüfen getestet und kann beobachtet werden, dassv1undv2Die Werte sind identisch und die auf dem Diagramm gezeichneten Linien sind vollständig überlappend. Die Ergebnisse der Funktionsanrufe hinterlassen Spuren von Werten in der Zeitreihenfolge, z. B. Code.ta.highest(high, 10)[1]Einer davonta.highest(high, 10)Die Ergebnisse, die durch den Aufruf der Funktion berechnet werden, können auch verwendet werden, um[1] ihren historischen Wert zu zitieren.ta.highest(high, 10)Das Ergebnis ist:ta.highest(high[1], 10)Ich bin nicht derjenige.ta.highest(high[1], 10)undta.highest(high, 10)[1]Das ist ein absolut gleichwertiges Produkt.

Ausgabe von Informationen mit einer anderen Grafikfunktion:
```
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)
```
Man kann sehen, dass die Werte der Variablen a und b in der Zeitreihe oben und unten der entsprechenden Bar angezeigt werden.

Die Struktur des Drehbuchs

Allgemeine Struktur

Im Anfangsteil des Tutorials haben wir einige Unterschiede zwischen der Verwendung der Sprache Pine auf FMZ und der Verwendung der Sprache Pine in Trading View zusammengefasst.indicator()、strategy()Ich bin nicht derjenige, der das tun will.library()Für die Kompatibilität mit den früheren Versionen von Pine-Skript schreibt man natürlich beim Schreiben von Strategien wie://@version=5，indicator()，strategy()Das ist auch möglich. Einige Strategie-Einstellungen können auch in der App verwendet werden.strategy()Die Parameter-Einstellungen in der Funktion.

<version>
<declaration_statement>
<code>

<version>Versionskontrollinformationen können ausgelassen werden.

Kommentare

Pine-Sprache//Als einzeilige Anmerkung, da die Pine-Sprache keine mehrseitigen Anmerkungen hat. FMZ erweitert die Anmerkung/**/Für mehrzeilige Kommentare.

Der Code

Eine Zeile in einem Skript, die keine Anmerkungen oder Kompilatoranweisungen enthält, ist ein Satz, der die Algorithmen des Skripts implementiert. Eine Statement kann eine dieser Inhalte sein.

Variablenerklärung
Wiedervergütung der Variablen
Funktionserklärung
Eingebaute Funktionsanrufe, benutzerdefinierte Funktionsanrufe
if，for，whileoderswitchÄquivalente Strukturen

Sätze können auf verschiedene Weise sortiert werden.

Einige Statements können mit einer Zeile ausgedrückt werden, wie zum Beispiel die meisten Variablenerklärungen, die nur eine Funktionsanrufzeile oder eine Einzeilinie enthalten. Andere, wie Strukturen, benötigen immer mehrere Zeilen, da sie einen lokalen Block benötigen.
Die globalen Aussagen des Drehbuchs (d.h. Teile, die nicht zu den Teilblöcken gehören) können nicht mit空格oder制表符(Tab-Taste) beginnen. Ihr erstes Zeichen muss auch das erste Zeichen der Zeile sein. Die Zeile, die an der ersten Position der Zeile beginnt, ist per Definition Teil des globalen Bereichs des Skripts.
Eine Struktur oder eine mehrstrichige Funktionserklärung benötigt immer einelocal block│ Ein Localblock muss in einen Zeichnersatz oder vier Räume zusammengefasst werden (sonst wird er als serieller Code der vorherigen Zeile analysiert, d.h. als kontinuierlicher Inhalt der vorherigen Code-Zeile beurteilt), wobei jedes Localblock eine andere Lokalfläche definiert.
Mehrere Einzeilsätze können in einer Zeile durch Komma ((,) als Trennzeichen verknüpft werden.
Eine Zeile kann Kommentare enthalten oder nur Kommentare haben.
Die Zeilen können auch zusammengepackt werden (weiter in mehreren Zeilen).

Beispielsweise besteht aus drei Lokalblöcken, von denen eine in der Angabe einer benutzerdefinierten Funktion und zwei in der Angabe einer Variablen die If-Struktur verwenden, die folgenden Code enthalten:

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

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

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

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

Codewechsel

Eine lange Zeile kann in mehrere Zeilen aufgeteilt oder "umgepackt" werden. Eine umgepackte Zeile muss in jede Anzahl von Räumen verkleinert werden, solange sie nicht ein Vielfaches von 4 ist (diese Grenzen werden für die Verkleinerung von Teilen verwendet).

a = open + high + low + close

Kann so verpackt werden (beachten Sie, dass die Anzahl der Schrumpffflächen pro Zeile keine Vielfache von 4 ist):

a = open +
      high +
          low +
             close

Ein langer Plot ((() -Aufruf kann in.

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)

Ein Satz in einer vom Benutzer definierten Funktionserklärung kann auch verpackt werden. Da jedoch ein Lokalblock syntaxgetreu mit einem Schrumpfbeginn beginnen muss ((4 Räume oder 1 Zeichnersatz), muss der Fortlauf des Satzes bei seiner Aufteilung in die nächste Zeile mit mehr als einem Schrumpfbeginn beginnen ((nicht gleich einem Multiplikator von 4 Räumen); zum Beispiel:

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

Identifikatoren und Operatoren

Kennzeichen

Bevor wir die Variablen kennen, müssen wir zuerst das Konzept der Symbolzeichen verstehen.FunktionenundVariablenDer Name (für die Benennung von Variablen, Funktionen) wird verwendet.FunktionenWie wir in unseren nächsten Tutorials erfahren werden, lernen wir zuerst die Symbole für die Anzeichen an.

1. Das Kennzeichen muss groß geschrieben sein.(A-Z)Oder klein geschrieben.(a-z)Buchstaben oder Unterstreifen(_)Der Beginn, der erste Charakter eines Kennzeichens.
2. Das nächste Zeichen nach dem ersten Zeichen des Identifikators kann sein:Schriftzeichen、UntergrenzeoderZahlen。
3. Die Namen der Kennzeichen sind groß und klein geschrieben.

Ein Beispiel dafür ist ein Kennzeichen mit folgenden Namen:

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

Wie in den meisten Programmiersprachen gibt es auch in der Pine-Sprache Schreibempfehlungen.

1, alle Buchstaben sind groß geschrieben, um die Konstante zu benennen.
2. VerwendungDie Regeln der kleinen HügelBenutzt für andere Kennzeichen.

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

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

Die Operatoren

Operatoren sind einige Operationszeichen, die in Programmiersprachen verwendet werden, um Expressions zu konstruieren, und Expressions sind Rechenregeln, die wir für einen bestimmten Rechenzweck entworfen haben, wenn wir Strategien schreiben. Operatoren in der Pine-Sprache werden nach Funktionen klassifiziert als:

Es gibt viele verschiedene Arten von Funktionen, wie z. B. Angabeoperatoren, Rechenoperatoren, Vergleichsoperatoren, Logikoperatoren,? :Die drei-Wert-Operatoren[]Historische Referenz-Operatoren.

Mit Arithmetischen Operatoren*Zum Beispiel gibt es den folgenden Testcode, um die Art der Probleme zu unterscheiden, die durch die Ergebnisse der Pine-Language-Operatoren in Trading View zurückgegeben werden:

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

Bei der Ausführung dieses Skripts in Trading View wird ein Fehler berichtet, weiladjustedLength = lenInput * factorDas Ergebnis nach dem Multiplikator ist:series intTyp ((Serie), jedochta.emaDer zweite Parameter der Funktion unterstützt diesen Typ nicht. Allerdings gibt es auf FMZ keine solchen strengen Einschränkungen.

Hier sehen wir gemeinsam, wie verschiedene Operatoren verwendet werden.

Zuordnungsoperator

Es gibt zwei Arten von Bewertungsoperatoren:=、:=Das haben wir auch in einigen Beispielen zu Beginn dieses Tutorials gesehen.

=Die Operatoren werden verwendet, um eine Variable zu initialisieren oder zu deklarieren.=Die Variablen nach der Initialisierung, der Erklärung der Zuordnung, beginnen mit diesem Wert in jedem folgenden Bar. Dies sind alle gültige Variablenerklärungen:

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)

Vorsicht.a = closeBewertungsstatements, bei denen die Variable a für jede Bar der aktuelle Schlusspreis für diese Bar ist (siehe unten). Andere Variablenb、c、dDie Ergebnisse werden durch ein Diagramm angezeigt.

:=Es wird verwendet, um einen Wert an eine vorhandene Variable neu zuzuordnen.:=Die Operatoren werden verwendet, um den Wert einer bereits deklarierten, initialierten Variable zu ändern. Wenn es verwendet wird:=Ein Operator kann Fehler bei nicht initialierten oder deklarierten Variablen erzeugen, z. B.:

a := 0

Das ist ein sehr schwieriger Fall.:=Die Assignment-Operatoren werden in der Regel verwendet, um bereits vorhandene Variablen neu zuzuordnen, z. B.:

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

plot(b)

Beurteilen, obclose > open(d.h. das aktuelle BAR ist die Sonnenscheinlinie), a ist der Wahrheitswert (true) ; dann wird der Code im lokalen Block der if-Sätze ausgeführt.b := b + 1, mit einem Assignment-Operator:=Die Variable b wird neu bewertet, einem 1 hinzugefügt und dann mit der Plot-Funktion in einem Diagramm die Werte der Variablen b in den einzelnen BARs der Zeitreihen in Zeilen dargestellt.

Ist es nicht so, dass wir hier die Variable b erklären, ohne dass wir beim Initiieren auf 0 irgendein Schlüsselwort verwenden?b=0Wir können also sehen, dass das Ergebnis der Ausführung dieses Codes ist, dass wir die Variable b jedes Mal wieder auf 0 setzen, wenn a ein wahrer Wert ist.close > openDann wird b bei dieser Ausführung 1 addiert, wenn die Plot-Funktion ein Diagramm zeichnet, aber b wird bei der nächsten Ausführung zu 0 neu zugewiesen. Auch hier ist es für Anfänger in der Pine-Sprache leicht, in eine Grube zu treten.

Wenn es um die Angabeoperatoren geht, müssen wir zwei Schlüsselwörter erweitern:var、varip

Ver-

In der Tat ist dieses Schlüsselwort, das wir in früheren Tutorials gesehen und verwendet haben, nur nicht zu der Zeit ausführlich erörtert worden.

var ist ein Schlüsselwort, das verwendet wird, um Variablen zu vergeben und einmalig zu initialisieren. In der Regel führt die Variablenbezeichnungssymmetrie, die das Schlüsselwort var nicht enthält, dazu, dass der Wert der Variablen bei jedem Datenaufruf überschattet wird. Im Gegensatz dazu können Variablen, die mit dem Schlüsselwort var vergeben werden, trotz der Datenauflage den Status erhalten.

Wir benutzen dieses Beispiel immer noch, aber wir benutzen es, wenn wir b zuordnen.varSchlüsselwörter.
```
a = close > open 
var b = 0 
if a
    b := b + 1

plot(b)
```
varDie Schlüsselwörter lassen die Variable b nur die ursprüngliche Erstbezeichnung ausführen und setzen sie bei jeder Ausführung der Strategielogik nicht mehr auf 0, so dass die Linie, die beim Laufen gezogen wird, beobachtet werden kann, dass b die Anzahl der Sonnenstrahlen BARs ist, die bei der aktuellen K-Linie BAR aufgetreten sind.

Variablen mit der Erklärung var können nicht nur global geschrieben werden, sondern auch in einem Codeblock, wie in diesem Beispiel:
```
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")
```
Die Variable a hält den Schlusspreis der ersten Säule in der Reihe. Die Variablen B bleiben bei der Eröffnungs- und Schlusskurs der ersten in der Reihe. Die Variable C hält den Schlusskurs der zehnten in der Serie stehenden grünen Kürze.
Variation

varipWir sehen dieses Schlüsselwort zum ersten Mal, und wir können die Beschreibung dieses Schlüsselworts ansehen:

varip ((var intrabar persist) ist ein Schlüsselwort für die Zuordnung und Einmalinitialierung von Variablen. Es ist ähnlich dem Schlüsselwort var, aber Variablen mit der Varip-Deklaration behalten ihren Wert zwischen Echtzeit-K-Linien-Aktualisierungen.

Ist es schwieriger zu verstehen? Ist es okay, wir erklären es mit Beispielen und es ist leicht zu verstehen.
```
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
```
Der Testcode zeigt sich in verschiedenen Formen im "Schließpreismodell" und "Echtzeitpreismodell":

Das Modell der Echtzeitpreise: Denken Sie daran, dass wir die Strategie in der historischen BAR-Phase und in der Echtzeit-BAR-Phase ausgeführt haben.var、varipVariablen für die Erklärungi、iiBei jeder Runde der Ausführung des Strategiekodes werden inkrementelle Operationen ausgeführt. So kann man sehen, dass die Zahlen, die auf der K-Line BAR für die Wiederholung des Ergebnisses angezeigt werden, jeweils inkrementell 1 sind. Wenn die historische K-Line-Phase endet, beginnt die Echtzeit-K-Line-Phase.i := i + 1undii := ii + 1Der Unterschied ist, dass ii jedes Mal geändert wird. i wird zwar jedes Mal geändert, aber bei der nächsten Ausführung der Strategielogik wird der vorherige Wert wiederhergestellt. (Erinnern Sie sich an den Rücklaufmechanismus, den wir im vorherigen Kapitel "Modelldurchführung" erörtert haben?), Der Wert von i wird erst festgestellt, wenn die aktuelle K-Leitung BAR abgelaufen ist.

Das Modell der Verkaufspreise: Da das Schlusspreismodell eine Strategie-Logik ausführt, die nur einmal ausgeführt wird, wenn jede K-Linie BAR abläuft. In dem Schlusspreismodell werden die Variablen der historischen K-Linie-Phase und der Echtzeit-K-Linie-Phase, die von var, varip erklärt werden, in den oben genannten Beispielen inkrementell vollständig übereinstimmend dargestellt, wobei jede K-Linie BAR inkrementell 1 ist.

Arithmetische Operatoren

Die Operatoren	Erläuterung
+	Die Gafa
-	Abbau von Gesetzen
*	Multiplikation
/	Ausnahme
%	Modellsuche

+、-Die Operatoren können als Binäroperatoren oder als Einheitsoperatoren verwendet werden. Andere Arithmetische Operatoren können nur als Binäroperatoren verwendet werden und geben Fehler zurück, wenn sie als Einheitsoperatoren verwendet werden.

1, Die Operatoren sind auf beiden Seiten mit einem Zahlentyp versehen. Das Ergebnis ist der Zahlentyp, der Ganztyp oder die Floppzahl. Wenn die Operatorzahl eine String ist, dann ist die Operatorzahl+, wird das Ergebnis eine String, die Zahlen werden in die Form einer String umgewandelt, die dann zusammengefügt wird. Wenn es sich um andere Arithmetik-Operatoren handelt, wird versucht, die String in eine Zahlenzahl zu konvertieren und dann zu arbeiten. 3. Wenn eine der Operationszahlen na ist, wird die Berechnung als Nullwert na ausgeführt und wird beim Drucken auf der FMZ NaN angezeigt.

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

Die Pine-Sprache auf FMZ unterscheidet sich hier etwas von der Pine-Sprache auf Trading View.

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

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

Die Funktion ist in der FMZ möglich, wird aber in der Trading-Ansicht mit einem Typenfehler versehen. Wenn die Operationen an beiden Seiten der Arithmetik-Operatoren Strings sind, wird das System die String zu einem Zahlenwert umwandeln. Wenn die nicht-numerische String nicht berechnet werden kann, wird das System-Operationsergebnis als null na betrachtet.

Vergleiche die Operatoren

Die Vergleichsoperatoren sind binäre Operatoren.

Die Operatoren	Erläuterung
<	Weniger als
>	Größer als
<=	Weniger ist gleich
>=	Größer als gleich
==	Gleichwertig
!=	Ungleichheit

Testbeispiel:

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

Wie Sie sehen können, ist der Vergleichsoperator sehr einfach zu verwenden, aber er ist auch der Operator, den wir am häufigsten verwenden, wenn wir Strategien schreiben.close、openUnd so weiter. Wie bei den Operationsoperatoren unterscheidet sich Pine auf FMZ von Trading View, da FMZ keine besonders strengen Anforderungstypen hat.d = "1" >= 2In FMZ gibt es keine Fehlermeldung. Bei der Ausführung wird die String zu einem Zahlenwert umgewandelt und dann wird die Operation verglichen. In Trading View gibt es Fehlermeldungen.

Logische Operatoren

Die Operatoren	Codezeichen	Erläuterung
Nicht	- Nein.	Einmalige Operatoren, nicht ausgeführt
und	und	Binäre Operatoren, die mit ((und) arbeiten
oder	oder	Binäre Operatoren oder Operationen

Wenn es um logische Operatoren geht, dann muss es um die Echtwerttabelle gehen. Wie wir es in der Highschool gelernt haben, nur dass wir hier im Retrospektivsystem testen und lernen:

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

Um zu verhindern, dass die immer wieder gedruckten Informationen durch das Retrospektiv die Beobachtung beeinflussen, benutzen wir eine neue Methode.runtime.error("stop")Die Aussage wird nach einer Druckdurchführung mit einem ungewöhnlichen Fehler gestoppt, sodass die Ausgabe beobachtet werden kann und festgestellt wird, dass der gedruckte Inhalt und die Echtwerttabelle identisch sind.

Dreifache Operatoren

Mit dreifachen Operatoren? :Die Kombination von drei Elementen und Operatoren.condition ? valueWhenConditionIsTrue : valueWhenConditionIsFalseWir haben es in früheren Lektionen schon gelernt. Eine sogenannte Dreifach-Expression, eine Dreifach-Operator, bedeutet, dass es insgesamt drei Operationen gibt.

condition ? valueWhenConditionIsTrue : valueWhenConditionIsFalseIn der MitteconditionWenn die Ausdrücke "true" oder "true" sind, dann ist der Wert:valueWhenConditionIsTrueWennconditionWir haben eine Hypothese.valueWhenConditionIsFalse。

Es gibt viele Beispiele, die praktisch nicht nützlich sind, aber einfach zu demonstrieren sind:

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)

Was passiert, wenn wir einen Kreuzstab treffen, ist egal! Dreifache Ausdrücke können auch eingebettet werden, so wie wir es in einem früheren Tutorial getan haben.

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)

Das ist das gleiche wiecondition ? valueWhenConditionIsTrue : valueWhenConditionIsFalseInnerlichvalueWhenConditionIsTrue、valueWhenConditionIsFalse, wird auch mit einem anderen Dreifach-Ausdruck ersetzt.

Historischer Operator

Mit historischen Operatoren[], beziehen sich auf die historischen Werte der Zeitreihe. Diese historischen Werte sind die Werte der Variablen auf der K-Linie BAR vor der aktuellen K-Linie BAR, wenn das Skript ausgeführt wird.[]Die Operatoren werden nach den Anrufen von Variablen, Ausdrücken und Funktionen verwendet.[]Die Zahlen in den Klammern sind die Abweichung der historischen Daten, die wir anführen wollen, von der Entfernung der aktuellen K-Line BAR. Zum Beispiel, wenn ich den Schlusskurs einer K-Line BAR zitieren möchte, dann kann man schreiben:close[1]。

Wir haben in früheren Kursen schon so etwas gesehen:

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

[]Der Operator kann nur einmal für denselben Wert verwendet werden, also wird er falsch geschrieben und gibt einen Fehler zurück:

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

Sie können sehen, dass einige meiner Schüler sagen, dass die Operatoren[]Das ist für die Serie-Struktur, die ähnlich aussieht wie eine Serie und eine Matrix. Im Folgenden zeigen wir mit einem Beispiel, wie sich eine Reihe und eine Array in der Pine-Sprache unterscheiden.

strategy("test", overlay=true)

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

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

Obwohla = close[1][2]Das ist ein Fehler, aber:

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

Wenn man die Zahlen in der normalen Arithmetik versteht, dann ist es nicht falsch, wenn man sie in der normalen Arithmetik schreibt.b = close[1]Nach der Zuordnung sollte b ein Wert sein.c = b[1], b kann abermals mit dem historischen Operator auf den historischen Wert zurückgeführt werden. Wie man sieht, ist das Konzept der Reihe in der Sprache Pine nicht so einfach wie die Array. Man kann den historischen Wert auf dem letzten Bar, der zu b zugeordnet wurde, als "close" verstehen. b ist auch eine Zeitreihenstruktur, die ihren historischen Wert weiter zitiert.

Wir können das Diagramm nach links ziehen und feststellen, dass die Werte von b und c auf der ersten K-Zeile null sind. Das ist, weil ein oder zwei Perioden-Historien, die beim Ausführen des Skripts auf der ersten K-Zeile BAR nicht vorne zitiert werden, nicht vorhanden sind.na、nzWir haben es auch in früheren Studien angesprochen.nz、naFunktionen, erinnern Sie sich noch, in welchem Abschnitt?) spezifische Fälle von Leerwerten behandelt, wie zum Beispiel:

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

Dies ist eine Art Handhabung für mögliche Referenzen an Nullwerte ((na)).

Priorisierung der Operatoren

Wir haben schon viele Operatoren in der Pine-Sprache gelernt, die durch verschiedene Kombinationen von Operationszahlen und Operationszahlen Ausdrücke bilden. Wie ist die Priorität dieser Operationen, wenn sie in den Ausdrücken berechnet werden?

Prioritäten	Die Operatoren
9	`[]`
8	Einheitliche Operatoren`+` 、`-`und`not`
7	`*`、`/`、`%`
6	Binäre Operatoren`+`、`-`
5	`>`、`<`、`>=`、`<=`
4	`==`、`!=`
3	`and`
2	`or`
1	`?:`

Die mit hoher Priorität ausgewiesenen Ausdrucksbereiche werden zuerst bearbeitet, wenn die Priorität gleich ist, dann von links nach rechts.()Die Ausdrücke werden in einem Umschlag umgeben, in dem die Teilbearbeitung gezwungen ist.

Variablen

Variablenerklärung

Wir haben bereits das Konzept der Variablen-Kennzeichen gelernt, die Variablen als Namen für Variablen benannt werden. Also: Variablen sind Kennzeichen, die Werte speichern.

Die Erklärung: Bei der Erklärung einer Variablen wird zuerst "Deklarationsmodus" geschrieben. 1. Verwenden Sie das SchlüsselwortvarDas ist nicht wahr. 2. Verwenden Sie SchlüsselwörtervaripDas ist nicht wahr. 3. Nichts geschrieben.

var、varipDie Schlüsselwörter, die wir bereits in den vorherigen Kapiteln über "Zuschreibungsoperatoren" gelernt haben, werden hier nicht mehr beschrieben.i = 1, in der Tat haben wir bereits gesagt, dass die Variablen, die so erklärt werden, und die Angabe, dass sie auf jeder K-Line BAR ausgeführt werden.
Typ Die Pine-Sprache auf FMZ ist für Typanforderungen nicht streng und kann in der Regel übersprungen werden. Allerdings kann eine Variable auch mit einem Typ deklariert werden, um die Skriptsysteme in Trading View zu unterstützen.
```
int i = 0 
float f = 1.1
```
Typen in der Trading View sind strengere Anforderungen, wenn der folgende Code in der Trading View verwendet wird:
```
baseLine0 = na          // compile time error!
```
Kennzeichen Ein Identifier ist der Name einer Variable, die in den vorherigen Kapiteln erwähnt wurde.https://www.fmz.com/bbs-topic/9390#标识符

Zusammenfassend kann man sagen, dass eine Variable so geschrieben werden kann:

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

Hier wird ein Angabe-Operator verwendet:=Bei der Variablenerklärung wird eine Variablenbezeichnung gegeben. Bei der Bezeichnung können Werte Strings, Zahlenwerte, Ausdrücke, Funktionsanrufe,if、 for、whileoderswitchDie Strukturen werden in den folgenden Kursen erläutert, obwohl wir in den vorherigen Kursen bereits die einfache Angabe von If-Sätzen gelernt haben.

Wir haben uns hier auf die Input-Funktion konzentriert, eine Funktion, die wir häufig verwenden, wenn wir unsere Design-Policies schreiben.

Die Eingabefunktion:

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

Die Input-Funktion auf der FMZ unterscheidet sich etwas von der Funktion in der Trading View, allerdings wird sie als Assignierungsinput für die Strategieparameter verwendet.

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)

Bei der Erklärung von Variablen wird häufig die Input-Funktion verwendet. In FMZ wird die Input-Funktion automatisch in der FMZ-Politik-Interface die Steuerung für die Einstellung der Politikparameter dargestellt. Die auf FMZ unterstützten Steuerungen verfügen derzeit über Zahlen-Eingabefelder, Text-Eingabefelder, Drop-Boxen, Blur-Wert-Auswahl.

Wir haben einige wichtige Parameter für die Input-Funktion erläutert:

defval: Default für die Einstellung der Input-Funktion als Strategieparameter, unterstützt die Variablen, Zahlen und Strings in der Pine-Sprache
title: Name der Parameter, die die Politik auf der Festplatte/zurückgeprüften Politik-Oberfläche anzeigt.
Tooltip: Hinweise auf die Politikparameter, die beim Hängen der Maus über die Politikparameter eine Textinformation mit der Einstellung dieser Parameter anzeigen.
group: Ein Name für eine Gruppe von Parametern, die als Parametergruppen bezeichnet werden können.

Neben der Erklärung einzelner Variablen und der Zuordnung gibt es in der Pine-Sprache auch eine Schreibweise, in der eine Gruppe von Variablen und eine Zuordnung erklärt wird:

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

Die häufigste ist, dass wirta.macdBei der Berechnung des MACD-Indikators können drei Datensätze berechnet werden, da der MACD-Indikator ein Multiline-Indikator ist.

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

Wir können einfach MACD-Diagramme mit diesem Code zeichnen. Nicht nur die eingebauten Funktionen können mehrere Variablen zurückgeben, sondern auch die geschriebenen Custom-Funktionen können mehrere Daten zurückgeben.

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)

Die Verwendung von Strukturen wie if als Multi-Variablen-Zuteilung ist ähnlich wie bei den oben genannten Custom Functions.

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

Konditionsstruktur

Einige Funktionen sind in lokalen Codeblöcken, die nicht in den bedingten Zweigen geschrieben werden können, vor allem folgende Funktionen:

Barfarbe (), Füllfarbe (), Linie (), Indikator (), Grafik (), Grafikleuchten (), Grafikbild (), Grafikbild (), Grafikbild ().

Auf Trading View werden Fehlerberichte zusammengestellt. Auf FMZ sind die Einschränkungen nicht so streng, aber es wird empfohlen, die Regeln auf Trading View zu befolgen. Zum Beispiel ist es nicht empfohlen, so zu schreiben, obwohl es auf FMZ keine Fehlerberichte gibt.

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

Das ist die Sprache.

Nächste Seite

Mehr