[TOC]

Schlüsselwörter, Grammatik, Einrichtung von Kurzbeschreibungen

Codestruktur

Die allgemeine Struktur, der Code in Pine folgt:

<version>
<declaration_statement>
<code>

Kommentare

FMZ-Notizersymbole für die Pine-Sprache: Einzeilenotation//Das ist ein sehr schwieriges Thema./* */Die Anmerkungen in den folgenden Beispielen werden beispielsweise geschrieben:

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

Ausgabe

Eine Kompilatorinstruktion in der folgenden Form teilt dem Kompilator mit, in welcher Version Pine das Skript geschrieben wurde:

//@version=5

V5 ist die Standardversion, die man aus dem Code entfernen kann.//@version=5。

Die Erklärung

• indicator()
• strategy()

Statements bestimmen den Typ eines Skripts, der wiederum bestimmt, was er zulässt und wie er verwendet und ausgeführt wird. Sie setzen wichtige Eigenschaften des Skripts ein, wie z. B. seinen Namen, wo er erscheint, wenn er in ein Diagramm hinzugefügt wird, die Präzision und das Format der Zahlen, die er anzeigt, und bestimmte Zahlen, die er bei der Ausführung verhält, wie z. B. die maximale Anzahl von Zeichnungsobjekten, die er in einem Diagramm anzeigt. Für Strategien umfassen Eigenschaften Parameter, die die Rücksichtnahme kontrollieren, wie z. B. Anfangskapital, Provisionen, Gleitpunkte usw.indicator()Oderstrategy()Ich habe mich in meinem eigenen Land niedergelassen.

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

Zeitreihenfolge

Eine Zeitreihe ist kein Datentyp oder Format. Sie ist ein grundlegendes Konzept in der Sprache PINE. Sie dient dazu, Werte zu speichern, die sich zeitlich kontinuierlich ändern. Jede Werte entspricht einem Zeitpunkt. Die Variablen sind eingebautopenDas ist ein Beispiel.openDie Variable erfasst den Eröffnungspreis für jede K-Line BAR, wenn dieseopenDas ist die Daten für die 5-minütige K-Linien-Zyklus.openDie Variablen enthalten den Startpreis der K-Line BAR (Säule) alle 5 Minuten.openDas heißt, wir beziehen uns auf den Startpreis der aktuellen K-Line BAR. Um einen früheren Wert in der Zeitreihe zu beziehen, verwenden wir[]Der historische Operator, der, wenn die Strategie auf einer K-Line BAR ausgeführt wird, dieopen[1]Das bedeutet, dass der Startpreis des vorherigen K-Line-BARs der aktuellen K-Line-BAR zitiert wird.

ObwohlZeitreihenfolgeEs ist leicht, an Datenstrukturen wie "Arrays" zu denken, obwohl die PINE-Sprache auch Arraytypen hat. Sie sind jedoch ein völlig anderes Konzept als Zeitreihen.

Die PINE-Sprache kann Zeitreihen so entwerfen, dass die Summe der Schlusskosten in der Strategiecode sehr einfach berechnet werden kann, und es ist nicht notwendig, eine Loop-Struktur wie for zu verwenden, sondern nur die eingebauten Funktionen der PINE-Sprache zu verwenden.ta.cum(close)Oder zum Beispiel: Wir müssen den Durchschnitt der höchsten und niedrigsten Preise der letzten 14 K-Linien BAR (d. h. die 14 K-Linien BAR, die am aktuellen Zeitpunkt der Codeausführung am nächsten sind) berechnen.ta.sma(high - low, 14)

Das Ergebnis eines Aufrufs einer Funktion auf der Zeitreihe hinterlässt auch einen Spuren auf der Zeitreihe.[]Der historische Operator bezieht sich auf den vorhergehenden Wert. Zum Beispiel können wir schreiben, ob der Schlusskurs der aktuellen K-Linie BAR den Maximalwert des höchsten Preises in den letzten 10 K-Linie BAR übersteigt (ohne die aktuelle K-Linie BAR).breach = close > ta.highest(close, 10)[1]Das kann auch so geschrieben werden:breach = close > ta.highest(close[1], 10)Ich bin nicht derjenige.ta.highest(close, 10)[1]undta.highest(close[1], 10)Ich bin nicht derjenige, der das sagt.

Sie können mit dem folgenden Code überprüfen:

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 obige Testcode liefert a und b an jeder BAR ihre Werte in der entsprechenden Zeitreihe aus, so dass man sehen kann, dass a und b immer gleich sind, so dass die beiden Anwendungen gleichwertig sind.

Die Templateparameter für die Pine-Language-Transaktions-Klasse

Die PINE-Strategien haben eine integrierte Vorlage für die "Pine-Sprachhandlungsklasse" und eine Anleitung zur Einstellung der Parameter.

Transaktions-Einstellungen

• Ausführung Schließpreismodell: Das Modell wird erst ausgeführt, wenn die aktuelle BAR abläuft, und die Transaktionen werden ausgeführt, wenn die unteren BARs beginnen. Echtzeit-Preismodelle: Bei jeder Preisänderung wird das Modell ausgeführt, mit dem Signal, um den Handel sofort auszuführen.
• Standardeinstellung: Wenn die Handelsanweisung keine Anzahl von Transaktionen angibt, wird die Anzahl der Transaktionen nach dieser Einstellung ausgeführt.
• Maximaler Einzeltrag: Die maximale Anzahl von Einzelträgen wird anhand der tatsächlichen Auflistung und in Verbindung mit diesem Parameter festgelegt, um die Auflistung pro Auflistung zu vermeiden.
• Anzahl der Gleitpreise: je nach定价货币精度Die Parameter und dieser Parameter bestimmen den Gleitpreis bei der Bestellung. Zum Beispiel wird die Preispräzision auf 2 gesetzt, d. h. genau bis zum zweiten Teilpunkt und genau bis 0.01; dann steht jeder Gleitpreispunkt für 0.01 Pricing-Einheiten.
• Die längste Periodenzahl der Variablen: beeinflusst die Anzahl der BAR-Linien des Diagramms K, mitjavascriptAnrufe in der StrategieSetMaxBarLenDie Funktion ist die gleiche.

Futures-Optionen

• Der Code der Sorte: Vertragskode, die nur eingestellt werden muss, wenn ein Austauschobjekt ein Nicht-Kontakt-Austauschobjekt ist.
• Mindeste Anzahl von Aufträgen: Mindeste Anzahl von Aufträgen beim Auftragen.

Festplattenoptionen

• Auto-Restore-Progress: Automatisiert den Status, in dem sich die letzte Politik befand, bevor sie gestoppt wurde.
• Anzahl der Auftragswiederholungen: Wenn keine Transaktion stattfindet, wird die Bestellung widerrufen und der Auftrag erneut aufgegeben. Der Parameter wird verwendet, um die maximale Anzahl der Wiederholungen zu begrenzen.
• Netzwerkanfragenintervall (millisekunden): Wirksam nur für den REST-Protokoll, um die Intervalle der Netzwerkanfragen zu kontrollieren und zu vermeiden, dass die Anfragen zu häufig sind und die Grenzen der Börse überschreiten.
• Konto-Synchronisierungszeit ((Sekunden): Zeiträume für die Synchronisierung von Konto-Daten.
• Post-Posit Synchronisation Zeit (milliseconds): Nur für einige Börsen, die durch Datenverzögerungen verursacht werden, kann eine größere Synchronisation Zeit eingestellt werden, um solche Probleme zu lindern.
• Hebel multiplier: Setzen Sie Hebel multiplier.

Bargeldgeschäfte, andere Einstellungen

• Einhandstransaktionen: Die Standard-Einhandstransaktionen gelten nur für Bargeld.
• Minimaler Umsatz: Minimaler Umsatz.
• Preisgenauigkeit: Preisgenauigkeit, d.h. die geringe Zahl der Preise.
• Transaktionsspezifische Präzision: die Präzision der nächsten Einheit, also die geringen Zahlenzahlen der nächsten Einheit.
• Gebühren: Für die Berechnung einiger Daten unter dieser Einstellung steht 0.002 für 2 auf tausend.
• Gewinn-und-Verlust-Statistik-Intervall: Nur auf der echten Platte zeigen Sie die Gewinn-und-Verlust-Statistiken.
• Versagen des Wiederversuchs (millisekunden): Wiederversuchsintervall, wenn die Netzwerkanfrage fehlschlägt.
• Benutzervertreter: Nur für den REST-Protokoll gültig.
• Häufige Fehler im Netz verbergen: Häufige Fehler im Log-Bereich verbergen.
• Wechseln Sie die Basisadresse: Nur für den REST-Protokoll gültig.
• Schieben Sie Benachrichtigungen: Schieben Sie Nachrichten in Ihre E-Mails.

Nachfolgender Deal

Eröffnung

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)                          // 指定（较低的）价格，计划下买单订单，等待成交开仓，限价开仓

Plateau

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

Der Haltungsmechanismus der PINE-Sprache ist ähnlich wie bei einer einseitigen Haltung. Beispielsweise wird bei einer Position in mehreren Richtungen ("Mehrseitige Haltung") der Haltungsmechanismus, wenn es einen Verkaufsaufgabe-Order, eine Planliste usw. gibt, ausgelöst.

Planungsliste

Bei der Verwendung der Anweisung zu bestellen, ist die Marktpreisliste der Standard, wenn kein Preis angegeben wird. Außer der Marktpreisliste kann man auch mit der Planliste bestellen, die nicht sofort mit der Planliste arbeitet. Die Planliste kann in der Plan-Auftrags-Warteschlange eines Programms, das nicht ausgelöst wurde, ausgeführt werden.Festplatte / RückmessungDie Zeit-Status-Informationen (d. h. Status-Tabellen, wenn die Strategie ausgeführt wird) sind in der Tabelle "Planning Orders" zu sehen. Das System wird diese Pläne nur dann tatsächlich ausgeben, wenn die Bedingungen für den Markt in Echtzeit erfüllt sind. Daher sind diese Pläne mit geringen Abweichungen in den Transaktionspreisen normal.strategy.entryWenn wir eine Funktion auflisten, können wir sagen,limit、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-Bestellungen

  Setzen Sie den Preis für die Bestellung ein, wenn die Bestellung als Bezahlung (d.h.directionDie Parameter sind:strategy.longDie Bestellung wird nur dann ausgelöst, wenn der aktuelle Marktpreis darunter liegt. Wenn die Bestellung als Verkaufsauftrag erfolgt (d.h.directionDie Parameter sind:strategy.shortDie Bestellung wird nur dann ausgelöst, wenn der aktuelle Marktpreis höher ist als dieser Preis.

• Stop-Bestellung

  Setzen Sie den Stop-Loss-Preis für die Bestellung, wenn die Bestellung ein Kauf ist und die Bestellung nur dann ausgelöst wird, wenn der aktuelle Marktpreis höher ist als dieser Preis. Wenn es sich um einen Verkaufs- oder Verkaufsauftrag handelt, wird der Auftrag nur dann ausgelöst, wenn der aktuelle Marktpreis darunter liegt.

• Stop-Limit-Bestellungen

  Sie können gleichzeitig eingestellt werden.limit、stopParameter, bei denen die Bestellung zuerst zu dem Preis ausgelöst wird, der die Bedingungen erfüllt.

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)
  

Bestimmungdefault_qty_type=strategy.percent_of_equityDann setzen Siedefault_qty_valueFür die Anzahl der Prozentsätze ((0 ~ 100), 1 oder 1%;; Berechnung der Einheitsmenge nach der Anzahl der in dem Konto bewerteten Währungen. Zum Beispiel: Das aktuelle Konto hat 10000 USDT, und setzen Sie 1% auf, d. h. Sie verwenden eine Einheitsmenge von 100 USDT (berechnet zum Verkauf anhand des aktuellen Preises).

Erklärung, logische Struktur und Schlüsselwörter

Ver-

var ist das Schlüsselwort für die Zuordnung und Einmalinitialierung von Variablen. Normalerweise führt eine Variablenbezeichnungssymmetrie, die nicht das Schlüsselwort var enthält, dazu, dass der Wert der Variablen jedes Mal überschattet wird, wenn die Daten aktualisiert werden. Im Gegensatz dazu können Variablen, die mit dem Schlüsselwort var zugewiesen werden, den Status-Satz beibehalten, obwohl die Daten aktualisiert werden, und nur dann geändert werden, wenn die Bedingungen in den if-expressions erfüllt sind.

var variable_name = expression

Erläuterung:

• variable_name- Jeder Name der in Pine Script zulässigen Benutzervariablen (kann mit Groß- und Kleinbuchstaben, Zahlen und Unterzeichen (_) versehen sein, kann aber nicht mit Zahlen beginnen)
• expression- Jede Arithmetische Ausdrucksform, wie die Definition einer regulären Variable.

Beispiele

// 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 hält den Schlusspreis der ersten Spalte in jeder Spalte 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.

Auf der FMZ gibt es zwei Modelle: ein Echtzeit-Preismodell, ein Schlusspreismodell und ein Modell für die Berechnung der Preise.var、varipDie Variablen, die erklärt werden, testen wir mit der folgenden Code.

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 Die oben genannten Testcodes werden in zwei Phasen ausgeführt: 1. Die historische K-Linienphase. 2. Die reale K-Linienphase.var、varipDie erklärte Variable i, ii wird bei jeder Ausführung des Strategiecodes inkrementell ausgeführt, weil (((if trueSo kann man sehen, dass die Zahlen, die auf der K-Linien-BAR für die Wiederholung des Ergebnisses angezeigt werden, jeweils inkrementell 1 sind.var、varipDa es sich um ein Real-Time-Preis-Modell handelt, wird bei jeder Preisänderung in einer K-Line-BAR wiederholt Strategie-Code ausgeführt.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, bis die aktuelle K-Linie BAR abläuft, bevor sie den festgelegten Wert aktualisiert (d. h. bei der nächsten Ausführung der Strategielogik nicht mehr wiederhergestellt wird).

• Modell für die Abschlusspreise Da das Schlusspreismodell nur eine Strategie-Logik ausführt, wenn jede K-Linie BAR abläuft.var、varipDie erklärten Variablen zeigen sich in den oben genannten Beispielen in absoluter Übereinstimmung mit einer Zunahme von 1 für jede K-Leitung BAR.

Variation

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.

varip variable_name = expression

Erläuterung:

• variable_name- Jeder Name der Benutzervariablen, der im Pine-Skript zulässig ist (kann Groß- und Kleinbuchstaben, Zahlen und Unterzeichen enthalten, kann aber nicht mit Zahlen beginnen)
• expression- irgendein arithmetischer Ausdruck, wie bei der Definition einer normalen Variable. In der ersten K-Linie wird der Ausdruck nur einmal berechnet und der Variable einmal zugewiesen.

Beispiele

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

Bei der Verwendung von var kehrt das Diagramm den Wert von bar_index zurück. Bei der Verwendung von varip erfolgt das gleiche Verhalten auf historischen K-Linien, aber in Echtzeit-K-Linien kehrt das Diagramm einen Wert zurück, der für jeden Tick um einen erhöht wird.

AnmerkungenKann nur mit einfachen Typen wie float, int, bool, string und Arrays dieser Typen verwendet werden.

- Das stimmt.

Der Wert einer Boole-Variablen oder wenn der Ausdruck verwendet wirdVergleichoderLogikDer Wert, den man berechnen kann, wenn man einen Operator benutzt.

AnmerkungenSiehe auchVergleichDie Operatoren undLogikBeschreibung der Operatoren.

Bis dann bool

falsche

Der Wert einer Variablen des Boole-Typs und die Ergebnisse der Vergleichsoperationen und Logikoperationen werden angegeben.

AnmerkungenSiehe auchVergleichDie Operatoren undLogikBeschreibung der Operatoren.

Bis dann bool

wenn

Die If-Sprache definiert die Satzblöcke, die ausgeführt werden müssen, wenn die Ausdrucksbedingungen erfüllt werden. Die vierten Version der Pine-Skriptsprache erlaubt Ihnen die Verwendung der else-if--Symmetrie.

Der allgemeine 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

Anmerkungen var_declarationX- Diese Variable erhält den Wert der if-Sätzecondition- Wenn die Bedingung true ist, wird der Satzblock verwendet.thenDie Logikvar_decl_then0，var_decl_then1Ähnlich wie) ⇒ Wenn die Bedingung false ist, wird der Satzblock verwendet.else ifOderelseDie Logikvar_decl_else0，var_decl_else1Und so weiter.return_expression_then , return_expression_else- Der letzte Ausdruck im Modul oder der Ausdruck aus dem Blockelse gibt den Endwert des Satzes zurück. Wenn eine Variable am Ende angegeben wird, ist ihr Wert der Ergebniswert.

Die Art des zurückgegebenen Werts der if-Stricture hängt vonreturn_expression_thenundreturn_expression_elseDie Typen müssen übereinstimmen, wenn sie in der TradingView ausgeführt werden: Es ist unmöglich, einen ganzen Wert aus dem then-Satzblock zurückzugeben, wenn Sie einen Stringwert in einem Else-Block haben.

Beispiele

// 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 ausgelassen werdenelseBlocks. In diesem Fall wird der Variable var_declarationX ein empty-Threshold (na, false oder ) zugewiesen, wenn die Bedingung false ist:

Beispiele

// 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 oder gar nicht verwendet werden.

Beispiele

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

Sie können es ignorieren.ifDer Ergebniswert des Satzes ((var_declarationX= kann übersprungen werden) ). Es kann nützlich sein, wenn Sie eine Nebenfunktion des Ausdrucks benötigen, z. B. im Strategiehandel:

Beispiele

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

Die If-Sätze können miteinander verknüpft sein:

Beispiele

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

für

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 optionelle Variablenerklärung, die als Wert für die return_expression in der Rückrunde zugewiesen wird.counter- Speichert die Variablen für den Rücklaufzählerwert, wobei bei jeder Wiederholung des Rücklaufs der Wert von 1 oder step_num erhöht/verringert wird.from_num- Startwert des Zählers. Die Verwendung der Ausdrücke series int/float threshold 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 im Fall von from_num > to_num).step_num- Zunahme/Abnahme des Zählers. Es ist optional. Der Standardwert ist +1 oder -1, je nachdem, welcher der größten von from_num oder to_num ist.statements | continue | break- beliebig viele Sätze, oder das Schlüsselwort "continue" oder "break" in vier Räume oder Tabs zusammengefasst;return_expression- Der Rückgabewert des Loops, wenn vorhanden, wird der Variable in der var_declaration zugewiesen. Wenn der Loop aufgrund der Schlüsselwörter continue oder break beendet wird, wird der Rückgabewert des Loops der Wert der letzten Variable sein, der vor dem Ausgang des Loops zugewiesen wurde.continue- ein Schlüsselwort, das nur in der Umlaufphase verwendet werden kann.break- Das Schlüsselwort für den Rückzug.

Beispiele

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

Bis dann for...in while

Für... in

for...inDie Struktur erlaubt die Wiederholung mehrerer Statements für jedes Element in der Array. Sie kann mit einem beliebigen Parameter verwendet werden:array_element, oder zusammen mit zwei Parametern:[index, array_element]Die zweite Form beeinflusst nicht die Funktion des Loops. Sie verfolgt die Index der aktuellen Ideration in der ersten Variable der Elemente.

[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 optionale Variablenerklärung, die dem Loop zugewiesen wirdreturn_expressionDer Wert von.index- Optionale Variablen für den aktuellen Iterationsindex verfolgen. ■ Index beginnt bei 0. ■ Variable sind im Kreislauf unveränderlich. ■ Wenn sie verwendet werden, muss sie in einem ebenfalls enthaltenen enthalten sein.array_elementDas ist eine der größten Schwierigkeiten, die es gibt.array_element- enthält eine Variable für jedes in einem Kreislauf zu bearbeitende Elemente in einem kontinuierlichen Array. Diese Variable ist im Kreislauf unveränderlich.array_id- Array-IDs mit Kreislauf-Ideration.statements | continue | break- beliebig viele Sätze, oder das Schlüsselwort "continue" oder "break" in vier Räume oder Tabs zusammengefasst;return_expression- Die Rückgabe des Kreislaufs wird zugewiesenvar_declarationDie Variablen, wenn vorhanden. Wenn die Schleife aufgrund der Schlüsselwörter continue oder break aussteigt, ist der Rücklaufwert der Schleife die letzte Variable, die der Schleife vor dem Aussteigen zugewiesen wurde.continue- ein Schlüsselwort, das nur in der Umlaufphase verwendet werden kann.break- Das Schlüsselwort für den Rückzug.

Ermöglicht die Änderung von Elementen oder ihrer Größe in einem Loop. Hier benutzen wirfor...inDie Einzelländerungsform kann bestimmt werden, wie viele OHLC-Werte von K-Linien auf jeder K-Line größer sind als die SMA für den Threshold von close:

Beispiele

// 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 haben wir die zwei For...in-Formen benutzt, um unsereisPosDie Werte der Arrays werden alstrueSie sind in unserem Land.valuesArrayDie entsprechenden Werte in der Array sind:

Beispiele

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

Bis dann for while array.sum array.min array.max

während

whileStatements erlauben die Bedingungen der lokalen Codeblöcke zu wiederholen.

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

Erläuterung:variable_declaration- Optionale Variablenerklärungen.return expressionSie können einen Initialitätswert für diese Variable angeben.boolean_expression- Wenn wahr, dann ausgeführtwhileWenn es falsch ist, ist es in der Liste der lokalen Blöcke.whileNach dem Satz wird das Skript weiter ausgeführt.continue - continueDie Schlüsselwörter führen zu einer Kreislaufverzweigung bis zur nächsten Iteration.break - breakDie Schlüsselwörter führen zum Ende der Schleife.whileDie Rede wird nach dem Satz fortgesetzt.return_expression- BereitstellungwhileEine Optionszeile, die einen Wert zurückgibt.

Beispiele

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

AnmerkungenAnfangswhileDer lokale Codeblock nach der Zeile muss in vier Räume oder einen Zeichner zusammengefasst werden.whileDie Kreisläufe.whileDie folgenden Boole-Expressionen müssen schließlich false werden, oder sie müssen ausgeführt werdenbreak。

Wechseln

Die switch-Operator verlagert die Kontrolle an einen der folgenden Satzungen, je nach Bedingungen und Ausdruckswerten.

[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 Schalter mit der Ausdrucksweise:

Beispiele

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

Ein Schalter ohne Ausdruckszeichen:

Beispiele

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ückgabe von WertenDer Wert des letzten Ausdrucks im ausgeführten lokalen Satzblock.

AnmerkungenNur ausgeführt werdenlocal_blockBeispiel oderdefault_local_blockEiner von ihnen.default_local_blockNur mit=>Die Markierung wird zusammen eingeführt und nur dann ausgeführt, wenn der vorherige Block nicht ausgeführt wurde.switchDas Ergebnis des Satzes wird einer Variable zugewiesen und nicht angegebendefault_local_blockWenn es nicht ausgeführt wirdlocal_blockDas Wort wird zurückgegeben.naIch werde.switchWenn man die Ergebnisse der Aussage einer Variablen zuweist, werden allelocal_blockDie Instanz muss einen Wert desselben Typs zurückgeben.

Bis dann if ?:

Reihe

series ist ein Schlüsselwort für den Datenserientyp.seriesDie Schlüsselwörter sind in der Regel unnötig.

Die Operatoren

=

Wird verwendet, um Variablen zu bezeichnen, aber nur, wenn Variablen erklärt werden (für den ersten Mal verwendet).

:=

Bewertungsoperator, der die Variablen auf der linken Seite bewertet.

!=

Es ist nicht gleich. Für jede Art von Ausdruck.

expr1 != expr2

Rückgabe von WertenEin Boole-Wert, oder eine Reihe von Boole-Werten.

%

Modul ((Integratum) ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠ ≠

expr1 % expr2

Rückgabe von WertenEine ganze Zahl oder ein Fluktuationswert oder eine Reihe von Werten.

AnmerkungenIn der Pine-Skriptatik wird der Trader beim Berechnen der Restzahl der ganzen Zahlen abgeschnitten; d. h. er wird bis zum kleinsten absoluten Wert in Vier- und Fünfstel gestellt.

Beispiel: -1 % 9 = -1 - 9 * truncate ((-1/9) = -1 - 9 * truncate ((-0.111) = -1 - 9 * 0 = -1.

%=

Modulbezeichnungen. Für Zahlenfragen.

expr1 %= expr2

Beispiele

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

Rückgabe von WertenEine ganze Zahl oder ein Fluktuationswert oder eine Reihe von Werten.

*

Multiplikation. Für Zahlen.

expr1 * expr2

Rückgabe von WertenEine ganze Zahl oder ein Fluktuationswert oder eine Reihe von Werten.

*=

Multiplikationsbezeichnungen.

expr1 *= expr2

Beispiele

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

Rückgabe von WertenEine ganze Zahl oder ein Fluktuationswert oder eine Reihe von Werten.

+

Zusätzliche oder einheitliche Anzeichen. Für Zahlenäußerungen oder Strings.

expr1 + expr2

+ expr

Rückgabe von WertenBinärität der String+Die Kombination von exp1 und exp2 wird zurückgegeben Die Zahlen geben einen ganzen Wert oder einen Schwellpunktwert oder eine Reihe von Werten zurück: Das binäre P +'gibt den Ausdruck 1 plus den Ausdruck 2 zurück. Ein-Zahlen-Zahlen + Zahlen-Zahlen kehrt expr ((für die Ein-Zahlen-Operator-Symmetrie keine Inhalte hinzugefügt) zurück).

AnmerkungenSie können Arithmetische Operatoren mit Zahlen und Zahlen von Variablen verwenden. Wenn Sie Zahlen verwenden, werden die Operatoren für Elemente verwendet.

+=

Die Verknüpfungsbezeichnung. gilt für Zahlenäußerungen oder Strings.

expr1 += expr2

Beispiele

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

Rückgabe von WertenFür die String, die Expr1- und Expr2-Serie zurückkehrt. Für die Zahlen, die eine ganze Zahl oder einen Schwellpunktwert oder eine Reihe von Werten zurückkehrt.

AnmerkungenSie können Arithmetische Operatoren mit Zahlen und Zahlen von Variablen verwenden. Wenn Sie Zahlen verwenden, werden die Operatoren für Elemente verwendet.

-

Subtraktionsregeln oder einheitliche negative Zahlen.

expr1 - expr2

- expr

Rückgabe von WertenEr gibt einen ganzen Wert oder einen Fluktuationswert oder eine Reihe von Werten zurück: Das binäre P+' gibt den Expr1 minus den Expr2 zurück. Ein Euro-Die Negativformel von expr wird zurückgegeben.

AnmerkungenSie können Arithmetische Operatoren mit Zahlen und Zahlen von Variablen verwenden. Wenn Sie Zahlen verwenden, werden die Operatoren für Elemente verwendet.

-=

Subtraktionsbezeichnungen.

expr1 -= expr2

Beispiele

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

Rückgabe von WertenEine ganze Zahl oder ein Fluktuationswert oder eine Reihe von Werten.

/

Die Ausnahme ─ gilt für Zahlenäußerungen ─.

expr1 / expr2

Rückgabe von WertenEine ganze Zahl oder ein Fluktuationswert oder eine Reihe von Werten.

/=

Ausnahmebezeichnungen. Für numerische Ausdrücke.

expr1 /= expr2

Beispiele

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

Rückgabe von WertenEine ganze Zahl oder ein Fluktuationswert oder eine Reihe von Werten.

<

Weniger als. Gilt für Zahlenäußerungen.

expr1 < expr2

Rückgabe von WertenEin Boole-Wert, oder eine Reihe von Boole-Werten.

<=

Weniger als oder gleich. Für Zahlenäußerungen.

expr1 <= expr2

Rückgabe von WertenEin Boole-Wert, oder eine Reihe von Boole-Werten.

==

Äquivalent an. Kann für jede Art von Ausdruck verwendet werden.

expr1 == expr2

Rückgabe von WertenEin Boole-Wert, oder eine Reihe von Boole-Werten.

=>

Der '=>' wird für die Benutzerdefinierten Funktionserklärungen undswitchIch habe mich in meinem eigenen Leben nicht geäußert.

Die Syntax der Funktionserklärung lautet:

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

Einer<local_block>Es sind null oder mehr Pine-Sätze.<function_result>Eine Variable, ein Ausdruck oder eine Elementegruppe.

Beispiele

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

AnmerkungenWeitere Informationen zu Benutzerdefinitionsfunktionen finden Sie auf der Seite der Benutzerhandbuchserklärungen und der Skriptbibliothek.

>

Größer als. Gilt für numerische Ausdrücke.

expr1 > expr2

Rückgabe von WertenEin Boole-Wert, oder eine Reihe von Boole-Werten.

>=

größer als oder gleich. Für Zahlenäußerungen gilt.

expr1 >= expr2

Rückgabe von WertenEin Boole-Wert, oder eine Reihe von Boole-Werten.

?:

Die drei-Stufen-Konditions-Operatoren.

expr1 ? expr2 : expr3

Beispiele

// 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ückgabe von WertenWenn express1 als true bewertet wird, wird express2 als express3 betrachtet. Die Nullwerte ((0 und NaN+, Infinity,-Infinity) werden als false betrachtet, alle anderen Werte als true.

AnmerkungenWenn Sie nicht möchten, verwenden Sie na als else-Verzweigung. Sie können zwei oder mehr?:Operatoren kombinieren, um Sätze zu realisieren, die ähnlich wie die Schaltfläche sind (siehe Beispiel oben). Sie können Arithmetische Operatoren mit Zahlen und Zahlen von Variablen verwenden. Wenn Sie Zahlen verwenden, werden die Operatoren für Elemente verwendet.

Bis dann na

[]

Reihe Unterzeichen ─ Bereitstellung von Zugriff auf frühere Werte der Reihe expr1 ─ Expr2 ist die Anzahl der letzten k-Streifen, die ein Wert sein muss ─ Schwimmen wird nach unten umgewandelt ─

expr1[expr2]

Beispiele

// [] 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ückgabe von WertenEine Reihe von Werten.

Bis dann math.floor

und

Logische AND. Für die Boolean-Expressionen gilt:

expr1 and expr2

Rückgabe von WertenEin Boole-Wert, oder eine Reihe von Boole-Werten.

oder

Die Logik OR↑ gilt für die Boole-Expression↑

expr1 or expr2

Rückgabe von WertenEin Boole-Wert, oder eine Reihe von Boole-Werten.

- Nein.

Logische Gegenseitigkeit ((NOT) ⇒ gilt für den Boolean-Ausdruck.

not expr1

Rückgabe von WertenEin Boole-Wert, oder eine Reihe von Boole-Werten.

Datentyp Schlüsselwörter

Boole

Ein Schlüsselwort für den Typ "Bool" für explizit erklärte Variablen oder Parameter. Die Variablen "Bool" können als true, false oder na bezeichnet werden.

Beispiele

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

AnmerkungenEine eindeutige Erwähnung des Typs in der Variablenerklärung ist optional, es sei denn, er wird mit na initialiert. Weitere Informationen zum Typ Pine finden Sie auf der Benutzerhandbuchseite des Typsystems.

Bis dann var varip int float color string true false

Inneres

Schlüsselwörter mit dem Typ int ((Integer) für explizit erklärte Variablen oder Parameter.

Beispiele

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

AnmerkungenEine eindeutige Erwähnung des Typs in der Variablenerklärung ist optional, es sei denn, er wird mit na initialiert. Weitere Informationen zum Typ Pine finden Sie auf der Benutzerhandbuchseite des Typsystems.

Bis dann var varip float bool color string

Schwimmen

Ein Schlüsselwort für den Typ "float" (Schwimmbereich) für explizit erklärte Variablen oder Parameter.

Beispiele

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

AnmerkungenEine eindeutige Erwähnung des Typs in der Variablenerklärung ist optional, es sei denn, er wird mit na initialiert.

Bis dann var varip int bool color string

String

Ein Schlüsselwort für den Typ "string", bei dem Variablen oder Parameter explizit erklärt werden.

Beispiele

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

AnmerkungenEine eindeutige Erwähnung des Typs in der Variablenerklärung ist optional, es sei denn, er wird mit na initialiert. Weitere Informationen zum Typ Pine finden Sie auf der Benutzerhandbuchseite des Typsystems.

Bis dann var varip int float bool str.tostring str.format

Farbe

Ein Schlüsselwort für den Typ "color", der Variablen oder Parameter eindeutig deklariert.

Beispiele

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

AnmerkungenDie Farbzeichen haben folgende Formate: #RRGGBB oder #RRGGBBAA. Die Buchstaben repräsentieren die sechzehnstelligen Werte 00 bis FF (die zehnstelligen 0 bis 255), wobei RR, GG und BB die Werte der Farbdichte Rot, Grün und Blau sind. AA ist der Optionswert für die Farbtransparenz (oder Alpha-Dichte), wobei 00 unsichtbar ist und FF unsichtbar. Eine eindeutige Erwähnung des Typs in der Variablenerklärung ist optional, es sei denn, er wird mit na initialiert. Weitere Informationen zum Typ Pine finden Sie auf der Benutzerhandbuchseite des Typsystems.

Bis dann var varip int float string color.rgb color.new

Reihenfolge

Schlüsselwörter für die Array-Array-Typen für explizit erklärte Variablen oder Parameter; kann verwendet werden.array.new<type>,array.fromDie Funktion erstellt Arrayobjekte (oder IDs).

Beispiele

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

AnmerkungenDie Arrayobjekte sind immer in der Form von Ketten.

Bis dann var array.new array.from

Gegenstände

Objekte in der PINE-Sprache sind Beispiele für benutzerdefinierte Typen (UDT), die als methodlose Klassen verstanden werden können, die es dem Benutzer ermöglichen, in einer Politik einen benutzerdefinierten Typ zu erstellen, der verschiedene Werte in einer Entität organisiert.

Definition von Typen

Lassen Sie uns einen Auftragstyp definieren, um die Auftragsdaten zu speichern:

type order
    float price
    float amount
    string symbol

• NutzungtypeDer Typ der Keyword-Deklaration.
• Der Typ wird nach dem Schlüsselwort type angegeben.
• Die erste Zeile type definiert den Typenamen, schrumpft in vier Felder und definiert die Felder, die der Typ enthält.
• Jedes Feld muss seinen Datentyp angeben, z. B. int, float, string.

Erstellen von Objekten

Benutzen Sie einen gut deklarierten Typ, rufennew()Funktion erstellt Objekte:

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

Das Beispiel lautet:

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

Sie können auch in folgenden Formen geschrieben werden:

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

Objekttypen für das Schlüsselwort var

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

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

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

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

Wenn eine Variable eines Objekts mit einem vom Benutzer definierten Typ mit dem Schlüsselwort var erklärt wird, wird das Schlüsselwort automatisch auf alle Felder dieses Objekts angewendet. Dies bedeutet, dass ein Objekt, das mit dem Schlüsselwort var erklärt wurde, seinen Zustand zwischen jeder Iteration behält, ohne dass sein Feldwert in jeder Iteration neu initialiert werden muss.

• Das Objekt firstBar wird mit dem Schlüsselwort var erklärt, so dass sein Feld (index, price, vol) seinen Wert in jeder Ideration behält, von der ersten Eintrag bis zum Ende der letzten Eintrag.
• Das Objekt currentBar verwendet keine var-Keyword-Deklaration, so dass sein Feld bei jedem Eintrag neu initialiert wird, und es gibt ein neues Objekt bei jeder Iteration.

Sie können die Unterschiede zwischen den beiden Objekten vergleichen, indem Sie die Indexfelder der beiden Objekte zeichnen. firstBar.index behält den vorher eingestellten Wert in jeder Ideration, während currentBar.index in jeder Ideration als bar_index-Wert für den aktuellen Eintrag neu initialiert wird.

Objekttypen für Varip-Keywords

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

//@type A custom type that counts the bars and ticks in the script's execution.
type Counter
    int       bars  = 0
    varip int ticks = 0

//@variable A `Counter` object whose reference persists throughout all bars.
var Counter counter = Counter.new()

// Add 1 to the `bars` and `ticks` fields. The `ticks` field is not subject to rollback on unconfirmed bars.
counter.bars  += 1
counter.ticks += 1

// Plot both fields for comparison.
plot(counter.bars, "Bar counter", color.blue, 3)
plot(counter.ticks, "Tick counter", color.purple, 3)

In Pine kann mit dem Varip-Keyword angezeigt werden, dass ein Objektfeld während der gesamten Skriptdurchführung bestehen bleibt, ohne in unbekannten Stücken zurückzukehren. In einer Erklärung mit dem Counter-Typ wird das Feld bars nicht mit dem Varip-Keyword versehen und wird daher in jeder unbekannten Spalte zurückgeschoben. Das Feld ticks verwendet das Varip-Keyword und wird daher nicht in der unbekannten Spalte zurückgeschoben. Das counter-Objekt wird mit dem Schlüsselwort var erklärt, so dass es während der gesamten Skriptdurchführung bestehen bleibt. In jeder Ideration werden die Bars-Felder und die Ticks-Felder um 1 erhöht. Die Bars-Felder rollen in jeder unbekannten Spalte um, die Ticks-Felder nicht. Schließlich können die Unterschiede zwischen den Feldern counter.bars und counter.ticks verglichen werden. Die Werte von counter.bars werden in jeder unerkannten Spalte zurückgeschoben, während die Werte von counter.ticks bis zum Ende der Skriptdurchführung zunehmen.

Ändern des Feldwerts

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)

if strategy.position_size != 0
    runtime.log(order1)
    order1.price := 999
    order1.amount := 100
    runtime.log(order1)
    runtime.error("stop")

Kann verwendet werden:=Die Neuausgabe-Operator ändert den Wert eines Objektfeldes.

Sammlung von Objekten

Ein Beispiel erklärt eine leere Array, die Objekte mit einem benutzerdefinierten Ordertyp speichert:

type order
    float price
    float amount
    string symbol

arrOrder = array.new<order>()

order1 = order.new(99, 1, "BTC_USDT")
order2 = order.new(100, 2, "ETH_USDT")

array.push(arrOrder, order1)
array.push(arrOrder, order2)

runtime.log(arrOrder)
runtime.error("stop")

Oder

type order
    float price
    float amount
    string symbol

var array<order> arrOrder = na
arrOrder := array.new<order>()

order1 = order.new(99, 1, "BTC_USDT")
order2 = order.new(100, 2, "ETH_USDT")

array.push(arrOrder, order1)
array.push(arrOrder, order2)

runtime.log(arrOrder)
runtime.error("stop")

Objekt kopieren

In Pine werden Objekte durch Referenzen zugewiesen. Beide beziehen sich auf das gleiche Objekt, wenn ein vorhandener Objekt einer neuen Variable zugewiesen wird.

//@version=5
indicator("")
type pivotPoint
    int x
    float y
pivot1 = pivotPoint.new()
pivot1.x := 1000
pivot2 = pivot1
pivot2.x := 2000
// Both plot the value 2000.
plot(pivot1.x)
plot(pivot2.x)

In dem folgenden Beispiel erstellen wir ein Pivot1-Objekt und setzen sein x-Feld auf 1000. Dann erklären wir, dass ein Pivot2-Objekt eine Variable enthält, die auf dieses Pivot-1-Objekt bezieht, so dass beide auf die gleiche Instanz verweisen. Daher ändert eine Änderung von Pivot2.x auch Pivot1.x, da beide auf das Feld von x auf das gleiche Objekt beziehen.

Um eine Kopie unabhängig vom ursprünglichen Objekt zu erstellen, können wir in diesem Fall die eingebaute copy() Methode verwenden. In diesem Beispiel erklären wir, dass pivot2 eine Variable bezieht, die sich auf eine Kopie von pivot1-Objekten bezieht. Jetzt ändert eine Änderung von pivot2.x nicht pivot1.x, da es sich um ein Feld von x bezieht, das sich auf ein einzelnes Objekt bezieht:

//@version=5
indicator("")
type pivotPoint
    int x
    float y
pivot1 = pivotPoint.new()
pivot1.x := 1000
pivot2 = pivotPoint.copy(pivot1)
pivot2.x := 2000
// Plots 1000 and 2000.
plot(pivot1.x)
plot(pivot2.x)

Es ist zu beachten, dass die Kopiermethode von TradingView Basiskopie ist. Wenn ein Objekt ein Feld mit einem speziellen Typ (z. B. ein Array) hat, werden diese Felder in der Basiskopie des Objekts auf die gleiche Instanz verwiesen. Die FMZ-Plattform ermöglicht die direkte Implementierung von Deep Copy ohne zusätzliche Bearbeitung.

Tiefe Kopien

//@version=5

indicator("test deepCopy")

type orderInfo
    float price
    float amount

type labelInfo
    orderInfo order
    string labelMsg

labelInfo1 = labelInfo.new(orderInfo.new(100, 0.1), "test labelInfo1")
labelInfo2 = labelInfo.copy(labelInfo1)

labelInfo1.labelMsg := "labelInfo1->2"    // 修改 labelInfo1 的基础类型字段，看是否影响 labelInfo2
labelInfo1.order.price := 999             // 修改 labelInfo1 的复合类型字段，看是否影响 labelInfo2

runtime.log(labelInfo1)
runtime.log(labelInfo2)
runtime.error("stop")

Testresultate, labelInfo.copy ((labelInfo1) wird bei Ausführung als tief kopiert, Änderungen an labelInfo1 beeinflussen labelInfo2 nicht.

Methoden

Methoden in der Pine-Sprache sind spezielle Funktionen, die mit dem eingebauten oder vom Benutzer definierten Typ eines bestimmten Instanzes verknüpft sind. In den meisten Fällen sind sie den normalen Funktionen ähnlich, bieten jedoch eine kürzere und bequemere Syntax. Benutzer können Methoden mit Punktzeichen direkt auf Variablen zugreifen, so wie sie auf Felder von Pine-Objekten zugreifen. Pine umfasst alle speziellen Arten von eingebauten Methoden, einschließlich Sammelzahlen, Matrizen, Matrixmappungen, Linien, Füllzeilen usw. Diese Methoden bieten Benutzern eine einfachere Möglichkeit, spezielle Programme dieser Arten im Skript aufzurufen.

Einbaumethoden

Ein Beispiel dafür ist ein Skript, das lautet:

//@version=5
indicator("Custom Sample BB", overlay = true)

float sourceInput  = input.source(close, "Source")
int   samplesInput = input.int(20, "Samples")
int   n            = input.int(10, "Bars")
float multiplier   = input.float(2.0, "StdDev")

var array<float> sourceArray = array.new<float>(samplesInput)
var float        sampleMean  = na
var float        sampleDev   = na

// Identify if `n` bars have passed.
if bar_index % n == 0
    // Update the queue.
    array.push(sourceArray, sourceInput)
    array.shift(sourceArray)
    // Update the mean and standard deviaiton values.
    sampleMean := array.avg(sourceArray)
    sampleDev  := array.stdev(sourceArray) * multiplier

// Calculate bands.
float highBand = sampleMean + sampleDev
float lowBand  = sampleMean - sampleDev

plot(sampleMean, "Basis", color.orange)
plot(highBand, "Upper", color.lime)
plot(lowBand, "Lower", color.red)

Das gleiche kann wie folgt geschrieben werden:

//@version=5
indicator("Custom Sample BB", overlay = true)

float sourceInput  = input.source(close, "Source")
int   samplesInput = input.int(20, "Samples")
int   n            = input.int(10, "Bars")
float multiplier   = input.float(2.0, "StdDev")

var array<float> sourceArray = array.new<float>(samplesInput)
var float        sampleMean  = na
var float        sampleDev   = na

// Identify if `n` bars have passed.
if bar_index % n == 0
    // Update the queue.
    sourceArray.push(sourceInput)
    sourceArray.shift()
    // Update the mean and standard deviaiton values.
    sampleMean := sourceArray.avg()
    sampleDev  := sourceArray.stdev() * multiplier

// Calculate band values.
float highBand = sampleMean + sampleDev
float lowBand  = sampleMean - sampleDev

plot(sampleMean, "Basis", color.orange)
plot(highBand, "Upper", color.lime)
plot(lowBand, "Lower", color.red)

Sie können sehen, dass PINE unterstützt wird.MethodsUnd dann wird der Codearray.avg(sourceArray)Die Methoden können in folgender Form geschrieben werden:sourceArray.avg()Das ist nicht wahr. Beachten Sie, dass FMZ nicht unterstützt wird.array.avgIch habe mich nicht geäußert.

Benutzerdefinierte Methoden

Pine erlaubt es Benutzern, eine benutzerdefinierte Methode zu definieren, die zusammen mit einem beliebigen Objekt eines eingebauten oder benutzerdefinierten Typs verwendet wird. Die Definitionsmethode ist im Wesentlichen die gleiche wie die Definitionsfunktion, jedoch mit zwei wesentlichen Unterschieden:

1. Das Schlüsselwort method muss vor dem Funktionsnamen enthalten sein. 2. Parameter der Methode, wobei der Typ des ersten Parameters explizit erklärt werden muss, da er den Typ des Objekts angibt, mit dem die Methode verknüpft wird.

Zum Beispiel, um die Code für die Berechnung von Brin-Messern in der folgenden Methode als benutzerdefinierte Methode zu verpacken:

//@version=5
indicator("Custom Sample BB", overlay = true)

float sourceInput  = input.source(close, "Source")
int   samplesInput = input.int(20, "Samples")
int   n            = input.int(10, "Bars")
float multiplier   = input.float(2.0, "StdDev")

var array<float> sourceArray = array.new<float>(samplesInput)
var float        sampleMean  = na
var float        sampleDev   = na

// Identify if `n` bars have passed.
if bar_index % n == 0
    // Update the queue.
    sourceArray.push(sourceInput)
    sourceArray.shift()
    // Update the mean and standard deviaiton values.
    sampleMean := sourceArray.avg()
    sampleDev  := sourceArray.stdev() * multiplier

// Calculate band values.
float highBand = sampleMean + sampleDev
float lowBand  = sampleMean - sampleDev

plot(sampleMean, "Basis", color.orange)
plot(highBand, "Upper", color.lime)
plot(lowBand, "Lower", color.red)

Siehe auch:

//@version=5
indicator("Custom Sample BB", overlay = true)

float sourceInput  = input.source(close, "Source")
int   samplesInput = input.int(20, "Samples")
int   n            = input.int(10, "Bars")
float multiplier   = input.float(2.0, "StdDev")

var array<float> sour

Mehr