Scala में वेरिएबल्स

DataCamp का नया लॉन्च किया गया Scala कोर्स देखें: Introduction to Scala.

Scala का व्यापक उपयोग डेटा वैज्ञानिकों द्वारा Big Data के क्षेत्र में Apache Spark के साथ बड़े डेटा वॉल्यूम को संभालने में किया जाता है। यह एक ऑब्जेक्ट-ओरिएंटेड और फंक्शनल प्रोग्रामिंग भाषा है, जिसमें नीचे सूचीबद्ध कई अन्य आवश्यक विशेषताएँ भी हैं:

1. Scala एक स्टैटिकली टाइप्ड भाषा है, जहाँ वेरिएबल का डेटा टाइप इस्तेमाल से पहले परिभाषित किया जाता है। टाइप जाँच रन-टाइम के बजाय कंपाइल-टाइम पर होती है।
2. यह एक "स्ट्रॉन्गली टाइप्ड" भाषा भी है, जहाँ वेरिएबल्स पर ऑपरेशन से पहले उनकी जाँच की जाती है।
3. यह टाइप इन्फरेंस को सपोर्ट करती है, जहाँ कंपाइलर अभिव्यक्ति या लिटरल्स से टाइप का अनुमान लगा लेता है, इसलिए वेरिएबल के टाइप की घोषणा वैकल्पिक होती है।

इस ट्यूटोरियल में, आप निम्नलिखित विषय कवर करेंगे:

• वेरिएबल्स
• Scala में वेरिएबल परिभाषित करने के नियम
• म्यूटेबल वेरिएबल्स
• इम्यूटेबल वेरिएबल्स
• एकाधिक घोषणाएँ और असाइनमेंट
• वेरिएबल का स्कोप

वेरिएबल्स

वेरिएबल्स मेमोरी में नामित स्थान होते हैं, और कंपाइलर संबंधित वेरिएबल के डेटा टाइप के अनुसार आरक्षित लोकेशन अलॉट करता है। Scala में वेरिएबल निम्नलिखित सिंटैक्स से घोषित किया जाता है:

val or val variable_name: variable_datatype = value;

ऊपर दिए गए सिंटैक्स में, वेरिएबल को दो तरीकों में से किसी एक से परिभाषित किया जा सकता है: 'var' या 'val' कीवर्ड का उपयोग करके। इसमें 'variable_name' आपका नया वेरिएबल है, जिसके बाद कॉलन आता है। वेरिएबल का डेटा टाइप 'variable_datatype' है, जो कोई भी वैध डेटा टाइप हो सकता है। उसके बाद 'value' प्रतीक 'variable_name' को असाइन हो जाता है।

उदाहरण:

val varValue: Byte = 8;

'val' वेरिएबल परिभाषित करने का कीवर्ड है और 'varValue' वेरिएबल का नाम है। इसका डेटा टाइप 'Byte' है और इसमें 8 मान संग्रहीत है। 'Byte' 8-बिट साइन किया हुआ मान है, जिसका दायरा 2⁻⁷ से 2⁷−1 तक होता है।

ऊपर 'variable_datatype' Scala के किसी भी डेटा टाइप का हो सकता है, जैसे:

1. Int: 32-बिट साइन किया हुआ मान (धनात्मक या ऋणात्मक), जिसका दायरा 2⁻³¹ से 2³¹−1 तक होता है।
2. Byte: 8-बिट साइन किया हुआ मान, जिसका दायरा 2⁻⁷ से 2⁷−1 तक होता है।
3. Short: 16-बिट साइन किया हुआ मान, जिसका दायरा 2⁻¹⁵ से 2¹⁵−1 तक होता है।
4. Float: यह 32-बिट या 64-बिट हो सकता है।

इसी तरह अन्य डेटा टाइप जैसे Long, Char, Boolean, Char, String, Boolean, Null के अपने-अपने दायरे होते हैं, और इनका विस्तृत विवरण Beginner’s Guide to Scala ट्यूटोरियल में दिया गया है। साथ ही, 'variable_datatype' का पहला अक्षर कैपिटल होना चाहिए, जैसे Int में 'I' कैपिटल होता है, जो दर्शाता है कि ऊपर दिए गए सभी डेटा टाइप Scala में ऑब्जेक्ट्स हैं।

Scala में वेरिएबल परिभाषित करने के नियम

Scala में वेरिएबल परिभाषित करने के नियम और परंपराएँ इस प्रकार हैं:

1. वेरिएबल का नाम लोअर कैमेल केस से शुरू होता है। उदाहरण के लिए, 'nameOfGirl' में पहला अक्षर 'n' छोटा है। इसके बाद हर शब्द के प्रारंभिक अक्षर जैसे 'O' और 'G' को कैपिटल करें।
2. वेरिएबल के नाम में Scala के आरक्षित शब्द या कीवर्ड शामिल नहीं होने चाहिए।
3. वेरिएबल नाम में डॉलर साइन ('$') और अंडरस्कोर ('_') हो सकता है। हालाँकि, '#','&' जैसे अन्य विशेष चिन्ह मान्य नहीं हैं। साथ ही, अंडरस्कोर का उपयोग हतोत्साहित किया जाता है।
4. वेरिएबल नाम में व्हाइट स्पेस (टैब, स्पेस) मान्य नहीं है।
5. वेरिएबल नाम अक्षर से शुरू होना चाहिए; यह संख्या या अन्य वर्णों से शुरू नहीं हो सकता।

म्यूटेबल वेरिएबल्स

म्यूटेबल वेरिएबल्स में, वेरिएबल के मान को घोषणा के बाद भी बदला जा सकता है।

म्यूटेबल वेरिएबल का सिंटैक्स नीचे दिखाया गया है:

var variable_name : variable_datatype = value;

म्यूटेबल वेरिएबल का सिंटैक्स इस प्रकार भी लिखा जा सकता है:

var variable_name = value;

म्यूटेबल वेरिएबल का उदाहरण नीचे दिया गया है:

var nameOfThing: String = "Car";

ऊपर के उदाहरण में var म्यूटेबल वेरिएबल्स परिभाषित करने का कीवर्ड है। वेरिएबल का नाम 'nameOfThing' है। इसके बाद कॉलन के साथ वेरिएबल का डेटा टाइप 'String' दिया गया है। इसका मान मेमोरी में 'Car' होगा।

उपरोक्त म्यूटेबल वेरिएबल का ही उदाहरण अलग सिंटैक्स से इस प्रकार भी लिखा जा सकता है:

var nameOfThing = "Car";

आप वेरिएबल को बिना डेटा टाइप बताए भी परिभाषित कर सकते हैं, जैसा ऊपर किया गया है। Scala कंपाइलर स्वतः इसे 'String' डेटा टाइप मान लेता है, जिसे Type Inference कहते हैं।

आप वेरिएबल के मान को आसानी से इस प्रकार बदल सकते हैं:

nameOfThing = "Bike";
print(nameOfThing)

वेरिएबल का मान "Car" से बदलकर "Bike" हो जाएगा। आउटपुट "Bike" होगा, क्योंकि 'var' कीवर्ड आपको वेरिएबल का मान बदलने देता है (स्रोत: Variables in Scala).

इम्यूटेबल वेरिएबल्स

इम्यूटेबल वेरिएबल वह है जिसका मान एक बार बनाए जाने के बाद बदला नहीं जा सकता, और इसे 'val' कीवर्ड से घोषित किया जाता है।

इम्यूटेबल वेरिएबल का सिंटैक्स नीचे दिखाया गया है:

val variable_name : variable_data type = value;

इम्यूटेबल वेरिएबल का सिंटैक्स इस प्रकार भी लिखा जा सकता है:

val variable_name = value;

इम्यूटेबल वेरिएबल का उदाहरण नीचे दिया गया है:

val numberOfThing: Int = 2;

ऊपर के उदाहरण में val इम्यूटेबल वेरिएबल्स परिभाषित करने का कीवर्ड है और वेरिएबल का नाम 'numberOfThing' है। इसके बाद कॉलन के साथ वेरिएबल का डेटा टाइप 'Int' दिया गया है और मेमोरी में संग्रहीत मान 2 है।

उपरोक्त इम्यूटेबल वेरिएबल का ही उदाहरण अलग सिंटैक्स से इस प्रकार भी लिखा जा सकता है:

val numberOfThing = 2;

आप वेरिएबल को बिना डेटा टाइप बताए भी परिभाषित कर सकते हैं, जैसा ऊपर किया गया है, जहाँ Scala कंपाइलर स्वतः इसे 'Int' डेटा टाइप मान लेता है। इस प्रक्रिया को Type Inference कहते हैं (स्रोत: Variables in Scala).

आप वेरिएबल का मान नीचे दिए अनुसार नहीं बदल सकते:

numberOfThing = 7;

ऊपर का उदाहरण इस तरह की त्रुटि देगा: "error: not found: value numberOfThing", जो दर्शाता है कि पुनः-असाइनमेंट संभव नहीं है, जैसा नीचे दिखाया गया है:

एकाधिक घोषणाएँ और असाइनमेंट

Scala में 'var' कीवर्ड का उपयोग करके, वेरिएबल नामों को कॉमा से अलग करते हुए और "=" चिह्न के साथ मान देकर, एक साथ कई घोषणाएँ संभव हैं।

var (x, y, z) = (5, 4.5, "Sit")

ऊपर के उदाहरण में आप देख सकते हैं कि x, y और z वेरिएबल्स को क्रमशः 5, 4.5 और "Sit" मान असाइन हुए हैं।

Scala में 'val' कीवर्ड के साथ, वेरिएबल नामों को कॉमा से अलग करते हुए और "=" चिह्न के साथ एक ही पंक्ति में एकाधिक असाइनमेंट भी संभव हैं।

val a, b, c = 1;

ऊपर के उदाहरण में आप देख सकते हैं कि a, b और c सभी वेरिएबल्स को 1 मान असाइन हुआ है।

वेरिएबल का स्कोप

स्कोप से आशय वेरिएबल्स की दृश्यता से है, जिनकी उम्र कोड के निर्दिष्ट ब्लॉक्स के भीतर होती है। वेरिएबल को लोकल या ग्लोबल स्कोप में परिभाषित किया जा सकता है। उदाहरण:

var globalVar = 10
def sub(){
var difference = 9-4;
}
print(difference)//Error
print(globalVar)//Valid

ऊपर के कोड में 'difference' वेरिएबल लोकल स्कोप में है, जहाँ इसे 'sub' मेथड के अंदर घोषित किया गया है, और घटाव ऑपरेशन का परिणाम मान्य होगा, परंतु मेथड 'sub' के बाहर इसका मान प्रिंट करना त्रुटि देगा। वहीं ग्लोबल स्कोप में 'globalVar' वेरिएबल को प्रोग्राम में कहीं से भी एक्सेस किया जा सकता है और उस पर कोई भी ऑपरेशन किया जा सकता है।

Scala में वेरिएबल्स के स्कोप के तीन प्रकार होते हैं (स्रोत: Scala- Variables):

1. लोकल वेरिएबल्स
2. फील्ड्स
3. मेथड पैरामीटर्स

लोकल वेरिएबल्स

लोकल वेरिएबल्स म्यूटेबल या इम्यूटेबल हो सकते हैं, ये किसी मेथड के अंदर घोषित किए जाते हैं और केवल उसी मेथड के अंदर सुलभ होते हैं, बाहर नहीं।

लोकल वेरिएबल्स के बारे में जानने के लिए नीचे दिया गया सरल उदाहरण देखें:

class Perimeter  
{
    def triangle()  
    {
        var side1 = 10;
        var side2 = 20;
        var side3 = 30;

        var total = side1+side2+side3;
        print("Perimeter of the  triangle is: " + total);
    }
}

object Test  
{

    def main(args:Array[String])  
    {
        val p1 = new Perimeter()
        p1.triangle()
    }
}

defined class Perimeter
defined object Test

ऊपर का कोड यह परिणाम देता है:

The perimeter of the triangle is: 60

ऊपर के प्रोग्राम में 'Perimeter' नाम की एक क्लास और 'Test' नाम का एक ऑब्जेक्ट है, जहाँ 'triangle' नाम का मेथड है जिसमें तीन म्यूटेबल वेरिएबल्स side1, side2, side3 हैं। गणना और परिणाम की प्रिंटिंग मेथड के अंदर ही होगी, जो सही आउटपुट देगी।

फील्ड्स

क्लास के अंदर परिभाषित वेरिएबल्स को फील्ड वेरिएबल्स कहा जाता है, जो म्यूटेबल या इम्यूटेबल किसी भी प्रकार के हो सकते हैं। यदि वेरिएबल क्लास के अंदर घोषित किया गया है पर किसी मेथड के अंदर नहीं, तो उसका एक्सेस मॉडिफायर स्वतः public माना जाएगा, और वेरिएबल प्रोग्राम में कहीं से भी सुलभ होगा। हालाँकि, private वेरिएबल को उसी परिभाषित क्लास के अंदर एक्सेस किया जा सकता है, लेकिन क्लास के स्कोप के बाहर या ऑब्जेक्ट में भी एक्सेस नहीं किया जा सकता।

class FieldExample
{
  var value1 = 10;
  private var value2 = 30;
  def operation()
  {
    println("Value of value1:"+value1)
  }
  println("Value of value2: "+value2);
}

object Demo
{
  def Main(args:Array[String])
  {
    val obj = new FieldExample()
    obj.operation()
    print(obj.value1)//Valid
    print(obj.value2)


  }
}

defined class FieldExample
defined object Demo

ऊपर का कोड यह परिणाम देता है:

Value of value2: 30
Value of value1:10
10

ऊपर दिए गए प्रोग्राम में 'FieldExample' नाम की एक क्लास, 'Demo' नाम का ऑब्जेक्ट और 'operation' नाम की एक मेथड है। सार्वजनिक वेरिएबल value1 को डॉट नोटेशन से एक्सेस किया जा सकता है और इसका मान 10 प्रिंट होता है। निजी वेरिएबल value2 का मान 30 है; उस वेरिएबल को एक्सेस करके प्रिंट करने पर त्रुटि होगी।

मेथड पैरामीटर्स

मेथड पैरामीटर्स वे वेरिएबल होते हैं जो मेथड के कॉल होने पर मान स्वीकार करते हैं, और वेरिएबल म्यूटेबल होना चाहिए, जिसे 'val' कीवर्ड से परिभाषित किया जाता है। साथ ही, जब उसका कोई रेफ़रेंस बनाया गया हो, तो वेरिएबल को मेथड के बाहर से भी एक्सेस किया जा सकता है।

मेथड पैरामीटर्स के बारे में जानने के लिए नीचे दिया गया सरल उदाहरण देखें:

class Triangle
{
    def calculate(height: Int, width: Int)
    {
        var result = 0.5*(height+width);
        println("Area of triangle is: " + result);
    }
}

object Area  
{
     def main(args:Array[String])
    {
        val a = new Triangle()
        a.calculate(4,5);
    }
}

defined class Triangle
defined object Area

उपरोक्त कोड यह परिणाम देता है:

Area of triangle is: 4.5

ऊपर दिए गए प्रोग्राम में 'Triangle' नाम की एक क्लास है। इसमें 'calculate' नाम की एक मेथड है जिसके दो मेथड पैरामीटर्स height और width हैं। जब ऑब्जेक्ट इंस्टेंस a के माध्यम से 'calculate' को कॉल किया जाता है, तो पूर्णांक मान 4 और 5 पास किए जाते हैं।

निष्कर्ष

बधाई हो, आप इस ट्यूटोरियल के अंत तक पहुँच गए हैं!

इस ट्यूटोरियल में, आपने Scala के वेरिएबल्स, वेरिएबल्स को परिभाषित करने के नियम, एकाधिक घोषणाओं और असाइनमेंट्स के साथ विभिन्न प्रकार के वेरिएबल्स, तथा उनमें वेरिएबल के स्कोप के बारे में जाना।

यदि आप Scala के बारे में और सीखना चाहते हैं, तो DataCamp का Introduction to Scala कोर्स देखें।