संसाधन लोड हो रहा है... लोड करना...

आविष्कारक ने पाइन भाषा के लिए क्वांटिफाइड परिचयात्मक ट्यूटोरियल

लेखक:आविष्कारक मात्रा - छोटे सपने, बनाया गयाः 2022-05-30 16:23:43, अद्यतन किया गयाः 2022-09-28 17:10:21

[TOC]

आविष्कारक ने पाइन भाषा के लिए क्वांटिफाइड परिचयात्मक ट्यूटोरियल

वीडियो ट्यूटोरियल के साथःट्रेडिंग व्यू के साथ पाइन भाषा का उपयोग करना बहुत मुश्किल है - पाइन भाषा के शुरुआती खोजकर्ता

आविष्कारक क्वांटिफाइड ट्रेडिंग प्लेटफ़ॉर्म पाइन भाषा लेखन नीतियों का समर्थन करता है, पुनरावृत्ति का समर्थन करता है, पाइन भाषा नीतियों को वास्तविक डिस्क पर चलाता है, पाइन भाषा के निम्न संस्करणों के साथ संगत है।FMZ.COM) पररणनीतिक चौककई पाइन रणनीतियाँ (स्क्रिप्ट) खोज और स्थानांतरण के लिए शामिल हैं।

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

कुछ स्पष्ट मतभेदों का संक्षिप्त सारांशः

1। एफएमजेड पर पाइन नीति, कोड की शुरुआत में संस्करण चिह्न//@versionऔर कोड के साथ शुरू होता हैstrategy、indicatorशब्द को लिखने की आवश्यकता नहीं है, एफएमजेड फिलहाल समर्थन नहीं करता हैimportआयात करनाlibraryइस तरह के लोगों के लिए।

कुछ रणनीतियों को इस तरह लिखा जा सकता हैः

//@version=5
indicator("My Script", overlay = true)
src = close
a = ta.sma(src, 5)
b = ta.sma(src, 50)
c = ta.cross(a, b)
plot(a, color = color.blue)
plot(b, color = color.black)
plotshape(c, color = color.red)

या यह लिखते हैंः

//@version=5
strategy("My Strategy", overlay=true)

longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
if (longCondition)
    strategy.entry("My Long Entry Id", strategy.long)

shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))
if (shortCondition)
    strategy.entry("My Short Entry Id", strategy.short)

एफएमजेड पर इसे सरल तरीके से कहा जा सकता हैः

src = close
a = ta.sma(src, 5)
b = ta.sma(src, 50)
c = ta.cross(a, b)
plot(a, color = color.blue, overlay=true)
plot(b, color = color.black, overlay=true)
plotshape(c, color = color.red, overlay=true)

याः

longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
if (longCondition)
    strategy.entry("My Long Entry Id", strategy.long)

shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))
if (shortCondition)
    strategy.entry("My Short Entry Id", strategy.short)

2, नीति (स्क्रिप्ट) कुछ लेनदेन से संबंधित सेटिंग्स एफएमजेड नीति इंटरफ़ेस पर "पाइन भाषा लेनदेन लाइब्रेरी" पैरामीटर द्वारा सेट की जाती हैं।
- समापन मूल्य मॉडल और वास्तविक समय मूल्य मॉडल ट्रेडिंग दृश्य में, हम कर सकते हैंstrategyफ़ंक्शन काcalc_on_every_tickएक पैरामीटर सेट करने के लिए रणनीति स्क्रिप्ट वास्तविक समय में रणनीति तर्क निष्पादित करता है जब कीमत हर बार बदलती है, जबcalc_on_every_tickपैरामीटर को सेट किया जाना चाहिएtrue◎ डिफ़ॉल्टcalc_on_every_tickपैरामीटर हैfalseइस प्रकार, एक बार जब रणनीति पूरी तरह से समाप्त हो जाती है, तो रणनीति तर्क को निष्पादित किया जाता है। FMZ पर, यह "पाइन भाषा ट्रेडिंग लाइब्रेरी" टेम्पलेट के पैरामीटर के माध्यम से सेट किया जाता है।
- रणनीति निष्पादन के समय मूल्य, घटती मात्रा आदि के संख्यात्मक सटीक नियंत्रण को FMZ पर निर्दिष्ट करने की आवश्यकता होती है ट्रेडिंग व्यू में, वास्तविक समय में ऑर्डर करने की सटीकता के साथ कोई समस्या नहीं है, क्योंकि केवल अनुकरण परीक्षण किया जा सकता है। एफएमजेड पर, पाइन रणनीति को वास्तविक समय में चलाया जा सकता है। तो रणनीति को व्यापारिक किस्मों के लिए लचीले ढंग से निर्दिष्ट मूल्य सटीकता, ऑर्डर संख्या सटीकता की आवश्यकता होती है। ये सटीकता सेटिंग्स संबंधित डेटा के अंशों को नियंत्रित करती हैं, ताकि डेटा को एक्सचेंज की घोषणा की आवश्यकताओं के अनुरूप न होने से रोका जा सके।
- फ्यूचर्स कॉन्ट्रैक्ट कोड एफएमजेड पर ट्रेडिंग किस्मों में दो गुण होते हैं, यदि यह अनुबंध है। वे "ट्रेड जोड़े" और "अनुबंध कोड" हैं, जिन्हें वास्तविक और पुनरीक्षण के दौरान स्पष्ट रूप से सेट किए जाने के अलावा, "पाइन भाषा ट्रेड लाइब्रेरी" टेम्पलेट के पैरामीटर "प्रजाति कोड" में विशिष्ट अनुबंध कोड सेट करने की आवश्यकता होती है। उदाहरण के लिए, स्थायी अनुबंध भरने के लिए।swap, कॉन्ट्रैक्ट कोड यह देखने के लिए है कि क्या एक्सचेंज में ऐसा कोई कॉन्ट्रैक्ट है। उदाहरण के लिए, कुछ ट्रेडों के लिए सभी तिमाही कॉन्ट्रैक्ट्स, यहां भर सकते हैं।quarter❖ ये अनुबंध कोड एफएमजेड के जावास्क्रिप्ट/पायथन/सी++ भाषा एपीआई दस्तावेज़ में परिभाषित वायदा अनुबंध कोड के अनुरूप हैं.
अन्य सेटिंग्स के लिए, उदाहरण के लिए, न्यूनतम उपशीर्षक मात्रा, डिफ़ॉल्ट उपशीर्षक मात्रा आदि के बारे में पाइन भाषा प्रलेखन में देखें।पाइन भाषाओं के लेन-देन की सूचीपैरामीटर का परिचय ।
3、runtime.debug 、runtime.log、runtime.errorFMZ विस्तारित फ़ंक्शन, डिबगिंग के लिए प्रयोग किया जाता है.

FMZ प्लेटफॉर्म पर डीबगिंग के लिए 3 फ़ंक्शन जोड़े गए हैं।
- runtime.debug: नियंत्रण कक्ष में चर जानकारी प्रिंट करने के लिए, आम तौर पर इस फ़ंक्शन का उपयोग नहीं किया जाता है.
- runtime.log: लॉग में सामग्री का आउटपुट करना ।;; FMZ PINE भाषा में विशेष फ़ंक्शन है ।;;
```
runtime.log(1, 2, 3, close, high, ...)，可以传多个参数。
```
- runtime.error: कॉल करने पर, यह रनटाइम में त्रुटि का कारण बनता है और संदेश पैरामीटर में निर्दिष्ट त्रुटि संदेश के साथ आता है.
```
runtime.error(message)
```
4. आंशिक रूप से चित्र फ़ंक्शन में विस्तारितoverlayपैरामीटर

FMZ पर पाइन भाषा, चित्रण फ़ंक्शनplot、plotshape、plotcharऔर बढ़ता हैoverlayपैरामीटर समर्थित, विषय या उपचित्र में चित्र निर्दिष्ट करने की अनुमति देता है.overlayसेटिंग्सtrueचित्र को थिम में सेट करेंfalseउपचित्रों में चित्रित करें. FMZ पर पाइन नीति चलाने पर विषय, उपचित्रों को एक साथ चित्रित करें।
5、syminfo.mintickअंतर्निहित चर का मान लेना

syminfo.mintickअंतर्निहित चर को वर्तमान किस्म के न्यूनतम अंकित मान के रूप में परिभाषित किया गया है; FMZ मेंवास्तविक डिस्क/पुनरीक्षणइंटरफ़ेस पर "पाइन भाषा ट्रेडिंग क्लासरूम" में टेम्पलेट पैरामीटर मूल्य निर्धारण मुद्रा सटीकता को नियंत्रित कर सकता है। मूल्य निर्धारण मुद्रा सटीकता सेट 2 है, जब मूल्य व्यापार के दौरान अंश के दूसरे स्थान तक सटीक है, तो मूल्य में न्यूनतम परिवर्तन की इकाई 0.01 है।syminfo.mintickयह 0.01 के बराबर है.
6. FMZ PINE स्क्रिप्ट में औसत कीमतें सेवा शुल्क सहित हैं

उदाहरण के लिएः आदेश की कीमत 8000 है, बिक्री की दिशा, एक हाथ की संख्या (एक), और लेनदेन के बाद औसत मूल्य 8000 नहीं है, 8000 से कम है (प्रक्रिया शुल्क लागत में शामिल है) ।

पाइन भाषा का आधार

पाइन भाषा के मूल सिद्धांतों को सीखने की शुरुआत करते समय, हम कुछ उदाहरणों में निर्देशों, कोड सिंटैक्स के साथ परिचित नहीं हो सकते हैं। यह समझ में नहीं आता है, हम पहले अवधारणाओं से परिचित हो सकते हैं, परीक्षण के उद्देश्य को समझ सकते हैं, या आप एफएमजेड के पाइन भाषा दस्तावेज को निर्देशों के लिए देख सकते हैं।

मॉडल निष्पादन

पाइन भाषा को सीखने के लिए पाइन भाषा के स्क्रिप्ट को निष्पादित करने की प्रक्रिया जैसे संबंधित अवधारणाओं को समझना बहुत आवश्यक है। पाइन भाषा की रणनीतियाँ चार्ट-आधारित चलती हैं, जिन्हें एक श्रृंखला के रूप में समझा जा सकता है गणना और संचालन, जो चार्ट पर समय अनुक्रम के पूर्ववर्ती क्रम में पहले से लोड किए गए डेटा से शुरू होते हैं। चार्ट का प्रारंभिक लोड किया गया डेटा सीमित होता है। वास्तविक समय में आमतौर पर यह डेटा मात्रा एक्सचेंज इंटरफ़ेस द्वारा लौटे डेटा के आधार पर निर्धारित की जाती है, और रीसेट समय के लिए डेटा मापने की सीमा रिटर्न सिस्टम डेटा स्रोत द्वारा प्रदान किए गए डेटा के आधार पर निर्धारित की जाती है। चार्ट के सबसे बाईं ओर पहली लाइन KBar, यानी चार्ट डेटासेट का पहला डेटा, जिसका सूचकांक 0 है। पाइन भाषा में अंतर्निहित चर के माध्यम से किया जा सकता है।bar_indexपाइन स्क्रिप्ट के निष्पादन के समय वर्तमान K लाइनBar के सूचकांक मान का संदर्भ देता है.

plot(bar_index, "bar_index")

plotफ़ंक्शन एक ऐसा फ़ंक्शन है जिसका हम भविष्य में अधिक उपयोग करेंगे. इसका उपयोग बहुत सरल है, यह इनपुट पैरामीटर के आधार पर चार्ट पर रेखा खींचने के लिए है, इनपुट डेटा हैbar_indexलाइन का नाम हैbar_indexआप देख सकते हैं कि पहले बार के शीर्ष पर bar_index नामक एक पंक्ति का मान 0 है और बार के दाईं ओर बढ़ने के साथ 1 बढ़ता है।

रणनीतियों के सेटअप के आधार पर, रणनीतियों के मॉडल निष्पादन के तरीके भी अलग-अलग होते हैं।收盘价模型और实时价模型◎ हम पहले भी संक्षेप में बंद मूल्य मॉडल, वास्तविक समय मूल्य मॉडल के अवधारणाओं का परिचय दिया है.

समापन मूल्य मॉडल

जब रणनीति कोड निष्पादित होता है, तो वर्तमान K-लाइन Bar का चक्र पूरी तरह से निष्पादित हो जाता है, और K-लाइन बंद होने पर K-लाइन चक्र समाप्त हो जाता है। इस समय, एक बार फिर पाइन रणनीति तर्क निष्पादित किया जाता है, और ट्रिगर किए गए ट्रेडिंग सिग्नल अगले K-लाइन Bar की शुरुआत में निष्पादित होते हैं।
वास्तविक समय मूल्य मॉडल

रणनीति कोड निष्पादित होने पर, वर्तमान K-लाइन बार बंद हो या न हो, प्रत्येक बाजार परिवर्तन के साथ पाइन रणनीति तर्क को दोहराया जाता है, और ट्रिगर किए गए ट्रेडिंग सिग्नल को तुरंत निष्पादित किया जाता है।

जब पाइन भाषा की नीति को चार्ट पर बाएं से दाएं चलाया जाता है, तो चार्ट पर K-लाइनBar विभाजित होती है历史Barऔर实时Barकाः

ऐतिहासिक बार

जब नीति "सच्चे मूल्य मॉडल" पर सेट होती है, तो चार्ट पर सभी K-लाइन बार होते हैं, लेकिन सबसे दाईं ओर एक K-लाइन बार होता है।历史Bar........................................................................................历史Barयह केवल एक बार किया जा सकता है। जब रणनीति "बंद मूल्य मॉडल" के रूप में सेट की जाती है, तो चार्ट पर सभी बार होते हैं历史Bar........................................................................................历史Barयह केवल एक बार किया जा सकता है।

इतिहास बार के आधार पर गणनाः नीति कोड इतिहास पट्टी के समापन पर एक बार निष्पादित होता है, और फिर नीति कोड अगले इतिहास पट्टी पर निष्पादित होता है, जब तक कि सभी इतिहास पट्टी एक बार निष्पादित न हो जाएं।
लाइव बार

जब रणनीति को अंतिम K-लाइन बार पर सबसे दाईं ओर निष्पादित किया जाता है, तो यह बार वास्तविक समय में बार बन जाता है। जब वास्तविक समय बंद हो जाता है, तो यह बार एक वास्तविक समय में बार बन जाता है। चार्ट के दाईं ओर एक नया वास्तविक समय बार उत्पन्न होता है।

जब रणनीति को "रियल टाइम प्राइस मॉडल" के रूप में सेट किया जाता है, तो वास्तविक समय में बार पर प्रत्येक बाजार परिवर्तन के लिए एक रणनीति तर्क निष्पादित किया जाता है। जब नीति "बंद मूल्य मॉडल" के रूप में सेट की जाती है, तो चार्ट पर वास्तविक समय में Bar नहीं दिखाई देता है।

वास्तविक समय पर आधारित Bar गणनाः यदि नीति को "बंदी मूल्य मॉडल" पर सेट किया गया है, तो चार्ट वास्तविक समय में Bar नहीं दिखाता है, नीति कोड केवल वर्तमान Bar के बंद होने पर एक बार निष्पादित होता है। यदि नीति को "सच्चे मूल्य मॉडल" के रूप में सेट किया जाता है, तो वास्तविक समय में बार पर गणना और इतिहास में बार पूरी तरह से अलग है, और वास्तविक समय में बार पर प्रत्येक बाजार परिवर्तन के लिए एक नीति कोड निष्पादित किया जाता है; उदाहरण के लिए, अंतर्निहित चर।high、low、closeऐतिहासिक बार में निश्चित है कि वास्तविक समय में संभव है कि प्रत्येक बार जब बाजार बदलता है तो ये मूल्य बदलते हैं। इसलिए इन मानों के आधार पर गणना किए गए संकेतक जैसे डेटा भी वास्तविक समय में बदलते हैं। वास्तविक समय में।closeयह हमेशा वर्तमान की नवीनतम कीमत का प्रतिनिधित्व करता है।highऔरlowहमेशा वर्तमान वास्तविक समय बार के प्रारंभ के बाद से प्राप्त उच्चतम उच्चतम और निम्नतम निम्नतम को दर्शाता है। ये अंतर्निहित चर वास्तविक समय बार के अंतिम अद्यतन पर अंतिम मूल्य को दर्शाता है।

वास्तविक समय में बार पर रणनीति निष्पादित करने के लिए पलटाव तंत्र (रियल टाइम मूल्य मॉडल): वास्तविक समय में बार निष्पादित होने पर, नीति के प्रत्येक नए पुनरावृत्ति के निष्पादन से पहले उपयोगकर्ता द्वारा परिभाषित चर को फिर से स्थापित किया जाता है। इसे एक पुनरावृत्ति कहा जाता है। हम पुनरावृत्ति तंत्र को समझने के लिए एक उदाहरण का उपयोग करते हैं, नीचे दिए गए कोड का परीक्षण करते हैं।

ध्यान देंः
```
/*backtest 
...
..
.
*/
```
पैकेज में एफएमजेड प्लेटफॉर्म पर कोड के रूप में संग्रहीत रीसेट कॉन्फ़िगरेशन जानकारी है।
```
/*backtest
start: 2022-06-03 09:00:00
end: 2022-06-08 15:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/

var n = 0
if not barstate.ishistory
    runtime.log("n + 1之前, n:", n, " 当前bar_index:", bar_index)
    n := n + 1
    runtime.log("n + 1之后, n:", n, " 当前bar_index:", bar_index)
  
plot(n, title="n")
```
हम केवल वास्तविक समय में प्रदर्शन के दृश्यों पर विचार कर रहे हैं, इसलिए हम बार का उपयोग करते हैंnot barstate.ishistoryअभिव्यक्ति की सीमा केवल वास्तविक समय Bar में चर n पर अधिशेष है और अधिशेष ऑपरेशन करने से पहले और बाद में उपयोग की जाती हैruntime.logफ़ंक्शन नीति लॉग में जानकारी का आउटपुट करता है.plotचित्रित वक्र n को देखा जा सकता है कि नीति ऐतिहासिक बार में चल रही थी जब n हमेशा 0 था; जब वास्तविक समय में बार चलाया जाता था तो n के अतिरिक्त 1 ऑपरेशन किए जाते थे, और वास्तविक समय में बार पर प्रत्येक चरण के लिए n के अतिरिक्त 1 ऑपरेशन किए जाते थे। यह लॉग जानकारी से देखा जा सकता है कि नीति कोड को प्रत्येक चरण में फिर से निष्पादित करने पर n को पिछले बार की नीति के अंतिम दायर के रूप में रीसेट किया जाता है। जबकि वास्तविक समय में बार पर नीति कोड को अंतिम बार निष्पादित करने पर n के मूल्य को अपडेट किया जाता है, तो यह देखा जा सकता है कि चार्ट वास्तविक समय में बार से शुरू होता है, और प्रत्येक बार बार में n के मूल्य को बढ़ाने के साथ वक्र n को बढ़ाता है।

यह एक संक्षिप्त विवरण हैः 1, जब नीति वास्तविक समय में Bar पर निष्पादित होती है, तो प्रत्येक लेनदेन अद्यतन के लिए एक नीति कोड निष्पादित किया जाता है । 2, वास्तविक समय में बार पर निष्पादित होने पर, नीति कोड को निष्पादित करने से पहले प्रत्येक बार चर को वापस चलाया जाता है । 3. जब वास्तविक समय में बार पर निष्पादित किया जाता है, तो चर को समापन अद्यतन पर एक बार प्रस्तुत किया जाता है।

चूंकि डेटा वापस चला जाता है, इसलिए चार्ट पर वक्र जैसे ग्राफ ऑपरेशन भी पुनः चित्रण का कारण बन सकते हैं, उदाहरण के लिए हम अभी परीक्षण कोड को संशोधित करते हैं, वास्तविक परीक्षणः
```
var n = 0
if not barstate.ishistory
    runtime.log("n + 1之前, n:", n, " 当前bar_index:", bar_index)
    n := open > close ? n + 1 : n
    runtime.log("n + 1之后, n:", n, " 当前bar_index:", bar_index)
  
plot(n, title="n")
```
क्षण ए का स्क्रीनशॉट

क्षण बी का स्क्रीनशॉट

हम केवल इस वाक्य को बदलते हैंःn := open > close ? n + 1 : n, वर्तमान वास्तविक समय में Bar के लिए एक सिग्नल है (यानी, उद्घाटन मूल्य बंद मूल्य से अधिक है) जब n के लिए 1 जोड़ा जाता है; जैसा कि पहले चित्र में देखा जा सकता है (क्षण A) में, क्योंकि उद्घाटन मूल्य बंद मूल्य से अधिक है (क्षण A) इसलिए n के लिए 1 जोड़ा जाता है, चार्ट की अवस्था n का मूल्य 5 है; फिर व्यवहार में बदलाव, मूल्य अद्यतन जैसा कि दूसरे चित्र में दिखाया गया है (क्षण B) । इस समय, उद्घाटन मूल्य बंद मूल्य (क्षण B) से कम है (क्षण B), n वापस चला गया और 1 नहीं जोड़ा गया है; चार्ट में वक्र n भी तुरंत फिर से चित्रित किया गया है, इस समय वक्र पर n का मूल्य 4 है; इसलिए वास्तविक समय में Bar पर दिखाए गए संकेत अनिश्चित हैं और बदल सकते हैं।
फ़ंक्शन में चर का संदर्भ

नीचे हम पाइन भाषा के फ़ंक्शन में चर का अध्ययन करते हैं। कुछ पाइन ट्यूटोरियल में वर्णित के अनुसार, फ़ंक्शन में चर और फ़ंक्शन के बाहर के चर में अंतर इस प्रकार हैः

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

क्या यह थोड़ा कठिन है? ठीक है, हम इसे FMZ पर चल रहे एक परीक्षण कोड के साथ समझते हैंः
```
/*backtest
start: 2022-06-03 09:00:00
end: 2022-06-08 15:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
  
f(a) => a[1]
f2() => close[1]  

oneBarInTwo = bar_index % 2 == 0
plotchar(oneBarInTwo ? f(close) : na, title = "f(close)", color = color.red, location = location.absolute, style = shape.xcross, overlay = true, char = "A")   
plotchar(oneBarInTwo ? f2() : na, title = "f2()", color = color.green, location = location.absolute, style = shape.circle, overlay = true, char = "B")   
plot(close[2], title = "close[2]", color = color.red, overlay = true)
plot(close[1], title = "close[1]", color = color.green, overlay = true)
```
पुनः परीक्षण चल रहा स्क्रीनशॉट

परीक्षण कोड अपेक्षाकृत सरल है और मुख्य रूप से दो तरीकों से संदर्भित डेटा को देखने के लिए हैःf(a) => a[1]औरf2() => close[1]。
- f(a) => a[1]: पैरामीटर का उपयोग करके, फ़ंक्शन अंत में वापस आ जाता हैa[1]。
- f2() => close[1]प्रत्यक्ष रूप से अंतर्निहित चर का उपयोग करनाःcloseऔर फ़ंक्शन अंत में वापस आता है.close[1]。
[]चिह्न डेटा श्रृंखला चर के इतिहास के संदर्भ संचालन के लिए उपयोग किया जाता है, close[1] जो वर्तमान समापन मूल्य से पहले एक बार के समापन मूल्य डेटा को संदर्भित करता है; हमारे परीक्षण कोड ने चार प्रकार के डेटा को चार्ट पर चित्रित किया हैः
- plotchar(oneBarInTwo ? f(close) : na, title = "f(close)", color = color.red, location = location.absolute, style = shape.xcross, overlay = true, char = "A")एक वर्ण A A, लाल रंग का है, जब oneBarInTwo सच है तब ही चित्रित किया जाता है, और चित्रित स्थान ((Y-अक्ष पर) के रूप में हैःf(close)लौटाया गया मान ।
- plotchar(oneBarInTwo ? f2() : na, title = "f2()", color = color.green, location = location.absolute, style = shape.circle, overlay = true, char = "B")एक वर्ण B को हरे रंग में चित्रित करें, जब oneBarInTwo सही हो तो चित्रित करें, और चित्रित स्थान (Y-अक्ष पर) इस प्रकार हैःf2()लौटाया गया मान ।
- plot(close[2], title = "close[2]", color = color.red, overlay = true)रेखा, लाल रंग की है और रेखांकित किया गया स्थान (Y-अक्ष पर):close[2]यानी वर्तमान बार के पहले 2 अंक (बाएं 2 अंक) पर बंद होने का मूल्य।
- plot(close[1], title = "close[1]", color = color.green, overlay = true)रेखाएं, हरे रंग की, रेखांकित स्थान (Y-अक्ष पर):close[1]यह वर्तमान बार के पहले नंबर 1 (बाएं नंबर 1 की ओर) पर बंद मूल्य है।
एक स्क्रैप दिखाया जा सकता है, हालांकि चित्र A में उपयोग किए जाने वाले फ़ंक्शन को चिह्नित किया गया हैf(a) => a[1]और चित्र B के लिए उपयोग किए जाने वाले फ़ंक्शनf2() => close[1]दोनों का उपयोग किया जाता है[1] डेटा श्रृंखला पर ऐतिहासिक डेटा को संदर्भित करने के लिए, लेकिन चार्ट पर "ए" और "बी" के लिए चिह्नित स्थान पूरी तरह से अलग हैं। "ए" चिह्नित स्थान हमेशा लाल रेखा पर पड़ता है, यानी रणनीति में कोड।plot(close[2], title = "close[2]", color = color.red, overlay = true)रेखाओं पर, रेखाओं का उपयोग किया जाता हैclose[2]。

और इसका कारण यह है कि यह K-लाइनBar के सूचकांक के माध्यम से है, जो कि अंतर्निहित चर है।bar_indexगणना करें कि क्या "A" और "B" चिह्नों को चित्रित किया गया है. "A" और "B" चिह्नों को प्रत्येक K-लाइन Bar पर चित्रित नहीं किया गया है.f(a) => a[1]इस तरह से संदर्भित मान, यदि फ़ंक्शन को हर बार नहीं बुलाया जाता है तो फ़ंक्शन के साथ मेल खाता हैf2() => close[1]इस तरह से संदर्भित मान भिन्न होते हैं (यहां तक कि जब एक ही सूचकांक का उपयोग किया जाता है जैसे कि [1]) ।
कुछ अंतर्निहित फलनों को प्रत्येक बार पर गणना करने की आवश्यकता होती है ताकि उनके परिणामों को सही ढंग से गणना की जा सके।

यह एक सरल उदाहरण के साथ समझाया गया हैः
```
res = close > close[1] ? ta.barssince(close < close[1]) : -1
plot(res, style = plot.style_histogram, color=res >= 0 ? color.red : color.blue)
```
हम फ़ंक्शन को कोड में कॉल करते हैं.ta.barssince(close < close[1])एक त्रिकोणीय ऑपरेटर में लिखा गया हैcondition ? value1 : value2इसने केवल उन लोगों के लिए ही परिणाम लाया है जोclose > close[1]时去调用ta.barssince函数。可偏偏ta.barssinceफ़ंक्शन पिछले बार से गणना कर रहा है.close < close[1]ta.barssince फ़ंक्शन को कॉल करने पर यह close > close[1] होता है, यानी वर्तमान बंद मूल्य पिछले बार के बंद मूल्य से बड़ा होता है, ta.barssince फ़ंक्शन को कॉल करने पर इसकी शर्त close < close[1] भी नहीं होती है और न ही हाल ही में स्थापित स्थिति होती है।

ta.barssince: कॉल करते समय, फ़ंक्शन na को लौटाता है यदि वर्तमान K पंक्ति से पहले यह शर्त कभी पूरी नहीं हुई है।

तस्वीरेंः

इसलिए जब हम चित्र बनाते हैं, तो हम केवल उस समय के डेटा को चित्रित करते हैं जब रेस चर का मूल्य होता है।

और इस समस्या से बचने के लिए, हम सिर्फ इसे जोड़ना चाहते हैं।ta.barssince(close < close[1])फ़ंक्शन कॉल को त्रिकोणीय ऑपरेटर से बाहर निकाला जाता है और किसी भी संभव शर्त शाखा के बाहर लिखा जाता है; जिससे यह प्रत्येक K-लाइन Bar पर गणना करता है।
```
a = ta.barssince(close < close[1])
res = close > close[1] ? a : -1
plot(res, style = plot.style_histogram, color=res >= 0 ? color.red : color.blue)
```

समयक्रम

पाइन भाषा में समय अनुक्रम की अवधारणा बहुत महत्वपूर्ण है और यह एक ऐसी अवधारणा है जिसे हमें पाइन भाषा सीखने के दौरान समझना चाहिए। समय अनुक्रम एक प्रकार नहीं है बल्कि समय के साथ संग्रहीत चर के निरंतर मानों के लिए एक बुनियादी संरचना है। हम जानते हैं कि पाइन स्क्रिप्ट चार्ट पर आधारित है, और चार्ट में दिखाए जाने वाले सबसे बुनियादी सामग्री के स्ट्रिंग ग्राफ हैं। समय अनुक्रम जिसमें प्रत्येक मान एक के स्ट्रिंग के टाइमबार से जुड़ा होता है।openएक पाइन भाषा का अंतर्निहित चर है जिसका निर्माण प्रत्येक K-लाइन के लिए बार के शुरुआती मूल्य के समय अनुक्रम को संग्रहीत करने के लिए किया गया है। इसे समझा जा सकता हैopenयह समय अनुक्रम संरचना वर्तमान K स्ट्रिंग के सभी K स्ट्रिंगBar के शुरुआती मूल्य का प्रतिनिधित्व करती है, जो पहले Bar से शुरू होने वाले वर्तमान स्क्रिप्ट द्वारा निष्पादित इस Bar के लिए है। यदि वर्तमान K स्ट्रिंग 5 मिनट की अवधि है, तो हम पाइन रणनीति कोड में संदर्भित करते हैं ((या उपयोग करते हैं)openसमय का उपयोग करके रणनीति कोड के वर्तमान निष्पादन पर K-लाइनBar का प्रारंभिक मूल्य है. यदि समय अनुक्रम में ऐतिहासिक मानों को संदर्भित करने की आवश्यकता है, तो इसका उपयोग किया जाना चाहिए[]ऑपरेटर... जब पाइन नीति किसी K-लाइन बार पर निष्पादित होती है, तो इसका उपयोग किया जाता हैopen[1]संदर्भित करेंopenसमयक्रम में वर्तमान स्क्रिप्ट द्वारा निष्पादित इस K-लाइन Bar के पहले K-लाइन Bar का शुरुआती मूल्य (यानी पिछले K-लाइन चक्र का शुरुआती मूल्य) ।

समय अनुक्रम में चर बहुत आसान है गणना करने के लिए हम इसे एक अंतर्निहित फ़ंक्शन के रूप में देखते हैं।ta.cumउदाहरण के लिएः

ta.cum

Cumulative (total) sum of `source`. In other words it's a sum of all elements of `source`.
ta.cum(source) → series float
RETURNS
Total sum series.
ARGUMENTS
source (series int/float)
SEE ALSO
math.sum

परीक्षण कोडः

v1 = 1
v2 = ta.cum(v1)
plot(v1, title="v1")
plot(v2, title="v2")
plot(bar_index+1, title="bar_index")

बहुत कुछ ऐसा ही है।ta.cumइस तरह के अंतर्निहित कार्य समय अनुक्रम पर डेटा को सीधे संसाधित कर सकते हैं, जैसे किta.cumयह है कि इनपुट चर के लिए प्रत्येक K-लाइन बार पर उनके मानों को जोड़ना, और फिर हम एक ग्राफ का उपयोग करते हैं जो इसे समझने में आसान बनाता है।

रणनीतिक संचालन प्रक्रिया	अंतर्निहित चर bar_index	v1	v2
रणनीति 1 K लाइन Bar पर चल रही है	0	1	1
रणनीति 2 K लाइन Bar पर चल रही है	1	1	2
रणनीति 3 K लाइन Bar पर चल रही है	2	1	3
…	…	…	…
रणनीति N + 1 वीं K रेखा पर चलती हैBar	एन	1	एन+1

जैसा कि आप देख सकते हैं, वास्तव में v1, v2 और यहां तक कि bar_index भी समय अनुक्रम संरचनाएं हैं, प्रत्येक बार पर संबंधित डेटा है। यह परीक्षण कोड केवल वास्तविक समय में Bar को चार्ट पर प्रदर्शित करने के लिए "रियल टाइम प्राइस मॉडल" या "क्लोजिंग प्राइस मॉडल" का उपयोग करके अलग करता है। गति को मापने के लिए हम "क्लोजिंग प्राइस मॉडल" रीटेस्ट परीक्षण का उपयोग करते हैं।

क्योंकि v1 एक बार में 1 बार होता है।ta.cum(v1)जब फ़ंक्शन को पहली K-लाइन Bar पर निष्पादित किया जाता है, तो इसका परिणाम 1 होता है, क्योंकि केवल पहली Bar होती है, इसलिए चर v2 को असाइन किया जाता है। जबta.cum(v1)दूसरे K-लाइन Bar पर निष्पादित होने पर, पहले से ही 2 K-लाइन Bar हैं ((पहला संबंधित अंतर्निहित चर bar_index 0 है, दूसरा संबंधित अंतर्निहित चर bar_index 1 है, इसलिए गणना का परिणाम 2 है, जो चर v2 को असाइन करता है, और इसी तरह। वास्तव में यह देखा जा सकता है कि v2 चार्ट में K-लाइन Bar की संख्या है, क्योंकि K-लाइन का सूचकांक है।bar_indexऔर अगर यह 0 से बढ़ता है, तोbar_index + 1यह वास्तव में K-लाइन बार की संख्या है.v2औरbar_indexयह वास्तव में ओवरलैप है।

मैं भी ऐसा ही कर सकता हूँ।ta.cumअंतर्निहित फ़ंक्शन वर्तमान चार्ट पर सभी Bar के समापन मूल्य का योग करता है, तो इसे केवल इस तरह लिखा जा सकता हैःta.cum(close), जब रणनीति सबसे दाईं ओर चलती है, तो वास्तविक समय में बारta.cum(close)इसका परिणाम चार्ट पर सभी बारों के समापन मूल्य का योग होता है (जब दाईं ओर नहीं चला जाता है, तो वर्तमान बार में जोड़ दिया जाता है) ।

समय अनुक्रम में चर को ऑपरेटरों के साथ भी संसाधित किया जा सकता है, उदाहरण के लिए कोडःta.sma(high - low, 14), अंतर्निहित चर को हटा देंhigh(के लाइन पर सबसे ज्यादा कीमत) घटाlow(के लाइन बार सबसे कम कीमत), अंतिम उपयोगta.smaफ़ंक्शन औसत लेता है।

फ़ंक्शन कॉल के परिणाम भी समय अनुक्रम में मान का निशान छोड़ देते हैं
```
v1 = ta.highest(high, 10)[1]
v2 = ta.highest(high[1], 10)
plot(v1, title="v1", overlay=true)
plot(v2, title="v2", overlay=true)
```
यह परीक्षण कोड पुनः परीक्षण के दौरान परीक्षण चलाता है, और यह देखा जा सकता है किv1औरv2मान समान हैं, और रेखाएं पूरी तरह से ओवरलैप हो जाती हैं। फ़ंक्शन कॉल के परिणामों को गणना करने के लिए समय अनुक्रम में मानों का निशान छोड़ दिया जाता है, जैसे कोड।ta.highest(high, 10)[1]इनमें से एकta.highest(high, 10)फ़ंक्शन कॉल द्वारा गणना किए गए परिणामों का उपयोग[1] इसके ऐतिहासिक मानों के संदर्भ में भी किया जा सकता है.ta.highest(high, 10)और यह है किta.highest(high[1], 10)इसलिए।ta.highest(high[1], 10)औरta.highest(high, 10)[1]यह पूरी तरह से बराबर है।

एक और चित्र फ़ंक्शन का उपयोग करके जानकारी सत्यापित करेंः
```
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, overlay=true)
plotchar(true, title="b", char=str.tostring(b), location=location.belowbar, color=color.green, overlay=true)
```
यह देखा जा सकता है कि समय अनुक्रम में चर a और चर b के मानों को संबंधित Bar के ऊपर और नीचे दिखाया गया है। इस चित्र कोड को सीखने के दौरान रखा जा सकता है क्योंकि परीक्षण, परीक्षण के दौरान अक्सर चार्ट पर सूचना का उत्पादन करने की आवश्यकता हो सकती है।

स्क्रिप्ट संरचना

सामान्य संरचना

इस ट्यूटोरियल के आरंभ में हमने कुछ अंतरों को संक्षेप में बताया है जो FMZ पर पाइन और ट्रेडिंग व्यू पर पाइन भाषा के उपयोग में हैं।indicator()、strategy()और अस्थायी रूप से समर्थन नहीं।library(). बेशक, पाइन स्क्रिप्ट के पहले संस्करणों के साथ संगत होने के लिए, रणनीति को लिखने के समय लिखा जाता है जैसेः//@version=5，indicator()，strategy()कुछ रणनीतिक सेटिंग्स भी हो सकती हैं।strategy()फ़ंक्शन में पैरामीटर सेटिंग्स।

<version>
<declaration_statement>
<code>

<version>संस्करण नियंत्रण जानकारी को छोड़ दिया जा सकता है।

टिप्पणी

पाइन भाषा का प्रयोग//एकल-पंक्ति के रूप में, क्योंकि पाइन भाषा में कई पंक्तियों के लिए कोई टिप्पणी नहीं है; FMZ ने टिप्पणी को बढ़ाया है/**/कई पंक्तियों की टिप्पणी के लिए प्रयोग किया जाता है।

कोड

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

चर की घोषणा
चर का पुनर्वितरण
फ़ंक्शन घोषणा
अंतर्निहित फ़ंक्शन कॉल, उपयोगकर्ता द्वारा परिभाषित फ़ंक्शन कॉल
if，for，whileयाswitchसमरूप संरचना

वाक्यों को कई तरीकों से व्यवस्थित किया जा सकता है

कुछ कथन एक पंक्ति के साथ व्यक्त किए जा सकते हैं, जैसे कि अधिकांश चर घोषणाएँ, केवल एक पंक्ति या एकल पंक्ति वाले फ़ंक्शन कॉल के साथ। अन्य, जैसे संरचनाएं, हमेशा कई पंक्तियों की आवश्यकता होती हैं क्योंकि उन्हें एक स्थानीय ब्लॉक की आवश्यकता होती है।
स्क्रिप्ट के वैश्विक दायरे के बयान (यानी भागों का हिस्सा नहीं) के साथ नहीं किया जा सकता है空格या制表符(टैब कुंजी) शुरू होता है. उनका पहला वर्ण भी उस पंक्ति का पहला वर्ण होना चाहिए. पंक्ति में पहले स्थान से शुरू होने वाली पंक्ति, परिभाषा के अनुसार, स्क्रिप्ट के वैश्विक दायरे का हिस्सा बन जाती है.
संरचना या बहु-पंक्ति फ़ंक्शन घोषणाओं को हमेशा एकlocal blockएक स्थानीय ब्लॉक को एक तालिका या चार स्थानों में संकुचित किया जाना चाहिए (अन्यथा, इसे पिछले पंक्ति के सीरियल कोड के रूप में हल किया जाता है, यानी पिछले पंक्ति के कोड के निरंतर सामग्री के रूप में परिभाषित किया जाता है) और प्रत्येक स्थानीय ब्लॉक एक अलग स्थानीय क्षेत्र को परिभाषित करता है।
कई एकल-पंक्ति वाले वाक्य को एक पंक्ति में कॉमा ((,) का उपयोग करके विभाजक के रूप में जोड़ा जा सकता है।
एक पंक्ति में टिप्पणी हो सकती है या सिर्फ टिप्पणी हो सकती है।
पंक्तियों को भी एक साथ रखा जा सकता है (बहु पंक्तियों पर जारी रखें) ।

उदाहरण के लिए, तीन लोकल शामिल हैं, एक कस्टम फ़ंक्शन घोषणा में, दो चर घोषणा में यदि संरचना का उपयोग करते हैं, निम्न कोड के साथः

indicator("", "", true)             // 声明语句(全局范围)，可以省略不写

barIsUp() =>                        // 函数声明(全局范围)
    close > open                    // 本地块(本地范围)

plotColor = if barIsUp()            // 变量声明 (全局范围)
    color.green                     // 本地块 (本地范围)
else
    color.red                       // 本地块 (本地范围)

runtime.log("color", color = plotColor)  // 调用一个内置函数输出日志 (全局范围)

कोड बदलने के लिए

लंबी पंक्तियों को कई पंक्तियों में विभाजित किया जा सकता है, या उन्हें "बंद" किया जा सकता है। बंडल की गई पंक्तियों को किसी भी संख्या में रिक्त स्थानों में संकुचित किया जाना चाहिए, जब तक कि यह 4 का गुणक न हो ((इन सीमाओं का उपयोग स्थानीय खंडों को संकुचित करने के लिए किया जाता है) ।)

a = open + high + low + close

इसे इस तरह से पैक किया जा सकता है (ध्यान दें कि प्रत्येक पंक्ति में संकुचित किए गए रिक्त स्थान की संख्या 4 के गुणक नहीं है):

a = open +
      high +
          low +
             close

एक लंबा प्लॉट ((() कॉल को में पैक किया जा सकता है।

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)

उपयोगकर्ता द्वारा परिभाषित फ़ंक्शन की घोषणा में एक कथन को भी पैक किया जा सकता है। हालांकि, चूंकि स्थानीय ब्लॉक को वाक्यविन्यास में एक संकुचन के साथ शुरू होना चाहिए ((4 रिक्त स्थान या 1 पैरामीटर), जब इसे अगली पंक्ति में विभाजित किया जाता है, तो कथन के निरंतर भाग को एक से अधिक संकुचन के साथ शुरू होना चाहिए ((4 रिक्त स्थान के गुणकों के बराबर नहीं है) । उदाहरण के लिएः

test(c, o) =>
    ret = c > o ?
       (c > o+5000 ? 
          1 :
              0):
       (c < o-5000 ? 
          -1 : 
              0)
           
                   
a = test(close, open)
plot(a, title="a")

पहचानकर्ता और ऑपरेटर

पहचानकर्ता

चर को समझने से पहले, हम पहले चिह्न चिह्न के अवधारणा को समझते हैं।फ़ंक्शनऔरचरनामों के लिए (वैकल्पिक, फ़ंक्शन नाम के लिए) ।फ़ंक्शनजैसा कि हम अपने बाद के ट्यूटोरियल में देखेंगे, सबसे पहले हम चिह्नों के बारे में सीखते हैं।

1. पहचानकर्ता को बड़े अक्षरों में लिखा जाना चाहिए(A-Z)या छोटा लिखना(a-z)अक्षर या रेखांकन(_)शुरुआत, पहचानकर्ता का पहला वर्ण।
2. पहचानकर्ता के पहले वर्ण के बाद अगला वर्ण हो सकता हैअक्षर、नीचे की रेखायासंख्याएँ。
3. पहचानकर्ता का नाम बड़े या छोटे अक्षरों में लिखा गया है.

उदाहरण के लिए, निम्नलिखित नामों के साथ पहचानकर्ताः

fmzVar
_fmzVar
fmz666Var
funcName
MAX_LEN
max_len
maxLen
3barsDown  // 错误的命名！使用了数字字符作为标识符的开头字符

जैसा कि अधिकांश प्रोग्रामिंग भाषाओं में होता है, पाइन भाषा में लेखन सुझाव भी होते हैं।

1, सभी अक्षरों को बड़े अक्षरों में लिखा जाता है।
2। उपयोगछोटे ऊँचे शिखर के नियमअन्य चिह्नों के लिए नामित किया गया।

// 命名变量、常量
GREEN_COLOR = #4CAF50
MAX_LOOKBACK = 100
int fastLength = 7

// 命名函数
zeroOne(boolValue) => boolValue ? 1 : 0

ऑपरेटर

ऑपरेटर प्रोग्रामिंग भाषा में अभिव्यक्ति के निर्माण के लिए उपयोग किए जाने वाले कुछ ऑपरेटिंग प्रतीकों को संदर्भित करते हैं, जबकि अभिव्यक्ति एक गणना नियम है जिसे हम किसी प्रकार के गणना के उद्देश्य के लिए डिज़ाइन करते हैं जब हम एक नीति लिखते हैं।

इसके अलावा, यह एक बहुत ही उपयोगी उपकरण है। यह एक बहुत ही उपयोगी उपकरण है।? :तीन-मूल्य वाले ऑपरेटर।[]ऐतिहासिक संदर्भ संकेतक ।

अंकगणितीय ऑपरेटर*उदाहरण के लिए, ट्रेडिंग व्यू पर पाइन भाषा के ऑपरेटरों के परिणामों को वापस करने वाले प्रकार के प्रश्नों में अंतर करने के लिए, निम्नलिखित परीक्षण कोड हैंः

//@version=5
indicator("")
lenInput = input.int(14, "Length")
factor = year > 2020 ? 3 : 1
adjustedLength = lenInput * factor
ma = ta.ema(close, adjustedLength)  // Compilation error!
plot(ma)

ट्रेडिंग व्यू में इस स्क्रिप्ट को चलाने के दौरान त्रुटि रिपोर्ट संकलित होती है, क्योंकिadjustedLength = lenInput * factorगुणा करने के बाद परिणाम हैseries intप्रकार ((सीरीज़), हालांकिta.emaफ़ंक्शन का दूसरा पैरामीटर इस प्रकार का समर्थन नहीं करता है. लेकिन FMZ पर इस तरह की कोई सख्त सीमा नहीं है, उपरोक्त कोड सामान्य रूप से चल सकता है.

नीचे हम विभिन्न ऑपरेटरों के उपयोग को देखते हैं।

आवंटित करने वाले ऑपरेटर

दो प्रकार के असाइनमेंट ऑपरेटर होते हैंः=、:=हम इस ट्यूटोरियल के शुरुआती भाग में कुछ उदाहरणों में भी देखा है।

=ऑपरेटरों का उपयोग चर को आरंभ करने या घोषित करने के लिए किया जाता है।=आरंभिकरण, घोषणा के बाद दिए गए चर को उसके बाद के प्रत्येक बार में इस मान से शुरू किया जाएगा; ये सभी वैध चर घोषणाएं हैंः

a = close           // 使用内置变量赋值给a
b = 10000           // 使用数值赋值
c = "test"          // 使用字符串赋值
d = color.green     // 使用颜色值赋值
plot(a, title="a")
plot(b, title="b")
plotchar(true, title="c", char=str.tostring(c), color=d, overlay=true)

ध्यान देंa = closeमान कथन, प्रत्येक बार पर चर a वर्तमान बार के समापन मूल्य (close) है; अन्य चरb、c、dएफएमजेड पर परीक्षण के बाद, परिणाम चित्रों से दिखाई देते हैं।

:=एक मौजूदा चर के लिए एक मूल्य को फिर से असाइन करने के लिए उपयोग किया जाता है, जिसे आसानी से समझा जा सकता है:=ऑपरेटरों का उपयोग पहले से घोषित, आरंभिक चर के मान को संशोधित करने के लिए किया जाता है। अगर इस्तेमाल किया:=एक ऑपरेटर एक अपरिवर्तनीय या घोषित चर के लिए एक त्रुटि उत्पन्न करता है, उदाहरण के लिएः

a := 0

तो, क्या आप जानते हैं?:=असाइनमेंट ऑपरेटर आम तौर पर मौजूदा चर को फिर से असाइन करने के लिए उपयोग किए जाते हैं, जैसेः

a = close > open 
b = 0 
if a
    b := b + 1

plot(b)

अगरclose > open(यानी वर्तमान BAR पूर्णांक है) और a चर सही है. यह if कथन के स्थानीय ब्लॉक में कोड निष्पादित करता है.b := b + 1, असाइनमेंट ऑपरेटर का उपयोग करें:=b को पुनः असाइन करें, एक 1 जोड़ें; फिर plot function का उपयोग करके चर b को समय अनुक्रम के प्रत्येक BAR पर मानों को रेखांकित करने के लिए करें।

क्या हम मानते हैं कि एक पूर्णांक BAR है और b लगातार 1 जोड़ता है? बेशक नहीं, हम यहाँ चर b को घोषणा करते हैं, 0 के रूप में आरंभ करते समय किसी भी कुंजी शब्द का उपयोग नहीं करते हैं। यह वाक्य।b=0तो आप देख सकते हैं कि इस कोड के निष्पादन का परिणाम यह है कि जब भी b को 0 पर रीसेट किया जाता है, यदि a सही है, तो यह मेल खाता है।close > openतो इस बार b 1 जोड़ता है, लेकिन अगले बार b को 0 के रूप में फिर से असाइन किया जाता है। यह भी पाइन भाषा के शुरुआती लोगों के लिए एक मुश्किल जगह है।

जब हम एनेमेशन ऑपरेटर की बात करते हैं, तो हमें दो महत्वपूर्ण शब्दों को समझाना होगाःvar、varip

विर

वास्तव में, हम पहले के ट्यूटोरियल में भी इस कीवर्ड को देख चुके हैं और इसका इस्तेमाल कर चुके हैं, लेकिन उस समय इस पर विस्तार से चर्चा नहीं की गई थी। आइए पहले इस कीवर्ड के विवरण पर एक नज़र डालेंः

var एक ऐसा कुंजीशब्द है जिसका उपयोग आवंटित करने और एक बार में आरंभ करने के लिए किया जाता है। आमतौर पर वैरिएबल असाइनमेंट सिंटैक्स जिसमें वैर की कुंजी शब्द शामिल नहीं होता है, का परिणाम यह होता है कि डेटा अपडेट होने पर वेरिएबल के मान को ओवरले कर देते हैं। इसके विपरीत, जब वेर की कुंजी शब्द का उपयोग करके आवंटित किए जाने वाले वैरिएबल्स का उपयोग किया जाता है, तो वे डेटा अपडेट होने के बावजूद स्थिति में रह सकते हैं।

हम इस उदाहरण का उपयोग कर रहे हैं, लेकिन हम b को असाइन करते हैं।varकीवर्ड ‖
```
a = close > open 
var b = 0 
if a
    b := b + 1

plot(b)
```
varकुंजी शब्द b चर को केवल प्रारंभिक पहले असाइनमेंट को निष्पादित करने देता है, और उसके बाद रणनीति तर्क को निष्पादित करने पर प्रत्येक बार b को 0 पर नहीं रीसेट करता है, इसलिए रन पर खींची गई रेखाओं को देखा जा सकता है कि b वर्तमान K लाइन BAR पर दिखाई देने वाले सूर्य के प्रकाश के बार की संख्या को वापस मापता है।

var घोषित चर को न केवल वैश्विक स्तर पर लिखा जा सकता है, बल्कि कोड ब्लॉक में भी लिखा जा सकता है, उदाहरण के लिएः
```
strategy(overlay=true)
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")
```
चर a श्रृंखला में पहले स्तंभ के समापन मूल्य को बरकरार रखता है। परिवर्तनीय कण b कणों ने श्रृंखला में पहले कणों की हरी कणों की कीमतों के बंद होने की कीमतों को बरकरार रखा। परिवर्तनीय एसी एसी ने श्रृंखला में दसवें एसी ग्रीन एसी के समापन मूल्य को बरकरार रखा।
विविधता

varipहम पहली बार इस कीवर्ड को देखते हैं, और हम इस कीवर्ड के विवरण को देख सकते हैंः

varip (var intrabar persist) एक कुंजी है जो आवंटन और एक बार में आरंभ करने वाले चर के लिए उपयोग की जाती है। यह var कुंजी के समान है, लेकिन varip घोषणा का उपयोग करने वाले चर को वास्तविक समय में K लाइन अपडेट के बीच अपना मान बनाए रखना चाहिए।

क्या यह समझना मुश्किल है? ठीक है, हम उदाहरणों के साथ समझते हैं, यह समझना आसान है।
```
strategy(overlay=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
i := i + 1
ii := ii + 1
```
यह परीक्षण कोड "क्लोजिंग प्राइस मॉडल" या "रियल टाइम प्राइस मॉडल" पर अलग-अलग प्रदर्शन करता हैः

वास्तविक समय मूल्य मॉडलः याद रखें कि हमने पहले बताया था कि रणनीति का निष्पादन समय ऐतिहासिक बार चरणों और वास्तविक समय में बार चरणों में विभाजित है।var、varipघोषणा के चरi、iiरणनीति कोड के प्रत्येक चरण के दौरान वृद्धिशील कार्य किया जाता है. इसलिए आप देख सकते हैं कि पुनरावृत्ति के परिणाम के लिए K लाइन BAR पर प्रदर्शित किए गए प्रत्येक संख्या में 1 की वृद्धि होती है. जब ऐतिहासिक K लाइन चरण समाप्त होता है, तो वास्तविक K लाइन चरण शुरू होता है. var,varip घोषणा के चर में अलग-अलग परिवर्तन होने लगते हैं. क्योंकि यह वास्तविक समय मूल्य मॉडल है, एक K लाइन BAR के भीतर प्रत्येक मूल्य परिवर्तन के लिए रणनीति कोड को एक बार फिर से निष्पादित किया जाता है।i := i + 1औरii := ii + 1यह भिन्नता यह है कि ii प्रत्येक बार संशोधित होता है. i, हालांकि, नीति के तर्क के अगले चरण में संशोधित होता है, लेकिन पिछले मूल्य को पुनः प्राप्त करता है (क्या आपको पिछले "मॉडल निष्पादन" अध्याय में वर्णित रिवर्स तंत्र याद है?), यह वर्तमान K-लाइन BAR के बाद अद्यतन होने तक i के मूल्य को निर्धारित नहीं करता है (यानी, नीति के तर्क के अगले चरण के निष्पादन में पहले के मूल्य को पुनः प्राप्त नहीं किया जाता है) । इसलिए यह देखा जा सकता है कि चर i अभी भी प्रत्येक बार बार में 1 जोड़ता है; लेकिन चर ii प्रत्येक बार में कई बार जोड़ता है।

समापन मूल्य मॉडलः चूंकि समापन मूल्य मॉडल में प्रत्येक K-लाइन BAR के समाप्त होने पर एक बार रणनीति तर्क निष्पादित किया जाता है। इसलिए समापन मूल्य मॉडल में, ऐतिहासिक K-लाइन चरण और वास्तविक समय K-लाइन चरण, var,varip घोषणा के चर ऊपर दिए गए उदाहरण में पूरी तरह से समान हैं, जो प्रत्येक K-लाइन BAR के लिए 1 की वृद्धि है।

अंकगणित ऑपरेटर

ऑपरेटर	स्पष्टीकरण
+	गाफिया
-	कानून को कम करना
*	गुणन
/	अपवाद
%	मोल्ड की मांग

+、-ऑपरेटर को द्विआधारी ऑपरेटर के रूप में भी इस्तेमाल किया जा सकता है, या फिर एकमुश्त ऑपरेटर के रूप में भी इस्तेमाल किया जा सकता है। अन्य गणितीय ऑपरेटर केवल द्विआधारी ऑपरेटर के रूप में उपयोग किए जा सकते हैं और यदि एकमुश्त ऑपरेटर के रूप में उपयोग किया जाता है तो यह त्रुटि देता है।

1, अंकगणितीय ऑपरेटर के दोनों ओर अंक प्रकार हैं, परिणाम संख्या प्रकार, पूर्णांक या फ्लोट बिंदु संख्या के लिए है। 2. यदि कोई ऑपरेटर स्ट्रिंग है, तो ऑपरेटर है+, तो गणना का परिणाम एक स्ट्रिंग है, संख्याओं को स्ट्रिंग के रूप में परिवर्तित किया जाता है, और फिर स्ट्रिंगों को एक साथ रखा जाता है. यदि अन्य गणितीय ऑपरेटर हैं, तो स्ट्रिंग को संख्याओं में परिवर्तित करने का प्रयास किया जाता है, और फिर ऑपरेशन किया जाता है. 3. यदि इनमें से कोई ऑपरेशन संख्या na है, तो गणना का परिणाम शून्य मूल्य na है, जो FMZ पर प्रिंट करते समय NaN दिखाता है।

a = 1 + 1 
b = 1 + 1.1
c = 1 + "1.1"
d = "1" + "1.1"
e = 1 + na 

runtime.log("a:", a, ", b:", b, ", c:", c, ", d:", d, ", e:", e)   
// a: 2 , b: 2.1 , c: 11.1 , d: 11.1 , e: NaN

FMZ पर पाइन भाषा यहाँ ट्रेडिंग दृश्य पर पाइन भाषा से थोड़ा अलग है, FMZ पर पाइन भाषा चर प्रकार के लिए बहुत कठोर नहीं है। उदाहरण के लिएः

a = 1 * "1.1"
b = "1" / "1.1"
c = 5 % "A" 

plot(a)
plot(b)
plot(c)

एफएमजेड पर चल सकता है, लेकिन ट्रेडिंग व्यू में टाइप त्रुटि देता है। गणितीय ऑपरेटरों के लिए, जब दोनों पक्षों पर ऑपरेशन की संख्या स्ट्रिंग होती है, तो सिस्टम स्ट्रिंग को संख्या में परिवर्तित करने के बाद गणना करता है। यदि गैर-संख्यात्मक स्ट्रिंग गणना नहीं कर सकती है, तो सिस्टम ऑपरेशन का परिणाम शून्य n है।

तुलनात्मक ऑपरेटर

तुलना ऑपरेटर द्विआधारी ऑपरेटर हैं।

ऑपरेटर	स्पष्टीकरण
<	से कम
>	से बड़ा
<=	से कम है
>=	से अधिक है
==	बराबर
!=	असमानता

परीक्षण उदाहरणः

a = 1 > 2 
b = 1 < 2 
c = "1" <= 2 
d = "1" >= 2 
e = 1 == 1 
f = 2 != 1 
g = open > close 
h = na > 1 
i = 1 > na

runtime.log("a:", a, ", b:", b, ", c:", c, ", d:", d, ", e:", e, ", f:", f, ", g:", g, ", h:", h, ", i:", i)   
// a: false , b: true , c: true , d: false , e: true , f: true , g: false , h: false , i: false

जैसा कि आप देख सकते हैं, तुलना ऑपरेटर का उपयोग करना बहुत सरल है, लेकिन यह सबसे अधिक ऑपरेटर है जिसका उपयोग हम अपनी नीतियों को लिखने के लिए करते हैं। आप संख्याओं और अंतर्निहित चरों की तुलना कर सकते हैं, जैसे किclose、openऔर इस तरह। एफएमजेड में ट्रेडिंग व्यू के पाइन से अलग, एफएमजेड में विशेष रूप से सख्त आवश्यकता प्रकार नहीं हैं, इसलिए इस तरह के बयानों में एक विशेष रूप से सख्त आवश्यकता प्रकार नहीं है।d = "1" >= 2एफएमजेड में कोई त्रुटि नहीं होती है, स्ट्रिंग को अंकों में परिवर्तित किया जाता है और फिर तुलना की जाती है।

तार्किक ऑपरेटर

ऑपरेटर	कोड चिह्न	स्पष्टीकरण
नहीं	नहीं	एकमुश्त ऑपरेटर, गैर-कार्यात्मक
के साथ	और	द्विआधारी ऑपरेटर, जो कि () और () के साथ काम करता है
या	या	द्विआधारी ऑपरेटर, या ऑपरेशन

लॉजिकल ऑपरेटर्स के बारे में बात करते हुए, हम निश्चित रूप से वास्तविक मान तालिकाओं के बारे में बात कर रहे हैं. जैसा कि हमने हाई स्कूल में सीखा था, लेकिन यहां हम रीट्रेस सिस्टम में परीक्षण करते हैं, सीखते हैंः

a = 1 == 1  // 使用比较运算符构成的表达式，结果为布尔值
b = 1 != 1
c = not b   // 逻辑非操作符
d = not a   // 逻辑非操作符

runtime.log("测试逻辑操作符：and", "#FF0000")
runtime.log("a:", a, ", c:", c, ", a and c:", a and c)
runtime.log("a:", a, ", b:", b, ", a and b:", a and b)
runtime.log("b:", b, ", c:", c, ", b and c:", b and c)
runtime.log("d:", d, ", b:", b, ", d and b:", d and b)

runtime.log("测试逻辑操作符：or", "#FF0000")
runtime.log("a:", a, ", c:", c, ", a or c:", a or c)
runtime.log("a:", a, ", b:", b, ", a or b:", a or b)
runtime.log("b:", b, ", c:", c, ", b or c:", b or c)
runtime.log("d:", d, ", b:", b, ", d or b:", d or b)

runtime.error("stop")

और फिर, हम एक और उपकरण का उपयोग करते हैं, जो हमें एक बार फिर से देखने के लिए अनुमति देता है।runtime.error("stop")एक बार मुद्रण करने के बाद, एक असामान्य त्रुटि को छोड़ दें ताकि पुनः परीक्षण बंद हो जाए, और फिर आप आउटपुट जानकारी को देख सकें, यह पता लगाने के लिए कि मुद्रित सामग्री और वास्तविक मूल्य सारणी वास्तव में समान हैं।

त्रिकोणीय ऑपरेटर

त्रिकोणीय ऑपरेटरों का उपयोग करना? :और ऑपरेटरों के संयोजन के साथ तीन-आयामी अभिव्यक्तिcondition ? valueWhenConditionIsTrue : valueWhenConditionIsFalseहम पहले के पाठों में भी परिचित हैं. तथाकथित त्रिकोणीय अभिव्यक्ति, त्रिकोणीय ऑपरेटर का अर्थ है कि इसमें कुल तीन ऑपरेशन हैं.

condition ? valueWhenConditionIsTrue : valueWhenConditionIsFalseconditionयदि यह सच है, तो अभिव्यक्ति का मान होगाःvalueWhenConditionIsTrue❖ यदिconditionमान लीजिये कि अभिव्यक्ति का मान हैvalueWhenConditionIsFalse。

हालांकि इसका कोई व्यावहारिक उपयोग नहीं है, लेकिन इसका एक आसान उदाहरण हैः

a = close > open
b = a ? "阳线" : "阴线"
c = not a ? "阴线" : "阳线"
plotchar(a, location=location.abovebar, color=color.red, char=b, overlay=true)
plotchar(not a, location=location.belowbar, color=color.green, char=c, overlay=true)

यदि आप क्रॉसस्टार को देखते हैं, तो यह कोई फर्क नहीं पड़ता! त्रिकोणीय अभिव्यक्ति भी एम्बेडेड हो सकती है, जैसा कि हमने पिछले ट्यूटोरियल में किया था।

a = close > open
b = a ? math.abs(close-open) > 30 ? "阳线" : "十字星" : math.abs(close-open) > 30 ? "阴线" : "十字星"
c = not a ? math.abs(close-open) > 30 ? "阴线" : "十字星" : math.abs(close-open) > 30 ? "阳线" : "十字星"
plotchar(a, location=location.abovebar, color=color.red, char=b, overlay=true)
plotchar(not a, location=location.belowbar, color=color.green, char=c, overlay=true)

वास्तव में यह एक तरह सेcondition ? valueWhenConditionIsTrue : valueWhenConditionIsFalseअंदरvalueWhenConditionIsTrue、valueWhenConditionIsFalse, इसके बजाय एक और त्रिकोणीय अभिव्यक्ति का उपयोग किया जाता है ।

इतिहास संकेतक

इतिहास संकेतक का प्रयोग करें[], संदर्भ समयक्रम में ऐतिहासिक मान. ये ऐतिहासिक मान वे मान हैं जो चर के वर्तमान K-लाइन BAR से पहले K-लाइन BAR पर हैं जब स्क्रिप्ट चल रही है.[]ऑपरेटर चर, अभिव्यक्ति और फ़ंक्शन कॉल के बाद प्रयोग किया जाता है।[]इस कोष्ठक में संख्याएं हैं जो हम संदर्भित करने वाले ऐतिहासिक डेटा की वर्तमान K लाइन BAR की दूरी से विचलन की मात्रा हैं। उदाहरण के लिए, मैं पिछले K लाइन BAR के समापन मूल्य को उद्धृत करना चाहता हूं, यह लिखा गया हैःclose[1]。

हम पहले के पाठ्यक्रमों में इस तरह के लेखन को देख चुके हैं:

high[10]
ta.sma(close, 10)[1]
ta.highest(high, 10)[20]
close > nz(close[1], open)

[]ऑपरेटर एक ही मूल्य पर केवल एक बार इस्तेमाल किया जा सकता है, इसलिए यह गलत लिखा है और एक त्रुटि देता हैः

a = close[1][2]   // 错误

आप यहाँ देख सकते हैं, और कुछ छात्र कह सकते हैं, ऑपरेटर[]यह एक सरणी संरचना के लिए प्रयोग किया जाता है, जो कि सरणी संरचना (series) और सरणी के समान दिखता है! नीचे हम एक उदाहरण के साथ यह दिखाने जा रहे हैं कि पाइन भाषा में एक श्रृंखला और एक सरणी क्या हैं।

strategy("test", overlay=true)

a = close
b = close[1]
c = b[1]

plot(a, title="a")
plot(b, title="b")
plot(c, title="c")

हालांकिa = close[1][2]यह गलत है, लेकिनः

b = close[1]
c = b[1]

यदि आप इसे सामान्य रूप से समझते हैं, तो यह गलत नहीं होगा।b = close[1]b एक संख्या होना चाहिए, हालांकिc = b[1]b को फिर भी इतिहास के लिए उपयोग किया जा सकता है; जैसा कि पाइन भाषा में श्रृंखला की अवधारणा सरणी के रूप में सरल नहीं है; इसे पिछले बार के इतिहास के रूप में समझा जा सकता है; b को असाइन किया गया है; b एक समय श्रृंखला संरचना भी है, जो अपने इतिहास को संदर्भित करना जारी रख सकती है; इसलिए हम देखते हैं कि चित्रित तीन पंक्तियों a, b और c में, b पंक्ति एक बार a से धीमी है, c पंक्ति एक बार b से धीमी है; c पंक्ति दो बार a से धीमी है।

हम चार्ट को सबसे बाईं ओर खींच सकते हैं और देख सकते हैं कि पहली K पंक्ति पर, b और c दोनों के मान शून्य हैं। यह इसलिए है क्योंकि जब स्क्रिप्ट पहली K पंक्ति BAR पर निष्पादित होती है, तो एक, दो चक्रों के इतिहास का कोई संदर्भ नहीं होता है, यह मौजूद नहीं होता है। इसलिए हमें अक्सर इस बात का ध्यान रखना चाहिए कि इतिहास डेटा को संदर्भित करते समय रिक्त मानों का संदर्भ दिया जाता है या नहीं।na、nzहम पहले भी इस बारे में बात कर चुके हैं.nz、naफ़ंक्शन, क्या आपको याद है कि किस अध्याय में?) विशिष्ट रूप से रिक्त मानों के साथ काम करता है, जैसेः

close > nz(close[1], open)    // 当引用close内置变量前一个BAR的历史值时，如果不存在，则使用open内置变量

यह एक ऐसी प्रक्रिया है जो शून्य ((na) को संदर्भित कर सकती है।

ऑपरेटर प्राथमिकता

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

प्राथमिकताएं	ऑपरेटर
9	`[]`
8	एक बार एक ऑपरेटर`+` 、`-`और`not`
7	`*`、`/`、`%`
6	द्विआधारी ऑपरेटर जब`+`、`-`
5	`>`、`<`、`>=`、`<=`
4	`==`、`!=`
3	`and`
2	`or`
1	`?:`

उच्च प्राथमिकता वाले अभिव्यक्ति भाग पहले संचालित होते हैं, यदि प्राथमिकता समान है तो बाएं से दाएं संचालित होते हैं। यदि किसी भाग को पहले संचालित करना अनिवार्य करना है, तो इसका उपयोग किया जा सकता है()इस भाग के लिए अभिव्यक्ति को पहले ऑपरेट करने के लिए बाध्य किया गया है।

चर

चर की घोषणा

हमने पहले ही एक चर के लिए एक चिह्न के रूप में चिह्नित चिह्न के बारे में सीखा है, जो कि चर के नाम के रूप में एक चर को नामित करता है। इसलिए यह भी कहा जाता हैः चर एक संरक्षित चिह्न है। तो एक चर को कैसे घोषित किया जाए?

घोषणा का पैटर्नः जब एक चर घोषित किया जाता है, तो सबसे पहले "प्रकटीकरण मोड" लिखा जाता है। 1। कीवर्ड का उपयोग करेंvar.. 2। खोजशब्दों का उपयोग करेंvarip.. 3. कुछ भी नहीं लिख रहा है।

var、varipहम पहले के अध्याय में सीख चुके हैं, और अब हम इस पर चर्चा नहीं करेंगे। यदि चर के घोषणा पैटर्न में कुछ भी नहीं लिखा गया है, तो उदाहरण के लिएःi = 1, वास्तव में हम पहले भी कहा है कि इस तरह के घोषित चर और असाइनमेंट, प्रत्येक K लाइन BAR पर निष्पादित किया जाता है ।
प्रकार FMZ पर पाइन भाषा प्रकार की आवश्यकताओं के लिए कठोर नहीं है और आमतौर पर इसे छोड़ दिया जा सकता है; हालांकि ट्रेडिंग दृश्य पर स्क्रिप्ट नीति के साथ संगतता के लिए, चर को घोषित करते समय भी प्रकार के साथ किया जा सकता है। उदाहरण के लिएः
```
int i = 0 
float f = 1.1
```
ट्रेडिंग व्यू में टाइप करना अपेक्षाकृत सख्त है, और ट्रेडिंग व्यू में निम्न कोड का उपयोग करने पर त्रुटि मिलती हैः
```
baseLine0 = na          // compile time error!
```
पहचानकर्ता एक पहचानकर्ता एक चर का नाम है, और पहचानकर्ता का नामकरण पिछले अध्याय में बताया गया है।https://www.fmz.com/bbs-topic/9390#标识符

संक्षेप में, एक परिवर्तनीय के लिए एक घोषणा लिख सकते हैंः

// [<declaration_mode>] [<type>] <identifier> = value 
   声明模式             类型     标识符       = 值

यहाँ एक विशेषता ऑपरेटर का उपयोग किया जाता हैः=जब वेरिएंट घोषित किया जाता है तो वेरिएंट को असाइनमेंट दिया जाता है। असाइनमेंट के दौरान, मान स्ट्रिंग, संख्या, अभिव्यक्ति, फ़ंक्शन कॉल,if、 for、whileयाswitchउदाहरण के लिए, यदि हम किसी शब्द के लिए एक वाक्य का उपयोग करते हैं, तो हम उस शब्द का उपयोग करने के बारे में बात कर रहे हैं।

यहाँ हम इनपुट फ़ंक्शन पर ध्यान केंद्रित करते हैं, एक ऐसा फ़ंक्शन जो हम अक्सर उपयोग करते हैं जब हम अपनी डिज़ाइन नीति लिखते हैं। यह एक बहुत ही महत्वपूर्ण फ़ंक्शन है जब हम अपनी डिज़ाइन नीति लिखते हैं।

इनपुट फ़ंक्शनः

input函数，参数defval、title、tooltip、inline、group

एफएमजेड पर इनपुट फ़ंक्शन ट्रेडिंग व्यू पर इनपुट फ़ंक्शन से थोड़ा अलग है, हालांकि यह फ़ंक्शन रणनीति पैरामीटर के लिए एक असाइनमेंट इनपुट के रूप में उपयोग किया जाता है। नीचे हम एक उदाहरण के साथ एफएमजेड पर इनपुट फ़ंक्शन के उपयोग का विस्तार करते हैंः

param1 = input(10, title="参数1名称", tooltip="参数1的描述信息", group="分组名称A")
param2 = input("close", title="参数2名称", tooltip="参数2的描述信息", group="分组名称A")
param3 = input(color.red, title="参数3名称", tooltip="参数3的描述信息", group="分组名称B")
param4 = input(close, title="参数4名称", tooltip="参数4的描述信息", group="分组名称B")
param5 = input(true, title="参数5名称", tooltip="参数5的描述信息", group="分组名称C")

ma = ta.ema(param4, param1)
plot(ma, title=param2, color=param3, overlay=param5)

एक चर को परिभाषित करने के लिए इनपुट फ़ंक्शन का उपयोग किया जाता है। एफएमजेड में इनपुट फ़ंक्शन स्वचालित रूप से एफएमजेड नीति इंटरफ़ेस में नीति पैरामीटर सेट करने के लिए नियंत्रण को चित्रित करता है। एफएमजेड पर समर्थित नियंत्रणों में वर्तमान में संख्यात्मक इनपुट बॉक्स, पाठ इनपुट बॉक्स, ड्रॉप-डाउन बॉक्स, बुल मान का चयन शामिल है।

हम इनपुट फ़ंक्शन के कुछ मुख्य पैरामीटर पेश करते हैंः

defval: इनपुट फ़ंक्शन के लिए सेट किए गए नीति पैरामीटर विकल्पों के लिए डिफ़ॉल्ट मान, पाइन भाषा के अंतर्निहित चर, संख्याओं, स्ट्रिंग्स का समर्थन करता है
title: नीति का नाम जो वास्तविक डिस्क / पुनः परीक्षण की नीति इंटरफ़ेस पर प्रदर्शित होता है.
टूलटिपः नीति पैरामीटर के लिए संकेत, जब माउस नीति पैरामीटर पर रहता है तो इस पैरामीटर को सेट करने के लिए पाठ संदेश प्रदर्शित करता है।
group: पॉलिसी पैरामीटर समूह नाम, पैरामीटर समूह के लिए दिया जा सकता है.

पाइन में अलग-अलग चरों की घोषणा और असाइनमेंट के अलावा, एक समूह को घोषित करने और उन्हें असाइन करने के लिए एक लेखन भी हैः

[变量A,变量B,变量C] = 函数 或者 ```if```、 ```for```、```while```或```switch```等结构

सबसे आम है कि हम उपयोग करते हैंta.macdजब MACD का उपयोग किया जाता है, तो यह तीन डेटा सेटों के साथ आता है, क्योंकि MACD एक बहु-स्तरीय संकेतक है; इसलिए इसे लिखा जा सकता हैः

[dif,dea,column] = ta.macd(close, 12, 26, 9)

plot(dif, title="dif")
plot(dea, title="dea")
plot(column, title="column", style=plot.style_histogram)

हम ऊपर दिए गए कोड का उपयोग करके मैकडी चार्ट को आसानी से खींच सकते हैं, न केवल अंतर्निहित फ़ंक्शन कई चर लौटा सकते हैं, बल्कि लिखे गए कस्टम फ़ंक्शन भी कई डेटा लौटा सकते हैं।

twoEMA(data, fastPeriod, slowPeriod) =>
    fast = ta.ema(data, fastPeriod)
    slow = ta.ema(data, slowPeriod)
    [fast, slow]

[ema10, ema20] = twoEMA(close, 10, 20)
plot(ema10, title="ema10", overlay=true)
plot(ema20, title="ema20", overlay=true)

यदि जैसे संरचनाओं का उपयोग करके कई चर को असाइन करने के लिए लिखने का तरीका ऊपर दिए गए कस्टम फ़ंक्शन के समान है, तो यह भी दिलचस्प है।

[ema10, ema20] = if true
    fast = ta.ema(close, 10)
    slow = ta.ema(close, 20)
    [fast, slow]

plot(ema10, title="ema10", color=color.fuchsia, overlay=true)
plot(ema20, title="ema20", color=color.aqua, overlay=true)

शर्त संरचना

कुछ फ़ंक्शन स्थानीय कोड ब्लॉकों में लिखे जा सकते हैं जो कि शर्त शाखाओं में नहीं लिखे जा सकते हैं, मुख्य रूप से निम्नलिखित फ़ंक्शनः

बारकलर (), भराव (), लाइन (), संकेतक (), प्लॉट (), प्लॉटकैंडल (), प्लॉटचर (), प्लॉटशेप (), प्लॉटशेप ())

ट्रेडिंग व्यू में त्रुटि रिपोर्ट संकलित की जाती है; एफएमजेड पर सीमाएं इतनी कठोर नहीं हैं, लेकिन ट्रेडिंग व्यू पर लेखन के नियमों का पालन करना भी उचित है। उदाहरण के लिए, एफएमजेड में त्रुटि रिपोर्ट नहीं की जाती है, लेकिन इसे लिखना उचित नहीं है।

strategy("test", overlay=true)
if close > open 
    plot(close, title="close")
else 
    plot(open, title="open")

if भाषा

अगला पृष्ठ

अधिक

2019 FMZ - सभी अधिकार सुरक्षित