बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala · पाठ

val, var और Types

Bindings और inference

पाठ 2, कुल 4 में से13 चरण

val, var और Types, CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

Scala में bindings

Scala में आप bindings का उपयोग करके values को नाम देते हैं। इसके लिए दो keywords हैं: val और var।

val अपरिवर्तनीय होता है, यानी उसे फिर से assign नहीं किया जा सकता, जबकि var परिवर्तनीय होता है और उसे फिर से assign किया जा सकता है।

val घोषित करना

val किसी नाम को एक बार किसी value से बाँधता है। उसे फिर से assign करने का प्रयास compile error उत्पन्न करता है।

डिफ़ॉल्ट रूप से val को प्राथमिकता दीजिए। अपरिवर्तनीयता code को समझना आसान बनाती है।

object Main {
  def main(args: Array[String]): Unit = {
    val name = "Ada"
    println(name)
  }
}

var घोषित करना

var को = का उपयोग करके फिर से assign किया जा सकता है। इसका उपयोग केवल तब कीजिए, जब आपको वास्तव में परिवर्तनीय state की आवश्यकता हो।

ध्यान दीजिए कि नया value फिर भी मूल type से मेल खाना चाहिए।

object Main {
  def main(args: Array[String]): Unit = {
    var count = 0
    count = count + 1
    count = count + 1
    println(count)
  }
}

Type inference

Scala आमतौर पर आपके लिए type निर्धारित कर लेता है। val x = 42 लिखने पर x अपने-आप Int बन जाता है।

इसे type inference कहते हैं: type हमेशा लिखे बिना भी आपको static typing मिलती है।

object Main {
  def main(args: Array[String]): Unit = {
    val x = 42
    val pi = 3.14
    val flag = true
    println(x)
    println(pi)
    println(flag)
  }
}

स्पष्ट type annotations

आप colon के बाद type को स्पष्ट रूप से भी लिख सकते हैं: val x: Int = 42।

यह documentation के लिए या inferred type से अधिक व्यापक type चुनने के लिए उपयोगी है।

object Main {
  def main(args: Array[String]): Unit = {
    val age: Int = 30
    val price: Double = 9.99
    val label: String = "Sale"
    println(label + ": " + price)
  }
}

सामान्य numeric types

Scala में कई numeric types होते हैं:

पूर्ण संख्याओं के लिए Int
बड़ी पूर्ण संख्याओं के लिए Long
दशमलव संख्याओं के लिए Double
छोटी दशमलव संख्याओं के लिए Float

Integer literal का default type Int होता है; decimal literal का default type Double होता है।

object Main {
  def main(args: Array[String]): Unit = {
    val whole: Int = 7
    val big: Long = 9000000000L
    val dec: Double = 2.5
    println(whole + dec)
  }
}

Boolean और Char

Boolean में true या false होता है। Char में single quotes में लिखा गया एक अक्षर होता है।

ये पूर्ण types हैं, जिन्हें आप vals और vars में सहेज सकते हैं।

object Main {
  def main(args: Array[String]): Unit = {
    val isReady: Boolean = true
    val grade: Char = 'A'
    println(isReady)
    println(grade)
  }
}

String type

String में double quotes के भीतर लिखा हुआ text होता है। Scala में strings अपरिवर्तनीय होती हैं।

आप उन्हें + से जोड़ सकते हैं और उन पर कई उपयोगी methods call कर सकते हैं।

object Main {
  def main(args: Array[String]): Unit = {
    val first = "Grace"
    val last = "Hopper"
    val full = first + " " + last
    println(full.toUpperCase)
  }
}

var की जगह val क्यों?

अपरिवर्तनीय values bugs की एक पूरी श्रेणी को रोकती हैं: कोई अन्य code उन्हें आपकी जानकारी के बिना बदल नहीं सकता।

समझना आसान होता है
concurrent code में अधिक सुरक्षित होता है
functional शैली को प्रोत्साहित करता है

var का उपयोग केवल तब कीजिए, जब परिवर्तन वास्तव में आवश्यक हो।

व्यवहार में type safety

Scala statically typed होने के कारण compiler program चलने से पहले type mismatches पकड़ लेता है।

Int में text assign करने पर compile time में error आएगा। यहाँ valid और type-correct code दिया गया है।

object Main {
  def main(args: Array[String]): Unit = {
    val quantity: Int = 3
    val unitPrice: Double = 4.50
    val total: Double = quantity * unitPrice
    println(total)
  }
}

सबको एक साथ रखना

एक छोटे program में immutable और mutable bindings को inference तथा annotations के साथ संयोजित कीजिए।

ध्यान दीजिए कि compiler आपके लिए हर type को कैसे track करता है।

object Main {
  def main(args: Array[String]): Unit = {
    val base = 100
    var running = base
    val step: Int = 25
    running = running + step
    println(running)
  }
}

त्वरित जाँच

Bindings और types की अपनी समझ जाँचिए।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

आपने सीखा कि Scala values को नाम कैसे देता है:

val अपरिवर्तनीय binding है; var परिवर्तनीय है
Type inference value के आधार पर type चुनता है
आप val x: Int जैसे स्पष्ट annotations जोड़ सकते हैं
मुख्य types में Int, Long, Double, Boolean, Char और String शामिल हैं
अधिक सुरक्षित और स्पष्ट code के लिए val को प्राथमिकता दीजिए

शुरुआत निःशुल्क

एआई शिक्षक के साथ Scala सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 39
पाठ: 143

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “val, var और Types” पाठ निःशुल्क है?

हाँ—“val, var और Types” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“val, var और Types” में मैं क्या सीखूँगा?

Bindings और inference आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“val, var और Types” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पर वापस जाएँ