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

FMZ PINE स्क्रिप्ट डॉक

लेखक:आविष्कारक मात्रा - छोटे सपने, बनाया गयाः 2022-04-28 16:05:05, अद्यतनः 2024-10-12 17:25:27

[TOC]

कीवर्ड, व्याकरण, सेटिंग्स का परिचय

कोड की संरचना

पाइन में कोड की सामान्य संरचना इस प्रकार हैः

<version>
<declaration_statement>
<code>

नोट्स

नोट्स एफएमजेड की पाइन भाषा द्वारा समर्थित प्रतीक: एकल-पंक्ति नोट्स//, बहु-पंक्ति नोट्स/* */, जैसे कि निम्नलिखित उदाहरण में नोट्स विधिः

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

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

संस्करण

निम्नलिखित रूप का एक संकलक निर्देश संकलक को बताता है कि पाइन के किस संस्करण में स्क्रिप्ट लिखी गई थी:

//@version=5

डिफ़ॉल्ट V5 संस्करण है, जो कोड से छोड़ा जा सकता है//@version=5.

घोषणा विवरण

indicator()
strategy()

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

कोड

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

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

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

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

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

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

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

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

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

न्यूलाइन कोड

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

a = open + high + low + close

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

a = open +
      high +
          low +
             close

एक लंबा प्लॉट ((() कॉल को इस तरह से लपेटा जा सकता हैः

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

उपयोगकर्ता-परिभाषित फ़ंक्शन घोषणाओं में कथन भी लपेटा जा सकता है। हालांकि, चूंकि एक स्थानीय ब्लॉक को सिंटैक्सिक रूप से एक इंडेंट (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")

समय श्रृंखला

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

अंतर्निहित चर ले लोopenउदाहरण के तौर पर,openअंतर्निहित चर प्रत्येक int प्रतिनिधित्व BAR का उद्घाटन मूल्य रिकॉर्ड करता है, यदि यहopenएक 5 मिनट int प्रतिनिधित्व अवधि डेटा है। तो यहopenचर प्रत्येक 5-मिनट int प्रतिनिधित्व बार (बार) के उद्घाटन मूल्य रिकॉर्ड करता है। जब आपकी रणनीति कार्यक्रम निष्पादित कर रहा है,openकोड में वर्तमान int प्रतिनिधित्व BAR के उद्घाटन मूल्य को संदर्भित करता है। समय श्रृंखला में पिछले मूल्यों (पिछले मूल्यों) को संदर्भित करने के लिए, हम उपयोग करते हैं[]इतिहास ऑपरेटर जब रणनीति एक निश्चित int प्रतिनिधित्व BAR पर निष्पादित किया जाता है,open[1]अर्थ वर्तमान int प्रतिनिधित्व BAR के पिछले int प्रतिनिधित्व BAR के उद्घाटन मूल्य को संदर्भित करना है।

हालांकिकालक्रमarray डेटा संरचना की बहुत याद दिलाता है, हालांकि PINE भाषा में भी एक सरणी प्रकार है। लेकिन वे और समय श्रृंखला पूरी तरह से अलग अवधारणाएं हैं।

पाइन भाषा में डिजाइन समय श्रृंखला आसानी से रणनीति कोड में समापन मूल्य के संचयी मूल्य की गणना कर सकते हैं, और वहाँ के लिए इस तरह के लूप संरचनाओं का उपयोग करने के लिए कोई जरूरत नहीं है, केवल अंतर्निहित समारोहta.cum(close)एक अन्य उदाहरण के लिए, हमें पिछले 14 int प्रतिनिधित्व बारों (यानी, कोड निष्पादित होने के वर्तमान क्षण के सबसे करीब 14 int प्रतिनिधित्व बार) के उच्चतम मूल्य और निम्नतम मूल्य के बीच अंतर के औसत मूल्य की गणना करने की आवश्यकता है, जिसे लिखा जा सकता हैःta.sma(high - low, 14)

एक समय श्रृंखला पर एक फ़ंक्शन को कॉल करने का परिणाम भी समय श्रृंखला पर एक निशान छोड़ देगा, फिर हम उपयोग करते हैं[]इतिहास ऑपरेटर पिछले मूल्यों को संदर्भित करने के लिए। उदाहरण के लिए, जब परीक्षण कर रहे हैं कि क्या वर्तमान int प्रतिनिधित्व BAR का समापन मूल्य पिछले 10 int प्रतिनिधित्व BAR (वर्तमान int प्रतिनिधित्व BAR को छोड़कर) में उच्चतम मूल्य के अधिकतम मूल्य से अधिक है। हम लिख सकते हैंbreach = close > ta.highest(close, 10)[1], और हम यह भी लिख सकते हैंbreach = close > ta.highest(close[1], 10)तो.ta.highest(close, 10)[1]औरta.highest(close[1], 10)समतुल्य हैं।

इसे निम्नलिखित कोड से सत्यापित किया जा सकता है:

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

a = ta.highest(close, 10)[1]
b = ta.highest(close[1], 10)

plotchar(true, title="a", char=str.tostring(a), location=location.abovebar, color=color.red)
plotchar(true, title="b", char=str.tostring(b), location=location.belowbar, color=color.green)

उपरोक्त परीक्षण कोड संबंधित समय श्रृंखला में प्रत्येक BAR पर a और b के मानों को आउटपुट करेगा। यह देखा जा सकता है कि a और b के मान हमेशा समान होते हैं, इसलिए ये दो प्रतिनिधित्व विधियां समकक्ष होती हैं।

पाइन भाषा व्यापार वर्ग पुस्तकालय के टेम्पलेट तर्क

PINE रणनीति के अंतर्निहित टेम्पलेट Pine Language Trade Class Library के तर्कों को सेट करने के लिए निर्देश।

व्यापार सेटिंग्स

निष्पादन मोड समापन मूल्य मॉडलः मॉडल को केवल वर्तमान BAR के पूरा होने के बाद निष्पादित किया जाता है, और व्यापार अगले BAR के शुरू होने पर निष्पादित किया जाता है। वास्तविक समय मूल्य मॉडलः यह मॉडल हर बार जब मूल्य चलता है, निष्पादित किया जाता है, और व्यापार को तुरंत निष्पादित करने के लिए एक संकेत होता है।
डिफ़ॉल्ट ओपन लॉट आकारः यदि ट्रेड ऑर्डर में ट्रेड राशि निर्दिष्ट नहीं है, तो ट्रेड को सेट राशि के अनुसार निष्पादित किया जाएगा।
एक व्यापार के लिए अधिकतम आदेश मात्राः वास्तविक बाजार और इस तर्क सेटिंग के अनुसार बाजार को प्रभावित करने से बचने के लिए प्रत्येक आदेश की अधिकतम राशि निर्धारित करें।
स्लिप पॉइंट्सः ऑर्डर देते समय स्लिप को निर्धारित करेंPricing Currency Precisionउदाहरण के लिए, मूल्य निर्धारण मुद्रा परिशुद्धता 2 पर सेट है, जो दूसरे दशमलव बिंदु तक सटीक है, 0.01 तक सटीक है। फिर प्रत्येक स्लिप पॉइंट 0.01 मूल्य निर्धारण इकाइयों का प्रतिनिधित्व करता है। इस समय, स्लिप पॉइंट 5 पर सेट है, और ऑर्डर देते समय स्लिप 0.05 है (स्लिप ऑर्डर ट्रेड के लिए ऑर्डर देते समय कीमत के उस हिस्से को संदर्भित करता है जो ओवरफ्लो होता है) ।
चर की सबसे लंबी अवधि संख्या: चार्ट में K-लाइन BAR की संख्या को प्रभावित करती है। यह फ़ंक्शन को कॉल करने के समान हैSetMaxBarLenमेंjavascript srategy.

वायदा विकल्प

विविधता कोडः अनुबंध कोड, इसे केवल तभी सेट करने की आवश्यकता है जब विनिमय वस्तु गैर-स्पॉट विनिमय वस्तु हो।
न्यूनतम अनुबंध आकारः आदेश देने के समय अनुबंध की न्यूनतम व्यापारिक मात्रा।

लाइव ट्रेडिंग विकल्प

ऑटो-रिकवरी प्रगतिः अंतिम रणनीति स्टॉप से पहले ऑटो-रिकवरी की स्थिति।
ऑर्डर पुनः प्रयास समयः यदि ऑर्डर को पूरा नहीं किया जाता है, तो ऑर्डर रद्द कर दिया जाएगा, और ऑर्डर को व्यापार करने का प्रयास करने के लिए फिर से रखा जाएगा। इस तर्क का उपयोग अधिकतम पुनः प्रयासों की संख्या को सीमित करने के लिए किया जाता है।
नेटवर्क पोलिंग अंतराल (मिलीसेकंड): केवल REST प्रोटोकॉल के लिए मान्य, यह अनुरोधों को बहुत बार होने और विनिमय सीमा से अधिक होने से रोकने के लिए नेटवर्क अनुरोध अंतराल को नियंत्रित करता है।
खाता सिंक्रनाइज़ेशन समय (सेकंड): खाता डेटा के सिंक्रनाइज़ेशन के लिए समय की अवधि।
स्थिति खोलने के बाद स्थिति सिंक्रनाइज़ेशन का समय (मिलीसेकंड): कुछ एक्सचेंजों में डेटा देरी के कारण दोहराए गए पदों के लिए, एक बड़ा सिंक्रनाइज़ेशन समय सेट करना ऐसी समस्याओं को कम कर सकता है।
लीवरेज मल्टीपल: लीवरेज मल्टीपल सेट करता है।

स्पॉट ट्रेडिंग, अन्य सेटिंग्स

एक लॉट की ट्रेडिंग मात्राः एक लॉट की डिफ़ॉल्ट ट्रेडिंग मात्रा, जो केवल स्पॉट के लिए मान्य है।
न्यूनतम व्यापारिक मात्राः न्यूनतम व्यापारिक मात्रा।
मूल्य निर्धारण मुद्रा परिशुद्धताः मूल्य परिशुद्धता, अर्थात मूल्य में दशमलव स्थानों की संख्या।
व्यापारिक किस्म की सटीकताः आदेश मात्रा की सटीकता, अर्थात आदेश मात्रा के दशमलव स्थानों की संख्या।
प्रसंस्करण शुल्कः इस सेटिंग के अनुसार कुछ डेटा की गणना करें, 0.002 का अर्थ है 2/1000.
लाभ और हानि के सांख्यिकीय अंतराल: इसका उपयोग केवल वास्तविक बाजार में लाभ और हानि के सांख्यिकीय आंकड़ों को प्रदर्शित करने के लिए किया जाता है।
असफल पुनः प्रयास (ms): नेटवर्क अनुरोध विफल होने पर पुनः प्रयास अंतराल.
प्रॉक्सी का प्रयोग करें: केवल REST प्रोटोकॉल के लिए मान्य है.
सामान्य नेटवर्क त्रुटियों को छिपाएंः लॉग क्षेत्र में सामान्य त्रुटि लॉग छिपाएं.
स्विच बेस पता: केवल REST प्रोटोकॉल के लिए मान्य है.
पुश अधिसूचनाएं: मेल बॉक्स आदि में पुश संदेश

आदेश व्यापार

खुली स्थिति

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

बंद स्थिति

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

व्यापार तंत्र

PINE भाषा की स्थिति तंत्र एक तरफ़ा स्थिति के समान है। उदाहरण के लिए, लंबी दिशा में स्थिति रखते समय (लंबी स्थिति), यदि बिक्री ऑपरेशन के लिए एक आदेश है, एक नियोजित आदेश, आदि (स्थिति की विपरीत दिशा में), निष्पादन ट्रिगर किया जाएगा, और लंबी दिशा में स्थिति पहले बंद हो जाएगी। (सभी लंबी स्थिति बंद करें), और फिर ट्रिगर किए गए आदेश को निष्पादित करें (बंद होने से पहले की स्थिति के सापेक्ष विपरीत दिशा में) ।

नियोजित आदेश

ऑर्डर प्लेसमेंट कमांड का उपयोग करके ऑर्डर देते समय, यदि कोई कीमत निर्दिष्ट नहीं है, तो डिफ़ॉल्ट रूप से एक मार्केट ऑर्डर है। मार्केट ऑर्डर के अलावा, आप एक योजनाबद्ध ऑर्डर के माध्यम से भी ऑर्डर दे सकते हैं, जो ऑर्डर देने के लिए तुरंत काम नहीं करता है। जब यह ट्रिगर नहीं होता है, तो योजनाबद्ध ऑर्डर प्रोग्राम की योजनाबद्ध ऑर्डर कतार में मौजूद होता है, और स्थिति की जानकारी के Planned Order तालिका टैब में देखा जा सकता है (यानी, जब रणनीति चल रही होती है तो स्थिति पट्टी)वास्तविक आदेश/बैकटेस्टिंग. सिस्टम केवल तभी ऑर्डर करेगा जब वास्तविक समय बाजार मूल्य इन नियोजित आदेशों को ट्रिगर करने की शर्तों को पूरा करता है। इसलिए इन आदेशों में व्यापार मूल्य में मामूली विचलन होना सामान्य है।strategy.entryएक आदेश रखने के लिए समारोह, हम निर्दिष्ट कर सकते हैंlimit, stop arguments.

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

सीमा क्रम

आदेश की सीमा मूल्य सेट करें. जब आदेश एक खरीद आदेश है (यानी, आदेश की सीमा मूल्य सेट)directionतर्क हैstrategy.long), आदेश तभी निष्पादित होगा जब वर्तमान बाजार मूल्य इस मूल्य से कम हो। जब आदेश एक बिक्री आदेश है (यानी,directionतर्क हैstrategy.short), आदेश तभी निष्पादित होगा जब वर्तमान बाजार मूल्य इस मूल्य से अधिक हो।
रोक आदेश

ऑर्डर की स्टॉप लॉस कीमत सेट करें. जब ऑर्डर एक खरीद ऑर्डर है, तो ऑर्डर तभी ट्रिगर किया जाएगा जब वर्तमान बाजार मूल्य इस कीमत से अधिक हो। जब कोई ऑर्डर एक बिक्री ऑर्डर होता है, तो ऑर्डर तभी ट्रिगर किया जाएगा जब बाजार की वर्तमान कीमत उस कीमत से कम हो।
रोक-सीमा आदेश

..limitऔरstopतर्क एक ही समय में सेट किए जा सकते हैं, और आदेश उस मूल्य पर ट्रिगर किया जाएगा जो पहले शर्तों को पूरा करता है।

इक्विटी प्रतिशत क्रम

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

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

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

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

निर्दिष्ट करने के बादdefault_qty_type=strategy.percent_of_equity, सेटdefault_qty_valueएक प्रतिशत राशि (0~100), 1 का अर्थ है 1। आदेश की मात्रा की गणना खाते में मुद्रा की राशि के अनुसार की जाती है। उदाहरण के लिएः यदि चालू खाते में 10,000 USDT है, तो 1% ऑर्डर सेट करने का अर्थ है 100 USDT के पैमाने के साथ एक ऑर्डर (बिक्री के समय वर्तमान मूल्य के आधार पर गणना) करना।

घोषणा, तार्किक संरचना कीवर्ड

विर

var एक कीवर्ड है जिसका उपयोग चर को आवंटित करने और एक बार आरंभ करने के लिए किया जाता है। सामान्य तौर पर, चर असाइनमेंट व्याकरण जिसमें कीवर्ड var नहीं होता है, के कारण डेटा अपडेट होने पर प्रत्येक बार चरs मान को अधिलेखित किया जाता है। इसके विपरीत, जब चर को कीवर्ड var का उपयोग करके असाइन किया जाता है, तो वे डेटा अपडेट के बावजूद राज्य को बनाए रख सकते हैं, इसे केवल तब बदल सकते हैं जब if-expressions में स्थितियां पूरी हो जाती हैं।

var variable_name = expression

स्पष्टीकरण:

variable_name- पाइन स्क्रिप्ट में किसी उपयोगकर्ता चर का कोई भी नाम अनुमति दी जाती है (इसमें बड़े और छोटे लैटिन अक्षर, संख्याएं और रेखांकन (_) हो सकते हैं, लेकिन यह संख्या से शुरू नहीं हो सकता है) ।
expression- किसी भी अंकगणितीय अभिव्यक्ति, बस एक नियमित चर को परिभाषित करने की तरह. अभिव्यक्ति का मूल्यांकन किया जाएगा और एक बार के लिए चर को सौंपा जाएगा.

उदाहरण

// Var keyword example
var a = close
var b = 0.0
var c = 0.0
var green_bars_count = 0
if close > open
    var x = close
    b := x
    green_bars_count := green_bars_count + 1
    if green_bars_count >= 10
        var y = close
        c := y
plot(a, title = "a")
plot(b, title = "b")
plot(c, title = "c")

चर a श्रृंखला में प्रत्येक बार के पहले बार की बंद कीमत रखता है। चर b श्रृंखला में पहले ग्रीन मूल्य पट्टी की समापन कीमत रखता है। चर c श्रृंखला में दसवें green बार का समापन मूल्य रखता है।

एफएमजेड पर, यह वास्तविक समय मूल्य मॉडल और समापन मूल्य मॉडल में विभाजित है। हम निम्नलिखित कोड का उपयोग चर द्वारा घोषित परीक्षण करने के लिए करते हैंvarऔरvarip.

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

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

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

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

वास्तविक समय मूल्य मॉडल उपरोक्त परीक्षण कोड को दो चरणों में निष्पादित किया जाता हैः 1. ऐतिहासिक इंट प्रतिनिधित्व चरण। 2. वास्तविक समय इंट प्रतिनिधित्व चरण। वास्तविक समय मूल्य मॉडल में, ऐतिहासिक इंट प्रतिनिधित्व चरण में, चर i और ii द्वारा घोषित किए जाते हैं।var, varipरणनीति कोड निष्पादन के प्रत्येक दौर में क्रमिक रूप से निष्पादित होते हैं (क्योंकिif trueइसलिए, यह देखा जा सकता है कि बैकटेस्ट परिणाम के int प्रतिनिधित्व BAR पर प्रदर्शित संख्याओं को एक-एक करके 1 से बढ़ाया जाता है। जब ऐतिहासिक int प्रतिनिधित्व चरण समाप्त होता है, तो वास्तविक समय int प्रतिनिधित्व चरण शुरू होता है।var, varipघोषित चर अलग-अलग बदलने लगते हैं. क्योंकि यह एक वास्तविक समय मूल्य मॉडल है, रणनीति कोड एक बार एक int प्रतिनिधित्व BAR में प्रत्येक मूल्य परिवर्तन के लिए निष्पादित किया जाएगा,i := i + 1औरii := ii + 1एक बार निष्पादित किया जाएगा। अंतर यह है कि ii को हर बार संशोधित किया जाता है। हालांकि i को भी हर बार संशोधित किया जाता है, पिछले मूल्य को बहाल किया जाएगा जब रणनीति तर्क अगले दौर में निष्पादित किया जाता है, और i का मूल्य तब तक अपडेट नहीं किया जाएगा जब तक कि वर्तमान int प्रतिनिधित्व BAR पूरा नहीं हो जाता (यानी, पिछले मूल्य को बहाल नहीं किया जाएगा जब रणनीति तर्क अगले दौर में निष्पादित किया जाता है) । इसलिए यह देखा जा सकता है कि चर i अभी भी प्रत्येक BAR के लिए 1 से बढ़ाया जाता है। लेकिन चर ii प्रत्येक BAR के लिए कई बार जमा होता है।
समापन मूल्य मॉडल चूंकि समापन मूल्य मॉडल रणनीति तर्क केवल एक बार प्रति इंट प्रतिनिधित्व बार चला जाता है निष्पादित करता है। तो चर द्वारा घोषितvarऔरvaripउपरोक्त उदाहरण में, ऐतिहासिक इंट प्रतिनिधित्व चरण और वास्तविक समय इंट प्रतिनिधित्व चरण दोनों में, समापन मूल्य मॉडल पर समान रूप से समान रूप से व्यवहार करते हैं, प्रति इंट प्रतिनिधित्व बार में 1 की वृद्धि करते हैं।

विविधता

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

varip variable_name = expression

स्पष्टीकरण:

variable_name- पाइन लिपि में किसी उपयोगकर्ता चर का कोई भी नाम अनुमति दी जाती है (इसमें बड़े और छोटे लैटिन अक्षर, संख्याएं और रेखांकन (_) हो सकते हैं, लेकिन यह संख्या से शुरू नहीं हो सकता है) ।
expression- किसी भी अंकगणितीय अभिव्यक्ति, जैसे कि समय नियमित चर को परिभाषित करता है। पहले K-लाइन बार पर, अभिव्यक्ति का मूल्यांकन किया जाता है और चर को केवल एक बार सौंपा जाता है।

उदाहरण

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

var का उपयोग करते समय, ग्राफ bar_index का मान लौटाएगा. varip के साथ, ऐतिहासिक सलाखों पर भी यही व्यवहार होता है, लेकिन लाइव सलाखों पर, चार्ट एक मूल्य लौटाता है जो प्रत्येक टिक के लिए एक बढ़ता है.

टिप्पणीइसका प्रयोग केवल सरल प्रकारों जैसे float, int, bool, string और इन प्रकारों के array के साथ किया जा सकता है.

सच

यह एक bool चर का मूल्य, या एक मूल्य है कि गणना की जा सकती है जब एक अभिव्यक्ति का उपयोग करता है का प्रतिनिधित्व करता हैतुलनायातार्किक operator.

टिप्पणीकृपया विवरण देखें।तुलनाऑपरेटर औरतार्किक Operators.

यह भी देखें bool

झूठी

यह एक बूल चर के मूल्य और तुलना संचालन और तार्किक संचालन के परिणाम का प्रतिनिधित्व करता है।

टिप्पणीकृपया विवरण देखें।तुलनाऑपरेटर औरतार्किक Operators.

यह भी देखें bool

यदि

एक यदि कथन कथन का एक ब्लॉक परिभाषित करता है जिसे एक अभिव्यक्ति की शर्त पूरी होने पर निष्पादित किया जाना चाहिए। पाइन स्क्रिप्टिंग भाषा का संस्करण 4 आपको else if व्याकरण का उपयोग करने की अनुमति देता है।

सार्वभौमिक कोडः

var_declarationX = if condition
    var_decl_then0
    var_decl_then1
    ...
    var_decl_thenN
    return_expression_then
else if [optional block]
    var_decl_else0
    var_decl_else1
    ...
　　var_decl_elseN
　　return_expression_else
else
    var_decl_else0
    var_decl_else1
    ...
    var_decl_elseN
    return_expression_else

टिप्पणी var_declarationX- इस चर अगर कथन का मूल्य प्राप्त करता हैcondition- यदि शर्त सच है, कथन ब्लॉक में तर्कthenप्रयोग किया जाता है (var_decl_then0, var_decl_then1, आदि) यदि शर्त झूठी है, कथन ब्लॉक में तर्कelse ifयाelseप्रयोग किया जाता है (var_decl_else0, var_decl_else1, आदि) ।return_expression_thenऔरreturn_expression_else- मॉड्यूल में अंतिम वाक्यांश या ब्लॉक else से वाक्यांश कथन का अंतिम मान लौटाता है। यदि चर को अंतिम घोषित किया गया था, तो इसका मान परिणाम मान होगा।

यदि कथन का लौटा मूल्य प्रकार के प्रकार पर निर्भर करता हैreturn_expression_thenऔरreturn_expression_else. ट्रेडिंग व्यू पर चलने पर, उनके प्रकार मेल खाने चाहिएः जब आपके पास else ब्लॉक में स्ट्रिंग मान है, तो उस ब्लॉक से पूर्णांक मान वापस करना संभव नहीं है। जब FMZ पर चल रहा है, तो निम्न उदाहरण त्रुटि की रिपोर्ट नहीं करेगा। जब y मान open है, तो ड्राइंग करते समय प्लॉट का मान n/a है।

उदाहरण

// This code compiles
x = if close > open
    close
else
    open  

// This code doesn't compile by trading view
// y = if close > open
//     close
// else
//     "open"
plot(x)

..elseब्लॉक को छोड़ दिया जा सकता है। इस मामले में, यदि शर्त गलत है, तो var_declarationX चर को empty मान (na, false, या ) सौंपा जाता हैः

उदाहरण

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

कई else if ब्लॉक का उपयोग किया जा सकता है या कोई भी नहीं। then, else if, else के ब्लॉक को चार स्थानों पर स्थानांतरित किया जाता हैः

उदाहरण

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

परिणामी मूल्यifयह उपयोगी हो सकता है यदि आपको अभिव्यक्ति के दुष्प्रभावों की आवश्यकता है, उदाहरण के लिए रणनीति व्यापार मेंः

उदाहरण

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

यदि कथन एक दूसरे को शामिल कर सकते हैंः

उदाहरण

// if
float x = na
if close > open
    if close > close[1]
        x := close
    else
        x := close[1]
else
    x := open
plot(x)

के लिए

for निर्माण कई कथन को बार-बार निष्पादित करने की अनुमति देता हैः

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

var_declaration- एक वैकल्पिक चर घोषणा जो लूप के return_expression के मान के रूप में सौंपी जाएगी.counter- एक चर जो लूप काउंटर मान रखता है, लूप के प्रत्येक पुनरावृत्ति पर 1 या step_num मान द्वारा वृद्धि / घटाव।from_num- काउंटर का आरंभिक मान। series int/float मान/अभिनय की अनुमति है।to_num- काउंटर का अंतिम मान. लूप टूट जाता है जब काउंटर to_num से बड़ा होता है (या from_num > to_num के मामले में to_num से छोटा होता है). series int/float मान/अभिव्यक्ति की अनुमति है, लेकिन वे केवल लूप के पहले पुनरावृत्ति पर मूल्यांकन किए जाते हैं.step_num- काउंटर का वृद्धि / घटाव मान. यह वैकल्पिक है. डिफ़ॉल्ट +1 या -1 है, जो कि from_num या to_num के सबसे बड़े पर निर्भर करता है. मानों का उपयोग करते समय, काउंटर को भी from_num या to_num के सबसे बड़े के अनुसार वृद्धि / घटाव किया जाता है, इसलिए step_num का +/- संकेत वैकल्पिक है.statements | continue | break- किसी भी संख्या में कथन, या continue या break कीवर्ड, 4 रिक्त स्थानों या एक टैब द्वारा इंडेंट किए गए।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...inconstruct सरणी में प्रत्येक तत्व के लिए कई कथन को दोहराने की अनुमति देता है। इसका उपयोग किसी भी तर्क के साथ किया जा सकता हैः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 कीवर्ड, 4 रिक्त स्थानों या एक टैब द्वारा इंडेंट किए गए।return_expression- लूप का रिटर्न वैल्यू लूप में चर को दिया जाता हैvar_declarationयदि लूप continue या break कीवर्ड के कारण समाप्त हो जाता है, तो लूप का रिटर्न मान वैरिएबल है जिसे लूप समाप्त होने से पहले अंतिम बार असाइन किया गया था.continue- एक कीवर्ड जो केवल लूप में इस्तेमाल किया जा सकता है. यह लूप के अगले पुनरावृत्ति को निष्पादित करने के लिए कारण बनता है.break- लूप से बाहर निकलने के लिए कुंजी शब्द।

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

उदाहरण

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

यहाँ, हम हमारे मानों को सेट करने के लिए के लिए... में के दो तर्क के रूप का उपयोग करते हैं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यदि गलत है, स्क्रिप्ट निष्पादन के बाद जारी हैwhile statement. continue-continueकीवर्ड अगले पुनरावृत्ति के लिए लूप शाखा करने के लिए कारण बनता है.break-breakकीवर्ड लूप को समाप्त करने के लिए कारण होता है. स्क्रिप्ट निष्पादन के बाद फिर से शुरू होता हैwhile statement. return_expression- वैकल्पिक पंक्ति जो रिटर्न मूल्य प्रदान करती हैwhile statement.

उदाहरण

// 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निष्पादित किया जाना चाहिए।

स्विच करना

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

[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 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निर्दिष्ट नहीं है, कथन लौटाता हैnaयदिlocal_blockनिष्पादित नहीं किया जाता है।switchएक चर के लिए कथन, सभीlocal_blockउदाहरणों को एक ही प्रकार का मान लौटा देना चाहिए.

यह भी देखें if ?:

सीरीज

series एक कीवर्ड है जो डेटा श्रृंखला प्रकार को दर्शाता है।series keyword.

ऑपरेटर

=

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

:=

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

!=

के बराबर नहीं है. किसी भी प्रकार के अभिव्यक्ति के लिए लागू.

expr1 != expr2

रिटर्नबूलियन मान, या बूलियन मानों का एक अनुक्रम।

%

मॉड्यूलो (पूर्णांक शेष) संख्यात्मक अभिव्यक्तियों पर लागू होता है।

expr1 % expr2

रिटर्नपूर्णांक या फ्लोट मान, या मानों की श्रृंखला।

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

उदाहरण: -1 % 9 = -1 - 9 * ट्रंकटेट ((-1/9) = -1 - 9 * ट्रंकटेट ((-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 का संयोजन देता है संख्या एक पूर्णांक या फ्लोटिंग पॉइंट मान, या मानों का एक अनुक्रम लौटाता हैः द्विआधारी + expr1 प्लस expr2 लौटाता है. यूनरी + एक्सप्र (कुछ भी यूनरी ऑपरेटर प्रतिरूपता में नहीं जोड़ा जाता है) लौटाता है।

टिप्पणीआप अंकगणितीय संचालकों का उपयोग संख्याओं के साथ-साथ श्रृंखला चरों के साथ भी कर सकते हैं। श्रृंखला के साथ उपयोग के मामले में संचालकों को तत्वानुसार लागू किया जाता है।

+=

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

expr1 += expr2

उदाहरण

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

रिटर्नस्ट्रिंग्स के लिए, expr1 और expr2 का संयोजन लौटाता है. संख्याओं के लिए, एक पूर्णांक या फ्लोट मान, या मानों की श्रृंखला लौटाता है.

-

घटाव या अनार्य माइनस. संख्यात्मक अभिव्यक्तियों पर लागू होता है.

expr1 - expr2

- expr

रिटर्नपूर्णांक या फ्लोटिंग-पॉइंट मान, या मानों की श्रृंखला लौटाता हैः द्विआधारी + expr1 माइनस expr2 लौटाता है. अनार्य-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 statements.

फ़ंक्शन घोषणा व्याकरण हैः

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

ए<local_block>शून्य या अधिक पाइन स्क्रिप्ट कथन है।<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)

रिटर्नexpr2 यदि expr1 का मूल्यांकन true पर किया जाता है, अन्यथा expr3। शून्य मान (0 और NaN, +Infinity, -Infinity) को गलत माना जाता है, कोई अन्य मान सही है।

टिप्पणीयदि आपको इसकी आवश्यकता नहीं है तो else शाखा के लिए na का प्रयोग करें। आप दो या दो से अधिक?: ऑपरेटरों को मिलाकर switch जैसे कथन के बराबर प्राप्त कर सकते हैं (ऊपर दिए गए उदाहरण देखें). आप अंकगणितीय संचालकों का उपयोग संख्याओं के साथ-साथ श्रृंखला चरों के साथ भी कर सकते हैं। श्रृंखला के साथ उपयोग के मामले में संचालकों को तत्वानुसार लागू किया जाता है।

यह भी देखें na

[]

श्रृंखला सबस्क्रिप्ट. श्रृंखला expr1 के पिछले मूल्यों तक पहुंच प्रदान करता है। expr2 अतीत में सलाखों की संख्या है, और यह संख्यात्मक होना चाहिए। फ्लोट्स को नीचे गोल किया जाएगा।

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

और

तार्किक और. बूलियन अभिव्यक्ति के लिए लागू.

expr1 and expr2

रिटर्नबूलियन मान, या बूलियन मानों की श्रृंखला।

या

तार्किक OR. बूलियन अभिव्यक्ति के लिए लागू.

expr1 or expr2

रिटर्नबूलियन मान, या बूलियन मानों की श्रृंखला।

नहीं

तार्किक नकार (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 i = 14    // Same as `i = 14`
i := na
plot(i)

यह भी देखें 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 s = "Hello World!"    // Same as `s = "Hello world!"`
// string s = na // same as "" 
plot(na, title=s)

यह भी देखें 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 से FF हेक्साडेसिमल मानों (0 से 255 दशमलव में) का प्रतिनिधित्व करते हैं जहां RR, GG और BB जोड़े रंग s लाल, हरे और नीले घटकों के लिए मान हैं। AA रंग s पारदर्शिता (या अल्फा घटक) के लिए एक वैकल्पिक मान है जहां 00 अदृश्य है और FF अपारदर्शी है। जब कोई AA जोड़ी प्रदान नहीं की जाती है, तो FF का उपयोग किया जाता है। हेक्साडेसिमल अक्षर ऊपरी या निचले अक्षर हो सकते हैं।

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

यह भी देखें var varip int float string color.rgb color.new

सरणी

एक चर या तर्क के array प्रकार को स्पष्ट रूप से घोषित करने के लिए उपयोग किया जाने वाला कीवर्ड।array.new<type>, array.from function.

उदाहरण

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

टिप्पणीसरणी वस्तुएं हमेशा श्रृंखला के रूप में होती हैं।

यह भी देखें var array.new array.from

वस्तुएँ

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

प्रकारों की परिभाषा

आइए आदेश जानकारी संग्रहीत करने के लिए एक आदेश प्रकार को परिभाषित करें:

type order
    float price
    float amount
    string symbol

प्रकारों कोtype keyword.
टाइप कीवर्ड के बाद टाइप का नाम आता है.
पहली पंक्ति प्रकार प्रकार नाम को परिभाषित करता है, चार रिक्त स्थानों को इंडेंट करता है, और प्रकार में निहित क्षेत्रों को परिभाषित करता है.
प्रत्येक फ़ील्ड को अपने डेटा प्रकार, जैसे 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)   // Output {"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 कीवर्ड का उपयोग करके घोषित किया जाता है, इसलिए इसके फ़ील्ड (सूचकांक, मूल्य, वॉल्यूम) प्रत्येक पुनरावृत्ति में अपने मूल्यों को बनाए रखेंगे, पहली प्रविष्टि से शुरू होकर और अंतिम प्रविष्टि के साथ समाप्त होंगे।
currentBar ऑब्जेक्ट को var कीवर्ड के साथ घोषित नहीं किया गया है, इसलिए इसके फ़ील्ड प्रत्येक प्रविष्टि पर पुनः आरंभ किए जाएंगे और आपके पास प्रत्येक पुनरावृत्ति पर एक नया ऑब्जेक्ट होगा.

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

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

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

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

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

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

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

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

अगला पृष्ठ

अधिक

भिखारीक्यों रणनीति स्क्वायर की नकल पाइन रणनीति वास्तविक नहीं हो सकता है

आविष्कारक मात्रा - छोटे सपनेठीक है, हम जाँच करेंगे।

भिखारीचांग सुपरबायो का अनुकूलित ट्रेंड ट्रैकर

आविष्कारक मात्रा - छोटे सपनेनमस्ते, क्या आप मुझे बता सकते हैं कि क्या रणनीति है?

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