होता है (या 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
यह किसी भी पैरामीटर के साथ इस्तेमाल किया जा सकता हैः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
कथन स्थानीय कोड ब्लॉक के सशर्त पुनरावृत्ति की अनुमति देता है.
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 ऑपरेटर शर्त और अभिव्यक्ति के मान के आधार पर नियंत्रण को कई कथनों में से एक में स्थानांतरित करता है।
[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
तो यह वापस आ जाता हैna
switch
जब एक वाक्य का परिणाम एक चर को आवंटित किया जाता है, तो सभीlocal_block
उदाहरणों को एक ही प्रकार के मान लौटाएं
और देखें
if
?:
series एक कुंजी शब्द है जो डेटा श्रृंखला प्रकार को दर्शाता है।series
खोजशब्दों की आवश्यकता नहीं होती है
चर को मान देने के लिए, लेकिन केवल जब वे घोषित किए जाते हैं ((पहली बार उपयोग करें)) ।
एस्केप ऑपरेटर, बाईं ओर दिए गए चर को एस्केप करता है। इसका उपयोग पहले घोषित किए गए चर को एस्केप करने के लिए किया जाता है।
किसी भी प्रकार के अभिव्यक्ति के लिए लागू।
expr1 != expr2
मान लौटाएँ बुल मान, या बुल मानों की एक श्रृंखला
मॉड्यूल संख्या ((पूर्णांक अतिरिक्त संख्या)
expr1 % expr2
मान लौटाएँ पूर्णांक या फ्लोटिंग पॉइंट मान, या मानों की एक श्रृंखला.
टिप्पणी पाइन स्क्रिप्ट में, जब पूर्णांक की शेष राशि की गणना की जाती है, तो व्यापार को काट दिया जाएगा। यानी, इसे सबसे कम निरपेक्ष मूल्य पर चौगुना कर दिया जाएगा। अर्जित मूल्य में लाभांश के समान प्रतीक होगा।
उदाहरण: -1 % 9 = -1 - 9 * truncate ((-1⁄9) = -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 बुल अभिव्यक्ति के लिए लागू होता है
expr1 and expr2
मान लौटाएँ बुल मान, या बुल मानों की एक श्रृंखला
तर्क OR बुल अभिव्यक्ति के लिए लागू होता है
expr1 or expr2
मान लौटाएँ बुल मान, या बुल मानों की एक श्रृंखला
तर्क उलटा ((NOT) लागू होता है बुल अभिव्यक्ति
not expr1
मान लौटाएँ बुल मान, या बुल मानों की एक श्रृंखला
“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 i = 14 // Same as `i = 14`
i := na
plot(i)
टिप्पणी चर कथन में स्पष्ट रूप से वर्णित प्रकार वैकल्पिक है, जब तक कि यह na के साथ आरंभ न हो। प्रकार प्रणाली के उपयोगकर्ता मैनुअल पृष्ठ पर पाइन प्रकार के बारे में अधिक जानकारी प्राप्त करें।
और देखें
var
varip
float
bool
color
string
फ़्लोट प्रकार की कुंजी शब्द जिसका उपयोग एक चर या पैरामीटर को स्पष्ट रूप से घोषित करने के लिए किया जाता है।
उदाहरण
// float
float f = 3.14 // Same as `f = 3.14`
f := na
plot(f)
टिप्पणी प्रकार को स्पष्ट रूप से वर्णित करना वैकल्पिक है, जब तक कि यह na से आरंभ न हो।
और देखें
var
varip
int
bool
color
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 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.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
PINE भाषा का ऑब्जेक्ट्स ऑब्जेक्ट यूजर-डिफाइंड टाइप ((UDT) का एक उदाहरण है, जिसे एक विधि-रहित वर्ग के रूप में समझा जा सकता है, जो उपयोगकर्ताओं को एक इकाई में विभिन्न मानों को व्यवस्थित करने के लिए कस्टम प्रकार बनाने की अनुमति देता है।
प्रकार परिभाषित करें
आइए हम ऑर्डर जानकारी को संग्रहीत करने के लिए एक ऑर्डर प्रकार को परिभाषित करेंः
type order
float price
float amount
string symbol
type
कीवर्ड घोषणा प्रकार वस्तु बनाने के लिए
प्रकार का उपयोग कर घोषित अच्छा, बुलाया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.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) विशेष प्रकार के फ़ंक्शन होते हैं जो किसी विशेष उदाहरण के अंतर्निहित या उपयोगकर्ता-परिभाषित प्रकार से जुड़े होते हैं। ज्यादातर मामलों में, वे मूल रूप से नियमित फ़ंक्शंस के समान होते हैं, लेकिन एक छोटी, अधिक सुविधाजनक सिंटैक्स प्रदान करते हैं। उपयोगकर्ताओं को चर पर विधियों का उपयोग करने के लिए सीधे बिंदु चिह्न का उपयोग कर सकते हैं, जैसे कि वे पाइन ऑब्जेक्ट के फ़ील्ड का उपयोग करते हैं। पाइन में सभी विशेष प्रकार के अंतर्निहित विधियां शामिल हैं, जिनमें सरणी, मैट्रिक्स, मैपिंग लाइन, भरने की लाइन, आदि शामिल हैं। ये विधियां उपयोगकर्ताओं को स्क्रिप्ट में इन प्रकार के विशेष प्रकार के कार्यक्रमों को कॉल करने के लिए एक सरल तरीका प्रदान करती हैं।
अंतर्निहित विधि
उदाहरण के लिए, एक स्क्रिप्ट कोडः
”`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)
“