[TOC]

Schlüsselwörter, Grammatik und Einstellungsbeschreibung

Code-Struktur

Die allgemeine Struktur, der der Code in Pine folgt:

<version>
<declaration_statement>
<code>

Anmerkungen

Kommentare für die FMZ-Pine-Sprache: Einzeilinks//Mehrsprachige Anmerkungen/* */Wie die Kommentare in den folgenden Beispielen geschrieben werden:

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

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

Veröffentlichung

Die Kompilator-Anweisung in der folgenden Form sagt dem Kompilator, in welcher Version des Skripts Pine geschrieben wurde:

//@version=5

Standardversion v5, kann im Code übersehen werden//@version=5。

Erklärung

• indicator()
• strategy()

Die Anweisungssätze bestimmen den Typ des Skripts, was wiederum entscheidet, was darin erlaubt ist, und wie es verwendet und ausgeführt wird. Sie setzen die Schlüsselattribute des Skripts ein, wie z. B. seinen Namen, wo er erscheint, wenn er in die Grafik hinzugefügt wird, die Genauigkeit und Format der Werte, die er anzeigt, und die Werte, die für bestimmte Verhaltensweisen bei der Steuerung seines Laufens gelten, wie z. B. die maximale Anzahl der Grafikobjekte, die er in der Grafik anzeigt. Für Strategien umfassen die Attribute Parameter, die mit der Rückwärtskontrolle gemessen werden, wie z. B. Startkapital, Provisionen, Gleitpunkte usw.indicator()oderstrategy()Das ist eine sehr schwierige Aufgabe.

Der Code

Eine Zeile in einem Skript, die keine Kommentare oder Kompilierer-Anweisungen enthält, ist ein Statement, das die Algorithmen des Skripts umsetzt. Ein Statement kann eines dieser Inhalte sein.

• Variablenerklärung
• Variablen neu zuordnen
• Funktionserklärung
• Eingebettete Funktionsaufrufe, benutzerdefinierte Funktionsaufrufe
• if，for，whileoderswitchGleichgewichtsstruktur

Sätze können auf verschiedene Arten angeordnet werden.

• Einige Sätze können in einer Zeile ausgedrückt werden, wie z. B. die meisten Variablenerklärungen, die nur eine Zeile mit einem Funktionsaufruf oder eine Einzelarbeitserklärung enthalten. Andere, wie Strukturen, benötigen immer mehrere Zeilen, da sie einen lokalen Block benötigen.
• Die globalen Aussagen des Skripts (d. h. die Teile, die nicht zu den lokalen Blöcken gehören) können nicht als空格oder制表符(Tab-Taste) beginnen. Ihr erster Buchstabe muss auch der erste Buchstabe der Zeile sein. Zeilen, die mit der ersten Position in der Zeile beginnen, sind per Definition Teil des globalen Umfangs des Skripts.
• Eine Struktur- oder Mehrzeilenfunktionsanweisung erfordert immer einelocal block。 Ein lokaler Block muss in ein Kennzeichen oder vier Leerzeichen geschrumpft werden (andernfalls wird er als die fortlaufende Inhalte der vorherigen Codezeile analysiert), wobei jeder lokale Block einen anderen lokalen Bereich definiert。
• Mehrere einzelne Sätze können in einer Zeile durch die Verwendung des Kommas ((,) als Trennzeichen in einer Reihe zusammengefügt werden.
• Eine Zeile kann Kommentare enthalten oder nur Kommentare sein.
• Die Zeilen können auch eingewickelt werden (weiter auf mehreren Zeilen).

Zum Beispiel umfasst es drei lokale Blöcke, eine in einer benutzerdefinierten Funktionsanweisung und zwei, die die if-Struktur in einer Variablenanweisung verwenden, wie folgt:

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

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

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

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

Code-Wechsel

Längere Zeilen können in mehrere Zeilen aufgeteilt oder “eingepflanzt” werden. Die eingepflanzte Zeile muss in eine beliebige Anzahl von Leerstellen geschrumpft werden, sofern sie nicht ein Vielfaches von 4 ist (diese Grenzen dienen dazu, in lokale Blöcke zu schrumpfen).

a = open + high + low + close

Es kann in folgenden Formularen verpackt werden (beachten Sie, dass die Anzahl der Zeilen, die pro Zeile eingekrümmt werden, kein Vielfaches von 4 ist):

a = open +
      high +
          low +
             close

Ein langer Plot ((() -Aufruf kann in eine Packe packt werden.

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)

Sätze in einer benutzerdefinierten Funktionsanweisung können auch verpackt werden. Da jedoch die lokalen Blöcke grammatisch mit einem Verkürzungszeichen beginnen müssen (z. B. 4 Felder oder 1 Schreibzeichen), müssen die Fortsetzungssätze der Sätze, wenn sie in die nächste Zeile aufgeteilt werden, mit einem oder mehr Verkürzungen beginnen (z. B. nicht gleich dem Vielfachen von 4 Feldern).

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

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

Zeitfolge

Zeitreihen sind keine Datentypen oder -formate. Zeitreihen sind ein grundlegendes Konzept in der Sprache PINE. Sie werden verwendet, um Werte zu speichern, die sich zeitlich fortlaufend ändern, wobei jeder Wert einem Zeitpunkt entspricht. Mit integrierten VariablenopenDas ist ein Beispiel.openDie eingebaute Variable zeichnet den Eröffnungspreis für jede K-Linie BAR auf, wenn dieseopenDas ist die Daten von 5 Minuten K-Linien-Perioden.openIn der Variablen werden die Eröffnungspreise für alle 5 Minuten der K-Zeile BAR ({column}) aufgezeichnet.openDas heißt, wir beziehen den Eröffnungswert der K-Linie BAR, in der wir uns gerade befinden. Um den vorherigen Wert in der Zeitserie zu beziehen, verwenden wir[]Der historische Operator, wenn die Strategie auf einer K-Linie BAR ausgeführt wird,open[1]Das bedeutet, dass der Anfangspreis der vorherigen K-Linie BAR der aktuellen K-Linie BAR angegeben wird.

ObwohlZeitfolgeEs ist leicht, an die Datenstruktur “Array” zu denken, obwohl die Sprache PINE auch Array-Typen hat. Sie sind jedoch ein völlig anderes Konzept als die Zeitreihen.

Die PINE-Sprache ist so konzipiert, dass die Zeitreihen in der Strategie-Code leicht berechnet werden können, ohne dass eine Kreislauf-Struktur wie for verwendet wird, sondern nur mit einer eingebauten Funktion der PINE-Sprache.ta.cum(close)Als weiteres Beispiel müssen wir den Mittelwert der Differenz zwischen dem höchsten und dem niedrigsten Wert der letzten 14 K-Linien berechnen.ta.sma(high - low, 14)

Das Ergebnis eines Aufrufs einer Funktion auf einer Zeitreihenfolge hinterlässt auch eine Spur auf der Zeitreihenfolge.[]Der historische Operator bezieht sich auf den vorherigen Wert. Zum Beispiel, um zu testen, ob der Schlusskurs der aktuellen K-Linie BAR den Maximalwert des höchsten Wertes der letzten 10 K-Linie BAR überschreitet (exklusive der aktuellen K-Linie BAR).breach = close > ta.highest(close, 10)[1]Das kann man auch so schreiben:breach = close > ta.highest(close[1], 10)Das ist es.ta.highest(close, 10)[1]Undta.highest(close[1], 10)Es ist gleichwertig.

Das kann mit folgenden Codes verifiziert werden:

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

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

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

Der oben genannte Testcode gibt a und b auf jeder BAR ihre entsprechenden Zeitreihenwerte aus, so dass a und b immer gleich sind, also gleichwertig.

Historisches Referenzieren

In Trading View gibt es eine maximale Anzahl von Artikeln für historische Datenbezüge (maximal 5000), z. B. folgender Code:

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

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

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

“Transaktions-Einstellungen” in der “Pine-Language-Trading-Klasse” mit der PINE-Language-Strategie auf der FMZ, Parameter: “Längste Periodennummer der Variablen” spezifisch für die maximale Anzahl von Artikeln, auf die Daten bezogen werden können.

indicator("test")

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

Das Parameter “Längste Periodenzahl der Variablen” sollte nicht zu groß eingestellt werden.

Modellparameter der Pine-Sprache

Beschreibung der Parameter-Einstellungen für die in der PINE-Strategie integrierte Vorlage “Pine Language Transaction Class Repository”.

Handelsplatz

• Ausführung Schlusskursmodell: Das Modell wird erst ausgeführt, wenn der aktuelle BAR abgelaufen ist, und der Handel wird ausgeführt, wenn der folgende BAR beginnt. Echtzeit-Preismodell: Bei jeder Preisänderung wird das Modell ausgeführt, und der Handel wird sofort ausgeführt, wenn ein Signal vorliegt.
• Default-Start-Hand-Nummer: Wenn die Handelsanweisung keine Handelsmenge angibt, wird der Handel mit der Anzahl ausgeführt, die für diese Einstellung festgelegt ist.
• Maximaler Betrag pro Auftrag: Entsprechend der tatsächlichen Platzierung, in Kombination mit dieser Parameter-Einstellung, bestimmen Sie die maximale Anzahl pro Auftrag und vermeiden Sie die Platzierung.
• Der Preisverlust liegt bei:定价货币精度Der Parameter und dieser Parameter bestimmen den Kursschwung zum Zeitpunkt des Auftrags. Zum Beispiel, wenn die Preisschwelle auf 2 festgelegt ist, d.h. auf die zweite Zahl der Komma, auf 0,01 genau. Dann repräsentiert jeder Kursschwungpunkt 0,01 Preiseinheiten. Wenn der Kursschwungpunkt auf 5 gesetzt ist, ist der Kursschwung zum Zeitpunkt des Auftrags 0,05 (der Kursschwungwert ist der Teil des Preises, der zum Zeitpunkt des Auftrags zum Zeitpunkt des Auftrags zum besseren Zweck und zum Abschluss des Auftrags überschüttet).
• Maximaler Zyklus der Variablen: Anzahl der BAR-Linien, die das Diagramm beeinflussen, undjavascriptIn der Strategie aufgerufenSetMaxBarLenDie Funktionen sind gleich.

Futures-Optionen

• Varietätcode: Vertragscode, der nur dann eingestellt werden muss, wenn das Exchange-Objekt ein Non-Cash Exchange-Objekt ist.
• Mindestbetrag der Aufträge: Der Mindestbetrag der Aufträge zum Zeitpunkt der Bestellung.

Reale Optionen

• Automatische Wiederaufnahme des Fortschritts: Wiederherstellung des Zustands vor dem Ende der letzten Strategie.
• Anzahl der Auftragswiederholungen: Wenn der Auftrag nicht ausgeführt wird, wird der Auftrag widerrufen und der Auftrag erneut getestet. Dieser Parameter dient zur Begrenzung der maximalen Anzahl von Wiederholungen.
• Netzwerk-Umfrageintervalle ((Millisekunden): Nur für REST-Protokollen gültig, um Netzwerk-Anfragenintervalle zu steuern und zu vermeiden, dass Anfragen zu häufig sind und die Börsengrenzen überschreiten.
• Kontosynchronisierungszeit (in Sekunden): Zeitspanne, in der die Kontodaten synchronisiert werden.
• Positionssynchronisierung nach der Eröffnung der Position (in Millisekunden): Die Einstellung einer größeren Synchronisierung kann diese Probleme lindern.
• Hebelzahl: Setzen Sie die Hebelzahl.

In-Konto-Transaktionen und andere Einstellungen

• Einmalige Transaktionsmenge: Die Standard-Einmalige Transaktionsmenge gilt nur für Bargeld.
• Minimaler Umsatz: Minimaler Umsatz.
• Preisexaktheit: Preisexaktheit, also die geringe Zahl der Preise.
• Handelsartgenauigkeit: Genauigkeit der nächsten Bestellung, d.h. die kleine Zahl der nächsten Bestellung.
• Die Gebühren für die Berechnung von Daten mit dieser Einstellung betragen 0,002 = 2 tausendstel.
• Verlust- und Verluststatistiken: Verlust- und Verluststatistiken werden nur auf der Festplatte verwendet.
• Versagter Wiederaufnahmeversuch ((ms): Wiederaufnahmeintervall bei fehlgeschlagenen Netzwerkanfragen.
• Die Verwendung eines Agenten gilt nur für REST-Protokollen.
• Verbergen Sie häufige Netzwerkfehler: Verbergen Sie häufige Fehler im Logbereich.
• Die Umschalt-Basis-Adresse gilt nur für REST-Protokollen.
• Push-Benachrichtigungen: Nachrichten an Postfächer weiterleiten usw.

Bestellung aufgeben

Positionen eröffnen

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

Niederlage

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

Handelsmechanismen

Die PINE-Sprache hat eine ähnliche Positionsmechanik wie einseitige Positionen. Zum Beispiel, wenn Positionen in mehreren Richtungen gehalten werden (z. B. wenn eine Position in mehreren Richtungen gehalten wird), werden die Orders, die zum Verkauf von Operationen, Planungslisten usw. ausgelöst (im Gegensatz zur Positionshaltung), zuerst die Positionen in mehreren Richtungen ausgeglichen (im Gegensatz zu allen Positionen), und dann die Orders ausgelöst (im Gegensatz zur Positionshaltung vor der Position).

Planungsbogen

Bei der Bestellung mit der Bestellinstruktion wird der Marktpreis als Default verwendet, wenn kein Preis angegeben ist. Außer dem Marktpreis kann auch über den Planbestell bestellt werden, der Planbestell wird nicht sofort betrieben. Der Planbestell kann in der Programmauftrags-Queue eingestellt werden, in der kein Programm vorhanden ist, wenn er ausgelöst wird.Festplatte / RückmessungIn der “Plan-Order”-Tabelle des Zeit-Status-Informations (d.h. der Status-Archiv, in dem die Strategie ausgeführt wird) sieht man, dass das System nur dann wirklich bestellt, wenn die Markt-Echtzeit-Preise die Bedingungen für die Auslösung dieser Plan-Einzelteile erfüllen. Daher ist es normal, dass diese Bestellungen mit einer geringen Abweichung von den Transaktionspreisen abschließen.strategy.entryWenn wir eine Funktion anfordern, können wirlimit、stopParameter

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

• Limit-Bestellung

Setzen Sie den Limitpreis für die Bestellung, wenn die Bestellung als Kaufpreis gilt (d.h.directionDie Parameter sindstrategy.longDer Auftrag wird nur dann ausgelöst, wenn der aktuelle Marktpreis unter diesem liegt. Wenn der Auftrag auf der Liste steht (d.h.directionDie Parameter sindstrategy.shortDer Auftrag wird nur dann ausgelöst, wenn der aktuelle Marktpreis höher ist als dieser Preis.

• Stop-Befehl

Setzen Sie einen Stop-Loss-Preis für eine Order, der nur dann ausgelöst wird, wenn der aktuelle Marktpreis höher ist als der Preis, zu dem die Order gekauft wurde. Wenn ein Auftrag als Verkaufspreis ausgeführt wird, wird der Auftrag nur dann ausgelöst, wenn der aktuelle Marktpreis unter diesem Preis liegt.

• Stop-Limit-Bestellung

Gleichzeitig eingestelltlimit、stopParameter, bei denen der Auftrag zu dem zuerst qualifizierten Preis ausgelöst wird.

Prozentsatz der Ansprüche

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

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

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

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

Geben Siedefault_qty_type=strategy.percent_of_equityNach der Einstellungdefault_qty_valueAls Prozentsatz ((0 ~ 100), 1 ist 1%. Der Auftrag wird nach der Anzahl der Währungen berechnet, die auf dem Konto angegeben sind. Beispielsweise: Das aktuelle Konto hat 10000 USDT und setzt einen Auftrag von 1%, d.h. einen Auftrag mit 100 USDT (berechnet nach dem aktuellen Preis beim Verkauf).

Erklärung, Logik und Schlüsselwörter

var

var ist das Schlüsselwort für die Verteilung und einmalige Initialisierung von Variablen. In der Regel führt eine Variablenzuweisung ohne das Schlüsselwort var dazu, dass die Variablenwerte bei jeder Datenaktualisierung überschrieben werden. Im Gegensatz dazu können Variablen, die mit dem Schlüsselwort var zugewiesen werden, trotz der Datenaktualisierung die Statuskarte behalten und nur dann ändern, wenn die Bedingungen in den if-Expressions erfüllt sind.

var variable_name = expression

Erklärungen:

• variable_name- jeder Name der in Pine Script erlaubten Benutzervariablen ((, der aus groß- und kleingeschriebenen lateinischen Buchstaben, Zahlen und Unterstrichen besteht))_), aber nicht mit einer Ziffer.)
• expression- Jeder arithmetische Ausdruck, wie die Definition einer regulären Variablen. Der Ausdruck wird berechnet und der Variablen einmal zugewiesen.

Beispiel

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

Die Variable ‘a’ behält den Schlusskurs der ersten Säule jeder Säule in der Reihe. Die Variable ‘b’ hält den Schlusskurs der ersten in der Reihe, der grünen Zitronen-Preisschwange. Die Variable ‘c’ hält den Schlusskurs für die zehnte Kartoffel in der Reihe.

Auf der FMZ gibt es eine Realzeit- und eine Schlusskursmodell, die für dievar、varipDie Variablen der Erklärung werden mit dem folgenden Code getestet:

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

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

// 将策略逻辑每轮改变的i、ii打印在图上
plotchar(true, title="ii", char=str.tostring(ii), location=location.abovebar, color=color.red)
plotchar(true, title="i", char=str.tostring(i), location=location.belowbar, color=color.green)

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

• Echtzeit-Preismodell Der Testcode wird in zwei Phasen ausgeführt: 1. Historische K-Linie 2. Echtzeit-K-Linie 3. Bei einem Echtzeit-Preismodell und der historischen K-Linie.var、varipDie Variablen i und ii der Erklärung werden bei jeder Ausführung des Strategiecodes in der Erhöhung ausgeführt, daif trueSo können wir sehen, dass die Zahlen, die auf der K-Linie BAR der Rückmessung angezeigt werden, jeweils in der Zunahme von 1 angezeigt werden. Wenn die historische K-Linie Phase endet, beginnt die reale K-Linie Phase.var、varipDa es sich um ein Echtzeit-Preismodell handelt, wird der Strategiecode für jede Preisänderung innerhalb einer K-Linie BAR ausgeführt.i := i + 1Undii := ii + 1Der Unterschied ist, dass ii jedes Mal geändert wird. Obwohl i auch jedes Mal geändert wird, wird der vorherige Wert bei der nächsten Ausführung der Strategie-Logik wiederhergestellt, bis der aktuelle K-Linien-BAR abgelaufen ist, um den Wert von i zu aktualisieren (das heißt, der vorherige Wert wird bei der nächsten Ausführung der Strategie-Logik nicht wiederhergestellt). So kann man sehen, dass die Variable i immer noch pro BAR erhöht wird.

• Schlusskursmodell Da die Schlusskursmodelle eine Strategie-Logik ausführen, wenn jeder K-Line BAR abgelaufen ist. In der Schlusskursmodelle werden die historischen K-Line-Phasen und die Echtzeit-K-Line-Phasen in der Schlusskursmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodellmodvar、varipDie Variablen, die in der Erklärung angegeben sind, zeigen sich in den oben genannten Beispielen in einer exzessiven Erhöhung, nämlich in einer Erhöhung von 1 BAR pro K-Zeile.

varip

varip ((var intrabar persist) ist ein Schlüsselwort für die Verteilung und einmalige Initialisierung von Variablen. Es ist ähnlich wie das Schlüsselwort var, aber die Variablen mit der Varip-Erklärung behalten ihren Wert zwischen den K-Linien-Aktualisierungen in Echtzeit.

varip variable_name = expression

Erklärungen:

• variable_name- jeder Name der in Pine erlaubten Benutzervariablen ((), der sich aus Groß- und Kleinbuchstaben, Zahlen und Unterstrichen zusammensetzen kann_), aber nicht mit einer Ziffer.)
• expression- jeder arithmetische Ausdruck, wie bei der Definition einer regulären Variablen. Auf der ersten K-Zeile wird der Ausdruck nur einmal berechnet und der Variablen einmal zugewiesen.

Beispiel

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

Mit var gibt die Grafik den Wert bar_index zurück. Mit varip geschieht das gleiche auf der historischen K-Linie, aber auf der realen K-Linie gibt die Grafik einen Wert zurück, der für jeden tick um 1 erhöht wird.

Anmerkung Nur mit einfachen Typen wie float, int, bool, string und Arrays dieser Typen verwendet werden.

true

Der Wert einer Variablen vom Typ Boole, oder wenn der Ausdruck verwendet wirdVergleichoderLogikDer Operator berechnet die Werte:

Anmerkung Siehe auchVergleichOperator undLogikBeschreibung des Operators:

Siehe auch bool

false

Zeigt die Werte einer Boole-Variablen sowie die Ergebnisse von Vergleichs- und Logikoperationen.

Anmerkung Siehe auchVergleichOperator undLogikBeschreibung des Operators:

Siehe auch bool

if

Eine If-Anweisung definiert den Satzblock, der ausgeführt werden muss, wenn die Ausdrucksbedingung erfüllt wird. Die Schreibsprache Pine Version 4 erlaubt die Verwendung der else if-Syntax.

Der Code stammt von:

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

Anmerkung var_declarationX- Diese Variable erhält die Werte der if-Sätze condition- Wenn die Bedingung wahr ist, wird ein Satzblock verwendetthenDie Logik in dervar_decl_then0，var_decl_then1Wenn die Bedingung “false” ist, wird ein Satzblock verwendet.else ifoderelseDie Logik in dervar_decl_else0，var_decl_else1Das ist eine gute Idee. return_expression_then , return_expression_else- Der letzte Ausdruck im Modul oder der Ausdruck aus dem Blockelse gibt den endgültigen Wert des Statements zurück. Wenn die Variablen am Ende der Erklärung stehen, ist ihr Wert der Ergebnis.

Der Typ der zurückgegebenen Werte für die if-Aussage hängt vonreturn_expression_thenUndreturn_expression_elseDie Typen müssen übereinstimmen, wenn sie auf TradingView ausgeführt werden: Es ist unmöglich, einen Integerwert aus dem Then-Sentenzblock zurückzugeben, wenn Sie einen Stringwert in der else-Block haben. Wenn die folgenden Beispiele auf FMZ ausgeführt werden, werden sie nicht fehlerhaft, und wenn die y-Werte “open” sind, ist die Zahl bei der Plotzeichnung n/a.

Beispiel

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

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

Kann weggelassen werdenelseBlock In diesem Fall wird der Variablen var_declarationX ein empty-Threshold (na, false oder ) zugewiesen, wenn die Bedingung false ist:

Beispiel

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

Es können mehrere else if-Blöcke verwendet werden oder gar keine. then, else if, else-Blöcke werden mit vier Leerstellen verschoben:

Beispiel

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

Kann ignoriert werdenifDas Ergebnis der Aussage ((var_declarationX= ist auszulassen)). Es kann nützlich sein, wenn Sie die Nebenwirkungen der Aussage benötigen, z. B. im Strategiehandel:

Beispiel

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

Die If-Sätze können sich gegenseitig umfassen:

Beispiel

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

for

Die ‘for’-Struktur erlaubt die Wiederholung mehrerer Sätze:

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

var_declaration- Eine optionale Variablen-Anweisung, die als Wert des return_expression für den Rücklauf zugewiesen wird. counter- Variable, die den Wert des Rücklaufzählers speichern und bei jeder Iteration des Rücklaufes den Wert 1 oder step_num erhöhen/reduzieren. from_num- Startwert des Zählers. Die Verwendung von Thresholds int/float Thresholds/Expressions ist erlaubt. to_num- Endwert des Zählers. Der Kreislauf wird unterbrochen, wenn der Zähler größer als to_num ist (oder kleiner als to_num, wenn from_num > to_num ist). Die Verwendung von Thresholds int/float Thresholds/Expressions ist erlaubt, aber sie werden nur bei der ersten Iteration des Kreislaufs bewertet. step_num- Der Zähler nimmt zu oder sinkt. Es ist optional. Der Standardwert ist +1 oder -1, je nachdem, welcher der größte von from_num oder to_num ist. statements | continue | break- Eine beliebige Anzahl von Sätzen, oder ‘continue’ oder ‘break’ Schlüsselwörter, in 4 Leerzeichen oder eine Tab eingekrümmt. return_expression- Die Rückgabewert des Loops wird, wenn vorhanden, einer Variablen in der var_declaration zugewiesen. Wenn der Loop aufgrund der Schlüsselwörter continue oder break aussteigt, wird die Rückgabewert des Loops der Wert der letzten Variablen zugewiesen, die vor dem Aussteigen des Loops zugewiesen wurden. continue- Schlüsselwörter, die nur im Rücklauf verwendet werden können. Sie führen dazu, dass die nächste Iteration des Rücklaufes ausgeführt wird. break- Die Schlüsselwörter für den Rückzug aus dem Kreis.

Beispiel

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

Siehe auch for...in while

for…in

for...inDie Struktur erlaubt die Wiederholung von mehreren Anweisungen für jedes Element im Array. Sie kann mit jedem der folgenden Parameter verwendet werden:array_element, oder mit zwei Parametern:[index, array_element]Die zweite Form beeinträchtigt nicht die Funktion des Loops. Sie verfolgt den Index der aktuellen Iteration in der ersten Variablen des Moleküls.

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

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

var_declaration- eine wählbare Variablen-Anweisung, die den Kreislaufreturn_expressionWerte von index- Optionale Variablen, die den aktuellen Iterationsindex verfolgen. Der Index beginnt mit 0. Die Variablen sind im Kreislauf unveränderlich.array_elementIn der Untergruppe array_element- enthält die Variablen für jedes Element der fortlaufenden Arrays, die in der Schleife behandelt werden sollen. Diese Variablen sind im Schleifer unveränderlich. array_id- Array-ID für die Kreis-Iteration. statements | continue | break- Eine beliebige Anzahl von Sätzen, oder ‘continue’ oder ‘break’ Schlüsselwörter, in 4 Leerzeichen oder eine Tab eingekrümmt. return_expression- Die Rückgabewert des Loops wird zugewiesen anvar_declarationWenn der Lauf aufgrund des Schlüsselworts ‘continue’ oder ‘break’ beendet wird, ist der Rückgabewert der Lauf die letzte Variable, die vor dem Ausstieg bewertet wurde. continue- Schlüsselwörter, die nur im Rücklauf verwendet werden können. Sie führen dazu, dass die nächste Iteration des Rücklaufes ausgeführt wird. break- Die Schlüsselwörter für den Rückzug aus dem Kreis.

Es ist erlaubt, Elemente oder Größen der Arrays innerhalb der Loop zu ändern. Hier verwenden wirfor...inEinparametrische Formulierungen für die Bestimmung, wie viele OHLC-Werte der K-Zeile größer sind als die ‘close’-Werte der SMA auf jeder K-Zeile:

Beispiel

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

Hier benutzen wir die zwei Formulierungen von for…in, um unsereisPosDer Wert des Arrays ist trueWenn sie bei uns sind.valuesArrayDie entsprechenden Werte im Array sind in der richtigen Zeit:

Beispiel

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

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

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

Siehe auch for while array.sum array.min array.max

while

whileDie Sätze erlauben die bedingte Iteration der lokalen Codeblöcke.

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

Erklärungen: variable_declaration- Wahlbare Variablen-Erklärungen.return expressionDie Variable kann mit einer Initialisierung versehen werden. boolean_expression- Wenn es wahr ist, wird ausgeführtwhileWenn false ist, wird inwhileDie Szenarien werden nach den Sätzen ausgeführt. continue - continueDie Schlüsselwörter führen zu einer Abzweigung des Kreislaufs in die nächste Iteration. break - breakSchlüsselwörter beenden den Kreislauf. Das Skript wird ausgeführt.whileDie Aussage wird wieder aufgenommen. return_expression- Ich gebe.whileOptionale Zeile, die Werte zurückgibt.

Beispiel

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

plot(factorial)

Anmerkung AnfangswhileDer lokale Codeblock nach der Zeile muss in vier Leerzeichen oder ein Zeichner eingekrempelt werden.whileDie KreisläufewhileDer nächste Boolean-Ausdruck muss entweder endgültig falsch sein oder ausgeführt werden.break。

switch

Der switch-Operator überträgt die Kontrolle an einen der mehreren Sätze, je nach den Bedingungen und den Werten des Ausdrucks.

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

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

Der Begriff “switch” wird mit den Ausdrücken:

Beispiel

// Switch using an expression

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

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

plot(ma)

Switch ohne Ausdruck:

Beispiel

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

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

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

Rückgabewert Der Wert des letzten Ausdrucks in dem ausgeführten lokalen Statementblock.

Anmerkung Nur ausgeführtlocal_blockBeispiel oderdefault_local_blockEiner davon.default_local_blockNur mit=>Die Markierung wird zusammen eingeführt und nur ausgeführt, wenn das vorherige Block nicht ausgeführt wurde. WennswitchDas Ergebnis der Aussage ist einer Variablen zugewiesen und nicht angegebendefault_local_blockWenn nicht ausgeführt,local_block, wird zurückgegeben.naIch werde…switchWenn die Ergebnisse der Sätze den Variablen zugeordnet werden, werden allelocal_blockDie Instanz muss den gleichen Typ zurückgeben.

Siehe auch if ?:

series

series ist ein Schlüsselwort, das den Datensatztyp angibt.seriesSchlüsselwörter sind in der Regel unnötig.

Operator

=

Verwendet wird, um Variablen Werte zuzuweisen, aber nur wenn Variablen erklärt werden (für den ersten Gebrauch).

:=

Der Verwertungsoperator, der den Werten der Variablen auf der linken Seite zugeordnet wird.

!=

Nicht gleich ≠. Die Ausdrucksweise ist für jeden Typ gültig ≠.

expr1 != expr2

Rückgabewert Bull-Werte, oder eine Reihe von Bull-Werten.

%

Modellzahlen ((Integer-Zusatzzahlen)) gelten für Zahlenwerte ausgedrückt.

expr1 % expr2

Rückgabewert Eine ganze Zahl oder ein Floating Point oder eine Reihe von Werten.

Anmerkung In einem Pine-Skript wird der Handel bei der Berechnung des Restbetrages der ganzen Zahlen unterbrochen. Das heißt, er wird zu dem kleinsten absoluten Wert umgerechnet. Der erhaltene Wert wird mit dem gleichen Symbol wie die Dividende gekennzeichnet.

Beispiel: -1 % 9 = -1 - 9 * truncate ((-¹⁄₉) = -1 - 9 * truncate ((-0.111) = -1 - 9 * 0 = -1。

%=

Modulbezeichnung. Gilt für Zahlen.

expr1 %= expr2

Beispiel

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

Rückgabewert Eine ganze Zahl oder ein Floating Point oder eine Reihe von Werten.

*

Die Multiplikation gilt für Zahlen.

expr1 * expr2

Rückgabewert Eine ganze Zahl oder ein Floating Point oder eine Reihe von Werten.

*=

Die Multiplikationsbezeichnung gilt für Zahlen.

expr1 *= expr2

Beispiel

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

Rückgabewert Eine ganze Zahl oder ein Floating Point oder eine Reihe von Werten.

+

Zusätzliche oder einheitliche Positivzahlen. Für Zahlen oder Zeichenketten.

expr1 + expr2

+ expr

Rückgabewert Binäre Strings+Gibt eine Zusammenführung von express1 und express2 zurück Die Zahl gibt eine ganze Zahl oder einen Floating-Point-Wert oder eine Reihe von Werten zurück: Die binäre ‘+’ gibt expr1 plus expr2。 zurück. Ein Yuan + Ein Yuan gibt expr zurück (nicht hinzugefügt für die Symmetrie des Ein-Yuan-Operators).

Anmerkung Sie können Arithmetik-Operatoren mit Zahlen und Variablen verwenden. Im Falle von Variablen werden die Operatoren auf die Elemente angewendet.

+=

Adjektiv-Beschreibung für Zahlen oder Zeichenketten

expr1 += expr2

Beispiel

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

Rückgabewert Für Strings gibt es eine Serienfolge von expr1 und expr2. Für Zahlen gibt es eine ganze Zahl oder einen Floating-Point-Wert oder eine Reihe von Werten.

Anmerkung Sie können Arithmetik-Operatoren mit Zahlen und Variablen verwenden. Im Falle von Variablen werden die Operatoren auf die Elemente angewendet.

-

Abzug oder Ein-Meter-Negativ-Nummer. Für die Zahlen-Ausdrücke.

expr1 - expr2

- expr

Rückgabewert Gibt eine ganze Zahl oder einen Floating-Point-Wert oder eine Reihe von Werten zurück: Die Binäre ‘+’ gibt expr1 minus expr2 wieder. Einfache-Gibt die Negativform von express zurück.

Anmerkung Sie können Arithmetik-Operatoren mit Zahlen und Variablen verwenden. Im Falle von Variablen werden die Operatoren auf die Elemente angewendet.

-=

Abträglichkeitsbezeichnung. Gilt für Zahlen.

expr1 -= expr2

Beispiel

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

Rückgabewert Eine ganze Zahl oder ein Floating Point oder eine Reihe von Werten.

/

Ausnahmen gelten für die numerischen Ausdrücke.

expr1 / expr2

Rückgabewert Eine ganze Zahl oder ein Floating Point oder eine Reihe von Werten.

/=

Der Ausnahmebefehl gilt für die numerischen Ausdrücke.

expr1 /= expr2

Beispiel

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

Rückgabewert Eine ganze Zahl oder ein Floating Point oder eine Reihe von Werten.

<

Weniger als ≠ gilt für die Zahlenform ≠

expr1 < expr2

Rückgabewert Bull-Werte, oder eine Reihe von Bull-Werten.

<=

Weniger als oder gleich ≠ ≠ ≠

expr1 <= expr2

Rückgabewert Bull-Werte, oder eine Reihe von Bull-Werten.

==

Gilt für jede Art von Ausdruck.

expr1 == expr2

Rückgabewert Bull-Werte, oder eine Reihe von Bull-Werten.

=>

Der Operator ‘=>’ wird verwendet, um eine benutzerdefinierte Funktionsdeklaration undswitchIn der Aussage:

Die Syntax der Funktionsdeklaration lautet:

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

Eine.<local_block>Es sind null oder mehr Pine-Aussagen. <function_result>Ist eine Variable, ein Ausdruck oder eine Gruppe.

Beispiel

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

Anmerkung Weitere Informationen zu den Benutzerdefinitionen finden Sie auf den Seiten “Erklärungen” und “Skriptbibliothek” des Benutzerhandbuchs.

>

Größer als gilt für Zahlen.

expr1 > expr2

Rückgabewert Bull-Werte, oder eine Reihe von Bull-Werten.

>=

Größer als oder gleich: Gilt für numerische Ausdrücke:

expr1 >= expr2

Rückgabewert Bull-Werte, oder eine Reihe von Bull-Werten.

?:

Der Dreifach-Bedingungs-Operator.

expr1 ? expr2 : expr3

Beispiel

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

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

Rückgabewert Wenn expr1 als true bewertet wird, dann ist expr2 und wenn nicht, dann ist es expr3. Die Nullwerte ((0 und NaN+, Infinity,-Infinity) werden als false und alle anderen Werte als true angesehen.

Anmerkung Wenn Sie es nicht benötigen, verwenden Sie na als eine Abzweigung von na. Sie können zwei oder mehrere?:-Operatoren kombinieren, um eine Aussage wie “switch” zu realisieren (siehe Beispiel oben). Sie können Arithmetik-Operatoren mit Zahlen und Variablen verwenden. Im Falle von Variablen werden die Operatoren auf die Elemente angewendet.

Siehe auch na

[]

Die Serie Subtitle bietet Zugriff auf die vorherigen Werte der Serie expr1 expr2 ist die Zahl der letzten k Zeilen, die ein Wert sein muss die Floating wird nach unten umgeordnet

expr1[expr2]

Beispiel

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

Rückgabewert Eine Reihe von Werten.

Siehe auch math.floor

and

Die Logik AND ≠ gilt für Boolean-Ausdrücke ≠.

expr1 and expr2

Rückgabewert Bull-Werte, oder eine Reihe von Bull-Werten.

or

OR-Logik gilt für Boolean-Ausdrücke.

expr1 or expr2

Rückgabewert Bull-Werte, oder eine Reihe von Bull-Werten.

not

Logische Umkehrung ((NOT) )

not expr1

Rückgabewert Bull-Werte, oder eine Reihe von Bull-Werten.

Datentyp Schlüsselwörter

bool

Die Schlüsselwörter des Typs bool (bool) für explizit erklärte Variablen oder Parameter. Die Werte der Variablen “Bool” können true, false oder na sein.

Beispiel

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

Anmerkung Die ausdrückliche Erwähnung des Typs in der Variablenerklärung ist optional, es sei denn, er wird mit na initiiert. Weitere Informationen zum Typ Pine finden Sie auf der Benutzerhandbuchseite des Typesystems.

Siehe auch var varip int float color string true false

int

Die Schlüsselwörter des Typs int ((integer)) für die eindeutige Angabe von Variablen oder Parametern.

Beispiel

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

Anmerkung Die ausdrückliche Erwähnung des Typs in der Variablenerklärung ist optional, es sei denn, er wird mit na initiiert. Weitere Informationen zum Typ Pine finden Sie auf der Benutzerhandbuchseite des Typesystems.

Siehe auch var varip float bool color string

float

Schlüsselwörter vom Typ float für explizit deklarierte Variablen oder Parameter.

Beispiel

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

Anmerkung Die eindeutige Erwähnung des Typs in der Variablenerklärung ist optional, es sei denn, es wird mit na initialisiert.

Siehe auch var varip int bool color string

string

Schlüsselwort vom Typ “string” für explizit deklarierte Variablen oder Parameter.

Beispiel

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

Anmerkung Die ausdrückliche Erwähnung des Typs in der Variablenerklärung ist optional, es sei denn, er wird mit na initiiert. Weitere Informationen zum Typ Pine finden Sie auf der Benutzerhandbuchseite des Typesystems.

Siehe auch var varip int float bool str.tostring str.format

color

Das Schlüsselwort für den Typ “color”, der für die Variablen oder Parameter einer expliziten Erklärung verwendet wird.

Beispiel

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

Anmerkung Die Farbschrift hat das folgende Format: #RRGGBB oder #RRGGBBAA. Die Buchstabenpaare repräsentieren die sechzehnstelligen Werte von 00 bis FF ((zehnstellige 0 bis 255), wobei RR, GG und BB die Werte der Farbanteile von Rot, Grün und Blau sind. AA ist die Farbtransparenz (oder die Alphaanteil), wobei 00 nicht sichtbar ist und FF nicht transparent ist. Die ausdrückliche Erwähnung des Typs in der Variablenerklärung ist optional, es sei denn, er wird mit na initiiert. Weitere Informationen zum Typ Pine finden Sie auf der Benutzerhandbuchseite des Typesystems.

Siehe auch var varip int float string color.rgb color.new

array

Die Schlüsselwörter für die Array-Array-Typen von Arrays, die Variablen oder Parameter ausdrücklich deklarieren.array.new<type>,array.fromDie Funktion erzeugt ein Arrayobjekt ((oder ID) .

Beispiel

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

Anmerkung Die Array-Objekte sind immer in der Form von -Serie .

Siehe auch var array.new array.from

Objects

Die PINE-Objekte sind ein Beispiel für die benutzerdefinierten Typen ((UDT) und können als Methodenlose Klassen verstanden werden, die es dem Benutzer ermöglichen, in der Strategie benutzerdefinierte Typen zu erstellen, die verschiedene Werte in einer Einheit organisieren.

Definition des Typs

Lassen Sie uns einen Order-Typ definieren, um die Bestellinformationen zu speichern:

type order
    float price
    float amount
    string symbol

• verwendentypeKeyword-Erklärungs-Typ
• Das Schlüsselwort type wird von der Typenbezeichnung gefolgt.
• Die erste Zeile “type” definiert den Typennamen und dann in vier Leerzeichen die Felder, die der Typ enthält.
• Jedes Feld muss seinen Datentyp angeben, z. B. int, float, string.

Erstellen von Objekten

Benutzen Sie die erklärten Typen, die aufgerufen werdennew()Objekt der Funktion:

order1 = order.new()

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

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

Sie können auch leere Objekte erstellen:

order order1 = na

Hier ist ein Beispiel aus der Praxis:

type order
    float price
    float amount
    string symbol

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

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

Ein Beispiel ist dieser Satz:

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

Das kann auch in folgender Form geschrieben werden:

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

Objekt-Typ für die Verwendung von var-Keywords

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

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

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

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

Wenn eine variable des Objekts mit einem benutzerdefinierten Typ zugewiesen wird, wird die Keyword-Erklärung mit var automatisch auf alle Felder des Objekts angewendet. Das bedeutet, dass ein mit der Keyword-Erklärung deklariertes Objekt seinen Zustand zwischen jeder Iteration behält, ohne dass seine Feldwerte bei jeder Iteration neu initialisiert werden müssen.

• Das firstBar-Objekt wird mit dem Schlüsselwort var deklariert, so dass sein Feld ((index, price, vol)) seine Werte bei jeder Iteration behält, beginnend mit dem ersten Eintrag bis zum Ende des letzten Eintrags.
• Das currentBar-Objekt verwendet keine var-Keyword-Erklärung, so dass seine Felder bei jedem Eintrag neu initialisiert werden und bei jeder Iteration ein neues Objekt vorhanden ist.

Indem Sie die Index-Felder zweier Objekte abbilden, können Sie die Unterschiede zwischen ihnen vergleichen. firstBar.index behält bei jeder Iteration den vorher festgelegten Wert bei, während currentBar.index bei jeder Iteration als bar_index-Wert des aktuellen Eintrags neu initialisiert wird.

Objekt-Typ für die Verwendung von Varip-Keywords

”`pine //@version=5 indicator(“Objects u