[TOC]

Einführung in Schlüsselwörter, Grammatik, Einstellungen

Struktur des Codes

Die allgemeine Struktur des Codes in Pine folgt:

<version>
<declaration_statement>
<code>

Anmerkungen

Anmerkungen Symbole, die von der Pine-Sprache des FMZ unterstützt werden: Einzeilenoten//, mehrzeilige Anmerkungen/* */, wie z. B. die Anmerkungen im folgenden Beispiel:

[macdLine, signalLine, histLine] = ta.macd(close, 12, 26, 9)  // calculate the MACD indicator

/*
The plot function draws the indicator line on the chart
*/
plot(macdLine, color = color.blue, title='macdLine')
plot(signalLine, color = color.orange, title='signalLine')
plot(histLine, color = color.red, title='histLine')

Ausgabe

Eine Kompiliereranweisung der folgenden Form teilt dem Kompilierer mit, mit welcher Version von Pine das Skript geschrieben wurde:

//@version=5

Die Standardversion ist V5, die aus dem Code weggelassen werden kann//@version=5.

Erklärungsbericht

• indicator()
• strategy()

Die Erklärungserklärung bestimmt den Typ des Skripts, der wiederum bestimmt, was in ihm erlaubt ist, und wie es verwendet und ausgeführt wird. Setzen Sie Schlüsseleigenschaften des Skripts, wie seinen Namen, wo er erscheinen wird, wenn er dem Diagramm hinzugefügt wird, die Präzision und das Format der angezeigten numerischen Werte und bestimmte numerische Werte, die sein Laufzeitverhalten bestimmen, zum Beispiel die maximale Anzahl von Zeichnungsobjekten, die im Diagramm angezeigt werden sollen. Für Strategien umfassen Attribute Argumente, die das Backtesting steuern, wie Anfangskapital, Provisionen, Rutsch usw.indicator()oderstrategy()Die Erklärung muss in einem Strategiecode in Pine of FMZ enthalten sein.

Code

Zeilen in einem Skript, die keine Kommentare oder Compiler-Anweisungen sind, sondern Statements, die den Algorithmus des Skripts implementieren.

• Variable Angabe
• Umzuweisung von Variablen
• Funktionserklärung
• Eingebaute Funktionsanrufe, benutzerdefinierte Funktionsanrufe
• if, for, whileoderswitchund andere Konstrukte

Die Auskünfte können auf verschiedene Weise angeordnet werden.

• Einige Anweisungen können in einer Zeile ausgedrückt werden, z. B. die meisten Variablendeklarationen, Zeilen, die nur einen Funktionsanruf enthalten, oder einzelne Funktionsdeklarationen. Andere, wie Strukturen, benötigen immer mehrere Zeilen, weil sie einen lokalen Block benötigen.
• Anweisungen im globalen Bereich eines Skripts (d. h. Teile, die nicht Teil eines lokalen Blocks sind) können nicht mit einemspaceodertab(Tab-Taste). Ihr erstes Zeichen muss auch das erste Zeichen der Zeile sein. Zeilen, die an der ersten Position einer Zeile beginnen, sind per Definition Teil des globalen Umfangs des Skripts.
• Einelocal blockist immer für Struktur- oder mehrzeilige Funktionsdeklarationen erforderlich. Ein lokaler Block muss durch einen Tab oder vier Leerzeichen eingelegt werden (andernfalls wird er als der verknüpfte Code der vorherigen Zeile analysiert, der als der kontinuierliche Inhalt der vorherigen Zeile bestimmt wird), und jeder lokale Block definiert einen anderen lokalen Bereich.
• Mehrere Einzeilinienaussagen können mit Kommas (,) als Abgrenzungszeichen auf einer Zeile verknüpft werden.
• Eine Zeile kann Kommentare oder nur Kommentare enthalten.
• Linien können auch verpackt werden (auf mehreren Linien fortgesetzt).

Zum Beispiel drei lokale Blöcke, einen in der kundenspezifischen Funktionsdeklaration und zwei in der Variablendeklaration mit der if-Struktur, wie folgt:

indicator("", "", true)             // Declaration statement (global scope), can be omitted

barIsUp() =>                        // Function declaration (global scope)
    close > open                    // Local block (local scope)

plotColor = if barIsUp()            // Variable declaration (global scope)
    color.green                     // Local block (local scope)
else
    color.red                       // Local block (local scope)

runtime.log("color", color = plotColor)  // Call a built-in function to output the log (global scope)

Code der neuen Zeile

Lange Linien können über mehrere Linien aufgeteilt oder umwickelt werden. Eine umwickelte Linie muss durch eine beliebige Menge an Leerzeichen eingelegt werden, solange sie nicht ein Vielfaches von 4 ist (diese Grenzen werden verwendet, um lokale Blöcke einzulegen).

a = open + high + low + close

Es kann so verpackt werden (beachten Sie, dass die Anzahl der durchgeschlagenen Leerzeichen pro Zeile kein Vielfaches von 4 ist):

a = open +
      high +
          low +
             close

Ein langer Plot ((() Anruf kann wie folgt verpackt werden:

close1 = request.security(syminfo.tickerid, "D", close)      // closing price data series of syminfo.tickerid daily level of the current trading pair
close2 = request.security(syminfo.tickerid, "240", close)    // closing price data series of syminfo.tickerid 240-minute level of the current trading pair
plot(ta.correlation(close, open, 100),                       // Line-long plot() calls can be wrapped
   color = color.new(color.purple, 40),
   style = plot.style_area,
   trackprice = true)

Behauptungen in benutzerdefinierten Funktionsdeklarationen können ebenfalls eingewürft werden. Da jedoch ein lokaler Block syntaktisch mit einem Eintrag (4 Leerzeichen oder 1 Tab) beginnen muss, muss die Fortsetzung einer Behauptung beim Aufspalten auf die nächste Zeile mit mehr als einem Eintrag (nicht gleich 4 Vielfachen von Leerzeichen) beginnen.

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

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

Zeitreihe

Zeitreihe ist kein Datentyp oder Format, sondern ein Konzept einer grundlegenden Struktur in der PINE-Sprache.

Nehmen Sie die integrierte VariableopenDas ist ein Beispiel.openDie integrierte Variable zeichnet den Eröffnungspreis jeder Int-Repräsentation BAR auf, wenn dieseopenist eine 5-minütige Int-Repräsentationsperiode.openDie Variable zeichnet den Eröffnungspreis jeder 5-minütigen Int-Repräsentation BAR (Bar) auf.openIn der Zeitreihe werden die vorhergehenden Werte (Vergangene Werte) in der Zeitreihe mit dem[]Wenn die Strategie auf einer bestimmten Int-Repräsentation BAR ausgeführt wird,open[1]Die Bedeutung bezieht sich auf den Eröffnungspreis der vorherigen Int-Repräsentation BAR der aktuellen Int-Repräsentation BAR.

ObwohlZeitreihenist sehr an die Datenstruktur array erinnert, obwohl die PINE-Sprache auch einen Array-Typ hat.

Die Zeitreihen, die in der Sprache der Kiefer entworfen sind, können leicht den kumulativen Wert des Schlusskurses im Strategiecode berechnen, und es ist nicht notwendig, Schleifstrukturen wie für, nur die eingebaute Funktion zu verwenden.ta.cum(close)Für ein anderes Beispiel müssen wir den Durchschnittswert der Differenz zwischen dem höchsten Preis und dem niedrigsten Preis der letzten 14 Int-Repräsentations-BARs (d. h. der 14 Int-Repräsentations-BARs, die dem aktuellen Zeitpunkt der Ausführung des Codes am nächsten sind) berechnen, der wie folgt geschrieben werden kann:ta.sma(high - low, 14)

Das Ergebnis des Aufrufs einer Funktion auf einer Zeitreihe wird auch eine Spur auf der Zeitreihe hinterlassen, wieder verwenden wir die[]Zum Beispiel können wir beim Testen, ob der Schlusskurs der aktuellen Int-Repräsentation BAR den maximalen Wert des höchsten Preises in der letzten 10 Int-Repräsentation BAR (ohne die aktuelle Int-Repräsentation BAR) übersteigt, schreiben:breach = close > ta.highest(close, 10)[1], und wir können auch schreibenbreach = close > ta.highest(close[1], 10)Also...ta.highest(close, 10)[1]undta.highest(close[1], 10)sind gleichwertig.

Dies kann mit dem folgenden Code überprüft 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 obige Testcode liefert die Werte von a und b für jede BAR in der entsprechenden Zeitreihe.

Musterargumente der Bibliothek der Piniensprache

Anweisungen für die Festlegung der Argumente der eingebauten Vorlage Pine Language Trade Class Library der PINE-Strategie.

Handelseinrichtungen

• Ausführungsart Schlusskursmodell: Das Modell wird erst ausgeführt, wenn der aktuelle BAR abgeschlossen ist, und der Handel wird ausgeführt, wenn der nächste BAR beginnt. Echtzeit-Preismodell: Das Modell wird jedes Mal ausgeführt, wenn sich der Preis bewegt, und es gibt ein Signal, um den Handel sofort auszuführen.
• Standardgröße des offenen Loses: Wenn der Auftrag den Handelsbetrag nicht angibt, wird der Handel nach dem festgelegten Betrag ausgeführt.
• Maximale Auftragsmenge für einen einzigen Handel: Der maximale Auftragsbetrag für jeden Auftrag ist gemäß dem tatsächlichen Markt und dieser Argumentation festzulegen, um zu vermeiden, dass er Auswirkungen auf den Markt hat.
• Gleitpunkte: Bestimmung des Gleitpunktes bei der Auftragserteilung nach demPricing Currency PrecisionDer Wert der Preise wird auf 2 gesetzt, was bis zum zweiten Dezimalpunkt genau ist, genau auf 0,01. Dann repräsentiert jeder Punkt der Rutschpunkte 0,01 Preiseinheiten. Zu diesem Zeitpunkt wird der Rutschpunkt auf 5 gesetzt, und die Rutschrate beim Auftragen ist 0,05 (der Rutsch bezieht sich auf den Teil des Preises, der beim Auftragen eines Bestellbetrags für einen besseren und Handicap-Auftrag überschwemmt).
• Die längste Periodenzahl der Variablen: beeinflusst die Anzahl der K-Linien BAR im Diagramm.SetMaxBarLenin derjavascript srategy.

Futuresoptionen

• Variantencode: Vertragskode, sie muss nur eingestellt werden, wenn das Austauschobjekt ein Nicht-Spot-Austauschobjekt ist.
• Mindestkontraktgröße: Das Mindesthandelsvolumen des Auftrags bei Auftragserteilung.

Optionen für den Live-Handel

• Automatische Wiederherstellung des Fortschritts: Automatische Wiederherstellung des Zustands vor dem letzten Strategie-Stopp.
• Order-Wiederholungszeiten: Wenn die Bestellung nicht ausgeführt wird, wird die Bestellung storniert und die Bestellung neu platziert, um den Handel zu versuchen. Dieses Argument wird verwendet, um die maximale Anzahl der Wiederholungen zu begrenzen.
• Netzwerk-Polling-Intervall (Millisekunden): Nur gültig für das REST-Protokoll, es steuert das Netzwerk-Anforderungsintervall, um zu verhindern, dass Anfragen zu häufig sind und das Austauschlimit überschreiten.
• Konto-Synchronisierungszeit (Sekunden): Zeitdauer für die Synchronisierung von Konto-Daten.
• Position Synchronisierungszeit nach Eröffnung einer Position (Millisekunden): Nur bei wiederholten Positionen, die durch Datenverzögerungen in einigen Börsen verursacht werden, kann die Einstellung einer längeren Synchronisierungszeit solche Probleme lindern.
• Leverage-Multiplikator: legt das Leverage-Multiplikator fest.

Spothandel, sonstige Einstellungen

• Handelsvolumen eines Loses: das Standardhandelsvolumen eines Loses, das nur für den Spot gilt.
• Mindesthandelsvolumen: Das Mindesthandelsvolumen.
• Preissteuerpräzision: Die Preissteuerpräzision, d. h. die Anzahl der Dezimalstellen im Preis.
• Genauigkeit der Handelssorte: die Genauigkeit der Bestellmenge, d. h. die Anzahl der Dezimalstellen der Bestellmenge.
• Bearbeitungsgebühr: Berechnen Sie einige Daten nach dieser Einstellung, 0,002 bedeutet 2/1000.
• Gewinn- und Verluststatistikintervall: Es wird nur für die Anzeige von Gewinn- und Verluststatistiken auf dem realen Markt verwendet.
• Wiederholungsversuch fehlgeschlagen (ms): Wiederholungsversuchsintervall, wenn die Netzwerkanfrage fehlschlägt.
• Verwenden Sie Proxy: Nur für das REST-Protokoll gültig.
• Verbergen von häufigen Netzwerkfehlern: Verbergen von häufigen Fehlerprotokollen im Protokollbereich.
• Switch-Basisadresse: nur für das REST-Protokoll gültig.
• Push-Benachrichtigungen: Push-Nachrichten an Postfächer usw.

Auftragshandel

Offene Position

strategy(title = "open long example", pyramiding = 3)                                // The number of orders placed in the same direction allowed by pyramiding
strategy.entry("long1", strategy.long, 0.01)                                         // Open a long position at the market price, specify the group label as long1
strategy.entry("long2", strategy.long, 0.02, when = close > ta.ema(close, 10))       // The condition is triggered, the order is executed, and the market price opens a long position
strategy.entry("long3", strategy.long, 0.03, limit = 30000)                          // Specify the (lower) price, plan to place a buy order, wait for a deal to open a position, and open a position at a limit price

Schließungsposition

strategy(title = "close long example", pyramiding = 2)                              // The number of orders placed in the same direction allowed by pyramiding
strategy.entry("long1", strategy.long, 0.1)                                         // Open a long position at the market price, specify the group label as long1
strategy.entry("long2", strategy.long, 0.1)                                         // Open a long position at the market price, specify the group label as long2
strategy.close("long1", when = strategy.position_size > 0.1, qty_percent = 50, comment = "close buy entry for 50%")   // To close a position, specify to close 50% of the positions whose group label is long1
strategy.close("long2", when = strategy.position_size > 0.1, qty_percent = 80, comment = "close buy entry for 80%")   // To close a position, specify to close 80% of the positions whose group label is long2

Handelsmechanismus

Der Positionsmechanismus der PINE-Sprache ähnelt einer Einwegposition. Zum Beispiel, wenn eine Position in der Long-Richtung (Long-Position) gehalten wird, wird die Ausführung ausgelöst, und die Position in der Long-Richtung wird zuerst geschlossen. (Schließen Sie alle Long-Positionen) und dann den ausgelösten Auftrag ausführen (in der gegenüberliegenden Richtung zur Position vor dem Schließen).

Geplante Ordnung

Wenn Sie eine Bestellung mit dem Befehl "Order Placement" platzieren, wenn kein Preis angegeben ist, ist der Standard eine Marktbestellung. Zusätzlich zur Marktbestellung können Sie auch eine Bestellung über eine geplante Bestellung platzieren, die nicht sofort zur Bestellung ausgeführt wird. Die geplante Bestellung existiert in der geplanten Bestellwarteschlange des Programms, wenn sie nicht ausgelöst wird, und kann in der Registerkarte Planned Order der Tabelle der Statusinformationen (d. h. der Statusleiste, wenn die Strategie ausgeführt wird) während der Bestellung angezeigt werdentatsächliche Bestellung/BacktestingDas System wird nur dann einen Auftrag erteilen, wenn der Echtzeitmarktpreis die Voraussetzungen erfüllt, um diese geplanten Aufträge auszulösen. Daher ist es normal, dass diese Aufträge eine leichte Abweichung des Handelspreises aufweisen.strategy.entryFunktion, um eine Bestellung zu platzieren, können wir dielimit, stop arguments.

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

• Grenzreihenfolge

  Wenn der Auftrag ein Kaufbefehl ist (d. h. derdirectionDas Argument iststrategy.long), wird der Auftrag nur ausgelöst, wenn der aktuelle Marktpreis unter diesem Preis liegt. Wenn es sich bei dem Auftrag um einen Verkaufsbefehl handelt (d. h.directionDas Argument iststrategy.short), wird der Auftrag nur ausgelöst, wenn der aktuelle Marktpreis höher ist als dieser Preis.

• Aufforderung zur Einstellung

  Wenn es sich bei der Bestellung um einen Kaufbefehl handelt, wird die Bestellung nur ausgelöst, wenn der aktuelle Marktpreis höher ist als dieser Preis. Wenn es sich bei einem Auftrag um einen Verkaufsauftrag handelt, wird der Auftrag nur ausgelöst, wenn der aktuelle Marktpreis unter diesem Preis liegt.

• Stop-Limit-Anweisung

  DielimitundstopDie Bestellung wird zum Preis ausgelöst, der die Bedingungen zuerst erfüllt.

Eigenkapitalanteil

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

// Simple moving average crossover strategy
longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))  

// If the moving average crossover condition is met, buy or sell
if (longCondition)
    strategy.entry("Long", strategy.long)  

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

Nach Festlegungdefault_qty_type=strategy.percent_of_equity, gesetztdefault_qty_valueDie Bestellmenge wird anhand des Betrags der auf dem Konto liegenden Währung berechnet. Zum Beispiel: Wenn das Girokonto 10.000 USDT hat, bedeutet die Angabe einer Order von 1% die Platzierung einer Order mit einer Skala von 100 USDT (berechnet anhand des aktuellen Verkaufspreises).

Erklärung, logische Struktur Schlüsselwörter

Ver-

var ist ein Schlüsselwort für die Zuordnung und einmalige Initialisierung von Variablen. Im Allgemeinen verursacht eine Variable-Zuteilungsgrammatik, die nicht das Schlüsselwort var enthält, dass der Variables-Wert jedes Mal überschrieben wird, wenn die Daten aktualisiert werden.

var variable_name = expression

Erläuterung:

• variable_name- Jeder Name einer Benutzervariable, der in Pine Script zulässig ist (er kann Groß- und Kleinbuchstaben, Zahlen und Unterzeichen (_) enthalten, kann aber nicht mit einer Zahl beginnen).
• expression- Jeder arithmetische Ausdruck, genau wie die Definition einer regulären Variablen.

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 enthält den Schlusskurs des ersten Balkens jedes Balkens in der Reihe. Die Variable b enthält den Schlusskurs der ersten grünen Preisleiste in der Reihe. Die Variable c enthält den Schlusskurs des zehnten grünen Balkens in der Reihe.

Auf FMZ ist es in Echtzeit-Preismodell und Schlusskursmodell unterteilt.varundvarip.

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

// Test var varip
var i = 0
varip ii = 0

// Print the i and ii changed in each round of the strategy logic on the graph
plotchar(true, title="ii", char=str.tostring(ii), location=location.abovebar, color=color.red)
plotchar(true, title="i", char=str.tostring(i), location=location.belowbar, color=color.green)

// Each round of logic execution increments i and ii by 1
if true
    i := i + 1
    ii := ii + 1

• Echtzeitpreismodell Der obige Testcode wird in zwei Phasen ausgeführt: 1. historische Int-Repräsentationsphase 2. Echtzeit-Int-Repräsentationsphase.var, varipwerden in jeder Runde der Strategiecode-Ausführung schrittweise ausgeführt (weilif trueWenn die historische Int-Repräsentationsphase endet, beginnt die Echtzeit-Int-Repräsentationsphase.var, varipDa es sich um ein Echtzeit-Preismodell handelt, wird der Strategie-Code für jede Preisänderung in einer Int-Repräsentation BAR einmal ausgeführt.i := i + 1undii := ii + 1Der Unterschied besteht darin, dass ii jedes Mal geändert wird. Obwohl i auch jedes Mal geändert wird, wird der vorherige Wert wiederhergestellt, wenn die Strategie-Logik in der nächsten Runde ausgeführt wird, und der Wert von i wird nicht aktualisiert, bis die aktuelle Int-Repräsentation BAR abgeschlossen ist (d. h. der vorherige Wert wird nicht wiederhergestellt, wenn die Strategie-Logik in der nächsten Runde ausgeführt wird).

• Modell für den Schlusspreis Da das Schlusskursmodell die Strategie-Logik nur einmal pro Int-Repräsentation BAR ausgeführt.varundvaripIn dem obigen Beispiel verhalten sich bei dem Schlusskursmodell in der historischen Int-Repräsentationsphase und in der Echtzeit-Int-Repräsentationsphase genau gleich schrittweise und erhöhen sich um 1 pro Int-Repräsentation BAR.

Variation

varip (var intrabar persist) ist ein Schlüsselwort, das zur Zuordnung und einmaligen Initialisierung von Variablen verwendet wird.

varip variable_name = expression

Erläuterung:

• variable_name- Jeder Name einer Benutzervariable, der in einer Pine-Schrift zulässig ist (er kann große und kleine lateinische Zeichen, Zahlen und Unterzeichen (_) enthalten, kann aber nicht mit einer Zahl beginnen).
• expression- Jeder arithmetische Ausdruck, wie die Zeit, die reguläre Variablen definiert.

Beispiel

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

Bei der Verwendung von var gibt das Diagramm den Wert von bar_index zurück. Bei varip tritt das gleiche Verhalten auf historischen Balken auf, aber bei Live-Bars gibt das Diagramm einen Wert zurück, der für jeden Tick um einen steigt.

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

- Das stimmt.

Es stellt den Wert einer bool-Variablen dar, oder einen Wert, der berechnet werden kann, wenn ein Ausdruck eineVergleichoderlogisch operator.

AnmerkungenSiehe Beschreibungen vonVergleicheBetreiber undDas ist logisch. Operators.

Siehe auch bool

falsche

Es stellt den Wert einer bool-Variablen und das Ergebnis von Vergleichsoperationen und logischen Operationen dar.

AnmerkungenSiehe Beschreibungen vonVergleicheBetreiber undDas ist logisch. Operators.

Siehe auch bool

wenn

Eine If-Anweisung definiert einen Satzblock, der ausgeführt werden muss, wenn die Bedingung eines Ausdrucks erfüllt ist.

Universeller Code 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-Anweisungcondition- Wenn die Bedingung wahr ist, die Logik in der Anweisung Blockthenverwendet wird (var_decl_then0, var_decl_then1Wenn die Bedingung falsch ist, wird die Logik in der Anweisung blockelse ifoderelseverwendet wird (var_decl_else0, var_decl_else1, etc.).return_expression_thenundreturn_expression_else- Der letzte Ausdruck im Modul oder der Ausdruck aus dem Block else gibt den endgültigen Wert der Anweisung zurück.

Der Typ des zurückgegebenen Werts der if-Anweisung hängt von der Art derreturn_expression_thenundreturn_expression_else. Beim Ausführen in TradingView müssen ihre Typen übereinstimmen: Wenn Sie einen Stringwert im else-Block haben, ist es nicht möglich, einen ganzen Wert aus dem entsprechenden Block zurückzugeben. Beim Ausführen im FMZ wird das folgende Beispiel keinen Fehler melden. Wenn der y-Wert open ist, ist der Wert des Plots beim Zeichnen 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)

DieelseWenn die Bedingung falsch ist, wird der Variablen var_declarationX ein empty-Wert (na, false oder ) zugewiesen:

Beispiel

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

Die Blöcke von then, else if, else werden vier Räume verschoben:

Beispiel

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

Der Ergebniswert derifEs kann nützlich sein, wenn Sie Nebenwirkungen von Ausdrücken benötigen, zum Beispiel im Strategiehandel:

Beispiel

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

Wenn Anweisungen einander enthalten können:

Beispiel

// 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 Konstruktion ermöglicht es, mehrere Anweisungen wiederholt auszuführen:

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

var_declaration- Eine optionale Variablenerklärung, die als Wert des return_expressions der Schleife zugewiesen wird.counter- Eine Variable, die den Wert des Schleifzählers hält und bei jeder Iteration der Schleife um 1 oder den Wert step_numm erhöht/verringert.from_num- Der Anfangswert des Zählers. series int/float Werte/Ausdrücke sind zulässig.to_num- Der endgültige Wert des Zählers. Die Schleife bricht, wenn der Zähler größer als to_num ist (oder kleiner als to_num im Fall von_num > to_num). series int/float Werte/Ausdrücke sind erlaubt, werden aber nur bei der ersten Iteration der Schleife ausgewertet.step_num- Der Inkrement/Decrement-Wert des Zählers. Er ist optional. Der Standardwert ist +1 oder -1, abhängig von dem größten von from_num oder to_num. Bei Verwendung von Werten wird der Zähler auch nach dem größten von from_num oder to_num erhöht/decremented, so dass das +/- Zeichen von step_num optional ist.statements | continue | break- eine beliebige Anzahl von Anweisungen oder der Schlüsselwörter continue oder break, die durch 4 Leerzeichen oder einen einzigen Tab eingedrückt sind.return_expression- Der Rückgabewert der Schleife, falls vorhanden, wird der Variablen in der var_declaration zugewiesen. Wenn die Schleife aufgrund der Schlüsselwörter continue oder break beendet wird, ist der Rückgabewert der Schleife der Rückgabewert der letzten Variablen, der vor dem Ausgang der Schleife ein Wert zugewiesen wurde.continue- Ein Schlüsselwort, das nur in Schleifen verwendet werden kann. Es verursacht die nächste Iteration der Schleife ausgeführt werden.break- Das Schlüsselwort, um aus der Schleife zu kommen.

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

Für... in

Diefor...inconstruct ermöglicht die Wiederholung mehrerer Anweisungen für jedes Element des Arrays. Es kann mit einem der beiden Argumente verwendet werden:array_element, oder mit zwei Argumenten:[index, array_element]Die zweite Form beeinflusst nicht die Funktion der Schleife. Sie verfolgt den Index der aktuellen Iteration in der ersten Variablen des Tupels.

[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, der der Wert der Schleifen zugewiesen wirdreturn_expression. index- Eine optionale Variable, die den aktuellen Iterationsindex verfolgt. Der Index beginnt bei 0. Variablen sind im Loop-Body unveränderlich.array_element. array_element- Eine Variable, die jedes aufeinanderfolgende Array-Element enthält, das in der Schleife verarbeitet werden soll.array_id- Die Array-ID der Schleifeniteration.statements | continue | break- eine beliebige Anzahl von Anweisungen oder der Schlüsselwörter continue oder break, die durch 4 Leerzeichen oder einen einzigen Tab eingedrückt sind.return_expression- Der Rückgabewert der Schleife wird der Variablen invar_declarationWenn die Schleife aufgrund der Schlüsselwörter continue oder break beendet wird, ist der Rückgabewert der Schleife die Variable, die zuletzt zugewiesen wurde, bevor die Schleife beendet wurde.continue- Ein Schlüsselwort, das nur in Schleifen verwendet werden kann. Es verursacht die nächste Iteration der Schleife ausgeführt werden.break- Das Schlüsselwort, um aus der Schleife zu kommen.

Ermöglicht die Änderung von Elementen eines Arrays oder ihrer Größe innerhalb einer Schleife. Hier verwenden wir die Ein-Argument-Form vonfor...inum für jeden Strich zu ermitteln, wie viele Stäbe einen OHLC-Wert haben, der größer ist als der SMA des close-Wertes:

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 verwenden wir die zwei-Argument-Form von für...in um die Werte unsererisPosAnschluss antrueWenn ihre entsprechenden Werte in unserervaluesArraydie Arrays sind positiv:

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

während

DiewhileDiese Anweisung erlaubt die bedingte Iteration von native Code-Blöcken.

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

Erläuterung:variable_declaration- Optionale Variablerdeklaration.return expressionkann einen Initialisierungswert für diese Variable bereitstellen.boolean_expression- Wenn wahr, den lokalen Block deswhileWenn falsch, wird die Ausführung des Skripts nach demwhile statement. continue- Die...continueDas Schlüsselwort führt dazu, dass sich die Schleife auf die nächste Iteration verzweigt.break- Die...breakDie Schaltfläche wird durch das Schlüsselwort beendet. Die Ausführung des Skripts wird nach demwhile statement. return_expression- Optionale Zeile, die den Renditewert derwhile statement.

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)

AnmerkungenDer native Code-Block nach der erstenwhileSie müssen durch vier Leerzeichen oder einen Tab eingelegt werden.whileSchleife, der folgende Boole-Ausdruckwhilemuss schließlich falsch werden, oderbreakSie müssen hingerichtet werden.

Wechseln

Der Schaltbetreiber überträgt die Steuerung auf eine von mehreren Anweisungen basierend auf der Bedingung und dem Wert 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

Wechseln mit Ausdruck:

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)

Wechsel 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ückkehrDer Wert des letzten Ausdrucks im ausgeführten lokalen Anweisungsblock.

AnmerkungenNur einelocal_blockInstanzen oderdefault_local_blockkann ausgeführt werden.default_local_blockist nur mit der=>Tag, und wird nur ausgeführt, wenn der vorhergehende Block nicht ausgeführt wird.switchAngabe wird einer Variablen zugeordnet unddefault_local_blocknicht angegeben ist, wird die Anweisung zurückgegebennawennlocal_blockDas Ergebnis einerswitchAnweisung für eine Variable, allelocal_blockInstanzen müssen einen Wert desselben Typs zurückgeben.

Siehe auch if ?:

Reihe

Der Typ der Datenreihe ist in der Regel unnötig, um explizit dieseries keyword.

Betreiber

=

Wird verwendet, um Variablen Werte zuzuweisen, jedoch nur, wenn die Variable deklariert wird (zuerst verwendet).

:=

Der Zuweisungsoperator weist der Variablen auf der linken Seite einen Wert zu.

!=

Nicht gleich. Anwendbar auf Ausdrücke jeglicher Art.

expr1 != expr2

RückkehrBoole-Wert oder eine Folge von Boole-Werten.

%

Modulo (Vollzahlrückstand). Anwendbar auf numerische Ausdrücke.

expr1 % expr2

RückkehrGanzzahl- oder Floatwert oder Wertreihe.

AnmerkungenBei der Berechnung des Ganzzahlrückstands wird der Quotient in Pine Script abgeschnitten, d.h. auf den niedrigsten absoluten Wert gerundet. Der resultierende Wert hat das gleiche Zeichen wie die Dividende.

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

%=

Modulenaufgabe, anwendbar auf Zahlen.

expr1 %= expr2

Beispiel

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

RückkehrGanzzahl- oder Floatwert oder Wertreihe.

*

Multiplikationszuweisung, anwendbar auf Zahlen.

expr1 * expr2

RückkehrGanzzahl- oder Floatwert oder Wertreihe.

*=

Multiplikationszuweisung, anwendbar auf Zahlen.

expr1 *= expr2

Beispiel

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

RückkehrGanzzahl- oder Floatwert oder Wertreihe.

+

Addition oder unarisches Plus. Anwendbar auf numerische Ausdrücke oder Zeichenfolgen.

expr1 + expr2

+ expr

RückkehrDas Binärsystem+der Zeichenfolge gibt die Kombination von expr1 und expr2 zurück Zahl Gibt einen ganzen oder einen Wert mit einem schwimmenden Zifferzeichen oder eine Wertfolge zurück: Binär + gibt expr1 plus expr2 zurück. Unarische + gibt expr zurück (nichts wird der unarischen Operator-Symmetrie hinzugefügt).

AnmerkungenSie können arithmetische Operatoren sowohl mit Zahlen als auch mit Reihenvariablen verwenden.

+=

Zusätzliche Zuordnung gilt für Zahlen oder Zeichenfolgen.

expr1 += expr2

Beispiel

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

RückkehrFür Zeichenfolgen, gibt die Verknüpfung von expr1 und expr2 zurück. Für Zahlen, gibt ein ganzzahliges oder float-Wert oder eine Reihe von Werten zurück.

AnmerkungenSie können arithmetische Operatoren sowohl mit Zahlen als auch mit Reihenvariablen verwenden.

-

Subtraktion oder unarische Minus.

expr1 - expr2

- expr

RückkehrGibt eine ganze Zahl oder einen Wert mit schwebendem Komma oder eine Reihe von Werten zurück: Binär + gibt expr1 minus expr2 zurück. Einheitlich-Gibt die Negation von expr zurück.

AnmerkungenSie können arithmetische Operatoren sowohl mit Zahlen als auch mit Reihenvariablen verwenden.

-=

Abzugszuweisung. Anwendbar auf Zahlen.

expr1 -= expr2

Beispiel

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

RückkehrGanzzahl- oder Floatwert oder Wertreihe.

/

Zuweisung von Divisionen, anwendbar auf Zahlen.

expr1 / expr2

RückkehrGanzzahl- oder Floatwert oder Wertreihe.

/=

Zuweisung von Divisionen, anwendbar auf Zahlen.

expr1 /= expr2

Beispiel

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

RückkehrGanzzahl- oder Floatwert oder Wertreihe.

<

Weniger als. Anwendbar auf numerische Ausdrücke.

expr1 < expr2

RückkehrBoolean-Wert oder Reihe von Boolean-Werten.

<=

Weniger als oder gleich. Anwendbar auf Zahlen.

expr1 <= expr2

RückkehrBoolean-Wert oder Reihe von Boolean-Werten.

==

Geltend für Ausdrücke jeglicher Art.

expr1 == expr2

RückkehrBoolean-Wert oder Reihe von Boolean-Werten.

=>

Der Operator => wird in benutzerdefinierten Funktionsdeklarationen und inswitch statements.

Die Grammatik der Funktionsdeklaration lautet:

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

Eine<local_block>ist null oder mehr Pine Script Anweisungen.<function_result>ist eine Variable, ein Ausdruck oder ein Tupel.

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

AnmerkungenMehr über benutzerdefinierte Funktionen erfahren Sie auf den Seiten des Benutzerhandbuchs über Deklarierung von Funktionen und Scriptbibliotheken.

>

Größer als. Anwendbar auf numerische Ausdrücke.

expr1 > expr2

RückkehrBoolean-Wert oder Reihe von Boolean-Werten.

>=

Größer als oder gleich. Anwendbar auf Zahlen.

expr1 >= expr2

RückkehrBoolean-Wert oder Reihe von Boolean-Werten.

?:

Ternärer bedingter 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ückkehrexpr2 wenn expr1 als wahr ausgewertet wird, expr3 andernfalls. Nullwert (0 und auch NaN, +Infinity, -Infinity) gilt als falsch, jeder andere Wert als wahr.

AnmerkungenVerwenden Sie na für else Zweig, wenn Sie ihn nicht benötigen. Sie können zwei oder mehr?: -Operatoren kombinieren, um das Äquivalent einer switch-ähnlichen Anweisung zu erreichen (siehe Beispiele oben). Sie können arithmetische Operatoren sowohl mit Zahlen als auch mit Reihenvariablen verwenden.

Siehe auch na

[]

Die Anzahl der Bars in der Vergangenheit ist expr1, und sie muss numerisch sein.

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ückkehrEine Reihe von Werten.

Siehe auch math.floor

und

Logische AND. Anwendbar auf booleanische Ausdrücke.

expr1 and expr2

RückkehrBoolean-Wert oder Reihe von Boolean-Werten.

oder

Logische OR. Anwendbar auf Boolean-Ausdrücke.

expr1 or expr2

RückkehrBoolean-Wert oder Reihe von Boolean-Werten.

- Nein.

Logische Negation (NOT). Anwendbar auf booleanische Ausdrücke.

not expr1

RückkehrBoolean-Wert oder Reihe von Boolean-Werten.

Schlüsselwörter für Datentypen

Boole

Schlüsselwort verwendet, um den bool (boolean) Typ einer Variablen oder eines Arguments ausdrücklich zu deklarieren. Bool Variablen können Werte haben: true, false oder na.

Beispiel

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

AnmerkungenDie explizite Erwähnung des Typs in einer Variablerdeklaration ist optional, außer wenn er mit na initialisiert wird. Erfahren Sie mehr über Pine Script-Typen auf der Seite Benutzerhandbuch des Typsystems.

Siehe auch var varip int float color string true false

Inneres

Schlüsselwort, das verwendet wird, um den int (ganzzahl) -Typ einer Variablen oder eines Arguments explizit zu deklarieren.

Beispiel

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

AnmerkungenDie explizite Erwähnung des Typs in einer Variablerdeklaration ist optional, außer wenn er mit na initialisiert wird. Erfahren Sie mehr über Pine Script-Typen auf der Seite Benutzerhandbuch des Typsystems.

Siehe auch var varip float bool color string

Schwimmen

Schlüsselwort, mit dem explizit der Typ float (Floating Point) einer Variablen oder eines Arguments erklärt wird.

Beispiel

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

AnmerkungenDie explizite Erwähnung des Typs in einer Variabeldeklaration ist optional, außer wenn er mit na initialisiert wird.

Siehe auch var varip int bool color string

String

Schlüsselwort, mit dem der string-Typ einer Variablen oder eines Arguments explizit erklärt wird.

Beispiel

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

AnmerkungenDie explizite Erwähnung des Typs in einer Variablerdeklaration ist optional, außer wenn er mit na initialisiert wird. Erfahren Sie mehr über Pine Script-Typen auf der Seite Benutzerhandbuch des Typsystems.

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

Farbe

Schlüsselwort, mit dem explizit der color-Typ einer Variablen oder eines Arguments angegeben wird.

Beispiel

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

AnmerkungenDie Buchstabenpaare stellen Hexadezimalwerte von 00 bis FF (0 bis 255 im Dezimal) dar, wobei die RR-, GG- und BB-Paare die Werte für die Farbkomponenten s rot, grün und blau sind. AA ist ein optionaler Wert für die Transparenz der Farbe s (oder Alpha-Komponente), wobei 00 unsichtbar und FF undurchsichtig ist. Wenn kein AA-Paar bereitgestellt wird, wird FF verwendet. Die Hexadezimalbuchstaben können groß oder klein sein.

Die explizite Erwähnung des Typs in einer Variablerdeklaration ist optional, außer wenn er mit na initialisiert wird. Erfahren Sie mehr über Pine Script-Typen auf der Seite Benutzerhandbuch des Typsystems.

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

Reihenfolge

Schlüsselwort verwendet, um den array Typ einer Variablen oder eines Arguments ausdrücklich zu deklarieren.array.new<type>, array.from function.

Beispiel

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

AnmerkungenArray-Objekte sind immer serie-Form.

Siehe auch var array.new array.from

Gegenstände

Objekte in der PINE-Sprache sind Instanzen benutzerdefinierter Typen (UDTs), die als methodlose Klassen verstanden werden können, die es Benutzern ermöglichen, benutzerdefinierte Typen in Strategien zu erstellen, um verschiedene Werte in einer Entität zu organisieren.

Definition von Typen

Lassen Sie uns einen Auftragstyp definieren, um Auftragsinformationen zu speichern:

type order
    float price
    float amount
    string symbol

• Die Typen werden unter Verwendung dertype keyword.
• Nach dem Schlüsselwort Typ folgt der Typenname.
• Der Typ der ersten Zeile definiert den Typenamen, vier Leerzeichen und die im Typ enthaltenen Felder.
• Jedes Feld muss seinen Datentyp deklarieren, z. B. int, float, string.

Erstellen von Objekten

Mit dem angegebenen Typ rufen Sie dienew()Funktion zum Erstellen eines Objekts:

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

Schauen wir uns ein praktisches Beispiel an:

type order
    float price
    float amount
    string symbol

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

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

In diesem Beispiel:

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

Es kann auch geschrieben werden:

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

Objekttyp für die Verwendung des Schlüsselworts 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 Sie das Schlüsselwort var verwenden, um eine Variable zu deklarieren, die einem Objekt eines benutzerdefinierten Typs zugewiesen ist, gilt das Schlüsselwort automatisch für alle Felder des Objekts. Dies bedeutet, dass ein über das Schlüsselwort var deklariertes Objekt seinen Zustand zwischen jeder Iteration beibehält, ohne dass seine Feldwerte in jeder Iteration neu initialisiert werden müssen.

• Das Objekt firstBar wird mit dem Schlüsselwort var deklariert, so dass seine Felder (Index, Preis, Volumen) ihre Werte in jeder Iteration behalten, beginnend mit dem ersten Eintrag und endend mit dem letzten Eintrag.
• Das Objekt currentBar wird nicht mit dem Schlüsselwort var deklariert, so dass seine Felder bei jedem Eintrag neu initialisiert werden und Sie bei jeder Iteration ein neues Objekt haben.

Durch das Zeichnen der Indexfelder der beiden Objekte können Sie die Unterschiede zwischen ihnen vergleichen. firstBar.index behält den zuvor festgelegten Wert in jeder Iteration bei, während currentBar.index in jeder Iteration auf den bar_index-Wert des aktuellen Eintrags neu initialisiert wird.

Objekttypen für die Verwendung des Schlüsselworts varip

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

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

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

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

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

In Pine wird das Schlüsselwort varip verwendet, um anzuzeigen, dass die Felder eines Objektes während der gesamten Skriptdurchführung bestehen bleiben und nicht auf unbestätigten Balken zurückrollen. In der Deklaration des Counter-Types verwendet das Feld bars nicht das Schlüsselwort varip, so dass es auf jedem nicht bestätigten Balken zurückrollt. Das Feld ticks verwendet das Schlüsselwort varip, so dass es nicht auf nicht bestätigten Balken zurückrollt. Das Counter-Objekt wird mit dem Schlüsselwort var deklariert, so dass es während der gesamten Skriptdurchführung bestehen bleibt. In jeder Iteration werden sowohl das Bars-Feld als auch das Tick-Feld um 1 erhöht. Schließlich können Sie den Unterschied zwischen den Feldern counter.bars und counter.ticks vergleichen. Der Wert von counter.bars rollt bei jedem nicht bestätigten Balken zurück, während der Wert von counter.ticks bis zum Ende der Skriptdurchführung weiter steigt.

Mehr