[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 werden oder durch ein Verpacken verpackt werden. Eine verpackte Zeile muss jede Anzahl von Räumen verkleinern, 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.

说明：
- ```variable_name``` - Pine Script中允许的用户变量的任何名称（可以包含大写和小写的拉丁字符，数字和下划线（_），但不能以数字开头）。
- ```expression``` - 任何算术表达式，就像定义常规变量一样。 将计算表达式并将其分配给变量一次。  

**例子**
```pine
// 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.

说明：
- ```variable_name``` - Pine脚本中允许的用户变量的任何名称（可以包含大写和小写拉丁字符、数字和下划线(_)，但不能以数字开头）。
- ```expression``` - 任何算术表达式，就像定义常规变量时一样。在第一根K线上，表达式仅计算一次并将其分配给变量一次。  

**例子**
```pine
// 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

  
### false

表示一个布尔类型变量的值，以及比较操作、逻辑操作的结果。

**备注**
请参阅**比较**运算符和**逻辑**运算符的描述。

**另见**
```bool```

### if

If语句定义了在满足表达式条件时必须执行的语句块。第4版的Pine脚本语言允许您使用“else if”语法。

通用编码来自：

VAR_DECLARATIONX = wenn Bedingung Der Wert der Verzögerung ist der Wert der Verzögerung. Der Wert des Verbrauchs ist der Wert des Verbrauchs. Ich... Variable_decl_thenN Rückgabe_ausdruck_dann sonstig, wenn [fakultativer Block] Der Wert des Verbrauchs ist zu messen Der Wert des Verbrauchs ist der Wert des Verbrauchs. Ich... Der Wert des Zinses wird nicht angepasst. Rückkehr_Ausdruck_anders andere Der Wert des Verbrauchs ist zu messen Der Wert des Verbrauchs ist der Wert des Verbrauchs. Ich... Der Wert des Zinses wird nicht angepasst. Rückkehr_Ausdruck_anders

**备注**
```var_declarationX``` - 此变量获取if语句的值
```condition``` - 如果条件为true，则使用语句块```then```中的逻辑(```var_decl_then0```，```var_decl_then1```等)。如果条件为false，则使用语句块```else if```或者```else```中的逻辑(```var_decl_else0```，```var_decl_else1```等)。
```return_expression_then , return_expression_else``` - 模块中的最后一个表达式或者来自块else的表达式将返回语句的最终值。 如果变量的声明在最后，它的值将是结果值。

if语句的返回值的类型取决于```return_expression_then```和```return_expression_else```类型。TradingView上运行时，它们的类型必须匹配：当你在else块中有一个字符串值时，不可能从then语句块返回一个整数值。在FMZ上运行时，以下例子不会报错，当y值取值"open"时，plot画图时的数值为n/a。

**例子**
```pine
// 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-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

```counter``` - 保存回圈计数器值的变数，在回圈的每次迭代中递增/递减 1 或 step_num 值。
```from_num``` - 计数器的起始值。允许使用“series int/float”值/表达式。
```to_num``` - 计数器的最终值。当计数器大于to_num（或小于to_num在from_num > to_num的情况下）时，循环中断。允许使用“series int/float”值/表达式，但它们仅在循环的第一次迭代时进行评估。
```step_num``` - 计数器的递增/递减值。它是可选的。默认值为+1或-1，具体取决于from_num或to_num中最大的一个。使用值时，计数器也会根据from_num或to_num中最大的那个而递增/递减，因此step_num的+/-符号是可选的。
```statements | continue | break``` - 任意数量的语句，或'continue'或'break'关键字，缩进4个空格或一次 tab。
```return_expression``` - 循环的返回值，如果存在，则分配给var_declaration中的变量。 如果循环由于“continue”或“break”关键字而退出，则循环的返回值是在循环退出之前分配值的最后一个变量的返回值。
```continue``` - 只能在回圈中使用的关键字。它导致回圈的下一次迭代被执行。
```break``` - 退出回圈的关键字。

**例子**
```pine
// 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

`for...in` 结构允许为数组中的每个元素重复执行多个语句。它可以与任一参数一起使用：`array_element`，或与两个参数一起使用：`[index, array_element]`。 第二种形式不影响循环的功能。它在元组的第一个变量中跟踪当前迭代的索引。

[var_declaration =] für array_element in array_id Erzählungen. Weiter. Rückkehr_Ausdruck

[var_declaration =] für [index, array_element] in array_id Erzählungen. Weiter. Rückkehr_Ausdruck

```var_declaration``` - 一个可选的变量声明，将被赋予循环的 `return_expression` 的值。
```index``` - 跟踪当前迭代索引的可选变量。索引从 0 开始。变量在循环体中是不可变的。使用时，它必须包含在一个也包含 `array_element` 的元组中。
```array_element``` - 包含要在循环中处理的每个连续阵列元素的变量。该变量在循环体中是不可变的。
```array_id``` - 回圈迭代的阵列ID。
```statements | continue | break``` - 任意数量的语句，或'continue'或'break'关键字，缩进4个空格或一次 tab。
```return_expression``` - 循环的返回值分配给 `var_declaration` 中的变量，如果存在的话。 如果循环由于'continue'或'break'关键字而退出，则循环的返回值是循环退出前最后一个赋值的变量。
```continue``` - 只能在回圈中使用的关键字。它导致回圈的下一次迭代被执行。
```break``` - 退出回圈的关键字。

允许在循环内修改阵列的元素或其大小。
在这里，我们使用 `for...in` 的单参数形式来确定在每个K线上，有多少K线的OHLC值大于'close'值的SMA：

**例子**
```pine
// 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

### while

`while`语句允许本地代码块的条件迭代。

Variable_declaration = while Boolean_expression Ich... Weiter Ich... Unterbrechung Ich... Rückkehr_Ausdruck

说明：
```variable_declaration``` - 可选的变量声明。`return expression`可以为这个变量提供初始化值。
```boolean_expression``` - 如果为true，则执行`while`语句的本地块。如果为false，则在`while`语句之后继续执行脚本。
```continue``` - `continue` 关键字导致循环分支到下一次迭代。
```break``` - `break` 关键字导致循环终止。脚本的执行在 `while` 语句之后恢复。
```return_expression``` - 提供 `while` 语句返回值的可选行。

**例子**
```pine
// 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

### series

series是一个关键字，表示数据系列类型。显式使用 `series` 关键字通常是不必要的。

## 运算符

### =

用于给变量赋值，但仅在声明变量时（第一次使用）。

### :=

赋值运算符，给左侧变量赋值。用于为先前声明的变量赋值。

### !=

不等于。适用于任何类型的表达式。

Expr1!= expr2

**返回值**
布尔值，或一系列布尔值。

### %

模数(整数余数)。 适用于数值表达式。

expr1 % expr2

**返回值**
整数或浮点值，或一系列值。

**备注**
在Pine脚本中，当计算整数的余数时，商将被截断。 即，将其四舍五入到最小绝对值。 所得值将具有与股息相同的符号。

示例：-1 % 9 = -1 - 9 * truncate(-1/9) = -1 - 9 * truncate(-0.111) = -1 - 9 * 0 = -1。

### %=

模数指派。适用于数值表达式。

expr1 %= expr2

**例子**
```pine
// 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 Helium + Helium ergibt expres1 plus expres2. 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 Schwellpunktwert oder eine Reihe von Werten zurück: Das binäre Kalium + Kalium ergibt expres 1 minus expres 2. 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.

=>

Die Funktion "=>" wird für die Benutzerdefinierung von 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.

**例子**
```pine
// 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

### []

系列下标。 提供对expr1系列的以前值的访问。 expr2是过去k线的数目，必须是数值。 浮动将被向下舍入。

Ausdruck 1[ausdruck 2]

**例子**
```pine
// [] 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

### and

逻辑 AND。适用于布尔表达式。

Expr1 und expr2

**返回值**
布尔值，或一系列布尔值。

### or

逻辑 OR。适用于布尔表达式。

expr1 oder expr2

**返回值**
布尔值，或一系列布尔值。

### not

逻辑求反(NOT)。 适用于布尔表达式。

nicht expr1

**返回值**
布尔值，或一系列布尔值。

## 数据类型关键字

### bool

用于显式声明变量或参数的“bool”（布尔）类型的关键字。"Bool"变量的值可以是true、false或na。

**例子**
```pine
// 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

### int

用于显式声明变量或参数的“int”（整数）类型的关键字。  

**例子**
```pine
// 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

### float

用于显式声明变量或参数的“float”（浮点）类型的关键字。  

**例子**
```pine
// 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

### string

用于显式声明变量或参数的"string"类型的关键字。

**例子**
```pine
// 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

### color

用于显式声明变量或参数的"color"类型的关键字。

**例子**
```pine
// 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

### array

用于显式声明变量或参数的“阵列”类型的关键字。可以使用```array.new<type>```,```array.from```函数创建阵列对象（或ID）。

**例子**
```pine
// 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

### Objects

PINE语言的Objects对象是用户定义类型（UDT）的实例，可以理解为无方法类，允许用户在策略中创建自定义类型在一个实体中组织不同的值。

**定义类型**

  让我们定义一个order类型来保存订单信息：
```pine
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:

`pine //@version=5 Indikator ((Besondere Probe BB, Überlagerung = wahr)

float sourceInput = input.source(schließen, Source) Input = input.int ((20, Samples) In diesem Fall ist die Anzahl der Daten zu berücksichtigen, die für die Berechnung der Daten verwendet werden. Flot-Multiplikator = input.float ((2.0, StdDev)

Var-Array sauer

Weitere Informationen