मूल बातें में

मूल बातें के बारे में

Julia एक डायनैमिक और स्ट्रांगली टाइप्ड प्रोग्रामिंग भाषा है। इसकी प्रोग्रामिंग शैली मुख्य रूप से फंक्शनल है, हालाँकि यह Haskell जैसी भाषाओं से ज़्यादा लचीली है।

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

पढ़ने में आसानी पर ज़ोर देने के बावजूद, जिससे यह Python और Ruby जैसी स्क्रिप्टिंग भाषा लगती है, Julia का कोड चलने से पहले कंपाइल हो जाता है। Just In Time (JIT) कंपाइलर हर फंक्शन के सामने आते ही उसके लिए बेहद ऑप्टिमाइज़्ड कोड बनाता है, जिससे कोड बहुत तेज़ चलता है।

Julia ऑब्जेक्ट-ओरिएंटेड भाषा नहीं है, और इसमें क्लासों का ऐसा पदानुक्रम नहीं है जो कई अन्य भाषाओं के केंद्र में होता है।

इसके बजाय (और यह पढ़ते समय कृपया घबराइए नहीं!), Julia इन पर निर्भर करती है:

• एक टाइप पदानुक्रम।
• कंपोज़ेबल फंक्शन (जो आसानी से, बहुमुखी और शक्तिशाली तरीकों से जुड़ सकें)।
• मल्टीपल डिस्पैच, यानी फंक्शन को अलग-अलग संख्या और टाइप के आर्गुमेंट के साथ कॉल किया जा सकता है।

ये कुछ उलझाने वाले शब्द सिलेबस में आगे बढ़ने के साथ और साफ होते जाएँगे।

आधिकारिक डॉक्युमेंटेशन में मौजूदा रिलीज़ के लिए बहुत उपयोगी जानकारी है, हालाँकि शुरुआती लोगों के लिए यह थोड़ा भारी पड़ सकता है।

• मैनुअल
• ट्यूटोरियल
• Julia के साथ शुरुआत कीजिए
• Python प्रोग्रामर के लिए नोट्स
• R प्रोग्रामर के लिए नोट्स
• C/C++ प्रोग्रामर के लिए नोट्स
• Matlab प्रोग्रामर के लिए नोट्स (यह एक प्रोप्राइटरी भाषा है, इंजीनियरों में बहुत लोकप्रिय, और Julia की एक प्रेरणा)

वीडियो में शामिल हैं:

• Julia का एक संक्षिप्त परिचय, Exercism प्रबंधन की ओर से!
• Julia का एक आसान परिचय
• हमारे साथ Julia सीखिए : 4 भागों की सीरीज़

कमेंट

अपने कोड में कमेंट डालना बहुत ज़रूरी है, ताकि लोग आपका कोड पढ़ सकें और आपके इरादे समझ सकें: चाहे दूसरे लोग हों, या भविष्य में आप खुद। कंपाइलर इन्हें (ज़्यादातर) अनदेखा कर देता है।

Julia में दो तरीके संभव हैं:

• एक लाइन के कमेंट # से शुरू होते हैं
• कई लाइनों वाले कमेंट #= से शुरू होते हैं और =# पर खत्म होते हैं। इन्हें एक के अंदर एक भी लिखा जा सकता है।

# This is a single-line comment

x = 3  # This is an inline comment

#=
	Multi-line comments can be used for longer explanations.

	They are especially useful to comment out blocks of code during debugging.
=#

वेरिएबल और असाइनमेंट

वेरिएबल बनाने के लिए उसे बस एक वैल्यू असाइन कीजिए:

julia> myvar = 42  # an integer (in fact, Int64)
42

julia> bigint = 1_234_567_890  # optionally use underscore as digit separator, for readability
1234567890

julia> name = "Maria"  # strings are surrounded by double-quotes ""
"Maria"

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

टाइप बताना ज़रूरी नहीं है, और ज़्यादातर Julia संदर्भ से ही उपयुक्त डिफॉल्ट अनुमान लगा लेती है।

Julia में टाइप एक महत्वपूर्ण विषय है। हम आगे के कॉन्सेप्ट में इन्हें और गहराई से देखेंगे। फिलहाल इनकी चिंता न करना ही बेहतर है।

कई फंक्शनल भाषाओं के उलट, Julia में वेरिएबल को दोबारा असाइन किया जा सकता है, और आप वेरिएबल से जुड़ी वैल्यू और टाइप दोनों को बदल सकते हैं:

julia> myvar = 3
3

julia> myvar = "now a string"
"now a string"

स्थिरांक

किसी भी फंक्शन के बाहर बनाए गए ग्लोबल वेरिएबल:

• अनुमत हैं।
• कभी-कभी ज़रूरी होते हैं।
• आम तौर पर इनसे बचना चाहिए (हालाँकि यह सिर्फ *.jl फाइलों में है; REPL अलग तरह से काम करता है)।

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

असाइनमेंट से पहले const कीवर्ड लगाने से कंपाइलर और कुशल कोड बना पाता है।

गलती से const वैल्यू बदलने की कोशिश करने पर चेतावनी मिलती है:

julia> const answer = 42
42

julia> answer = 24
WARNING: redefinition of constant Main.answer. This may fail, cause incorrect answers, or produce other errors.
24

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

अंकगणित ज़्यादातर आम तरीके से ही काम करता है:

2 + 3  # 5 (addition)
2 - 3  # -1 (subtraction)
2 * 3  # 6 (multiplication)
8 / 2  # 4.0 (division)
8 % 3  # 2 (remainder)
2 ^ 3  # 8 (exponentiation)

ध्यान दीजिए कि / से भाग देने पर परिणाम हमेशा एक दशमलव संख्या होता है।

हम आगे के कॉन्सेप्ट में इस पर फिर बात करेंगे, जहाँ पूर्णांक भाग के बारे में बात होगी: div() या ÷ से भाग का दशमलव हिस्सा काटा जाता है, और // से परिमेय संख्या मिलती है।

फंक्शन

सबसे अच्छी रनटाइम परफॉर्मेंस के लिए बेहतर है कि आप ज़्यादातर कोड फंक्शन के अंदर रखें। कुछ अन्य भाषाओं के उलट, यहाँ बहुत सारे छोटे फंक्शन रखना कोई बुरी बात नहीं है।

Julia में नाम वाला फंक्शन बनाने के दो आम तरीके हैं:

1. function कीवर्ड का उपयोग करके

   function muladd(x, y, z)
       x * y + z
   end
   

   पढ़ने में आसानी के लिए 4 स्पेस का इंडेंटेशन आम बात है, लेकिन कंपाइलर इसे अनदेखा कर देता है। end कीवर्ड ज़रूरी है: यह Python से ज़्यादा Ruby जैसा है।

   ध्यान दीजिए कि हम return x * y + z लिख भी सकते थे। लेकिन Julia के फंक्शन हमेशा आखिरी में मूल्यांकित हुए एक्सप्रेशन को लौटाते हैं, इसलिए return कीवर्ड लगाना ज़रूरी नहीं है। कई प्रोग्रामर अपने इरादे और साफ करने के लिए इसे लिखना पसंद करते हैं।

2. "असाइनमेंट रूप" का उपयोग करके

   muladd(x, y, z) = x * y + z
   

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

दोनों रूप बराबर हैं और बिल्कुल एक ही तरह इस्तेमाल होते हैं, इसलिए जो पढ़ने में ज़्यादा आसान लगे उसे चुनिए।

फंक्शन को कॉल करने के लिए उसका नाम लिखा जाता है और फंक्शन के हर पैरामीटर के लिए आर्गुमेंट पास किए जाते हैं:

# invoking a function
muladd(10, 5, 1)

# and of course you can invoke a function within the body of another function:
square_plus_one(x) = muladd(x, x, 1)

इन्हें "नाम वाले" फंक्शन कहने से आप अंदाज़ा लगा सकते हैं कि "अनाम" फंक्शन भी होते हैं। इन पर आगे किसी कॉन्सेप्ट में बात होगी।

नाम रखने के नियम

बहुत सी भाषाओं की तरह Julia में भी ज़रूरी है कि नाम (वेरिएबल, फंक्शन और और भी बहुत चीज़ों के) एक अक्षर से शुरू हों, और उसके बाद अक्षरों, अंकों और अंडरस्कोर का कोई भी मेल हो सकता है।

आम परंपरा है कि वेरिएबल, स्थिरांक और फंक्शन के नाम छोटे अक्षरों में हों, और अंडरस्कोर से तब तक बचा जाए जब तक उलझन से बचने के लिए ज़रूरी न हो।

लेकिन Julia हर जगह Unicode का उपयोग करती है, इसलिए "अक्षर" का मतलब काफी लचीले तरीके से लिया जाता है।

अंग्रेज़ी के अलावा दूसरी भाषाएँ भी समर्थित हैं, और इमोजी भी (हालाँकि कृपया अच्छी रुचि दिखाइए और कुछ उपयुक्त चुनिए)।

खास तौर पर गणितज्ञों को पसंद आने वाले सभी ग्रीक अक्षर उपलब्ध हैं (और कई उपयोगी वैल्यू पहले से परिभाषित हैं):

julia> π   # a built-in constant
π = 3.1415926535897...

Julia को समझने वाले एडिटर, जैसे REPL, Pluto.jl और Julia प्लगइन के साथ VS Code, इन अक्षरों को लिखना आसान बना देते हैं।

π के लिए \pi टाइप कीजिए और फिर <Tab> दबाइए। आपका टाइप किया हुआ ग्रीक अक्षर से बदल जाएगा।

इसके और भी कई उदाहरण आप आगे के कॉन्सेप्ट में देखेंगे।

वास्तव में, बैकस्लैश वाले ये संक्षिप्त रूप सिर्फ Julia के लिए खास नहीं हैं। ये LaTeX से लिए गए हैं, जो एक टाइपसेटिंग सिस्टम है जिसे कई वैज्ञानिक और इंजीनियर रिपोर्ट लिखने के लिए लगभग रोज़ इस्तेमाल करते हैं।