Julia Language
भाव

अभिव्यक्ति के लिए परिचय

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

उदाहरण के लिए, हम एक स्क्रिप्ट लिख सकते हैं या निम्नलिखित की व्याख्या कर सकते हैं: जूलिया> 1 + 1 2

अभिव्यक्ति बनाने का एक तरीका है :() सिंटैक्स का उपयोग करना। उदाहरण के लिए:

julia> MyExpression = :(1+1)
:(1 + 1)
julia> typeof(MyExpression)
Expr

अब हमारे पास Expr type ऑब्जेक्ट है। बस बनने के बाद, यह कुछ भी नहीं करता है - यह किसी भी अन्य वस्तु की तरह चारों ओर बैठता है जब तक उस पर कार्रवाई नहीं की जाती है। इस मामले में, हम eval() फ़ंक्शन का उपयोग करके उस अभिव्यक्ति का मूल्यांकन कर सकते हैं:

julia> eval(MyExpression)
2

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

1+1
eval(:(1+1))

अगर हम सिर्फ 1 + 1 बराबर खोजना चाहते हैं, तो हम eval(:(1+1)) में बहुत अधिक जटिल सिंटैक्स के माध्यम से क्यों जाना चाहते हैं? मूल कारण यह है कि हम अपने कोड में एक बिंदु पर एक अभिव्यक्ति को परिभाषित कर सकते हैं, संभवतः इसे बाद में संशोधित कर सकते हैं, और फिर बाद में अभी भी इसका मूल्यांकन कर सकते हैं। यह संभावित रूप से जूलिया प्रोग्रामर के लिए शक्तिशाली नई क्षमताओं को खोल सकता है। अभिव्यक्तियाँ जूलिया में मेटाप्रोग्रामिंग का एक प्रमुख घटक है।

भाव पैदा करना

विभिन्न प्रकार के कई तरीके हैं जिनका उपयोग एक ही प्रकार की अभिव्यक्ति बनाने के लिए किया जा सकता है। इंट्रो इंट्रोक्स में जिन शब्दों का उल्लेख है :() । शायद शुरू करने के लिए सबसे अच्छी जगह, हालांकि तार के साथ है। इससे जूलिया में अभिव्यक्ति और तार के बीच कुछ मौलिक समानताएं प्रकट करने में मदद मिलती है।

स्ट्रिंग से अभिव्यक्ति बनाएँ

जूलिया प्रलेखन से :

प्रत्येक जूलिया कार्यक्रम एक स्ट्रिंग के रूप में जीवन शुरू करता है

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

इस प्रकार, एक अभिव्यक्ति बनाने का एक तरीका यह है कि तार parse() को स्ट्रिंग पर लागू किया जाए। निम्नलिखित अभिव्यक्ति, एक बार इसका मूल्यांकन करने के बाद, प्रतीक x 2 का मान निर्दिष्ट करेगा।

MyStr = "x = 2"
MyExpr = parse(MyStr)
julia> x
ERROR: UndefVarError: x not defined
eval(MyExpr)
julia> x
2

अभिव्यक्ति का उपयोग कर बनाएँ :() सिंटैक्स

MyExpr2 = :(x = 2)
julia> MyExpr == MyExpr2
true

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

julia> MyExpr2.args
2-element Array{Any,1}:
  :x
 2  

Expr() फ़ंक्शन का उपयोग करके अभिव्यक्ति बनाएं

MyExpr3 = Expr(:(=), :x, 2)
MyExpr3 == MyExpr

यह वाक्य रचना उपसर्ग संकेतन पर आधारित है । दूसरे शब्दों में, Expr() निर्दिष्ट Expr() फ़ंक्शन के लिए पहला तर्क head या उपसर्ग है। शेष अभिव्यक्ति के arguments हैं। head यह निर्धारित करता है कि तर्कों पर कौन से संचालन किए जाएंगे।

इस पर अधिक जानकारी के लिए, अभिव्यक्ति वस्तुओं के क्षेत्र देखें

इस सिंटैक्स का उपयोग करते समय, वस्तुओं के लिए वस्तुओं और प्रतीकों का उपयोग करने के बीच अंतर करना महत्वपूर्ण है। उदाहरण के लिए, उपरोक्त उदाहरण में, अभिव्यक्ति 2 के प्रतीक को मान प्रदान करता है :x , एक पूरी तरह से समझदार ऑपरेशन। यदि हम x उपयोग इस तरह से करते हैं, तो हमें निरर्थक परिणाम मिलेगा:

julia> Expr(:(=), x, 5)
:(2 = 5)

इसी तरह, अगर हम देखते हैं कि args जाँच करें:

julia> Expr(:(=), x, 5).args
2-element Array{Any,1}:
 2
 5

इस प्रकार, Expr() फ़ंक्शन प्रतीकों में उसी स्वचालित परिवर्तन का प्रदर्शन नहीं करता है जैसे :() अभिव्यक्ति बनाने के लिए वाक्यविन्यास।

quote...end का उपयोग करके बहु-पंक्ति अभिव्यक्तियाँ बनाएँ quote...end

MyQuote = 
quote
    x = 2
    y = 3
end
julia> typeof(MyQuote)
Expr

ध्यान दें कि quote...end साथ quote...end हम उन अभिव्यक्तियों को बना सकते हैं जिनमें उनके args फ़ील्ड में अन्य अभिव्यक्तियाँ हैं:

julia> typeof(MyQuote.args[2])
Expr

इस args फ़ील्ड पर अधिक के लिए अभिव्यक्ति ऑब्जेक्ट्स की फ़ील्ड देखें।

अभिव्यक्ति बनाने पर अधिक

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

अभिव्यक्ति वस्तुओं के क्षेत्र

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

MyExpr3 = Expr(:(=), :x, 2)

एक्सप्रेशन बनाने में चर्चा की। हम निम्न प्रकार से head और args देख सकते हैं:

julia> MyExpr3.head
:(=)

julia> MyExpr3.args
2-element Array{Any,1}:
  :x
 2  

अभिव्यक्तियाँ उपसर्ग संकेतन पर आधारित हैं। जैसे, head आम तौर पर उस ऑपरेशन को निर्दिष्ट करता है जो कि args पर किया जाना है। सिर जूलिया प्रकार का Symbol होना चाहिए।

जब कोई मान एक मान निर्दिष्ट करने के लिए होता है (जब इसका मूल्यांकन हो जाता है), तो यह आम तौर पर एक सिर का उपयोग करेगा :(=) । इस के लिए निश्चित रूप से स्पष्ट विविधताएं हैं जिन्हें नियोजित किया जा सकता है, जैसे:

ex1 = Expr(:(+=), :x, 2)

: अभिव्यक्ति प्रमुखों के लिए कॉल करें

अभिव्यक्तियों के लिए एक और सामान्य head है :call । उदाहरण के लिए

ex2 = Expr(:call, :(*), 2, 3)
eval(ex2) ## 6

उपसर्ग संकेतन के सम्मेलनों के बाद, ऑपरेटरों का मूल्यांकन बाएं से दाएं किया जाता है। इस प्रकार, यहां इस अभिव्यक्ति का मतलब है कि हम उस फ़ंक्शन को कॉल करेंगे जो कि बाद के तत्वों पर पहले तत्व के args पर निर्दिष्ट है। हम इसी तरह हो सकता है:

julia> ex2a = Expr(:call, :(-), 1, 2, 3)
:(1 - 2 - 3)

या अन्य, संभावित रूप से अधिक दिलचस्प कार्य, जैसे

julia> ex2b = Expr(:call, :rand, 2,2)
:(rand(2,2))

julia> eval(ex2b)
2x2 Array{Float64,2}:
 0.429397  0.164478
 0.104994  0.675745

उपयोग करते समय head का स्वचालित निर्धारण :() अभिव्यक्ति निर्माण संकेतन

ध्यान दें :call का उपयोग अभिव्यक्ति के कुछ निर्माणों में प्रमुख रूप से किया जाता है, जैसे

julia> :(x + 2).head
:call

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

julia> :(x = 2).head
:(=)

वास्तव में, यदि आप निश्चित नहीं हैं कि आपके द्वारा उपयोग किए जा रहे किसी अभिव्यक्ति के लिए सही सिर का उपयोग क्या है, उदाहरण के लिए, Expr() यह क्या उपयोग करने के लिए सुझाव और विचार प्राप्त करने के लिए एक उपयोगी उपकरण हो सकता है।

प्रक्षेप और भाव

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

n = 2
julia> MyString = "there are $n ducks"
"there are 2 ducks"

हम स्ट्रिंग में n का मान सम्मिलित करने के लिए $ साइन का उपयोग करते हैं। हम अभिव्यक्ति के साथ एक ही तकनीक का उपयोग कर सकते हैं। उदाहरण के लिए

a = 2
ex1 = :(x = 2*$a)  ##     :(x = 2 * 2)
a = 3
eval(ex1)
x # 4

इसके विपरीत करें:

a = 2
ex2 = :(x = 2*a) # :(x = 2a)
a = 3
eval(ex2)
x # 6

इस प्रकार, पहले उदाहरण के साथ, हम पहले से निर्धारित a कि उस समय का उपयोग उस समय किया जाएगा जब अभिव्यक्ति का मूल्यांकन किया जाता है। दूसरे उदाहरण के साथ, तथापि, जूलिया संकलक केवल दिखेगा a हमारे अभिव्यक्ति के लिए मूल्यांकन के समय में अपने मूल्य को खोजने के लिए।

अभिव्यक्तियों पर बाहरी संदर्भ

कई उपयोगी वेब संसाधन हैं जो जूलिया में आपके ज्ञान के ज्ञान को आगे बढ़ाने में मदद कर सकते हैं। इसमें शामिल है:

• जूलिया डॉक्स - मेटाप्रोग्रामिंग
• विकीबूकस - जूलिया मेटाप्रोग्रामिंग
• जूलिया के मैक्रोज़, अभिव्यक्ति, आदि के लिए और उलझन में, ग्रे काल्हौन द्वारा
• जूलिया का महीना - एंड्रयू कोलियर द्वारा मेटाप्रोग्रामिंग
• जूलिया में जॉन माइल्स व्हाइट द्वारा प्रतीकात्मक भेदभाव

एसओ पोस्ट:

• जूलिया में एक "प्रतीक" क्या है? स्टेफन कारपिन्स्की द्वारा उत्तर
• जूलिया इस अभिव्यक्ति को इस जटिल तरीके से क्यों व्यक्त करता है?
• जूलिया अभिव्यक्ति प्रक्षेप उदाहरण का स्पष्टीकरण