लसाग्ना

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

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

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

वेरिएबल को पहले से घोषित करने की ज़रूरत नहीं है। बस किसी उपयुक्त नाम को एक वैल्यू असाइन कर दीजिए:

julia> myvar = 42  # an integer
42

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

कॉन्स्टेंट

अगर कोई वैल्यू पूरे प्रोग्राम में उपलब्ध रहनी चाहिए, लेकिन उसके बदलने की उम्मीद नहीं है, तो उसे कॉन्स्टेंट घोषित कर देना सबसे अच्छा है।

असाइनमेंट से पहले 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

ध्यान दीजिए कि const को सिर्फ किसी फंक्शन के बाहर ही घोषित किया जा सकता है। आम तौर पर यह *.jl फाइल में सबसे ऊपर, फंक्शन की परिभाषाओं से पहले होता है।

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

ये कई दूसरी भाषाओं की तरह ही होते हैं:

2 + 3  # 5 (addition)
2 - 3  # -1 (subtraction)
2 * 3  # 6 (multiplication)
8 / 2  # 4.0 (division with floating-point result)
8 % 3  # 2 (remainder)

फंक्शन

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

1. function कीवर्ड का इस्तेमाल करके

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

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

   ध्यान दीजिए कि हम 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 में भी नाम (वेरिएबल, फंक्शन और कई और चीज़ों के) किसी अक्षर से शुरू होने चाहिए, और उसके बाद अक्षरों, अंकों और अंडरस्कोर का कोई भी मेल हो सकता है।

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