�� होता है (या from_num > to_num के मामले में to_num से छोटा होता है). loop को int/float thresholds/expressions का उपयोग करने की अनुमति है, लेकिन वे केवल loop के पहले पुनरावृत्ति पर मूल्यांकन किए जाते हैं। step_num- काउंटर का वृद्धि/घटास मान. यह वैकल्पिक है. डिफ़ॉल्ट मान +1 या -1 है, जो कि from_num या to_num में से सबसे बड़ा है. जब मान का उपयोग किया जाता है, तो काउंटर भी from_num या to_num में से सबसे बड़े के आधार पर वृद्धि/घटास करता है, इसलिए step_num का +/- चिह्न वैकल्पिक है। statements | continue | break- किसी भी संख्या में वाक्यांश, या ‘continue’ या ‘break’ कीवर्ड, चार रिक्त स्थान या एक टैब में संकुचित करें। return_expression- लूप का रिटर्न मान, यदि मौजूद है, तो var_declaration में एक चर को आवंटित किया जाता है। यदि लूप continue या break कीवर्ड के कारण बाहर निकलता है, तो लूप का रिटर्न मान लूप से बाहर निकलने से पहले आवंटित किए गए अंतिम चर का रिटर्न मान होगा। continue- केवल उन कीवर्ड का उपयोग करें जो रिटर्न में हैं। break- कुंजी शब्द: वापस सर्कल से बाहर निकलें

उदाहरण

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

और देखें for...in while

for…in

for...inयह किसी भी पैरामीटर के साथ इस्तेमाल किया जा सकता हैःarray_element, या दो मापदंडों के साथ प्रयोग किया जाता हैः[index, array_element]│ दूसरा रूप चक्र के कार्य को प्रभावित नहीं करता है │ यह तत्व के पहले चर में वर्तमान पुनरावृत्ति के सूचकांक को ट्रैक करता है │

[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- एक वैकल्पिक चर कथन, जो आवर्तन के लिए दिया जाएगाreturn_expressionका मान index- वर्तमान आवर्ती सूचकांक के लिए एक वैकल्पिक चर का पालन करना ⇒ सूचकांक 0 से शुरू होता है ⇒ चर चक्र में अपरिवर्तनीय है ⇒ जब उपयोग किया जाता है, तो इसे एक में शामिल किया जाना चाहिए ⇒array_elementके उपसमूहों में से array_element- चक्र में संसाधित किए जाने वाले प्रत्येक अनुक्रमिक सरणी तत्वों के चर को शामिल करता है। यह चर चक्र में अपरिवर्तनीय है। array_id- एक बार फिर से चक्र के लिए सरणी आईडी। statements | continue | break- किसी भी संख्या में वाक्यांश, या ‘continue’ या ‘break’ कीवर्ड, चार रिक्त स्थान या एक टैब में संकुचित करें। return_expression- रिटर्न को आवंटित किया गया हैvar_declarationचर, यदि कोई हो। यदि कोई लूप ‘continue’ या ‘break’ कीवर्ड के कारण बाहर निकलता है, तो लूप का रिटर्न मान लूप से बाहर निकलने से पहले दिए गए अंतिम चर है। continue- केवल उन कीवर्ड का उपयोग करें जो रिटर्न में हैं। break- कुंजी शब्द: वापस सर्कल से बाहर निकलें

लूप के भीतर सरणी के तत्वों या उनके आकार को संशोधित करने की अनुमति देता है. यहाँ, हम उपयोग करते हैंfor...inके एकल-पैरामीटर रूप में यह निर्धारित करने के लिए कि प्रत्येक K पंक्ति पर, कितने K पंक्तियों का OHLC मान ‘close’ मान से बड़ा है:

उदाहरण

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

यहाँ, हम दो arguments के रूप में for…in का उपयोग कर रहे हैं ताकि हम अपनेisPosसरणी का मान सेट trueजब वे हमारे पास थे।valuesArrayसरणी में समकक्ष सही समय है:

उदाहरण

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

और देखें for while array.sum array.min array.max

while

whileकथन स्थानीय कोड ब्लॉक के सशर्त पुनरावृत्ति की अनुमति देता है.

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

व्याख्या: variable_declaration- वैकल्पिक चर घोषणाएँreturn expressionइस चर के लिए एक आरंभिक मान प्रदान किया जा सकता है. boolean_expression- यदि सही है, तो निष्पादित करेंwhileवाक्य का स्थानीय खंड. यदि false है, तोwhileवाक्य के बाद स्क्रिप्ट को निष्पादित करना जारी रखें। continue - continueकीवर्ड के कारण चक्र अगले पुनरावृत्ति तक फैलता है। break - breakकुंजीशब्दों के कारण चक्र समाप्त हो गया.whileबयान के बाद बरामद return_expression- उपलब्ध है।whileवैकल्पिक पंक्ति जिसमें कथन मान देता है.

उदाहरण

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

टिप्पणी आरंभिकwhileपंक्ति के बाद स्थानीय कोड ब्लॉक को चार रिक्त स्थान या एक मेनू चिह्न में स्क्रॉल करना होगा. समाप्त करना होगाwhileचक्रwhileऔर फिर, हम जानते हैं कि हम क्या कर सकते हैं, और हम जानते हैं कि हम क्या कर सकते हैं।break。

switch

switch ऑपरेटर शर्त और अभिव्यक्ति के मान के आधार पर नियंत्रण को कई कथनों में से एक में स्थानांतरित करता है।

[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

इस अभिव्यक्ति के साथ switch:

उदाहरण

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

अभिव्यक्ति के बिना स्विचः

उदाहरण

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)

मान लौटाएँ निष्पादित स्थानीय कथन ब्लॉक में अंतिम अभिव्यक्ति का मान

टिप्पणी केवल निष्पादितlocal_blockउदाहरण याdefault_local_blockपहला।default_local_blockकेवल=>एक साथ चिह्नित किया जाता है और केवल तभी निष्पादित किया जाता है जब पिछले ब्लॉक निष्पादित नहीं किया गया हो। यदिswitchकथन का परिणाम एक चर को सौंपा गया है और निर्दिष्ट नहीं हैdefault_local_blockयदि नहीं किया जाता हैlocal_blockतो यह वापस आ जाता हैnaswitchजब एक वाक्य का परिणाम एक चर को आवंटित किया जाता है, तो सभीlocal_blockउदाहरणों को एक ही प्रकार के मान लौटाएं

और देखें if ?:

series

series एक कुंजी शब्द है जो डेटा श्रृंखला प्रकार को दर्शाता है।seriesखोजशब्दों की आवश्यकता नहीं होती है

ऑपरेटर

=

चर को मान देने के लिए, लेकिन केवल जब वे घोषित किए जाते हैं ((पहली बार उपयोग करें)) ।

:=

एस्केप ऑपरेटर, बाईं ओर दिए गए चर को एस्केप करता है। इसका उपयोग पहले घोषित किए गए चर को एस्केप करने के लिए किया जाता है।

!=

किसी भी प्रकार के अभिव्यक्ति के लिए लागू।

expr1 != expr2

मान लौटाएँ बुल मान, या बुल मानों की एक श्रृंखला

%

मॉड्यूल संख्या ((पूर्णांक अतिरिक्त संख्या)

expr1 % expr2

मान लौटाएँ पूर्णांक या फ्लोटिंग पॉइंट मान, या मानों की एक श्रृंखला.

टिप्पणी पाइन स्क्रिप्ट में, जब पूर्णांक की शेष राशि की गणना की जाती है, तो व्यापार को काट दिया जाएगा। यानी, इसे सबसे कम निरपेक्ष मूल्य पर चौगुना कर दिया जाएगा। अर्जित मूल्य में लाभांश के समान प्रतीक होगा।

उदाहरण: -1 % 9 = -1 - 9 * truncate ((-¹⁄₉) = -1 - 9 * truncate ((-0.111) = -1 - 9 * 0 = -1。

%=

मॉड्यूल निर्दिष्ट करता है. यह संख्यात्मक अभिव्यक्ति के लिए लागू होता है.

expr1 %= expr2

उदाहरण

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

मान लौटाएँ पूर्णांक या फ्लोटिंग पॉइंट मान, या मानों की एक श्रृंखला.

*

गुणन संख्यात्मक अभिव्यक्ति के लिए लागू

expr1 * expr2

मान लौटाएँ पूर्णांक या फ्लोटिंग पॉइंट मान, या मानों की एक श्रृंखला.

*=

गुणन विधि को निर्दिष्ट करता है। यह संख्यात्मक अभिव्यक्तियों पर लागू होता है।

expr1 *= expr2

उदाहरण

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

मान लौटाएँ पूर्णांक या फ्लोटिंग पॉइंट मान, या मानों की एक श्रृंखला.

+

जोड़ या एक पूर्णांक. संख्यात्मक अभिव्यक्ति या स्ट्रिंग के लिए लागू होता है.

expr1 + expr2

+ expr

मान लौटाएँ स्ट्रिंग का द्विआधारीकरण+Expr1 और Expr2 के संयोजन को लौटाता है संख्याएँ पूर्णांक या फ्लोट पॉइंट मान या मानों की एक श्रृंखला लौटाता हैः द्विआधारी ‘+’ लौटाता है एक्सपीआर 1 प्लस एक्सपीआर 2. युआन + युआन वापस expr ((एक युआन ऑपरेटर के लिए सममित करने के लिए कुछ भी नहीं जोड़ा गया है)

टिप्पणी आप अंकों के साथ अंकगणित ऑपरेटरों का उपयोग कर सकते हैं और चर की एक सरणी का उपयोग कर सकते हैं। सरणी के मामले में, ऑपरेटर तत्वों पर लागू होते हैं।

+=

जोड़-निर्देश संख्यात्मक अभिव्यक्ति या स्ट्रिंग के लिए लागू

expr1 += expr2

उदाहरण

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

मान लौटाएँ स्ट्रिंग के लिए, expr1 और expr2 का क्रमबद्ध होना। संख्याओं के लिए, पूर्णांक या फ्लोट मान, या मानों की एक श्रृंखला।

टिप्पणी आप अंकों के साथ अंकगणित ऑपरेटरों का उपयोग कर सकते हैं और चर की एक सरणी का उपयोग कर सकते हैं। सरणी के मामले में, ऑपरेटर तत्वों पर लागू होते हैं।

-

घटाव विधि या एक-अंक ऋणात्मक संख्या.

expr1 - expr2

- expr

मान लौटाएँ एक पूर्णांक या फ्लोटिंग पॉइंट मान, या मानों की एक श्रृंखला लौटाता हैः द्विआधारी ‘+’ लौटाता है एक्सपीआर 1 माइनस एक्सपीआर 2. एक यूआन-Expr के लिए नकारात्मक फ़ंक्शन लौटाता है

टिप्पणी आप अंकों के साथ अंकगणित ऑपरेटरों का उपयोग कर सकते हैं और चर की एक सरणी का उपयोग कर सकते हैं। सरणी के मामले में, ऑपरेटर तत्वों पर लागू होते हैं।

-=

संख्यात्मक अभिव्यक्ति के लिए लागू।

expr1 -= expr2

उदाहरण

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

मान लौटाएँ पूर्णांक या फ्लोटिंग पॉइंट मान, या मानों की एक श्रृंखला.

/

अपवाद संख्यात्मक अभिव्यक्तियों के लिए लागू

expr1 / expr2

मान लौटाएँ पूर्णांक या फ्लोटिंग पॉइंट मान, या मानों की एक श्रृंखला.

/=

संख्यात्मक अभिव्यक्ति के लिए लागू किया गया।

expr1 /= expr2

उदाहरण

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

मान लौटाएँ पूर्णांक या फ्लोटिंग पॉइंट मान, या मानों की एक श्रृंखला.

<

से कम संख्यात्मक अभिव्यक्ति के लिए लागू

expr1 < expr2

मान लौटाएँ बुल मान, या बुल मानों की एक श्रृंखला

<=

से कम या बराबर संख्यात्मक अभिव्यक्ति के लिए

expr1 <= expr2

मान लौटाएँ बुल मान, या बुल मानों की एक श्रृंखला

==

किसी भी प्रकार की अभिव्यक्ति के लिए लागू होता है।

expr1 == expr2

मान लौटाएँ बुल मान, या बुल मानों की एक श्रृंखला

=>

’=>’ ऑपरेटर उपयोगकर्ता द्वारा परिभाषित फ़ंक्शन घोषणाओं औरswitchवाक्य में

फ़ंक्शन कथन की सिंटैक्स इस प्रकार है:

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

एक<local_block>0 या अधिक पाइन वाक्यांशों से। <function_result>एक चर, एक अभिव्यक्ति या एक उपसमूह है.

उदाहरण

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

टिप्पणी आप उपयोगकर्ता पुस्तिका के घोषणा फ़ंक्शन और स्क्रिप्ट लाइब्रेरी पृष्ठों में उपयोगकर्ता परिभाषित फ़ंक्शन के बारे में अधिक जानकारी प्राप्त कर सकते हैं।

>

से अधिक संख्यात्मक अभिव्यक्ति के लिए लागू

expr1 > expr2

मान लौटाएँ बुल मान, या बुल मानों की एक श्रृंखला

>=

से बड़ा या बराबर

expr1 >= expr2

मान लौटाएँ बुल मान, या बुल मानों की एक श्रृंखला

?:

त्रिमूर्ति शर्त संचालक

expr1 ? expr2 : expr3

उदाहरण

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

मान लौटाएँ यदि expr1 को true माना जाता है, तो expr2 है, अन्यथा expr3 है। शून्य मान ((0 और NaN +, अनंत, अनंत) को false माना जाता है, अन्य सभी मान true हैं।

टिप्पणी यदि आपको इसकी आवश्यकता नहीं है, तो कृपया na का उपयोग करें। आप दो या दो से अधिक: ऑपरेटरों का उपयोग कर सकते हैं, जो एक वाक्य को लागू करने के लिए है जैसे कि switch () (उपरोक्त उदाहरण देखें) । आप अंकों के साथ अंकगणित ऑपरेटरों का उपयोग कर सकते हैं और चर की एक सरणी का उपयोग कर सकते हैं। सरणी के मामले में, ऑपरेटर तत्वों पर लागू होते हैं।

और देखें na

[]

अनुक्रम अनुक्रम पूर्ववर्ती मानों तक पहुंच प्रदान करता है एक्सपीआर 1 श्रृंखला एक्सपीआर 2 पिछले k पंक्तियों की संख्या है, जो संख्यात्मक होना चाहिए फ्लोट को नीचे की ओर घुमाया जाएगा

expr1[expr2]

उदाहरण

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

मान लौटाएँ मानों की एक श्रृंखला

और देखें math.floor

and

तर्क AND बुल अभिव्यक्ति के लिए लागू होता है

expr1 and expr2

मान लौटाएँ बुल मान, या बुल मानों की एक श्रृंखला

or

तर्क OR बुल अभिव्यक्ति के लिए लागू होता है

expr1 or expr2

मान लौटाएँ बुल मान, या बुल मानों की एक श्रृंखला

not

तर्क उलटा ((NOT) लागू होता है बुल अभिव्यक्ति

not expr1

मान लौटाएँ बुल मान, या बुल मानों की एक श्रृंखला

डेटा प्रकार कीवर्ड

bool

“Bool” चर के मान true, false या na हो सकते हैं।

उदाहरण

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

टिप्पणी चर कथन में स्पष्ट रूप से वर्णित प्रकार वैकल्पिक है, जब तक कि यह na के साथ आरंभ न हो। प्रकार प्रणाली के उपयोगकर्ता मैनुअल पृष्ठ पर पाइन प्रकार के बारे में अधिक जानकारी प्राप्त करें।

और देखें var varip int float color string true false

int

int ((पूर्णांक) प्रकार की कुंजी शब्द जिसका उपयोग स्पष्ट रूप से किसी चर या पैरामीटर को घोषित करने के लिए किया जाता है

उदाहरण

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

टिप्पणी चर कथन में स्पष्ट रूप से वर्णित प्रकार वैकल्पिक है, जब तक कि यह na के साथ आरंभ न हो। प्रकार प्रणाली के उपयोगकर्ता मैनुअल पृष्ठ पर पाइन प्रकार के बारे में अधिक जानकारी प्राप्त करें।

और देखें var varip float bool color string

float

फ़्लोट प्रकार की कुंजी शब्द जिसका उपयोग एक चर या पैरामीटर को स्पष्ट रूप से घोषित करने के लिए किया जाता है।

उदाहरण

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

टिप्पणी प्रकार को स्पष्ट रूप से वर्णित करना वैकल्पिक है, जब तक कि यह na से आरंभ न हो।

और देखें var varip int bool color string

string

“string” प्रकार की कुंजी शब्द का उपयोग स्पष्ट रूप से घोषित चर या पैरामीटर के लिए किया जाता है

उदाहरण

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

टिप्पणी चर कथन में स्पष्ट रूप से वर्णित प्रकार वैकल्पिक है, जब तक कि यह na के साथ आरंभ न हो। प्रकार प्रणाली के उपयोगकर्ता मैनुअल पृष्ठ पर पाइन प्रकार के बारे में अधिक जानकारी प्राप्त करें।

और देखें var varip int float bool str.tostring str.format

color

“color” प्रकार की कुंजी शब्द का उपयोग स्पष्ट रूप से घोषित चर या पैरामीटर के लिए किया जाता है.

उदाहरण

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

टिप्पणी रंगीन अक्षरों का निम्न प्रारूप होता हैः #RRGGBB या #RRGGBBAA. अक्षर जोड़े 00 से एफएफ के सोलह अंकों के मानों का प्रतिनिधित्व करते हैं ((0 से 255 के दशमलव), जिनमें आरआर, जीजी और बीबी जोड़े रंग के लाल, हरे और नीले रंग के अंशों के मान हैं। AA रंग पारदर्शिता है ((या अल्फा अंश), जिसमें 00 अदृश्य है, एफएफ गैर-पारदर्शी है। जब एए समकक्ष प्रदान नहीं किया जाता है, तो एफएफ का उपयोग किया जाता है। सोलह अंकों के अक्षर बड़े या छोटे हो सकते हैं। चर कथन में स्पष्ट रूप से वर्णित प्रकार वैकल्पिक है, जब तक कि यह na के साथ आरंभ न हो। प्रकार प्रणाली के उपयोगकर्ता मैनुअल पृष्ठ पर पाइन प्रकार के बारे में अधिक जानकारी प्राप्त करें।

और देखें var varip int float string color.rgb color.new

array

स्पष्ट रूप से वर्णित चर या पैरामीटर के लिए उपयोग की जाने वाली कुंजीशब्दों के प्रकारों के लिए कुंजीशब्दों का उपयोग करेंarray.new<type>,array.fromफ़ंक्शन एक सरणी ऑब्जेक्ट बनाता है ((या आईडी)

उदाहरण

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

टिप्पणी array ऑब्जेक्ट हमेशा arrays के रूप में होते हैं.

और देखें var array.new array.from

Objects

PINE भाषा का ऑब्जेक्ट्स ऑब्जेक्ट यूजर-डिफाइंड टाइप ((UDT) का एक उदाहरण है, जिसे एक विधि-रहित वर्ग के रूप में समझा जा सकता है, जो उपयोगकर्ताओं को एक इकाई में विभिन्न मानों को व्यवस्थित करने के लिए कस्टम प्रकार बनाने की अनुमति देता है।

प्रकार परिभाषित करें

आइए हम ऑर्डर जानकारी को संग्रहीत करने के लिए एक ऑर्डर प्रकार को परिभाषित करेंः

type order
    float price
    float amount
    string symbol

• उपयोगtypeकीवर्ड घोषणा प्रकार
• type कीवर्ड के बाद type का नाम
• पहली पंक्ति type प्रकार के नाम को परिभाषित करने के बाद, चार रिक्त स्थानों में स्क्रॉल करें और उस प्रकार को शामिल करने वाले फ़ील्ड को परिभाषित करें।
• प्रत्येक फ़ील्ड को अपने डेटा प्रकार को निर्दिष्ट करने की आवश्यकता होती है, जैसे कि int, float, string।

वस्तु बनाने के लिए

प्रकार का उपयोग कर घोषित अच्छा, बुलायाnew()फ़ंक्शन बनाने के लिए ऑब्जेक्टः

order1 = order.new()

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

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

आप खाली ऑब्जेक्ट भी बना सकते हैंः

order order1 = na

एक वास्तविक उदाहरण देखेंः

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

उदाहरण के लिए, यह वाक्यः

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

इसे निम्न रूप में भी लिखा जा सकता हैः

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

ऑब्जेक्ट का प्रकार 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")

जब var कुंजीशब्द घोषणा का उपयोग किया जाता है तो उपयोगकर्ता द्वारा परिभाषित प्रकार के ऑब्जेक्ट के लिए एक चर आवंटित किया जाता है, तो यह कुंजीशब्द स्वचालित रूप से उस ऑब्जेक्ट के सभी फ़ील्डों पर लागू होता है। इसका मतलब है कि var कुंजीशब्द घोषणा के माध्यम से ऑब्जेक्ट प्रत्येक पुनरावृत्ति के बीच अपनी स्थिति बनाए रखेगा, और प्रत्येक पुनरावृत्ति में अपने फ़ील्ड मान को फिर से आरंभ करने की आवश्यकता नहीं होगी।

• firstBar ऑब्जेक्ट को var कीवर्ड के साथ घोषित किया गया है, इसलिए इसका फ़ील्ड ((index, price, vol) प्रत्येक पुनरावृत्ति में अपने मान को बनाए रखेगा, जो पहले प्रविष्टि से शुरू होता है और अंतिम प्रविष्टि तक समाप्त होता है।
• currentBar ऑब्जेक्ट var कीवर्ड घोषणा का उपयोग नहीं करता है, इसलिए इसके फ़ील्ड को प्रत्येक प्रविष्टि पर फिर से आरंभ किया जाएगा और प्रत्येक पुनरावृत्ति में एक नया ऑब्जेक्ट होगा।

दो वस्तुओं के इंडेक्स फ़ील्ड को मैप करके, आप उनके बीच के अंतरों की तुलना कर सकते हैं। firstBar.index प्रत्येक पुनरावृत्ति में पहले से सेट किए गए मान को बनाए रखेगा, जबकि currentBar.index प्रत्येक पुनरावृत्ति में वर्तमान आइटम के bar_index मान के रूप में पुनः आरंभ करेगा।

ऑब्जेक्ट प्रकार के लिए varp कीवर्ड का उपयोग

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

पिन में, varp कुंजी शब्द का उपयोग करने से यह संकेत मिलता है कि ऑब्जेक्ट के फ़ील्ड पूरे स्क्रिप्ट निष्पादन के दौरान निरंतर रहते हैं, बिना पुष्टि किए गए कॉलम में वापस नहीं जाते हैं। काउंटर प्रकार के कथन में, bars फ़ील्ड में varp कुंजी शब्द का उपयोग नहीं किया जाता है, इसलिए यह प्रत्येक अनिर्धारित कॉलम के भीतर वापस चला जाता है। जबकि ticks फ़ील्ड में varp कुंजी शब्द का उपयोग किया जाता है, इसलिए यह अनिर्धारित कॉलम के भीतर वापस नहीं जाता है। counter ऑब्जेक्ट को var कीवर्ड के साथ घोषित किया गया है, इसलिए यह स्क्रिप्ट निष्पादन के दौरान मौजूद रहेगा। प्रत्येक पुनरावृत्ति में, bars फ़ील्ड और ticks फ़ील्ड को 1 की वृद्धि की जाती है। bars फ़ील्ड प्रत्येक अनचेक किए गए कॉलम के भीतर वापस आ जाती है, जबकि ticks फ़ील्ड वापस नहीं आती है। अंत में, counter.bars और counter.ticks फ़ील्ड्स को चित्रित करके, उनके बीच के अंतरों की तुलना की जा सकती है। counter.bars का मान प्रत्येक अनपेक्षित कॉलम के भीतर वापस आ जाएगा, जबकि counter.ticks का मान बढ़ता रहेगा, जब तक कि स्क्रिप्ट निष्पादन समाप्त नहीं हो जाता।

फ़ील्ड मानों को संशोधित करें

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

इस्तेमाल किया जा सकता है:=पुनर्मूल्यांकन ऑपरेटर ऑब्जेक्ट फ़ील्ड के मान को बदलता है

वस्तुओं का संग्रह

उदाहरण एक रिक्त सरणी को घोषित करता है, जो उपयोगकर्ता द्वारा परिभाषित ऑर्डर प्रकार के ऑब्जेक्ट को संग्रहीत करेगाः

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

या

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

प्रतिलिपि वस्तु

पाइन में, ऑब्जेक्ट्स को संदर्भों द्वारा आवंटित किया जाता है। जब कोई मौजूदा ऑब्जेक्ट किसी नए चर को आवंटित किया जाता है, तो दोनों एक ही ऑब्जेक्ट को इंगित करते हैं।

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

नीचे दिए गए उदाहरण में, हम एक pivot1 ऑब्जेक्ट बनाते हैं और उसके x फ़ील्ड को 1000 पर सेट करते हैं। इसके बाद, हम एक pivot2 को घोषित करते हैं जिसमें उस pivot1 ऑब्जेक्ट का संदर्भ है, इसलिए दोनों एक ही उदाहरण को इंगित करते हैं। इसलिए, pivot2.x को बदलने से pivot1.x भी बदल जाएगा, क्योंकि दोनों एक ही ऑब्जेक्ट के x फ़ील्ड को संदर्भित करते हैं।

मूल ऑब्जेक्ट से स्वतंत्र एक प्रतिलिपि बनाने के लिए, इस मामले में हम अंतर्निहित copy () विधि का उपयोग कर सकते हैं। इस उदाहरण में, हम pivot2 को pivot1 ऑब्जेक्ट के प्रतिकृति उदाहरण के चर के रूप में घोषित करते हैं। अब, pivot2.x को बदलना pivot1.x को नहीं बदलेगा, क्योंकि यह x को एक अलग ऑब्जेक्ट फ़ील्ड में संदर्भित करता हैः

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

ध्यान दें कि ट्रेडिंग व्यू की कॉपी विधि शार्प कॉपी है। यदि किसी ऑब्जेक्ट में विशेष प्रकार के फ़ील्ड (जैसे एरे) हैं, तो ऑब्जेक्ट की शार्प कॉपी में ये फ़ील्ड ऑब्जेक्ट के समान उदाहरणों को इंगित करेंगे। एफएमजेड प्लेटफ़ॉर्म सीधे गहरी प्रतिलिपि को लागू करता है और अतिरिक्त प्रसंस्करण की आवश्यकता नहीं होती है, उदाहरण के लिएः

गहरा प्रतिलिपि

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

परीक्षण परिणाम, labelInfo.copy ((labelInfo1) निष्पादित होने पर गहरी प्रतिलिपि है, labelInfo1 में किसी भी फ़ील्ड को संशोधित करने से labelInfo2 को प्रभावित नहीं किया जाएगा।

Methods

पाइन भाषा में विधियाँ (Methods) विशेष प्रकार के फ़ंक्शन होते हैं जो किसी विशेष उदाहरण के अंतर्निहित या उपयोगकर्ता-परिभाषित प्रकार से जुड़े होते हैं। ज्यादातर मामलों में, वे मूल रूप से नियमित फ़ंक्शंस के समान होते हैं, लेकिन एक छोटी, अधिक सुविधाजनक सिंटैक्स प्रदान करते हैं। उपयोगकर्ताओं को चर पर विधियों का उपयोग करने के लिए सीधे बिंदु चिह्न का उपयोग कर सकते हैं, जैसे कि वे पाइन ऑब्जेक्ट के फ़ील्ड का उपयोग करते हैं। पाइन में सभी विशेष प्रकार के अंतर्निहित विधियां शामिल हैं, जिनमें सरणी, मैट्रिक्स, मैपिंग लाइन, भरने की लाइन, आदि शामिल हैं। ये विधियां उपयोगकर्ताओं को स्क्रिप्ट में इन प्रकार के विशेष प्रकार के कार्यक्रमों को कॉल करने के लिए एक सरल तरीका प्रदान करती हैं।

अंतर्निहित विधि

उदाहरण के लिए, एक स्क्रिप्ट कोडः

”`pine //@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 sourceArray = array.new(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)

“